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