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