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