MagickCore  7.1.2-29
Convert, Edit, Or Compose Bitmap Images
quantum-export.c
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % QQQ U U AAA N N TTTTT U U M M %
7 % Q Q U U A A NN N T U U MM MM %
8 % Q Q U U AAAAA N N N T U U M M M %
9 % Q QQ U U A A N NN T U U M M %
10 % QQQQ UUU A A N N T UUU M M %
11 % %
12 % EEEEE X X PPPP OOO RRRR TTTTT %
13 % E X X P P O O R R T %
14 % EEE X PPPP O O RRRR T %
15 % E X X P O O R R T %
16 % EEEEE X X P OOO R R T %
17 % %
18 % MagickCore Methods to Export Quantum Pixels %
19 % %
20 % Software Design %
21 % Cristy %
22 % October 1998 %
23 % %
24 % %
25 % Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
26 % dedicated to making software imaging solutions freely available. %
27 % %
28 % You may not use this file except in compliance with the License. You may %
29 % obtain a copy of the License at %
30 % %
31 % https://imagemagick.org/license/ %
32 % %
33 % Unless required by applicable law or agreed to in writing, software %
34 % distributed under the License is distributed on an "AS IS" BASIS, %
35 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
36 % See the License for the specific language governing permissions and %
37 % limitations under the License. %
38 % %
39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
40 %
41 %
42 */
43 ␌
44 /*
45  Include declarations.
46 */
47 #include "MagickCore/studio.h"
48 #include "MagickCore/property.h"
49 #include "MagickCore/blob.h"
50 #include "MagickCore/blob-private.h"
51 #include "MagickCore/color-private.h"
52 #include "MagickCore/exception.h"
53 #include "MagickCore/exception-private.h"
54 #include "MagickCore/cache.h"
55 #include "MagickCore/constitute.h"
56 #include "MagickCore/delegate.h"
57 #include "MagickCore/geometry.h"
58 #include "MagickCore/list.h"
59 #include "MagickCore/magick.h"
60 #include "MagickCore/memory_.h"
61 #include "MagickCore/monitor.h"
62 #include "MagickCore/option.h"
63 #include "MagickCore/pixel.h"
64 #include "MagickCore/pixel-accessor.h"
65 #include "MagickCore/quantum.h"
66 #include "MagickCore/quantum-private.h"
67 #include "MagickCore/resource_.h"
68 #include "MagickCore/semaphore.h"
69 #include "MagickCore/statistic.h"
70 #include "MagickCore/stream.h"
71 #include "MagickCore/string_.h"
72 #include "MagickCore/utility.h"
73 ␌
74 /*
75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
76 % %
77 % %
78 % %
79 + E x p o r t Q u a n t u m P i x e l s %
80 % %
81 % %
82 % %
83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
84 %
85 % ExportQuantumPixels() transfers one or more pixel components from the image
86 % pixel cache to a user supplied buffer. The pixels are returned in network
87 % byte order. It returns the number of exported pixels.
88 %
89 % The format of the ExportQuantumPixels method is:
90 %
91 % size_t ExportQuantumPixels(const Image *image,CacheView *image_view,
92 % QuantumInfo *quantum_info,const QuantumType quantum_type,
93 % unsigned char *magick_restrict pixels,ExceptionInfo *exception)
94 %
95 % A description of each parameter follows:
96 %
97 % o image: the image.
98 %
99 % o image_view: the image cache view.
100 %
101 % o quantum_info: the quantum info.
102 %
103 % o quantum_type: Declare which pixel components to transfer (RGB, RGBA,
104 % etc).
105 %
106 % o pixels: The components are transferred to this buffer.
107 %
108 % o exception: return any errors or warnings in this structure.
109 %
110 */
111 
112 static inline unsigned char *PopQuantumDoublePixel(QuantumInfo *quantum_info,
113  const double pixel,unsigned char *magick_restrict pixels)
114 {
115  double
116  *p;
117 
118  unsigned char
119  quantum[8];
120 
121  (void) memset(quantum,0,sizeof(quantum));
122  p=(double *) quantum;
123  *p=(double) (pixel*quantum_info->state.inverse_scale+quantum_info->minimum);
124  if (quantum_info->endian == LSBEndian)
125  {
126  *pixels++=quantum[0];
127  *pixels++=quantum[1];
128  *pixels++=quantum[2];
129  *pixels++=quantum[3];
130  *pixels++=quantum[4];
131  *pixels++=quantum[5];
132  *pixels++=quantum[6];
133  *pixels++=quantum[7];
134  return(pixels);
135  }
136  *pixels++=quantum[7];
137  *pixels++=quantum[6];
138  *pixels++=quantum[5];
139  *pixels++=quantum[4];
140  *pixels++=quantum[3];
141  *pixels++=quantum[2];
142  *pixels++=quantum[1];
143  *pixels++=quantum[0];
144  return(pixels);
145 }
146 
147 static inline unsigned char *PopQuantumFloatPixel(QuantumInfo *quantum_info,
148  const float pixel,unsigned char *magick_restrict pixels)
149 {
150  float
151  *p;
152 
153  unsigned char
154  quantum[4];
155 
156  (void) memset(quantum,0,sizeof(quantum));
157  p=(float *) quantum;
158  *p=(float) ((double) pixel*quantum_info->state.inverse_scale+
159  quantum_info->minimum);
160  if (quantum_info->endian == LSBEndian)
161  {
162  *pixels++=quantum[0];
163  *pixels++=quantum[1];
164  *pixels++=quantum[2];
165  *pixels++=quantum[3];
166  return(pixels);
167  }
168  *pixels++=quantum[3];
169  *pixels++=quantum[2];
170  *pixels++=quantum[1];
171  *pixels++=quantum[0];
172  return(pixels);
173 }
174 
175 static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
176  const QuantumAny pixel,unsigned char *magick_restrict pixels)
177 {
178  ssize_t
179  i;
180 
181  size_t
182  quantum_bits;
183 
184  if (quantum_info->state.bits == 0UL)
185  quantum_info->state.bits=8U;
186  for (i=(ssize_t) quantum_info->depth; i > 0L; )
187  {
188  quantum_bits=(size_t) i;
189  if (quantum_bits > quantum_info->state.bits)
190  quantum_bits=quantum_info->state.bits;
191  i-=(ssize_t) quantum_bits;
192  if (i < 0)
193  i=0;
194  if (quantum_info->state.bits == 8UL)
195  *pixels='\0';
196  quantum_info->state.bits-=quantum_bits;
197  *pixels|=(((pixel >> i) &~ (((QuantumAny) ~0UL) << quantum_bits)) <<
198  quantum_info->state.bits);
199  if (quantum_info->state.bits == 0UL)
200  {
201  pixels++;
202  quantum_info->state.bits=8UL;
203  }
204  }
205  return(pixels);
206 }
207 
208 static inline unsigned char *PopQuantumLongPixel(QuantumInfo *quantum_info,
209  const size_t pixel,unsigned char *magick_restrict pixels)
210 {
211  ssize_t
212  i;
213 
214  size_t
215  quantum_bits;
216 
217  if (quantum_info->state.bits == 0U)
218  quantum_info->state.bits=32UL;
219  for (i=(ssize_t) quantum_info->depth; i > 0; )
220  {
221  quantum_bits=(size_t) i;
222  if (quantum_bits > quantum_info->state.bits)
223  quantum_bits=quantum_info->state.bits;
224  quantum_info->state.pixel|=(((pixel >> ((ssize_t) quantum_info->depth-i)) &
225  quantum_info->state.mask[quantum_bits]) << (32U-
226  quantum_info->state.bits));
227  i-=(ssize_t) quantum_bits;
228  quantum_info->state.bits-=quantum_bits;
229  if (quantum_info->state.bits == 0U)
230  {
231  pixels=PopLongPixel(quantum_info->endian,quantum_info->state.pixel,
232  pixels);
233  quantum_info->state.pixel=0U;
234  quantum_info->state.bits=32U;
235  }
236  }
237  return(pixels);
238 }
239 
240 static void ExportPixelChannel(const Image *image,QuantumInfo *quantum_info,
241  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
242  unsigned char *magick_restrict q,PixelChannel channel)
243 {
244  QuantumAny
245  range;
246 
247  ssize_t
248  x;
249 
250  p+=(ptrdiff_t) image->channel_map[channel].offset;
251  switch (quantum_info->depth)
252  {
253  case 8:
254  {
255  unsigned char
256  pixel;
257 
258  for (x=0; x < (ssize_t) number_pixels; x++)
259  {
260  pixel=ScaleQuantumToChar(*p);
261  q=PopCharPixel(pixel,q);
262  p+=(ptrdiff_t) GetPixelChannels(image);
263  q+=(ptrdiff_t) quantum_info->pad;
264  }
265  break;
266  }
267  case 16:
268  {
269  unsigned short
270  pixel;
271 
272  if (quantum_info->format == FloatingPointQuantumFormat)
273  {
274  for (x=0; x < (ssize_t) number_pixels; x++)
275  {
276  pixel=SinglePrecisionToHalf(QuantumScale*(*p));
277  q=PopShortPixel(quantum_info->endian,pixel,q);
278  p+=(ptrdiff_t) GetPixelChannels(image);
279  q+=(ptrdiff_t) quantum_info->pad;
280  }
281  break;
282  }
283  for (x=0; x < (ssize_t) number_pixels; x++)
284  {
285  pixel=ScaleQuantumToShort(*p);
286  q=PopShortPixel(quantum_info->endian,pixel,q);
287  p+=(ptrdiff_t) GetPixelChannels(image);
288  q+=(ptrdiff_t) quantum_info->pad;
289  }
290  break;
291  }
292  case 32:
293  {
294  unsigned int
295  pixel;
296 
297  if (quantum_info->format == FloatingPointQuantumFormat)
298  {
299  for (x=0; x < (ssize_t) number_pixels; x++)
300  {
301  q=PopQuantumFloatPixel(quantum_info,(float) *p,q);
302  p+=(ptrdiff_t) GetPixelChannels(image);
303  q+=(ptrdiff_t) quantum_info->pad;
304  }
305  break;
306  }
307  for (x=0; x < (ssize_t) number_pixels; x++)
308  {
309  pixel=ScaleQuantumToLong(*p);
310  q=PopLongPixel(quantum_info->endian,pixel,q);
311  p+=(ptrdiff_t) GetPixelChannels(image);
312  q+=(ptrdiff_t) quantum_info->pad;
313  }
314  break;
315  }
316  case 64:
317  {
318  if (quantum_info->format == FloatingPointQuantumFormat)
319  {
320  for (x=0; x < (ssize_t) number_pixels; x++)
321  {
322  q=PopQuantumDoublePixel(quantum_info,(double) *p,q);
323  p+=(ptrdiff_t) GetPixelChannels(image);
324  q+=(ptrdiff_t) quantum_info->pad;
325  }
326  break;
327  }
328  magick_fallthrough;
329  }
330  default:
331  {
332  range=GetQuantumRange(quantum_info->depth);
333  for (x=0; x < (ssize_t) number_pixels; x++)
334  {
335  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(*p,range),q);
336  p+=(ptrdiff_t) GetPixelChannels(image);
337  q+=(ptrdiff_t) quantum_info->pad;
338  }
339  break;
340  }
341  }
342 }
343 
344 static void ExportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
345  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
346  unsigned char *magick_restrict q,ExceptionInfo *exception)
347 {
348  if (image->alpha_trait == UndefinedPixelTrait)
349  {
350  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
351  "ImageDoesNotHaveAnAlphaChannel","`%s'",image->filename);
352  return;
353  }
354  ExportPixelChannel(image,quantum_info,number_pixels,p,q,AlphaPixelChannel);
355 }
356 
357 static void ExportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
358  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
359  unsigned char *magick_restrict q)
360 {
361  QuantumAny
362  range;
363 
364  ssize_t
365  x;
366 
367  ssize_t
368  bit;
369 
370  switch (quantum_info->depth)
371  {
372  case 8:
373  {
374  for (x=0; x < (ssize_t) number_pixels; x++)
375  {
376  q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
377  q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
378  q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
379  p+=(ptrdiff_t) GetPixelChannels(image);
380  q+=(ptrdiff_t) quantum_info->pad;
381  }
382  break;
383  }
384  case 10:
385  {
386  unsigned int
387  pixel;
388 
389  range=GetQuantumRange(quantum_info->depth);
390  if (quantum_info->pack == MagickFalse)
391  {
392  for (x=0; x < (ssize_t) number_pixels; x++)
393  {
394  pixel=(unsigned int) (
395  ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
396  ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
397  ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
398  q=PopLongPixel(quantum_info->endian,pixel,q);
399  p+=(ptrdiff_t) GetPixelChannels(image);
400  q+=(ptrdiff_t) quantum_info->pad;
401  }
402  break;
403  }
404  if (quantum_info->quantum == 32UL)
405  {
406  for (x=0; x < (ssize_t) number_pixels; x++)
407  {
408  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
409  q=PopQuantumLongPixel(quantum_info,pixel,q);
410  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
411  range);
412  q=PopQuantumLongPixel(quantum_info,pixel,q);
413  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
414  q=PopQuantumLongPixel(quantum_info,pixel,q);
415  p+=(ptrdiff_t) GetPixelChannels(image);
416  q+=(ptrdiff_t) quantum_info->pad;
417  }
418  break;
419  }
420  for (x=0; x < (ssize_t) number_pixels; x++)
421  {
422  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
423  q=PopQuantumPixel(quantum_info,pixel,q);
424  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
425  q=PopQuantumPixel(quantum_info,pixel,q);
426  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
427  q=PopQuantumPixel(quantum_info,pixel,q);
428  p+=(ptrdiff_t) GetPixelChannels(image);
429  q+=(ptrdiff_t) quantum_info->pad;
430  }
431  break;
432  }
433  case 12:
434  {
435  unsigned int
436  pixel;
437 
438  range=GetQuantumRange(quantum_info->depth);
439  if (quantum_info->pack == MagickFalse)
440  {
441  for (x=0; x < (3*(ssize_t) number_pixels-1); x+=2)
442  {
443  switch (x % 3)
444  {
445  default:
446  case 0:
447  {
448  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
449  range);
450  break;
451  }
452  case 1:
453  {
454  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
455  range);
456  break;
457  }
458  case 2:
459  {
460  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
461  range);
462  p+=(ptrdiff_t) GetPixelChannels(image);
463  break;
464  }
465  }
466  q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
467  q);
468  switch ((x+1) % 3)
469  {
470  default:
471  case 0:
472  {
473  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
474  range);
475  break;
476  }
477  case 1:
478  {
479  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
480  range);
481  break;
482  }
483  case 2:
484  {
485  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
486  range);
487  p+=(ptrdiff_t) GetPixelChannels(image);
488  break;
489  }
490  }
491  q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
492  q);
493  q+=(ptrdiff_t) quantum_info->pad;
494  }
495  for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
496  {
497  switch ((x+bit) % 3)
498  {
499  default:
500  case 0:
501  {
502  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
503  range);
504  break;
505  }
506  case 1:
507  {
508  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
509  range);
510  break;
511  }
512  case 2:
513  {
514  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
515  range);
516  p+=(ptrdiff_t) GetPixelChannels(image);
517  break;
518  }
519  }
520  q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
521  q);
522  q+=(ptrdiff_t) quantum_info->pad;
523  }
524  if (bit != 0)
525  p+=(ptrdiff_t) GetPixelChannels(image);
526  break;
527  }
528  if (quantum_info->quantum == 32UL)
529  {
530  for (x=0; x < (ssize_t) number_pixels; x++)
531  {
532  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
533  q=PopQuantumLongPixel(quantum_info,pixel,q);
534  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
535  range);
536  q=PopQuantumLongPixel(quantum_info,pixel,q);
537  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
538  q=PopQuantumLongPixel(quantum_info,pixel,q);
539  p+=(ptrdiff_t) GetPixelChannels(image);
540  q+=(ptrdiff_t) quantum_info->pad;
541  }
542  break;
543  }
544  for (x=0; x < (ssize_t) number_pixels; x++)
545  {
546  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
547  q=PopQuantumPixel(quantum_info,pixel,q);
548  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
549  q=PopQuantumPixel(quantum_info,pixel,q);
550  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
551  q=PopQuantumPixel(quantum_info,pixel,q);
552  p+=(ptrdiff_t) GetPixelChannels(image);
553  q+=(ptrdiff_t) quantum_info->pad;
554  }
555  break;
556  }
557  case 16:
558  {
559  unsigned short
560  pixel;
561 
562  if (quantum_info->format == FloatingPointQuantumFormat)
563  {
564  for (x=0; x < (ssize_t) number_pixels; x++)
565  {
566  pixel=SinglePrecisionToHalf(QuantumScale*(double)
567  GetPixelBlue(image,p));
568  q=PopShortPixel(quantum_info->endian,pixel,q);
569  pixel=SinglePrecisionToHalf(QuantumScale*(double)
570  GetPixelGreen(image,p));
571  q=PopShortPixel(quantum_info->endian,pixel,q);
572  pixel=SinglePrecisionToHalf(QuantumScale*(double)
573  GetPixelRed(image,p));
574  q=PopShortPixel(quantum_info->endian,pixel,q);
575  p+=(ptrdiff_t) GetPixelChannels(image);
576  q+=(ptrdiff_t) quantum_info->pad;
577  }
578  break;
579  }
580  for (x=0; x < (ssize_t) number_pixels; x++)
581  {
582  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
583  q=PopShortPixel(quantum_info->endian,pixel,q);
584  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
585  q=PopShortPixel(quantum_info->endian,pixel,q);
586  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
587  q=PopShortPixel(quantum_info->endian,pixel,q);
588  p+=(ptrdiff_t) GetPixelChannels(image);
589  q+=(ptrdiff_t) quantum_info->pad;
590  }
591  break;
592  }
593  case 32:
594  {
595  unsigned int
596  pixel;
597 
598  if (quantum_info->format == FloatingPointQuantumFormat)
599  {
600  for (x=0; x < (ssize_t) number_pixels; x++)
601  {
602  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
603  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
604  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
605  p+=(ptrdiff_t) GetPixelChannels(image);
606  q+=(ptrdiff_t) quantum_info->pad;
607  }
608  break;
609  }
610  for (x=0; x < (ssize_t) number_pixels; x++)
611  {
612  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
613  q=PopLongPixel(quantum_info->endian,pixel,q);
614  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
615  q=PopLongPixel(quantum_info->endian,pixel,q);
616  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
617  q=PopLongPixel(quantum_info->endian,pixel,q);
618  p+=(ptrdiff_t) GetPixelChannels(image);
619  q+=(ptrdiff_t) quantum_info->pad;
620  }
621  break;
622  }
623  case 64:
624  {
625  if (quantum_info->format == FloatingPointQuantumFormat)
626  {
627  for (x=0; x < (ssize_t) number_pixels; x++)
628  {
629  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
630  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
631  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
632  p+=(ptrdiff_t) GetPixelChannels(image);
633  q+=(ptrdiff_t) quantum_info->pad;
634  }
635  break;
636  }
637  magick_fallthrough;
638  }
639  default:
640  {
641  range=GetQuantumRange(quantum_info->depth);
642  for (x=0; x < (ssize_t) number_pixels; x++)
643  {
644  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
645  range),q);
646  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
647  range),q);
648  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
649  range),q);
650  p+=(ptrdiff_t) GetPixelChannels(image);
651  q+=(ptrdiff_t) quantum_info->pad;
652  }
653  break;
654  }
655  }
656 }
657 
658 static void ExportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
659  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
660  unsigned char *magick_restrict q)
661 {
662  QuantumAny
663  range;
664 
665  ssize_t
666  x;
667 
668  switch (quantum_info->depth)
669  {
670  case 8:
671  {
672  unsigned char
673  pixel;
674 
675  for (x=0; x < (ssize_t) number_pixels; x++)
676  {
677  pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
678  q=PopCharPixel(pixel,q);
679  pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
680  q=PopCharPixel(pixel,q);
681  pixel=ScaleQuantumToChar(GetPixelRed(image,p));
682  q=PopCharPixel(pixel,q);
683  pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
684  q=PopCharPixel(pixel,q);
685  p+=(ptrdiff_t) GetPixelChannels(image);
686  q+=(ptrdiff_t) quantum_info->pad;
687  }
688  break;
689  }
690  case 10:
691  {
692  unsigned int
693  pixel;
694 
695  range=GetQuantumRange(quantum_info->depth);
696  if (quantum_info->pack == MagickFalse)
697  {
698  ssize_t
699  i;
700 
701  size_t
702  quantum;
703 
704  ssize_t
705  n;
706 
707  n=0;
708  quantum=0;
709  pixel=0;
710  for (x=0; x < (ssize_t) number_pixels; x++)
711  {
712  for (i=0; i < 4; i++)
713  {
714  switch (i)
715  {
716  case 0: quantum=(size_t) GetPixelRed(image,p); break;
717  case 1: quantum=(size_t) GetPixelGreen(image,p); break;
718  case 2: quantum=(size_t) GetPixelBlue(image,p); break;
719  case 3: quantum=(size_t) GetPixelAlpha(image,p); break;
720  }
721  switch (n % 3)
722  {
723  case 0:
724  {
725  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
726  range) << 22);
727  break;
728  }
729  case 1:
730  {
731  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
732  range) << 12);
733  break;
734  }
735  case 2:
736  {
737  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
738  range) << 2);
739  q=PopLongPixel(quantum_info->endian,pixel,q);
740  pixel=0;
741  break;
742  }
743  }
744  n++;
745  }
746  p+=(ptrdiff_t) GetPixelChannels(image);
747  q+=(ptrdiff_t) quantum_info->pad;
748  }
749  break;
750  }
751  if (quantum_info->quantum == 32UL)
752  {
753  for (x=0; x < (ssize_t) number_pixels; x++)
754  {
755  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
756  q=PopQuantumLongPixel(quantum_info,pixel,q);
757  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
758  range);
759  q=PopQuantumLongPixel(quantum_info,pixel,q);
760  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
761  q=PopQuantumLongPixel(quantum_info,pixel,q);
762  pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
763  range);
764  q=PopQuantumLongPixel(quantum_info,pixel,q);
765  p+=(ptrdiff_t) GetPixelChannels(image);
766  q+=(ptrdiff_t) quantum_info->pad;
767  }
768  break;
769  }
770  for (x=0; x < (ssize_t) number_pixels; x++)
771  {
772  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
773  q=PopQuantumPixel(quantum_info,pixel,q);
774  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
775  q=PopQuantumPixel(quantum_info,pixel,q);
776  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
777  q=PopQuantumPixel(quantum_info,pixel,q);
778  pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
779  q=PopQuantumPixel(quantum_info,pixel,q);
780  p+=(ptrdiff_t) GetPixelChannels(image);
781  q+=(ptrdiff_t) quantum_info->pad;
782  }
783  break;
784  }
785  case 16:
786  {
787  unsigned short
788  pixel;
789 
790  if (quantum_info->format == FloatingPointQuantumFormat)
791  {
792  for (x=0; x < (ssize_t) number_pixels; x++)
793  {
794  pixel=SinglePrecisionToHalf(QuantumScale*(double)
795  GetPixelBlue(image,p));
796  q=PopShortPixel(quantum_info->endian,pixel,q);
797  pixel=SinglePrecisionToHalf(QuantumScale*(double)
798  GetPixelGreen(image,p));
799  q=PopShortPixel(quantum_info->endian,pixel,q);
800  pixel=SinglePrecisionToHalf(QuantumScale*(double)
801  GetPixelRed(image,p));
802  q=PopShortPixel(quantum_info->endian,pixel,q);
803  pixel=SinglePrecisionToHalf(QuantumScale*(double)
804  GetPixelAlpha(image,p));
805  q=PopShortPixel(quantum_info->endian,pixel,q);
806  p+=(ptrdiff_t) GetPixelChannels(image);
807  q+=(ptrdiff_t) quantum_info->pad;
808  }
809  break;
810  }
811  for (x=0; x < (ssize_t) number_pixels; x++)
812  {
813  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
814  q=PopShortPixel(quantum_info->endian,pixel,q);
815  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
816  q=PopShortPixel(quantum_info->endian,pixel,q);
817  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
818  q=PopShortPixel(quantum_info->endian,pixel,q);
819  pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
820  q=PopShortPixel(quantum_info->endian,pixel,q);
821  p+=(ptrdiff_t) GetPixelChannels(image);
822  q+=(ptrdiff_t) quantum_info->pad;
823  }
824  break;
825  }
826  case 32:
827  {
828  unsigned int
829  pixel;
830 
831  if (quantum_info->format == FloatingPointQuantumFormat)
832  {
833  for (x=0; x < (ssize_t) number_pixels; x++)
834  {
835  float
836  float_pixel;
837 
838  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
839  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
840  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
841  float_pixel=(float) GetPixelAlpha(image,p);
842  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
843  p+=(ptrdiff_t) GetPixelChannels(image);
844  q+=(ptrdiff_t) quantum_info->pad;
845  }
846  break;
847  }
848  for (x=0; x < (ssize_t) number_pixels; x++)
849  {
850  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
851  q=PopLongPixel(quantum_info->endian,pixel,q);
852  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
853  q=PopLongPixel(quantum_info->endian,pixel,q);
854  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
855  q=PopLongPixel(quantum_info->endian,pixel,q);
856  pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
857  q=PopLongPixel(quantum_info->endian,pixel,q);
858  p+=(ptrdiff_t) GetPixelChannels(image);
859  q+=(ptrdiff_t) quantum_info->pad;
860  }
861  break;
862  }
863  case 64:
864  {
865  if (quantum_info->format == FloatingPointQuantumFormat)
866  {
867  double
868  pixel;
869 
870  for (x=0; x < (ssize_t) number_pixels; x++)
871  {
872  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
873  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
874  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
875  pixel=(double) GetPixelAlpha(image,p);
876  q=PopQuantumDoublePixel(quantum_info,pixel,q);
877  p+=(ptrdiff_t) GetPixelChannels(image);
878  q+=(ptrdiff_t) quantum_info->pad;
879  }
880  break;
881  }
882  magick_fallthrough;
883  }
884  default:
885  {
886  range=GetQuantumRange(quantum_info->depth);
887  for (x=0; x < (ssize_t) number_pixels; x++)
888  {
889  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
890  range),q);
891  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
892  range),q);
893  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
894  range),q);
895  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
896  range),q);
897  p+=(ptrdiff_t) GetPixelChannels(image);
898  q+=(ptrdiff_t) quantum_info->pad;
899  }
900  break;
901  }
902  }
903 }
904 
905 static void ExportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
906  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
907  unsigned char *magick_restrict q)
908 {
909  QuantumAny
910  range;
911 
912  ssize_t
913  x;
914 
915  switch (quantum_info->depth)
916  {
917  case 8:
918  {
919  unsigned char
920  pixel;
921 
922  for (x=0; x < (ssize_t) number_pixels; x++)
923  {
924  pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
925  q=PopCharPixel(pixel,q);
926  pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
927  q=PopCharPixel(pixel,q);
928  pixel=ScaleQuantumToChar(GetPixelRed(image,p));
929  q=PopCharPixel(pixel,q);
930  pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
931  q=PopCharPixel(pixel,q);
932  p+=(ptrdiff_t) GetPixelChannels(image);
933  q+=(ptrdiff_t) quantum_info->pad;
934  }
935  break;
936  }
937  case 10:
938  {
939  unsigned int
940  pixel;
941 
942  range=GetQuantumRange(quantum_info->depth);
943  if (quantum_info->pack == MagickFalse)
944  {
945  ssize_t
946  i;
947 
948  size_t
949  quantum;
950 
951  ssize_t
952  n;
953 
954  n=0;
955  quantum=0;
956  pixel=0;
957  for (x=0; x < (ssize_t) number_pixels; x++)
958  {
959  for (i=0; i < 4; i++)
960  {
961  switch (i)
962  {
963  case 0: quantum=(size_t) GetPixelRed(image,p); break;
964  case 1: quantum=(size_t) GetPixelGreen(image,p); break;
965  case 2: quantum=(size_t) GetPixelBlue(image,p); break;
966  case 3: quantum=(size_t) GetPixelOpacity(image,p); break;
967  }
968  switch (n % 3)
969  {
970  case 0:
971  {
972  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
973  range) << 22);
974  break;
975  }
976  case 1:
977  {
978  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
979  range) << 12);
980  break;
981  }
982  case 2:
983  {
984  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
985  range) << 2);
986  q=PopLongPixel(quantum_info->endian,pixel,q);
987  pixel=0;
988  break;
989  }
990  }
991  n++;
992  }
993  p+=(ptrdiff_t) GetPixelChannels(image);
994  q+=(ptrdiff_t) quantum_info->pad;
995  }
996  break;
997  }
998  if (quantum_info->quantum == 32UL)
999  {
1000  for (x=0; x < (ssize_t) number_pixels; x++)
1001  {
1002  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
1003  q=PopQuantumLongPixel(quantum_info,pixel,q);
1004  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
1005  range);
1006  q=PopQuantumLongPixel(quantum_info,pixel,q);
1007  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
1008  q=PopQuantumLongPixel(quantum_info,pixel,q);
1009  pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
1010  range);
1011  q=PopQuantumLongPixel(quantum_info,pixel,q);
1012  p+=(ptrdiff_t) GetPixelChannels(image);
1013  q+=(ptrdiff_t) quantum_info->pad;
1014  }
1015  break;
1016  }
1017  for (x=0; x < (ssize_t) number_pixels; x++)
1018  {
1019  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
1020  q=PopQuantumPixel(quantum_info,pixel,q);
1021  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
1022  q=PopQuantumPixel(quantum_info,pixel,q);
1023  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
1024  q=PopQuantumPixel(quantum_info,pixel,q);
1025  pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
1026  q=PopQuantumPixel(quantum_info,pixel,q);
1027  p+=(ptrdiff_t) GetPixelChannels(image);
1028  q+=(ptrdiff_t) quantum_info->pad;
1029  }
1030  break;
1031  }
1032  case 16:
1033  {
1034  unsigned short
1035  pixel;
1036 
1037  if (quantum_info->format == FloatingPointQuantumFormat)
1038  {
1039  for (x=0; x < (ssize_t) number_pixels; x++)
1040  {
1041  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1042  GetPixelBlue(image,p));
1043  q=PopShortPixel(quantum_info->endian,pixel,q);
1044  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1045  GetPixelGreen(image,p));
1046  q=PopShortPixel(quantum_info->endian,pixel,q);
1047  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1048  GetPixelRed(image,p));
1049  q=PopShortPixel(quantum_info->endian,pixel,q);
1050  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1051  GetPixelOpacity(image,p));
1052  q=PopShortPixel(quantum_info->endian,pixel,q);
1053  p+=(ptrdiff_t) GetPixelChannels(image);
1054  q+=(ptrdiff_t) quantum_info->pad;
1055  }
1056  break;
1057  }
1058  for (x=0; x < (ssize_t) number_pixels; x++)
1059  {
1060  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1061  q=PopShortPixel(quantum_info->endian,pixel,q);
1062  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1063  q=PopShortPixel(quantum_info->endian,pixel,q);
1064  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1065  q=PopShortPixel(quantum_info->endian,pixel,q);
1066  pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
1067  q=PopShortPixel(quantum_info->endian,pixel,q);
1068  p+=(ptrdiff_t) GetPixelChannels(image);
1069  q+=(ptrdiff_t) quantum_info->pad;
1070  }
1071  break;
1072  }
1073  case 32:
1074  {
1075  unsigned int
1076  pixel;
1077 
1078  if (quantum_info->format == FloatingPointQuantumFormat)
1079  {
1080  for (x=0; x < (ssize_t) number_pixels; x++)
1081  {
1082  float
1083  float_pixel;
1084 
1085  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
1086  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
1087  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
1088  float_pixel=(float) GetPixelOpacity(image,p);
1089  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1090  p+=(ptrdiff_t) GetPixelChannels(image);
1091  q+=(ptrdiff_t) quantum_info->pad;
1092  }
1093  break;
1094  }
1095  for (x=0; x < (ssize_t) number_pixels; x++)
1096  {
1097  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1098  q=PopLongPixel(quantum_info->endian,pixel,q);
1099  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1100  q=PopLongPixel(quantum_info->endian,pixel,q);
1101  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1102  q=PopLongPixel(quantum_info->endian,pixel,q);
1103  pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
1104  q=PopLongPixel(quantum_info->endian,pixel,q);
1105  p+=(ptrdiff_t) GetPixelChannels(image);
1106  q+=(ptrdiff_t) quantum_info->pad;
1107  }
1108  break;
1109  }
1110  case 64:
1111  {
1112  if (quantum_info->format == FloatingPointQuantumFormat)
1113  {
1114  double
1115  pixel;
1116 
1117  for (x=0; x < (ssize_t) number_pixels; x++)
1118  {
1119  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
1120  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
1121  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
1122  pixel=(double) GetPixelOpacity(image,p);
1123  q=PopQuantumDoublePixel(quantum_info,pixel,q);
1124  p+=(ptrdiff_t) GetPixelChannels(image);
1125  q+=(ptrdiff_t) quantum_info->pad;
1126  }
1127  break;
1128  }
1129  magick_fallthrough;
1130  }
1131  default:
1132  {
1133  range=GetQuantumRange(quantum_info->depth);
1134  for (x=0; x < (ssize_t) number_pixels; x++)
1135  {
1136  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1137  range),q);
1138  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1139  range),q);
1140  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1141  range),q);
1142  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
1143  range),q);
1144  p+=(ptrdiff_t) GetPixelChannels(image);
1145  q+=(ptrdiff_t) quantum_info->pad;
1146  }
1147  break;
1148  }
1149  }
1150 }
1151 
1152 static void ExportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
1153  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1154  unsigned char *magick_restrict q,ExceptionInfo *exception)
1155 {
1156  if (image->colorspace != CMYKColorspace)
1157  {
1158  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1159  "ColorSeparatedImageRequired","`%s'",image->filename);
1160  return;
1161  }
1162  ExportPixelChannel(image,quantum_info,number_pixels,p,q,BlackPixelChannel);
1163 }
1164 
1165 static void ExportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
1166  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1167  unsigned char *magick_restrict q)
1168 {
1169  Quantum
1170  cbcr[4];
1171 
1172  ssize_t
1173  i,
1174  x;
1175 
1176  unsigned int
1177  pixel;
1178 
1179  size_t
1180  quantum;
1181 
1182  ssize_t
1183  n;
1184 
1185  n=0;
1186  quantum=0;
1187  switch (quantum_info->depth)
1188  {
1189  case 10:
1190  {
1191  if (quantum_info->pack == MagickFalse)
1192  {
1193  for (x=0; x < (ssize_t) number_pixels; x+=2)
1194  {
1195  for (i=0; i < 4; i++)
1196  {
1197  switch (n % 3)
1198  {
1199  case 0:
1200  {
1201  quantum=(size_t) GetPixelRed(image,p);
1202  break;
1203  }
1204  case 1:
1205  {
1206  quantum=(size_t) GetPixelGreen(image,p);
1207  break;
1208  }
1209  case 2:
1210  {
1211  quantum=(size_t) GetPixelBlue(image,p);
1212  break;
1213  }
1214  }
1215  cbcr[i]=(Quantum) quantum;
1216  n++;
1217  }
1218  pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
1219  (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
1220  q=PopLongPixel(quantum_info->endian,pixel,q);
1221  p+=(ptrdiff_t) GetPixelChannels(image);
1222  pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
1223  (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
1224  q=PopLongPixel(quantum_info->endian,pixel,q);
1225  p+=(ptrdiff_t) GetPixelChannels(image);
1226  q+=(ptrdiff_t) quantum_info->pad;
1227  }
1228  break;
1229  }
1230  break;
1231  }
1232  default:
1233  {
1234  QuantumAny
1235  range;
1236 
1237  for (x=0; x < (ssize_t) number_pixels; x+=2)
1238  {
1239  for (i=0; i < 4; i++)
1240  {
1241  switch (n % 3)
1242  {
1243  case 0:
1244  {
1245  quantum=(size_t) GetPixelRed(image,p);
1246  break;
1247  }
1248  case 1:
1249  {
1250  quantum=(size_t) GetPixelGreen(image,p);
1251  break;
1252  }
1253  case 2:
1254  {
1255  quantum=(size_t) GetPixelBlue(image,p);
1256  break;
1257  }
1258  }
1259  cbcr[i]=(Quantum) quantum;
1260  n++;
1261  }
1262  range=GetQuantumRange(quantum_info->depth);
1263  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[1],range),q);
1264  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
1265  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
1266  p+=(ptrdiff_t) GetPixelChannels(image);
1267  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[3],range),q);
1268  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
1269  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
1270  p+=(ptrdiff_t) GetPixelChannels(image);
1271  q+=(ptrdiff_t) quantum_info->pad;
1272  }
1273  break;
1274  }
1275  }
1276 }
1277 
1278 static void ExportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
1279  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1280  unsigned char *magick_restrict q,ExceptionInfo *exception)
1281 {
1282  ssize_t
1283  x;
1284 
1285  if (image->colorspace != CMYKColorspace)
1286  {
1287  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1288  "ColorSeparatedImageRequired","`%s'",image->filename);
1289  return;
1290  }
1291  switch (quantum_info->depth)
1292  {
1293  case 8:
1294  {
1295  unsigned char
1296  pixel;
1297 
1298  for (x=0; x < (ssize_t) number_pixels; x++)
1299  {
1300  pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1301  q=PopCharPixel(pixel,q);
1302  pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1303  q=PopCharPixel(pixel,q);
1304  pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1305  q=PopCharPixel(pixel,q);
1306  pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1307  q=PopCharPixel(pixel,q);
1308  p+=(ptrdiff_t) GetPixelChannels(image);
1309  q+=(ptrdiff_t) quantum_info->pad;
1310  }
1311  break;
1312  }
1313  case 16:
1314  {
1315  unsigned short
1316  pixel;
1317 
1318  if (quantum_info->format == FloatingPointQuantumFormat)
1319  {
1320  for (x=0; x < (ssize_t) number_pixels; x++)
1321  {
1322  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1323  GetPixelRed(image,p));
1324  q=PopShortPixel(quantum_info->endian,pixel,q);
1325  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1326  GetPixelGreen(image,p));
1327  q=PopShortPixel(quantum_info->endian,pixel,q);
1328  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1329  GetPixelBlue(image,p));
1330  q=PopShortPixel(quantum_info->endian,pixel,q);
1331  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1332  GetPixelBlack(image,p));
1333  q=PopShortPixel(quantum_info->endian,pixel,q);
1334  p+=(ptrdiff_t) GetPixelChannels(image);
1335  q+=(ptrdiff_t) quantum_info->pad;
1336  }
1337  break;
1338  }
1339  for (x=0; x < (ssize_t) number_pixels; x++)
1340  {
1341  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1342  q=PopShortPixel(quantum_info->endian,pixel,q);
1343  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1344  q=PopShortPixel(quantum_info->endian,pixel,q);
1345  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1346  q=PopShortPixel(quantum_info->endian,pixel,q);
1347  pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1348  q=PopShortPixel(quantum_info->endian,pixel,q);
1349  p+=(ptrdiff_t) GetPixelChannels(image);
1350  q+=(ptrdiff_t) quantum_info->pad;
1351  }
1352  break;
1353  }
1354  case 32:
1355  {
1356  unsigned int
1357  pixel;
1358 
1359  if (quantum_info->format == FloatingPointQuantumFormat)
1360  {
1361  for (x=0; x < (ssize_t) number_pixels; x++)
1362  {
1363  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),
1364  q);
1365  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
1366  q);
1367  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
1368  q);
1369  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlack(image,p),
1370  q);
1371  p+=(ptrdiff_t) GetPixelChannels(image);
1372  q+=(ptrdiff_t) quantum_info->pad;
1373  }
1374  break;
1375  }
1376  for (x=0; x < (ssize_t) number_pixels; x++)
1377  {
1378  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1379  q=PopLongPixel(quantum_info->endian,pixel,q);
1380  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1381  q=PopLongPixel(quantum_info->endian,pixel,q);
1382  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1383  q=PopLongPixel(quantum_info->endian,pixel,q);
1384  pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1385  q=PopLongPixel(quantum_info->endian,pixel,q);
1386  p+=(ptrdiff_t) GetPixelChannels(image);
1387  q+=(ptrdiff_t) quantum_info->pad;
1388  }
1389  break;
1390  }
1391  case 64:
1392  {
1393  if (quantum_info->format == FloatingPointQuantumFormat)
1394  {
1395  for (x=0; x < (ssize_t) number_pixels; x++)
1396  {
1397  q=PopQuantumDoublePixel(quantum_info,(double)
1398  GetPixelRed(image,p),q);
1399  q=PopQuantumDoublePixel(quantum_info,(double)
1400  GetPixelGreen(image,p),q);
1401  q=PopQuantumDoublePixel(quantum_info,(double)
1402  GetPixelBlue(image,p),q);
1403  q=PopQuantumDoublePixel(quantum_info,(double)
1404  GetPixelBlack(image,p),q);
1405  p+=(ptrdiff_t) GetPixelChannels(image);
1406  q+=(ptrdiff_t) quantum_info->pad;
1407  }
1408  break;
1409  }
1410  magick_fallthrough;
1411  }
1412  default:
1413  {
1414  QuantumAny
1415  range;
1416 
1417  range=GetQuantumRange(quantum_info->depth);
1418  for (x=0; x < (ssize_t) number_pixels; x++)
1419  {
1420  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1421  range),q);
1422  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1423  range),q);
1424  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1425  range),q);
1426  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1427  range),q);
1428  p+=(ptrdiff_t) GetPixelChannels(image);
1429  q+=(ptrdiff_t) quantum_info->pad;
1430  }
1431  break;
1432  }
1433  }
1434 }
1435 
1436 static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
1437  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1438  unsigned char *magick_restrict q,ExceptionInfo *exception)
1439 {
1440  ssize_t
1441  x;
1442 
1443  if (image->colorspace != CMYKColorspace)
1444  {
1445  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1446  "ColorSeparatedImageRequired","`%s'",image->filename);
1447  return;
1448  }
1449  switch (quantum_info->depth)
1450  {
1451  case 8:
1452  {
1453  unsigned char
1454  pixel;
1455 
1456  for (x=0; x < (ssize_t) number_pixels; x++)
1457  {
1458  pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1459  q=PopCharPixel(pixel,q);
1460  pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1461  q=PopCharPixel(pixel,q);
1462  pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1463  q=PopCharPixel(pixel,q);
1464  pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1465  q=PopCharPixel(pixel,q);
1466  pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
1467  q=PopCharPixel(pixel,q);
1468  p+=(ptrdiff_t) GetPixelChannels(image);
1469  q+=(ptrdiff_t) quantum_info->pad;
1470  }
1471  break;
1472  }
1473  case 16:
1474  {
1475  unsigned short
1476  pixel;
1477 
1478  if (quantum_info->format == FloatingPointQuantumFormat)
1479  {
1480  for (x=0; x < (ssize_t) number_pixels; x++)
1481  {
1482  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1483  GetPixelRed(image,p));
1484  q=PopShortPixel(quantum_info->endian,pixel,q);
1485  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1486  GetPixelGreen(image,p));
1487  q=PopShortPixel(quantum_info->endian,pixel,q);
1488  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1489  GetPixelBlue(image,p));
1490  q=PopShortPixel(quantum_info->endian,pixel,q);
1491  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1492  GetPixelBlack(image,p));
1493  q=PopShortPixel(quantum_info->endian,pixel,q);
1494  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1495  GetPixelAlpha(image,p));
1496  q=PopShortPixel(quantum_info->endian,pixel,q);
1497  p+=(ptrdiff_t) GetPixelChannels(image);
1498  q+=(ptrdiff_t) quantum_info->pad;
1499  }
1500  break;
1501  }
1502  for (x=0; x < (ssize_t) number_pixels; x++)
1503  {
1504  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1505  q=PopShortPixel(quantum_info->endian,pixel,q);
1506  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1507  q=PopShortPixel(quantum_info->endian,pixel,q);
1508  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1509  q=PopShortPixel(quantum_info->endian,pixel,q);
1510  pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1511  q=PopShortPixel(quantum_info->endian,pixel,q);
1512  pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
1513  q=PopShortPixel(quantum_info->endian,pixel,q);
1514  p+=(ptrdiff_t) GetPixelChannels(image);
1515  q+=(ptrdiff_t) quantum_info->pad;
1516  }
1517  break;
1518  }
1519  case 32:
1520  {
1521  unsigned int
1522  pixel;
1523 
1524  if (quantum_info->format == FloatingPointQuantumFormat)
1525  {
1526  for (x=0; x < (ssize_t) number_pixels; x++)
1527  {
1528  q=PopQuantumFloatPixel(quantum_info,(float)
1529  GetPixelRed(image,p),q);
1530  q=PopQuantumFloatPixel(quantum_info,(float)
1531  GetPixelGreen(image,p),q);
1532  q=PopQuantumFloatPixel(quantum_info,(float)
1533  GetPixelBlue(image,p),q);
1534  q=PopQuantumFloatPixel(quantum_info,(float)
1535  GetPixelBlack(image,p),q);
1536  q=PopQuantumFloatPixel(quantum_info,(float)
1537  GetPixelAlpha(image,p),q);
1538  p+=(ptrdiff_t) GetPixelChannels(image);
1539  q+=(ptrdiff_t) quantum_info->pad;
1540  }
1541  break;
1542  }
1543  for (x=0; x < (ssize_t) number_pixels; x++)
1544  {
1545  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1546  q=PopLongPixel(quantum_info->endian,pixel,q);
1547  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1548  q=PopLongPixel(quantum_info->endian,pixel,q);
1549  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1550  q=PopLongPixel(quantum_info->endian,pixel,q);
1551  pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1552  q=PopLongPixel(quantum_info->endian,pixel,q);
1553  pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
1554  q=PopLongPixel(quantum_info->endian,pixel,q);
1555  p+=(ptrdiff_t) GetPixelChannels(image);
1556  q+=(ptrdiff_t) quantum_info->pad;
1557  }
1558  break;
1559  }
1560  case 64:
1561  {
1562  if (quantum_info->format == FloatingPointQuantumFormat)
1563  {
1564  for (x=0; x < (ssize_t) number_pixels; x++)
1565  {
1566  q=PopQuantumDoublePixel(quantum_info,(double)
1567  GetPixelRed(image,p),q);
1568  q=PopQuantumDoublePixel(quantum_info,(double)
1569  GetPixelGreen(image,p),q);
1570  q=PopQuantumDoublePixel(quantum_info,(double)
1571  GetPixelBlue(image,p),q);
1572  q=PopQuantumDoublePixel(quantum_info,(double)
1573  GetPixelBlack(image,p),q);
1574  q=PopQuantumDoublePixel(quantum_info,(double)
1575  GetPixelAlpha(image,p),q);
1576  p+=(ptrdiff_t) GetPixelChannels(image);
1577  q+=(ptrdiff_t) quantum_info->pad;
1578  }
1579  break;
1580  }
1581  magick_fallthrough;
1582  }
1583  default:
1584  {
1585  QuantumAny
1586  range;
1587 
1588  range=GetQuantumRange(quantum_info->depth);
1589  for (x=0; x < (ssize_t) number_pixels; x++)
1590  {
1591  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1592  range),q);
1593  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1594  range),q);
1595  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1596  range),q);
1597  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1598  range),q);
1599  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
1600  range),q);
1601  p+=(ptrdiff_t) GetPixelChannels(image);
1602  q+=(ptrdiff_t) quantum_info->pad;
1603  }
1604  break;
1605  }
1606  }
1607 }
1608 
1609 static void ExportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
1610  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1611  unsigned char *magick_restrict q,ExceptionInfo *exception)
1612 {
1613  ssize_t
1614  x;
1615 
1616  if (image->colorspace != CMYKColorspace)
1617  {
1618  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1619  "ColorSeparatedImageRequired","`%s'",image->filename);
1620  return;
1621  }
1622  switch (quantum_info->depth)
1623  {
1624  case 8:
1625  {
1626  unsigned char
1627  pixel;
1628 
1629  for (x=0; x < (ssize_t) number_pixels; x++)
1630  {
1631  pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1632  q=PopCharPixel(pixel,q);
1633  pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1634  q=PopCharPixel(pixel,q);
1635  pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1636  q=PopCharPixel(pixel,q);
1637  pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1638  q=PopCharPixel(pixel,q);
1639  pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
1640  q=PopCharPixel(pixel,q);
1641  p+=(ptrdiff_t) GetPixelChannels(image);
1642  q+=(ptrdiff_t) quantum_info->pad;
1643  }
1644  break;
1645  }
1646  case 16:
1647  {
1648  unsigned short
1649  pixel;
1650 
1651  if (quantum_info->format == FloatingPointQuantumFormat)
1652  {
1653  for (x=0; x < (ssize_t) number_pixels; x++)
1654  {
1655  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1656  GetPixelRed(image,p));
1657  q=PopShortPixel(quantum_info->endian,pixel,q);
1658  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1659  GetPixelGreen(image,p));
1660  q=PopShortPixel(quantum_info->endian,pixel,q);
1661  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1662  GetPixelBlue(image,p));
1663  q=PopShortPixel(quantum_info->endian,pixel,q);
1664  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1665  GetPixelBlack(image,p));
1666  q=PopShortPixel(quantum_info->endian,pixel,q);
1667  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1668  GetPixelOpacity(image,p));
1669  q=PopShortPixel(quantum_info->endian,pixel,q);
1670  p+=(ptrdiff_t) GetPixelChannels(image);
1671  q+=(ptrdiff_t) quantum_info->pad;
1672  }
1673  break;
1674  }
1675  for (x=0; x < (ssize_t) number_pixels; x++)
1676  {
1677  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1678  q=PopShortPixel(quantum_info->endian,pixel,q);
1679  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1680  q=PopShortPixel(quantum_info->endian,pixel,q);
1681  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1682  q=PopShortPixel(quantum_info->endian,pixel,q);
1683  pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1684  q=PopShortPixel(quantum_info->endian,pixel,q);
1685  pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
1686  q=PopShortPixel(quantum_info->endian,pixel,q);
1687  p+=(ptrdiff_t) GetPixelChannels(image);
1688  q+=(ptrdiff_t) quantum_info->pad;
1689  }
1690  break;
1691  }
1692  case 32:
1693  {
1694  unsigned int
1695  pixel;
1696 
1697  if (quantum_info->format == FloatingPointQuantumFormat)
1698  {
1699  for (x=0; x < (ssize_t) number_pixels; x++)
1700  {
1701  float
1702  float_pixel;
1703 
1704  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
1705  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
1706  q);
1707  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
1708  q);
1709  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlack(image,p),
1710  q);
1711  float_pixel=(float) (GetPixelOpacity(image,p));
1712  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1713  p+=(ptrdiff_t) GetPixelChannels(image);
1714  q+=(ptrdiff_t) quantum_info->pad;
1715  }
1716  break;
1717  }
1718  for (x=0; x < (ssize_t) number_pixels; x++)
1719  {
1720  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1721  q=PopLongPixel(quantum_info->endian,pixel,q);
1722  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1723  q=PopLongPixel(quantum_info->endian,pixel,q);
1724  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1725  q=PopLongPixel(quantum_info->endian,pixel,q);
1726  pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1727  q=PopLongPixel(quantum_info->endian,pixel,q);
1728  pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
1729  q=PopLongPixel(quantum_info->endian,pixel,q);
1730  p+=(ptrdiff_t) GetPixelChannels(image);
1731  q+=(ptrdiff_t) quantum_info->pad;
1732  }
1733  break;
1734  }
1735  case 64:
1736  {
1737  if (quantum_info->format == FloatingPointQuantumFormat)
1738  {
1739  double
1740  pixel;
1741 
1742  for (x=0; x < (ssize_t) number_pixels; x++)
1743  {
1744  q=PopQuantumDoublePixel(quantum_info,(double)
1745  GetPixelRed(image,p),q);
1746  q=PopQuantumDoublePixel(quantum_info,(double)
1747  GetPixelGreen(image,p),q);
1748  q=PopQuantumDoublePixel(quantum_info,(double)
1749  GetPixelBlue(image,p),q);
1750  q=PopQuantumDoublePixel(quantum_info,(double)
1751  GetPixelBlack(image,p),q);
1752  pixel=(double) (GetPixelOpacity(image,p));
1753  q=PopQuantumDoublePixel(quantum_info,pixel,q);
1754  p+=(ptrdiff_t) GetPixelChannels(image);
1755  q+=(ptrdiff_t) quantum_info->pad;
1756  }
1757  break;
1758  }
1759  magick_fallthrough;
1760  }
1761  default:
1762  {
1763  QuantumAny
1764  range;
1765 
1766  range=GetQuantumRange(quantum_info->depth);
1767  for (x=0; x < (ssize_t) number_pixels; x++)
1768  {
1769  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1770  range),q);
1771  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1772  range),q);
1773  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1774  range),q);
1775  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1776  range),q);
1777  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
1778  GetPixelOpacity(image,p),range),q);
1779  p+=(ptrdiff_t) GetPixelChannels(image);
1780  q+=(ptrdiff_t) quantum_info->pad;
1781  }
1782  break;
1783  }
1784  }
1785 }
1786 
1787 static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
1788  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
1789  unsigned char *magick_restrict q)
1790 {
1791  QuantumAny
1792  range;
1793 
1794  ssize_t
1795  x;
1796 
1797  switch (quantum_info->depth)
1798  {
1799  case 1:
1800  {
1801  double
1802  threshold;
1803 
1804  unsigned char
1805  black,
1806  white;
1807 
1808  ssize_t
1809  bit;
1810 
1811  black=0x00;
1812  white=0x01;
1813  if (quantum_info->min_is_white != MagickFalse)
1814  {
1815  black=0x01;
1816  white=0x00;
1817  }
1818  threshold=(double) QuantumRange/2.0;
1819  for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1820  {
1821  *q='\0';
1822  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
1823  p+=(ptrdiff_t) GetPixelChannels(image);
1824  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
1825  p+=(ptrdiff_t) GetPixelChannels(image);
1826  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
1827  p+=(ptrdiff_t) GetPixelChannels(image);
1828  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
1829  p+=(ptrdiff_t) GetPixelChannels(image);
1830  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
1831  p+=(ptrdiff_t) GetPixelChannels(image);
1832  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
1833  p+=(ptrdiff_t) GetPixelChannels(image);
1834  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
1835  p+=(ptrdiff_t) GetPixelChannels(image);
1836  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
1837  p+=(ptrdiff_t) GetPixelChannels(image);
1838  q++;
1839  }
1840  if ((number_pixels % 8) != 0)
1841  {
1842  *q='\0';
1843  for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1844  {
1845  *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
1846  p+=(ptrdiff_t) GetPixelChannels(image);
1847  }
1848  q++;
1849  }
1850  break;
1851  }
1852  case 4:
1853  {
1854  unsigned char
1855  pixel;
1856 
1857  for (x=0; x < ((ssize_t) number_pixels-1) ; x+=2)
1858  {
1859  pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1860  *q=(((pixel >> 4) & 0xf) << 4);
1861  p+=(ptrdiff_t) GetPixelChannels(image);
1862  pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1863  *q|=pixel >> 4;
1864  p+=(ptrdiff_t) GetPixelChannels(image);
1865  q++;
1866  }
1867  if ((number_pixels % 2) != 0)
1868  {
1869  pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1870  *q=(((pixel >> 4) & 0xf) << 4);
1871  p+=(ptrdiff_t) GetPixelChannels(image);
1872  q++;
1873  }
1874  break;
1875  }
1876  case 8:
1877  {
1878  unsigned char
1879  pixel;
1880 
1881  for (x=0; x < (ssize_t) number_pixels; x++)
1882  {
1883  pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1884  q=PopCharPixel(pixel,q);
1885  p+=(ptrdiff_t) GetPixelChannels(image);
1886  q+=(ptrdiff_t) quantum_info->pad;
1887  }
1888  break;
1889  }
1890  case 10:
1891  {
1892  range=GetQuantumRange(quantum_info->depth);
1893  if (quantum_info->pack == MagickFalse)
1894  {
1895  unsigned int
1896  pixel;
1897 
1898  for (x=0; x < ((ssize_t) number_pixels-2); x+=3)
1899  {
1900  pixel=(unsigned int) (ScaleQuantumToAny(ClampToQuantum(
1901  GetPixelLuma(image,p+2*GetPixelChannels(image))),range) << 22 |
1902  ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
1903  GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
1904  ClampToQuantum(GetPixelLuma(image,p)),range) << 2);
1905  q=PopLongPixel(quantum_info->endian,pixel,q);
1906  p+=(ptrdiff_t) 3*GetPixelChannels(image);
1907  q+=(ptrdiff_t) quantum_info->pad;
1908  }
1909  if (x < (ssize_t) number_pixels)
1910  {
1911  pixel=0U;
1912  if (x++ < ((ssize_t) number_pixels-1))
1913  pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
1914  GetPixelChannels(image))),range) << 12;
1915  if (x++ < (ssize_t) number_pixels)
1916  pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),
1917  range) << 2;
1918  q=PopLongPixel(quantum_info->endian,pixel,q);
1919  }
1920  break;
1921  }
1922  for (x=0; x < (ssize_t) number_pixels; x++)
1923  {
1924  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
1925  GetPixelLuma(image,p)),range),q);
1926  p+=(ptrdiff_t) GetPixelChannels(image);
1927  q+=(ptrdiff_t) quantum_info->pad;
1928  }
1929  break;
1930  }
1931  case 12:
1932  {
1933  unsigned short
1934  pixel;
1935 
1936  range=GetQuantumRange(quantum_info->depth);
1937  if (quantum_info->pack == MagickFalse)
1938  {
1939  for (x=0; x < (ssize_t) number_pixels; x++)
1940  {
1941  pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
1942  q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel >> 4),
1943  q);
1944  p+=(ptrdiff_t) GetPixelChannels(image);
1945  q+=(ptrdiff_t) quantum_info->pad;
1946  }
1947  break;
1948  }
1949  for (x=0; x < (ssize_t) number_pixels; x++)
1950  {
1951  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
1952  GetPixelLuma(image,p)),range),q);
1953  p+=(ptrdiff_t) GetPixelChannels(image);
1954  q+=(ptrdiff_t) quantum_info->pad;
1955  }
1956  break;
1957  }
1958  case 16:
1959  {
1960  unsigned short
1961  pixel;
1962 
1963  if (quantum_info->format == FloatingPointQuantumFormat)
1964  {
1965  for (x=0; x < (ssize_t) number_pixels; x++)
1966  {
1967  pixel=SinglePrecisionToHalf(QuantumScale*(double)
1968  GetPixelLuma(image,p));
1969  q=PopShortPixel(quantum_info->endian,pixel,q);
1970  p+=(ptrdiff_t) GetPixelChannels(image);
1971  q+=(ptrdiff_t) quantum_info->pad;
1972  }
1973  break;
1974  }
1975  for (x=0; x < (ssize_t) number_pixels; x++)
1976  {
1977  pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
1978  q=PopShortPixel(quantum_info->endian,pixel,q);
1979  p+=(ptrdiff_t) GetPixelChannels(image);
1980  q+=(ptrdiff_t) quantum_info->pad;
1981  }
1982  break;
1983  }
1984  case 32:
1985  {
1986  unsigned int
1987  pixel;
1988 
1989  if (quantum_info->format == FloatingPointQuantumFormat)
1990  {
1991  for (x=0; x < (ssize_t) number_pixels; x++)
1992  {
1993  float
1994  float_pixel;
1995 
1996  float_pixel=(float) GetPixelLuma(image,p);
1997  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1998  p+=(ptrdiff_t) GetPixelChannels(image);
1999  q+=(ptrdiff_t) quantum_info->pad;
2000  }
2001  break;
2002  }
2003  for (x=0; x < (ssize_t) number_pixels; x++)
2004  {
2005  pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2006  q=PopLongPixel(quantum_info->endian,pixel,q);
2007  p+=(ptrdiff_t) GetPixelChannels(image);
2008  q+=(ptrdiff_t) quantum_info->pad;
2009  }
2010  break;
2011  }
2012  case 64:
2013  {
2014  if (quantum_info->format == FloatingPointQuantumFormat)
2015  {
2016  for (x=0; x < (ssize_t) number_pixels; x++)
2017  {
2018  double
2019  pixel;
2020 
2021  pixel=GetPixelLuma(image,p);
2022  q=PopQuantumDoublePixel(quantum_info,pixel,q);
2023  p+=(ptrdiff_t) GetPixelChannels(image);
2024  q+=(ptrdiff_t) quantum_info->pad;
2025  }
2026  break;
2027  }
2028  magick_fallthrough;
2029  }
2030  default:
2031  {
2032  range=GetQuantumRange(quantum_info->depth);
2033  for (x=0; x < (ssize_t) number_pixels; x++)
2034  {
2035  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2036  GetPixelLuma(image,p)),range),q);
2037  p+=(ptrdiff_t) GetPixelChannels(image);
2038  q+=(ptrdiff_t) quantum_info->pad;
2039  }
2040  break;
2041  }
2042  }
2043 }
2044 
2045 static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
2046  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2047  unsigned char *magick_restrict q)
2048 {
2049  QuantumAny
2050  range;
2051 
2052  ssize_t
2053  x;
2054 
2055  switch (quantum_info->depth)
2056  {
2057  case 1:
2058  {
2059  double
2060  threshold;
2061 
2062  unsigned char
2063  black,
2064  pixel,
2065  white;
2066 
2067  ssize_t
2068  bit;
2069 
2070  black=0x00;
2071  white=0x01;
2072  if (quantum_info->min_is_white != MagickFalse)
2073  {
2074  black=0x01;
2075  white=0x00;
2076  }
2077  threshold=(double) QuantumRange/2.0;
2078  for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2079  {
2080  *q='\0';
2081  *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
2082  pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2083  0x00 : 0x01);
2084  *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
2085  p+=(ptrdiff_t) GetPixelChannels(image);
2086  *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
2087  pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2088  0x00 : 0x01);
2089  *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
2090  p+=(ptrdiff_t) GetPixelChannels(image);
2091  *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
2092  pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2093  0x00 : 0x01);
2094  *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
2095  p+=(ptrdiff_t) GetPixelChannels(image);
2096  *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
2097  pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2098  0x00 : 0x01);
2099  *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
2100  p+=(ptrdiff_t) GetPixelChannels(image);
2101  q++;
2102  }
2103  if ((number_pixels % 4) != 0)
2104  {
2105  *q='\0';
2106  for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
2107  {
2108  *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
2109  (7-bit);
2110  pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2111  0x00 : 0x01);
2112  *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
2113  (7-bit-1));
2114  p+=(ptrdiff_t) GetPixelChannels(image);
2115  }
2116  q++;
2117  }
2118  break;
2119  }
2120  case 4:
2121  {
2122  unsigned char
2123  pixel;
2124 
2125  for (x=0; x < (ssize_t) number_pixels ; x++)
2126  {
2127  pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2128  *q=(((pixel >> 4) & 0xf) << 4);
2129  pixel=(unsigned char) (16.0*QuantumScale*(double)
2130  GetPixelAlpha(image,p)+0.5);
2131  *q|=pixel & 0xf;
2132  p+=(ptrdiff_t) GetPixelChannels(image);
2133  q++;
2134  }
2135  break;
2136  }
2137  case 8:
2138  {
2139  unsigned char
2140  pixel;
2141 
2142  for (x=0; x < (ssize_t) number_pixels; x++)
2143  {
2144  pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2145  q=PopCharPixel(pixel,q);
2146  pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2147  q=PopCharPixel(pixel,q);
2148  p+=(ptrdiff_t) GetPixelChannels(image);
2149  q+=(ptrdiff_t) quantum_info->pad;
2150  }
2151  break;
2152  }
2153  case 16:
2154  {
2155  unsigned short
2156  pixel;
2157 
2158  if (quantum_info->format == FloatingPointQuantumFormat)
2159  {
2160  for (x=0; x < (ssize_t) number_pixels; x++)
2161  {
2162  pixel=SinglePrecisionToHalf(QuantumScale*(double)
2163  GetPixelLuma(image,p));
2164  q=PopShortPixel(quantum_info->endian,pixel,q);
2165  pixel=SinglePrecisionToHalf(QuantumScale*(double)
2166  GetPixelAlpha(image,p));
2167  q=PopShortPixel(quantum_info->endian,pixel,q);
2168  p+=(ptrdiff_t) GetPixelChannels(image);
2169  q+=(ptrdiff_t) quantum_info->pad;
2170  }
2171  break;
2172  }
2173  for (x=0; x < (ssize_t) number_pixels; x++)
2174  {
2175  pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2176  q=PopShortPixel(quantum_info->endian,pixel,q);
2177  pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2178  q=PopShortPixel(quantum_info->endian,pixel,q);
2179  p+=(ptrdiff_t) GetPixelChannels(image);
2180  q+=(ptrdiff_t) quantum_info->pad;
2181  }
2182  break;
2183  }
2184  case 32:
2185  {
2186  unsigned int
2187  pixel;
2188 
2189  if (quantum_info->format == FloatingPointQuantumFormat)
2190  {
2191  for (x=0; x < (ssize_t) number_pixels; x++)
2192  {
2193  float
2194  float_pixel;
2195 
2196  float_pixel=(float) GetPixelLuma(image,p);
2197  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2198  float_pixel=(float) (GetPixelAlpha(image,p));
2199  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2200  p+=(ptrdiff_t) GetPixelChannels(image);
2201  q+=(ptrdiff_t) quantum_info->pad;
2202  }
2203  break;
2204  }
2205  for (x=0; x < (ssize_t) number_pixels; x++)
2206  {
2207  pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2208  q=PopLongPixel(quantum_info->endian,pixel,q);
2209  pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2210  q=PopLongPixel(quantum_info->endian,pixel,q);
2211  p+=(ptrdiff_t) GetPixelChannels(image);
2212  q+=(ptrdiff_t) quantum_info->pad;
2213  }
2214  break;
2215  }
2216  case 64:
2217  {
2218  if (quantum_info->format == FloatingPointQuantumFormat)
2219  {
2220  for (x=0; x < (ssize_t) number_pixels; x++)
2221  {
2222  double
2223  pixel;
2224 
2225  pixel=GetPixelLuma(image,p);
2226  q=PopQuantumDoublePixel(quantum_info,pixel,q);
2227  pixel=(double) (GetPixelAlpha(image,p));
2228  q=PopQuantumDoublePixel(quantum_info,pixel,q);
2229  p+=(ptrdiff_t) GetPixelChannels(image);
2230  q+=(ptrdiff_t) quantum_info->pad;
2231  }
2232  break;
2233  }
2234  magick_fallthrough;
2235  }
2236  default:
2237  {
2238  range=GetQuantumRange(quantum_info->depth);
2239  for (x=0; x < (ssize_t) number_pixels; x++)
2240  {
2241  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2242  GetPixelLuma(image,p)),range),q);
2243  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2244  range),q);
2245  p+=(ptrdiff_t) GetPixelChannels(image);
2246  q+=(ptrdiff_t) quantum_info->pad;
2247  }
2248  break;
2249  }
2250  }
2251 }
2252 
2253 static void ExportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
2254  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2255  unsigned char *magick_restrict q,ExceptionInfo *exception)
2256 {
2257  ssize_t
2258  x;
2259 
2260  ssize_t
2261  bit;
2262 
2263  if (image->storage_class != PseudoClass)
2264  {
2265  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2266  "ColormappedImageRequired","`%s'",image->filename);
2267  return;
2268  }
2269  switch (quantum_info->depth)
2270  {
2271  case 1:
2272  {
2273  unsigned char
2274  pixel;
2275 
2276  for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
2277  {
2278  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2279  *q=((pixel & 0x01) << 7);
2280  p+=(ptrdiff_t) GetPixelChannels(image);
2281  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2282  *q|=((pixel & 0x01) << 6);
2283  p+=(ptrdiff_t) GetPixelChannels(image);
2284  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2285  *q|=((pixel & 0x01) << 5);
2286  p+=(ptrdiff_t) GetPixelChannels(image);
2287  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2288  *q|=((pixel & 0x01) << 4);
2289  p+=(ptrdiff_t) GetPixelChannels(image);
2290  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2291  *q|=((pixel & 0x01) << 3);
2292  p+=(ptrdiff_t) GetPixelChannels(image);
2293  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2294  *q|=((pixel & 0x01) << 2);
2295  p+=(ptrdiff_t) GetPixelChannels(image);
2296  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2297  *q|=((pixel & 0x01) << 1);
2298  p+=(ptrdiff_t) GetPixelChannels(image);
2299  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2300  *q|=((pixel & 0x01) << 0);
2301  p+=(ptrdiff_t) GetPixelChannels(image);
2302  q++;
2303  }
2304  if ((number_pixels % 8) != 0)
2305  {
2306  *q='\0';
2307  for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2308  {
2309  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2310  *q|=((pixel & 0x01) << (unsigned char) bit);
2311  p+=(ptrdiff_t) GetPixelChannels(image);
2312  }
2313  q++;
2314  }
2315  break;
2316  }
2317  case 4:
2318  {
2319  unsigned char
2320  pixel;
2321 
2322  for (x=0; x < ((ssize_t) number_pixels-1) ; x+=2)
2323  {
2324  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2325  *q=((pixel & 0xf) << 4);
2326  p+=(ptrdiff_t) GetPixelChannels(image);
2327  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2328  *q|=((pixel & 0xf) << 0);
2329  p+=(ptrdiff_t) GetPixelChannels(image);
2330  q++;
2331  }
2332  if ((number_pixels % 2) != 0)
2333  {
2334  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2335  *q=((pixel & 0xf) << 4);
2336  p+=(ptrdiff_t) GetPixelChannels(image);
2337  q++;
2338  }
2339  break;
2340  }
2341  case 8:
2342  {
2343  for (x=0; x < (ssize_t) number_pixels; x++)
2344  {
2345  q=PopCharPixel((unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2346  p+=(ptrdiff_t) GetPixelChannels(image);
2347  q+=(ptrdiff_t) quantum_info->pad;
2348  }
2349  break;
2350  }
2351  case 16:
2352  {
2353  if (quantum_info->format == FloatingPointQuantumFormat)
2354  {
2355  for (x=0; x < (ssize_t) number_pixels; x++)
2356  {
2357  q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
2358  QuantumScale*(double) GetPixelIndex(image,p)),q);
2359  p+=(ptrdiff_t) GetPixelChannels(image);
2360  q+=(ptrdiff_t) quantum_info->pad;
2361  }
2362  break;
2363  }
2364  for (x=0; x < (ssize_t) number_pixels; x++)
2365  {
2366  q=PopShortPixel(quantum_info->endian,(unsigned short)
2367  GetPixelIndex(image,p),q);
2368  p+=(ptrdiff_t) GetPixelChannels(image);
2369  q+=(ptrdiff_t) quantum_info->pad;
2370  }
2371  break;
2372  }
2373  case 32:
2374  {
2375  if (quantum_info->format == FloatingPointQuantumFormat)
2376  {
2377  for (x=0; x < (ssize_t) number_pixels; x++)
2378  {
2379  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
2380  p+=(ptrdiff_t) GetPixelChannels(image);
2381  q+=(ptrdiff_t) quantum_info->pad;
2382  }
2383  break;
2384  }
2385  for (x=0; x < (ssize_t) number_pixels; x++)
2386  {
2387  q=PopLongPixel(quantum_info->endian,(unsigned int)
2388  GetPixelIndex(image,p),q);
2389  p+=(ptrdiff_t) GetPixelChannels(image);
2390  q+=(ptrdiff_t) quantum_info->pad;
2391  }
2392  break;
2393  }
2394  case 64:
2395  {
2396  if (quantum_info->format == FloatingPointQuantumFormat)
2397  {
2398  for (x=0; x < (ssize_t) number_pixels; x++)
2399  {
2400  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
2401  p+=(ptrdiff_t) GetPixelChannels(image);
2402  q+=(ptrdiff_t) quantum_info->pad;
2403  }
2404  break;
2405  }
2406  magick_fallthrough;
2407  }
2408  default:
2409  {
2410  for (x=0; x < (ssize_t) number_pixels; x++)
2411  {
2412  q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2413  p+=(ptrdiff_t) GetPixelChannels(image);
2414  q+=(ptrdiff_t) quantum_info->pad;
2415  }
2416  break;
2417  }
2418  }
2419 }
2420 
2421 static void ExportIndexAlphaQuantum(const Image *image,
2422  QuantumInfo *quantum_info,const MagickSizeType number_pixels,
2423  const Quantum *magick_restrict p,unsigned char *magick_restrict q,
2424  ExceptionInfo *exception)
2425 {
2426  ssize_t
2427  x;
2428 
2429  ssize_t
2430  bit;
2431 
2432  if (image->storage_class != PseudoClass)
2433  {
2434  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2435  "ColormappedImageRequired","`%s'",image->filename);
2436  return;
2437  }
2438  switch (quantum_info->depth)
2439  {
2440  case 1:
2441  {
2442  unsigned char
2443  pixel;
2444 
2445  for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2446  {
2447  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2448  *q=((pixel & 0x01) << 7);
2449  pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2450  TransparentAlpha ? 1 : 0);
2451  *q|=((pixel & 0x01) << 6);
2452  p+=(ptrdiff_t) GetPixelChannels(image);
2453  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2454  *q|=((pixel & 0x01) << 5);
2455  pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2456  TransparentAlpha ? 1 : 0);
2457  *q|=((pixel & 0x01) << 4);
2458  p+=(ptrdiff_t) GetPixelChannels(image);
2459  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2460  *q|=((pixel & 0x01) << 3);
2461  pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2462  TransparentAlpha ? 1 : 0);
2463  *q|=((pixel & 0x01) << 2);
2464  p+=(ptrdiff_t) GetPixelChannels(image);
2465  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2466  *q|=((pixel & 0x01) << 1);
2467  pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2468  TransparentAlpha ? 1 : 0);
2469  *q|=((pixel & 0x01) << 0);
2470  p+=(ptrdiff_t) GetPixelChannels(image);
2471  q++;
2472  }
2473  if ((number_pixels % 4) != 0)
2474  {
2475  *q='\0';
2476  for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2477  {
2478  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2479  *q|=((pixel & 0x01) << (unsigned char) (bit+4));
2480  pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2481  TransparentAlpha ? 1 : 0);
2482  *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
2483  p+=(ptrdiff_t) GetPixelChannels(image);
2484  }
2485  q++;
2486  }
2487  break;
2488  }
2489  case 4:
2490  {
2491  unsigned char
2492  pixel;
2493 
2494  for (x=0; x < (ssize_t) number_pixels ; x++)
2495  {
2496  pixel=(unsigned char) ((ssize_t) GetPixelIndex(image,p));
2497  *q=((pixel & 0xf) << 4);
2498  pixel=(unsigned char) (16.0*QuantumScale*(double)
2499  GetPixelAlpha(image,p)+0.5);
2500  *q|=((pixel & 0xf) << 0);
2501  p+=(ptrdiff_t) GetPixelChannels(image);
2502  q++;
2503  }
2504  break;
2505  }
2506  case 8:
2507  {
2508  unsigned char
2509  pixel;
2510 
2511  for (x=0; x < (ssize_t) number_pixels; x++)
2512  {
2513  q=PopCharPixel((unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2514  pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2515  q=PopCharPixel(pixel,q);
2516  p+=(ptrdiff_t) GetPixelChannels(image);
2517  q+=(ptrdiff_t) quantum_info->pad;
2518  }
2519  break;
2520  }
2521  case 16:
2522  {
2523  unsigned short
2524  pixel;
2525 
2526  if (quantum_info->format == FloatingPointQuantumFormat)
2527  {
2528  for (x=0; x < (ssize_t) number_pixels; x++)
2529  {
2530  q=PopShortPixel(quantum_info->endian,(unsigned short)
2531  ((ssize_t) GetPixelIndex(image,p)),q);
2532  pixel=SinglePrecisionToHalf(QuantumScale*(double)
2533  GetPixelAlpha(image,p));
2534  q=PopShortPixel(quantum_info->endian,pixel,q);
2535  p+=(ptrdiff_t) GetPixelChannels(image);
2536  q+=(ptrdiff_t) quantum_info->pad;
2537  }
2538  break;
2539  }
2540  for (x=0; x < (ssize_t) number_pixels; x++)
2541  {
2542  q=PopShortPixel(quantum_info->endian,(unsigned short)
2543  ((ssize_t) GetPixelIndex(image,p)),q);
2544  pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2545  q=PopShortPixel(quantum_info->endian,pixel,q);
2546  p+=(ptrdiff_t) GetPixelChannels(image);
2547  q+=(ptrdiff_t) quantum_info->pad;
2548  }
2549  break;
2550  }
2551  case 32:
2552  {
2553  unsigned int
2554  pixel;
2555 
2556  if (quantum_info->format == FloatingPointQuantumFormat)
2557  {
2558  for (x=0; x < (ssize_t) number_pixels; x++)
2559  {
2560  float
2561  float_pixel;
2562 
2563  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelIndex(image,p),q);
2564  float_pixel=(float) GetPixelAlpha(image,p);
2565  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2566  p+=(ptrdiff_t) GetPixelChannels(image);
2567  q+=(ptrdiff_t) quantum_info->pad;
2568  }
2569  break;
2570  }
2571  for (x=0; x < (ssize_t) number_pixels; x++)
2572  {
2573  q=PopLongPixel(quantum_info->endian,(unsigned int)
2574  GetPixelIndex(image,p),q);
2575  pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2576  q=PopLongPixel(quantum_info->endian,pixel,q);
2577  p+=(ptrdiff_t) GetPixelChannels(image);
2578  q+=(ptrdiff_t) quantum_info->pad;
2579  }
2580  break;
2581  }
2582  case 64:
2583  {
2584  if (quantum_info->format == FloatingPointQuantumFormat)
2585  {
2586  for (x=0; x < (ssize_t) number_pixels; x++)
2587  {
2588  double
2589  pixel;
2590 
2591  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelIndex(image,p),q);
2592  pixel=(double) GetPixelAlpha(image,p);
2593  q=PopQuantumDoublePixel(quantum_info,pixel,q);
2594  p+=(ptrdiff_t) GetPixelChannels(image);
2595  q+=(ptrdiff_t) quantum_info->pad;
2596  }
2597  break;
2598  }
2599  magick_fallthrough;
2600  }
2601  default:
2602  {
2603  QuantumAny
2604  range;
2605 
2606  range=GetQuantumRange(quantum_info->depth);
2607  for (x=0; x < (ssize_t) number_pixels; x++)
2608  {
2609  q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2610  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2611  range),q);
2612  p+=(ptrdiff_t) GetPixelChannels(image);
2613  q+=(ptrdiff_t) quantum_info->pad;
2614  }
2615  break;
2616  }
2617  }
2618 }
2619 
2620 static void ExportMultispectralQuantum(const Image *image,
2621  QuantumInfo *quantum_info,const MagickSizeType number_pixels,
2622  const Quantum *magick_restrict p,unsigned char *magick_restrict q,
2623  ExceptionInfo *exception)
2624 {
2625  ssize_t
2626  i,
2627  x;
2628 
2629  if (image->number_meta_channels == 0)
2630  {
2631  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2632  "MultispectralImageRequired","`%s'",image->filename);
2633  return;
2634  }
2635  if (quantum_info->meta_channel != 0)
2636  {
2637  ExportPixelChannel(image,quantum_info,number_pixels,p,q,
2638  (PixelChannel) (MetaPixelChannels+quantum_info->meta_channel-1));
2639  return;
2640  }
2641  switch (quantum_info->depth)
2642  {
2643  case 8:
2644  {
2645  unsigned char
2646  pixel;
2647 
2648  for (x=0; x < (ssize_t) number_pixels; x++)
2649  {
2650  for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2651  {
2652  pixel=ScaleQuantumToChar(p[i]);
2653  q=PopCharPixel(pixel,q);
2654  }
2655  p+=(ptrdiff_t) GetPixelChannels(image);
2656  q+=(ptrdiff_t) quantum_info->pad;
2657  }
2658  break;
2659  }
2660  case 16:
2661  {
2662  unsigned short
2663  pixel;
2664 
2665  if (quantum_info->format == FloatingPointQuantumFormat)
2666  {
2667  for (x=0; x < (ssize_t) number_pixels; x++)
2668  {
2669  for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2670  {
2671  pixel=SinglePrecisionToHalf(QuantumScale*(double) p[i]);
2672  q=PopShortPixel(quantum_info->endian,pixel,q);
2673  }
2674  p+=(ptrdiff_t) GetPixelChannels(image);
2675  q+=(ptrdiff_t) quantum_info->pad;
2676  }
2677  break;
2678  }
2679  for (x=0; x < (ssize_t) number_pixels; x++)
2680  {
2681  for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2682  {
2683  pixel=ScaleQuantumToShort(p[i]);
2684  q=PopShortPixel(quantum_info->endian,pixel,q);
2685  }
2686  p+=(ptrdiff_t) GetPixelChannels(image);
2687  q+=(ptrdiff_t) quantum_info->pad;
2688  }
2689  break;
2690  }
2691  case 32:
2692  {
2693  unsigned int
2694  pixel;
2695 
2696  if (quantum_info->format == FloatingPointQuantumFormat)
2697  {
2698  for (x=0; x < (ssize_t) number_pixels; x++)
2699  {
2700  for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2701  q=PopQuantumFloatPixel(quantum_info,(float) p[i],q);
2702  p+=(ptrdiff_t) GetPixelChannels(image);
2703  q+=(ptrdiff_t) quantum_info->pad;
2704  }
2705  break;
2706  }
2707  for (x=0; x < (ssize_t) number_pixels; x++)
2708  {
2709  for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2710  {
2711  pixel=ScaleQuantumToLong(p[i]);
2712  q=PopLongPixel(quantum_info->endian,pixel,q);
2713  }
2714  p+=(ptrdiff_t) GetPixelChannels(image);
2715  q+=(ptrdiff_t) quantum_info->pad;
2716  }
2717  break;
2718  }
2719  case 64:
2720  {
2721  if (quantum_info->format == FloatingPointQuantumFormat)
2722  {
2723  for (x=0; x < (ssize_t) number_pixels; x++)
2724  {
2725  for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2726  q=PopQuantumDoublePixel(quantum_info,(double) p[i],q);
2727  p+=(ptrdiff_t) GetPixelChannels(image);
2728  q+=(ptrdiff_t) quantum_info->pad;
2729  }
2730  break;
2731  }
2732  magick_fallthrough;
2733  }
2734  default:
2735  {
2736  QuantumAny
2737  range;
2738 
2739  range=GetQuantumRange(quantum_info->depth);
2740  for (x=0; x < (ssize_t) number_pixels; x++)
2741  {
2742  for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2743  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(p[i],range),q);
2744  p+=(ptrdiff_t) GetPixelChannels(image);
2745  q+=(ptrdiff_t) quantum_info->pad;
2746  }
2747  break;
2748  }
2749  }
2750 }
2751 
2752 static void ExportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
2753  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2754  unsigned char *magick_restrict q,ExceptionInfo *exception)
2755 {
2756  QuantumAny
2757  range;
2758 
2759  ssize_t
2760  x;
2761 
2762  if (image->alpha_trait == UndefinedPixelTrait)
2763  {
2764  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2765  "ImageDoesNotHaveAnAlphaChannel","`%s'",image->filename);
2766  return;
2767  }
2768  switch (quantum_info->depth)
2769  {
2770  case 8:
2771  {
2772  unsigned char
2773  pixel;
2774 
2775  for (x=0; x < (ssize_t) number_pixels; x++)
2776  {
2777  pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
2778  q=PopCharPixel(pixel,q);
2779  p+=(ptrdiff_t) GetPixelChannels(image);
2780  q+=(ptrdiff_t) quantum_info->pad;
2781  }
2782  break;
2783  }
2784  case 16:
2785  {
2786  unsigned short
2787  pixel;
2788 
2789  if (quantum_info->format == FloatingPointQuantumFormat)
2790  {
2791  for (x=0; x < (ssize_t) number_pixels; x++)
2792  {
2793  pixel=SinglePrecisionToHalf(QuantumScale*(double)
2794  GetPixelOpacity(image,p));
2795  q=PopShortPixel(quantum_info->endian,pixel,q);
2796  p+=(ptrdiff_t) GetPixelChannels(image);
2797  q+=(ptrdiff_t) quantum_info->pad;
2798  }
2799  break;
2800  }
2801  for (x=0; x < (ssize_t) number_pixels; x++)
2802  {
2803  pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
2804  q=PopShortPixel(quantum_info->endian,pixel,q);
2805  p+=(ptrdiff_t) GetPixelChannels(image);
2806  q+=(ptrdiff_t) quantum_info->pad;
2807  }
2808  break;
2809  }
2810  case 32:
2811  {
2812  unsigned int
2813  pixel;
2814 
2815  if (quantum_info->format == FloatingPointQuantumFormat)
2816  {
2817  for (x=0; x < (ssize_t) number_pixels; x++)
2818  {
2819  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelOpacity(image,p),q);
2820  p+=(ptrdiff_t) GetPixelChannels(image);
2821  q+=(ptrdiff_t) quantum_info->pad;
2822  }
2823  break;
2824  }
2825  for (x=0; x < (ssize_t) number_pixels; x++)
2826  {
2827  pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
2828  q=PopLongPixel(quantum_info->endian,pixel,q);
2829  p+=(ptrdiff_t) GetPixelChannels(image);
2830  q+=(ptrdiff_t) quantum_info->pad;
2831  }
2832  break;
2833  }
2834  case 64:
2835  {
2836  if (quantum_info->format == FloatingPointQuantumFormat)
2837  {
2838  for (x=0; x < (ssize_t) number_pixels; x++)
2839  {
2840  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelOpacity(image,p),q);
2841  p+=(ptrdiff_t) GetPixelChannels(image);
2842  q+=(ptrdiff_t) quantum_info->pad;
2843  }
2844  break;
2845  }
2846  magick_fallthrough;
2847  }
2848  default:
2849  {
2850  range=GetQuantumRange(quantum_info->depth);
2851  for (x=0; x < (ssize_t) number_pixels; x++)
2852  {
2853  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
2854  GetPixelOpacity(image,p),range),q);
2855  p+=(ptrdiff_t) GetPixelChannels(image);
2856  q+=(ptrdiff_t) quantum_info->pad;
2857  }
2858  break;
2859  }
2860  }
2861 }
2862 
2863 static void ExportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
2864  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
2865  unsigned char *magick_restrict q)
2866 {
2867  QuantumAny
2868  range;
2869 
2870  ssize_t
2871  x;
2872 
2873  ssize_t
2874  bit;
2875 
2876  switch (quantum_info->depth)
2877  {
2878  case 8:
2879  {
2880  for (x=0; x < (ssize_t) number_pixels; x++)
2881  {
2882  q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
2883  q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
2884  q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
2885  p+=(ptrdiff_t) GetPixelChannels(image);
2886  q+=(ptrdiff_t) quantum_info->pad;
2887  }
2888  break;
2889  }
2890  case 10:
2891  {
2892  unsigned int
2893  pixel;
2894 
2895  range=GetQuantumRange(quantum_info->depth);
2896  if (quantum_info->pack == MagickFalse)
2897  {
2898  for (x=0; x < (ssize_t) number_pixels; x++)
2899  {
2900  pixel=(unsigned int) (
2901  ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
2902  ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
2903  ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
2904  q=PopLongPixel(quantum_info->endian,pixel,q);
2905  p+=(ptrdiff_t) GetPixelChannels(image);
2906  q+=(ptrdiff_t) quantum_info->pad;
2907  }
2908  break;
2909  }
2910  if (quantum_info->quantum == 32UL)
2911  {
2912  for (x=0; x < (ssize_t) number_pixels; x++)
2913  {
2914  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
2915  q=PopQuantumLongPixel(quantum_info,pixel,q);
2916  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
2917  range);
2918  q=PopQuantumLongPixel(quantum_info,pixel,q);
2919  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
2920  q=PopQuantumLongPixel(quantum_info,pixel,q);
2921  p+=(ptrdiff_t) GetPixelChannels(image);
2922  q+=(ptrdiff_t) quantum_info->pad;
2923  }
2924  break;
2925  }
2926  for (x=0; x < (ssize_t) number_pixels; x++)
2927  {
2928  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
2929  q=PopQuantumPixel(quantum_info,pixel,q);
2930  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
2931  q=PopQuantumPixel(quantum_info,pixel,q);
2932  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
2933  q=PopQuantumPixel(quantum_info,pixel,q);
2934  p+=(ptrdiff_t) GetPixelChannels(image);
2935  q+=(ptrdiff_t) quantum_info->pad;
2936  }
2937  break;
2938  }
2939  case 12:
2940  {
2941  unsigned int
2942  pixel;
2943 
2944  range=GetQuantumRange(quantum_info->depth);
2945  if (quantum_info->pack == MagickFalse)
2946  {
2947  for (x=0; x < (3*(ssize_t) number_pixels-1); x+=2)
2948  {
2949  switch (x % 3)
2950  {
2951  default:
2952  case 0:
2953  {
2954  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
2955  range);
2956  break;
2957  }
2958  case 1:
2959  {
2960  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
2961  range);
2962  break;
2963  }
2964  case 2:
2965  {
2966  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
2967  range);
2968  p+=(ptrdiff_t) GetPixelChannels(image);
2969  break;
2970  }
2971  }
2972  q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
2973  q);
2974  switch ((x+1) % 3)
2975  {
2976  default:
2977  case 0:
2978  {
2979  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
2980  range);
2981  break;
2982  }
2983  case 1:
2984  {
2985  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
2986  range);
2987  break;
2988  }
2989  case 2:
2990  {
2991  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
2992  range);
2993  p+=(ptrdiff_t) GetPixelChannels(image);
2994  break;
2995  }
2996  }
2997  q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
2998  q);
2999  q+=(ptrdiff_t) quantum_info->pad;
3000  }
3001  for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3002  {
3003  switch ((x+bit) % 3)
3004  {
3005  default:
3006  case 0:
3007  {
3008  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3009  range);
3010  break;
3011  }
3012  case 1:
3013  {
3014  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3015  range);
3016  break;
3017  }
3018  case 2:
3019  {
3020  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3021  range);
3022  p+=(ptrdiff_t) GetPixelChannels(image);
3023  break;
3024  }
3025  }
3026  q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),
3027  q);
3028  q+=(ptrdiff_t) quantum_info->pad;
3029  }
3030  if (bit != 0)
3031  p+=(ptrdiff_t) GetPixelChannels(image);
3032  break;
3033  }
3034  if (quantum_info->quantum == 32UL)
3035  {
3036  for (x=0; x < (ssize_t) number_pixels; x++)
3037  {
3038  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3039  q=PopQuantumLongPixel(quantum_info,pixel,q);
3040  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3041  range);
3042  q=PopQuantumLongPixel(quantum_info,pixel,q);
3043  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3044  q=PopQuantumLongPixel(quantum_info,pixel,q);
3045  p+=(ptrdiff_t) GetPixelChannels(image);
3046  q+=(ptrdiff_t) quantum_info->pad;
3047  }
3048  break;
3049  }
3050  for (x=0; x < (ssize_t) number_pixels; x++)
3051  {
3052  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3053  q=PopQuantumPixel(quantum_info,pixel,q);
3054  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3055  q=PopQuantumPixel(quantum_info,pixel,q);
3056  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3057  q=PopQuantumPixel(quantum_info,pixel,q);
3058  p+=(ptrdiff_t) GetPixelChannels(image);
3059  q+=(ptrdiff_t) quantum_info->pad;
3060  }
3061  break;
3062  }
3063  case 16:
3064  {
3065  unsigned short
3066  pixel;
3067 
3068  if (quantum_info->format == FloatingPointQuantumFormat)
3069  {
3070  for (x=0; x < (ssize_t) number_pixels; x++)
3071  {
3072  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3073  GetPixelRed(image,p));
3074  q=PopShortPixel(quantum_info->endian,pixel,q);
3075  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3076  GetPixelGreen(image,p));
3077  q=PopShortPixel(quantum_info->endian,pixel,q);
3078  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3079  GetPixelBlue(image,p));
3080  q=PopShortPixel(quantum_info->endian,pixel,q);
3081  p+=(ptrdiff_t) GetPixelChannels(image);
3082  q+=(ptrdiff_t) quantum_info->pad;
3083  }
3084  break;
3085  }
3086  for (x=0; x < (ssize_t) number_pixels; x++)
3087  {
3088  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3089  q=PopShortPixel(quantum_info->endian,pixel,q);
3090  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3091  q=PopShortPixel(quantum_info->endian,pixel,q);
3092  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3093  q=PopShortPixel(quantum_info->endian,pixel,q);
3094  p+=(ptrdiff_t) GetPixelChannels(image);
3095  q+=(ptrdiff_t) quantum_info->pad;
3096  }
3097  break;
3098  }
3099  case 32:
3100  {
3101  unsigned int
3102  pixel;
3103 
3104  if (quantum_info->format == FloatingPointQuantumFormat)
3105  {
3106  for (x=0; x < (ssize_t) number_pixels; x++)
3107  {
3108  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),
3109  q);
3110  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
3111  q);
3112  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
3113  q);
3114  p+=(ptrdiff_t) GetPixelChannels(image);
3115  q+=(ptrdiff_t) quantum_info->pad;
3116  }
3117  break;
3118  }
3119  for (x=0; x < (ssize_t) number_pixels; x++)
3120  {
3121  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3122  q=PopLongPixel(quantum_info->endian,pixel,q);
3123  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3124  q=PopLongPixel(quantum_info->endian,pixel,q);
3125  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3126  q=PopLongPixel(quantum_info->endian,pixel,q);
3127  p+=(ptrdiff_t) GetPixelChannels(image);
3128  q+=(ptrdiff_t) quantum_info->pad;
3129  }
3130  break;
3131  }
3132  case 64:
3133  {
3134  if (quantum_info->format == FloatingPointQuantumFormat)
3135  {
3136  for (x=0; x < (ssize_t) number_pixels; x++)
3137  {
3138  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
3139  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
3140  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
3141  p+=(ptrdiff_t) GetPixelChannels(image);
3142  q+=(ptrdiff_t) quantum_info->pad;
3143  }
3144  break;
3145  }
3146  magick_fallthrough;
3147  }
3148  default:
3149  {
3150  range=GetQuantumRange(quantum_info->depth);
3151  for (x=0; x < (ssize_t) number_pixels; x++)
3152  {
3153  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3154  range),q);
3155  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3156  range),q);
3157  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3158  range),q);
3159  p+=(ptrdiff_t) GetPixelChannels(image);
3160  q+=(ptrdiff_t) quantum_info->pad;
3161  }
3162  break;
3163  }
3164  }
3165 }
3166 
3167 static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
3168  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
3169  unsigned char *magick_restrict q)
3170 {
3171  QuantumAny
3172  range;
3173 
3174  ssize_t
3175  x;
3176 
3177  switch (quantum_info->depth)
3178  {
3179  case 8:
3180  {
3181  unsigned char
3182  pixel;
3183 
3184  for (x=0; x < (ssize_t) number_pixels; x++)
3185  {
3186  pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3187  q=PopCharPixel(pixel,q);
3188  pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3189  q=PopCharPixel(pixel,q);
3190  pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3191  q=PopCharPixel(pixel,q);
3192  pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
3193  q=PopCharPixel(pixel,q);
3194  p+=(ptrdiff_t) GetPixelChannels(image);
3195  q+=(ptrdiff_t) quantum_info->pad;
3196  }
3197  break;
3198  }
3199  case 10:
3200  {
3201  unsigned int
3202  pixel;
3203 
3204  range=GetQuantumRange(quantum_info->depth);
3205  if (quantum_info->pack == MagickFalse)
3206  {
3207  ssize_t
3208  i;
3209 
3210  size_t
3211  quantum;
3212 
3213  ssize_t
3214  n;
3215 
3216  n=0;
3217  quantum=0;
3218  pixel=0;
3219  for (x=0; x < (ssize_t) number_pixels; x++)
3220  {
3221  for (i=0; i < 4; i++)
3222  {
3223  switch (i)
3224  {
3225  case 0: quantum=(size_t) GetPixelRed(image,p); break;
3226  case 1: quantum=(size_t) GetPixelGreen(image,p); break;
3227  case 2: quantum=(size_t) GetPixelBlue(image,p); break;
3228  case 3: quantum=(size_t) GetPixelAlpha(image,p); break;
3229  }
3230  switch (n % 3)
3231  {
3232  case 0:
3233  {
3234  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3235  range) << 22);
3236  break;
3237  }
3238  case 1:
3239  {
3240  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3241  range) << 12);
3242  break;
3243  }
3244  case 2:
3245  {
3246  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3247  range) << 2);
3248  q=PopLongPixel(quantum_info->endian,pixel,q);
3249  pixel=0;
3250  break;
3251  }
3252  }
3253  n++;
3254  }
3255  p+=(ptrdiff_t) GetPixelChannels(image);
3256  q+=(ptrdiff_t) quantum_info->pad;
3257  }
3258  break;
3259  }
3260  if (quantum_info->quantum == 32UL)
3261  {
3262  for (x=0; x < (ssize_t) number_pixels; x++)
3263  {
3264  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3265  q=PopQuantumLongPixel(quantum_info,pixel,q);
3266  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3267  range);
3268  q=PopQuantumLongPixel(quantum_info,pixel,q);
3269  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3270  q=PopQuantumLongPixel(quantum_info,pixel,q);
3271  pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
3272  range);
3273  q=PopQuantumLongPixel(quantum_info,pixel,q);
3274  p+=(ptrdiff_t) GetPixelChannels(image);
3275  q+=(ptrdiff_t) quantum_info->pad;
3276  }
3277  break;
3278  }
3279  for (x=0; x < (ssize_t) number_pixels; x++)
3280  {
3281  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3282  q=PopQuantumPixel(quantum_info,pixel,q);
3283  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3284  q=PopQuantumPixel(quantum_info,pixel,q);
3285  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3286  q=PopQuantumPixel(quantum_info,pixel,q);
3287  pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
3288  q=PopQuantumPixel(quantum_info,pixel,q);
3289  p+=(ptrdiff_t) GetPixelChannels(image);
3290  q+=(ptrdiff_t) quantum_info->pad;
3291  }
3292  break;
3293  }
3294  case 16:
3295  {
3296  unsigned short
3297  pixel;
3298 
3299  if (quantum_info->format == FloatingPointQuantumFormat)
3300  {
3301  for (x=0; x < (ssize_t) number_pixels; x++)
3302  {
3303  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3304  GetPixelRed(image,p));
3305  q=PopShortPixel(quantum_info->endian,pixel,q);
3306  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3307  GetPixelGreen(image,p));
3308  q=PopShortPixel(quantum_info->endian,pixel,q);
3309  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3310  GetPixelBlue(image,p));
3311  q=PopShortPixel(quantum_info->endian,pixel,q);
3312  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3313  GetPixelAlpha(image,p));
3314  q=PopShortPixel(quantum_info->endian,pixel,q);
3315  p+=(ptrdiff_t) GetPixelChannels(image);
3316  q+=(ptrdiff_t) quantum_info->pad;
3317  }
3318  break;
3319  }
3320  for (x=0; x < (ssize_t) number_pixels; x++)
3321  {
3322  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3323  q=PopShortPixel(quantum_info->endian,pixel,q);
3324  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3325  q=PopShortPixel(quantum_info->endian,pixel,q);
3326  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3327  q=PopShortPixel(quantum_info->endian,pixel,q);
3328  pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
3329  q=PopShortPixel(quantum_info->endian,pixel,q);
3330  p+=(ptrdiff_t) GetPixelChannels(image);
3331  q+=(ptrdiff_t) quantum_info->pad;
3332  }
3333  break;
3334  }
3335  case 32:
3336  {
3337  unsigned int
3338  pixel;
3339 
3340  if (quantum_info->format == FloatingPointQuantumFormat)
3341  {
3342  for (x=0; x < (ssize_t) number_pixels; x++)
3343  {
3344  float
3345  float_pixel;
3346 
3347  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);
3348  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
3349  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
3350  float_pixel=(float) GetPixelAlpha(image,p);
3351  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3352  p+=(ptrdiff_t) GetPixelChannels(image);
3353  q+=(ptrdiff_t) quantum_info->pad;
3354  }
3355  break;
3356  }
3357  for (x=0; x < (ssize_t) number_pixels; x++)
3358  {
3359  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3360  q=PopLongPixel(quantum_info->endian,pixel,q);
3361  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3362  q=PopLongPixel(quantum_info->endian,pixel,q);
3363  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3364  q=PopLongPixel(quantum_info->endian,pixel,q);
3365  pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
3366  q=PopLongPixel(quantum_info->endian,pixel,q);
3367  p+=(ptrdiff_t) GetPixelChannels(image);
3368  q+=(ptrdiff_t) quantum_info->pad;
3369  }
3370  break;
3371  }
3372  case 64:
3373  {
3374  if (quantum_info->format == FloatingPointQuantumFormat)
3375  {
3376  double
3377  pixel;
3378 
3379  for (x=0; x < (ssize_t) number_pixels; x++)
3380  {
3381  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);
3382  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
3383  q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
3384  pixel=(double) GetPixelAlpha(image,p);
3385  q=PopQuantumDoublePixel(quantum_info,pixel,q);
3386  p+=(ptrdiff_t) GetPixelChannels(image);
3387  q+=(ptrdiff_t) quantum_info->pad;
3388  }
3389  break;
3390  }
3391  magick_fallthrough;
3392  }
3393  default:
3394  {
3395  range=GetQuantumRange(quantum_info->depth);
3396  for (x=0; x < (ssize_t) number_pixels; x++)
3397  {
3398  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3399  range),q);
3400  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3401  range),q);
3402  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3403  range),q);
3404  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
3405  range),q);
3406  p+=(ptrdiff_t) GetPixelChannels(image);
3407  q+=(ptrdiff_t) quantum_info->pad;
3408  }
3409  break;
3410  }
3411  }
3412 }
3413 
3414 static void ExportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
3415  const MagickSizeType number_pixels,const Quantum *magick_restrict p,
3416  unsigned char *magick_restrict q)
3417 {
3418  QuantumAny
3419  range;
3420 
3421  ssize_t
3422  x;
3423 
3424  switch (quantum_info->depth)
3425  {
3426  case 8:
3427  {
3428  unsigned char
3429  pixel;
3430 
3431  for (x=0; x < (ssize_t) number_pixels; x++)
3432  {
3433  pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3434  q=PopCharPixel(pixel,q);
3435  pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3436  q=PopCharPixel(pixel,q);
3437  pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3438  q=PopCharPixel(pixel,q);
3439  pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
3440  q=PopCharPixel(pixel,q);
3441  p+=(ptrdiff_t) GetPixelChannels(image);
3442  q+=(ptrdiff_t) quantum_info->pad;
3443  }
3444  break;
3445  }
3446  case 10:
3447  {
3448  unsigned int
3449  pixel;
3450 
3451  range=GetQuantumRange(quantum_info->depth);
3452  if (quantum_info->pack == MagickFalse)
3453  {
3454  ssize_t
3455  i;
3456 
3457  size_t
3458  quantum;
3459 
3460  ssize_t
3461  n;
3462 
3463  n=0;
3464  quantum=0;
3465  pixel=0;
3466  for (x=0; x < (ssize_t) number_pixels; x++)
3467  {
3468  for (i=0; i < 4; i++)
3469  {
3470  switch (i)
3471  {
3472  case 0: quantum=(size_t) GetPixelRed(image,p); break;
3473  case 1: quantum=(size_t) GetPixelGreen(image,p); break;
3474  case 2: quantum=(size_t) GetPixelBlue(image,p); break;
3475  case 3: quantum=(size_t) GetPixelOpacity(image,p); break;
3476  }
3477  switch (n % 3)
3478  {
3479  case 0:
3480  {
3481  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3482  range) << 22);
3483  break;
3484  }
3485  case 1:
3486  {
3487  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3488  range) << 12);
3489  break;
3490  }
3491  case 2:
3492  {
3493  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3494  range) << 2);
3495  q=PopLongPixel(quantum_info->endian,pixel,q);
3496  pixel=0;
3497  break;
3498  }
3499  }
3500  n++;
3501  }
3502  p+=(ptrdiff_t) GetPixelChannels(image);
3503  q+=(ptrdiff_t) quantum_info->pad;
3504  }
3505  break;
3506  }
3507  if (quantum_info->quantum == 32UL)
3508  {
3509  for (x=0; x < (ssize_t) number_pixels; x++)
3510  {
3511  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3512  q=PopQuantumLongPixel(quantum_info,pixel,q);
3513  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3514  range);
3515  q=PopQuantumLongPixel(quantum_info,pixel,q);
3516  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3517  q=PopQuantumLongPixel(quantum_info,pixel,q);
3518  pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
3519  range);
3520  q=PopQuantumLongPixel(quantum_info,pixel,q);
3521  p+=(ptrdiff_t) GetPixelChannels(image);
3522  q+=(ptrdiff_t) quantum_info->pad;
3523  }
3524  break;
3525  }
3526  for (x=0; x < (ssize_t) number_pixels; x++)
3527  {
3528  pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3529  q=PopQuantumPixel(quantum_info,pixel,q);
3530  pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3531  q=PopQuantumPixel(quantum_info,pixel,q);
3532  pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3533  q=PopQuantumPixel(quantum_info,pixel,q);
3534  pixel=(unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
3535  q=PopQuantumPixel(quantum_info,pixel,q);
3536  p+=(ptrdiff_t) GetPixelChannels(image);
3537  q+=(ptrdiff_t) quantum_info->pad;
3538  }
3539  break;
3540  }
3541  case 16:
3542  {
3543  unsigned short
3544  pixel;
3545 
3546  if (quantum_info->format == FloatingPointQuantumFormat)
3547  {
3548  for (x=0; x < (ssize_t) number_pixels; x++)
3549  {
3550  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3551  GetPixelRed(image,p));
3552  q=PopShortPixel(quantum_info->endian,pixel,q);
3553  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3554  GetPixelGreen(image,p));
3555  q=PopShortPixel(quantum_info->endian,pixel,q);
3556  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3557  GetPixelBlue(image,p));
3558  q=PopShortPixel(quantum_info->endian,pixel,q);
3559  pixel=SinglePrecisionToHalf(QuantumScale*(double)
3560  GetPixelOpacity(image,p));
3561  q=PopShortPixel(quantum_info->endian,pixel,q);
3562  p+=(ptrdiff_t) GetPixelChannels(image);
3563  q+=(ptrdiff_t) quantum_info->pad;
3564  }
3565  break;
3566  }
3567  for (x=0; x < (ssize_t) number_pixels; x++)
3568  {
3569  pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3570  q=PopShortPixel(quantum_info->endian,pixel,q);
3571  pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3572  q=PopShortPixel(quantum_info->endian,pixel,q);
3573  pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3574  q=PopShortPixel(quantum_info->endian,pixel,q);
3575  pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
3576  q=PopShortPixel(quantum_info->endian,pixel,q);
3577  p+=(ptrdiff_t) GetPixelChannels(image);
3578  q+=(ptrdiff_t) quantum_info->pad;
3579  }
3580  break;
3581  }
3582  case 32:
3583  {
3584  unsigned int
3585  pixel;
3586 
3587  if (quantum_info->format == FloatingPointQuantumFormat)
3588  {
3589  for (x=0; x < (ssize_t) number_pixels; x++)
3590  {
3591  float
3592  float_pixel;
3593 
3594  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),
3595  q);
3596  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),
3597  q);
3598  q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),
3599  q);
3600  float_pixel=(float) GetPixelOpacity(image,p);
3601  q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3602  p+=(ptrdiff_t) GetPixelChannels(image);
3603  q+=(ptrdiff_t) quantum_info->pad;
3604  }
3605  break;
3606  }
3607  for (x=0; x < (ssize_t) number_pixels; x++)
3608  {
3609  pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3610  q=PopLongPixel(quantum_info->endian,pixel,q);
3611  pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3612  q=PopLongPixel(quantum_info->endian,pixel,q);
3613  pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3614  q=PopLongPixel(quantum_info->endian,pixel,q);
3615  pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
3616  q=PopLongPixel(quantum_info->endian,pixel,q);
3617  p+=(ptrdiff_t) GetPixelChannels(image);
3618  q+=(ptrdiff_t) quantum_info->pad;
3619  }
3620  break;
3621  }
3622  case 64:
3623  {
3624  if (quantum_info->format == FloatingPointQuantumFormat)
3625  {
3626  double
3627  pixel;
3628 
3629  for (x=0; x < (ssize_t) number_pixels; x++)
3630  {
3631  q=PopQuantumDoublePixel(quantum_info,(double)
3632  GetPixelRed(image,p),q);
3633  q=PopQuantumDoublePixel(quantum_info,(double)
3634  GetPixelGreen(image,p),q);
3635  q=PopQuantumDoublePixel(quantum_info,(double)
3636  GetPixelBlue(image,p),q);
3637  pixel=(double) GetPixelOpacity(image,p);
3638  q=PopQuantumDoublePixel(quantum_info,pixel,q);
3639  p+=(ptrdiff_t) GetPixelChannels(image);
3640  q+=(ptrdiff_t) quantum_info->pad;
3641  }
3642  break;
3643  }
3644  magick_fallthrough;
3645  }
3646  default:
3647  {
3648  range=GetQuantumRange(quantum_info->depth);
3649  for (x=0; x < (ssize_t) number_pixels; x++)
3650  {
3651  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3652  range),q);
3653  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3654  range),q);
3655  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3656  range),q);
3657  q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
3658  range),q);
3659  p+=(ptrdiff_t) GetPixelChannels(image);
3660  q+=(ptrdiff_t) quantum_info->pad;
3661  }
3662  break;
3663  }
3664  }
3665 }
3666 
3667 MagickExport size_t ExportQuantumPixels(const Image *image,
3668  CacheView *image_view,QuantumInfo *quantum_info,
3669  const QuantumType quantum_type,unsigned char *magick_restrict pixels,
3670  ExceptionInfo *exception)
3671 {
3672  const Quantum
3673  *magick_restrict p;
3674 
3675  MagickSizeType
3676  number_pixels;
3677 
3678  size_t
3679  extent;
3680 
3681  ssize_t
3682  x;
3683 
3684  unsigned char
3685  *magick_restrict q;
3686 
3687  assert(image != (Image *) NULL);
3688  assert(image->signature == MagickCoreSignature);
3689  assert(quantum_info != (QuantumInfo *) NULL);
3690  assert(quantum_info->signature == MagickCoreSignature);
3691  assert(exception != (ExceptionInfo *) NULL);
3692  assert(exception->signature == MagickCoreSignature);
3693  if (IsEventLogging() != MagickFalse)
3694  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3695  if (pixels == (unsigned char *) NULL)
3696  pixels=(unsigned char *) GetQuantumPixels(quantum_info);
3697  if (image_view == (CacheView *) NULL)
3698  {
3699  number_pixels=GetImageExtent(image);
3700  p=GetVirtualPixelQueue(image);
3701  }
3702  else
3703  {
3704  number_pixels=GetCacheViewExtent(image_view);
3705  p=GetCacheViewVirtualPixelQueue(image_view);
3706  }
3707  if (p == (Quantum *) NULL)
3708  return(0);
3709  if (quantum_info->alpha_type == AssociatedQuantumAlpha)
3710  {
3711  double
3712  Sa;
3713 
3714  Quantum
3715  *magick_restrict r;
3716 
3717  /*
3718  Associate alpha.
3719  */
3720  if (image_view == (CacheView *) NULL)
3721  r=GetAuthenticPixelQueue(image);
3722  else
3723  r=GetCacheViewAuthenticPixelQueue(image_view);
3724  for (x=0; x < (ssize_t) image->columns; x++)
3725  {
3726  ssize_t
3727  i;
3728 
3729  Sa=QuantumScale*(double) GetPixelAlpha(image,r);
3730  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
3731  {
3732  PixelChannel channel = GetPixelChannelChannel(image,i);
3733  PixelTrait traits = GetPixelChannelTraits(image,channel);
3734  if ((traits & UpdatePixelTrait) == 0)
3735  continue;
3736  r[i]=ClampToQuantum(Sa*(double) r[i]);
3737  }
3738  r+=(ptrdiff_t) GetPixelChannels(image);
3739  }
3740  }
3741  if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3742  {
3743  Quantum
3744  quantum;
3745 
3746  Quantum
3747  *magick_restrict r;
3748 
3749  if (image_view == (CacheView *) NULL)
3750  r=GetAuthenticPixelQueue(image);
3751  else
3752  r=GetCacheViewAuthenticPixelQueue(image_view);
3753  for (x=0; x < (ssize_t) number_pixels; x++)
3754  {
3755  quantum=GetPixelRed(image,r);
3756  SetPixelRed(image,GetPixelGreen(image,r),r);
3757  SetPixelGreen(image,quantum,r);
3758  r+=(ptrdiff_t) GetPixelChannels(image);
3759  }
3760  }
3761  q=pixels;
3762  ResetQuantumState(quantum_info);
3763  extent=GetQuantumExtent(image,quantum_info,quantum_type);
3764  switch (quantum_type)
3765  {
3766  case AlphaQuantum:
3767  {
3768  ExportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
3769  break;
3770  }
3771  case BGRQuantum:
3772  {
3773  ExportBGRQuantum(image,quantum_info,number_pixels,p,q);
3774  break;
3775  }
3776  case BGRAQuantum:
3777  {
3778  ExportBGRAQuantum(image,quantum_info,number_pixels,p,q);
3779  break;
3780  }
3781  case BGROQuantum:
3782  {
3783  ExportBGROQuantum(image,quantum_info,number_pixels,p,q);
3784  break;
3785  }
3786  case BlackQuantum:
3787  {
3788  ExportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
3789  break;
3790  }
3791  case BlueQuantum:
3792  case YellowQuantum:
3793  {
3794  ExportPixelChannel(image,quantum_info,number_pixels,p,q,BluePixelChannel);
3795  break;
3796  }
3797  case CMYKQuantum:
3798  {
3799  ExportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
3800  break;
3801  }
3802  case CMYKAQuantum:
3803  {
3804  ExportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
3805  break;
3806  }
3807  case MultispectralQuantum:
3808  {
3809  ExportMultispectralQuantum(image,quantum_info,number_pixels,p,q,exception);
3810  break;
3811  }
3812  case CMYKOQuantum:
3813  {
3814  ExportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
3815  break;
3816  }
3817  case CbYCrYQuantum:
3818  {
3819  ExportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
3820  break;
3821  }
3822  case GrayQuantum:
3823  {
3824  ExportGrayQuantum(image,quantum_info,number_pixels,p,q);
3825  break;
3826  }
3827  case GrayAlphaQuantum:
3828  {
3829  ExportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
3830  break;
3831  }
3832  case GreenQuantum:
3833  case MagentaQuantum:
3834  {
3835  ExportPixelChannel(image,quantum_info,number_pixels,p,q,
3836  GreenPixelChannel);
3837  break;
3838  }
3839  case IndexQuantum:
3840  {
3841  ExportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
3842  break;
3843  }
3844  case IndexAlphaQuantum:
3845  {
3846  ExportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
3847  break;
3848  }
3849  case RedQuantum:
3850  case CyanQuantum:
3851  {
3852  ExportPixelChannel(image,quantum_info,number_pixels,p,q,RedPixelChannel);
3853  break;
3854  }
3855  case OpacityQuantum:
3856  {
3857  ExportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
3858  break;
3859  }
3860  case RGBQuantum:
3861  case CbYCrQuantum:
3862  {
3863  ExportRGBQuantum(image,quantum_info,number_pixels,p,q);
3864  break;
3865  }
3866  case RGBAQuantum:
3867  case CbYCrAQuantum:
3868  {
3869  ExportRGBAQuantum(image,quantum_info,number_pixels,p,q);
3870  break;
3871  }
3872  case RGBOQuantum:
3873  {
3874  ExportRGBOQuantum(image,quantum_info,number_pixels,p,q);
3875  break;
3876  }
3877  default:
3878  break;
3879  }
3880  if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3881  {
3882  Quantum
3883  quantum;
3884 
3885  Quantum
3886  *magick_restrict r;
3887 
3888  if (image_view == (CacheView *) NULL)
3889  r=GetAuthenticPixelQueue(image);
3890  else
3891  r=GetCacheViewAuthenticPixelQueue(image_view);
3892  for (x=0; x < (ssize_t) number_pixels; x++)
3893  {
3894  quantum=GetPixelRed(image,r);
3895  SetPixelRed(image,GetPixelGreen(image,r),r);
3896  SetPixelGreen(image,quantum,r);
3897  r+=(ptrdiff_t) GetPixelChannels(image);
3898  }
3899  }
3900  return(extent);
3901 }
_CacheView
Definition: cache-view.c:66
_ExceptionInfo
Definition: exception.h:102
_Image
Definition: image.h:132
_QuantumInfo
Definition: quantum-private.h:47