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