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