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"
114 static inline unsigned char *PopQuantumDoublePixel(
QuantumInfo *quantum_info,
115 const double pixel,
unsigned char *magick_restrict pixels)
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)
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];
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];
149 static inline unsigned char *PopQuantumFloatPixel(
QuantumInfo *quantum_info,
150 const float pixel,
unsigned char *magick_restrict pixels)
158 (void) memset(quantum,0,
sizeof(quantum));
160 *p=(float) ((
double) pixel*quantum_info->state.inverse_scale+
161 quantum_info->minimum);
162 if (quantum_info->endian == LSBEndian)
164 *pixels++=quantum[0];
165 *pixels++=quantum[1];
166 *pixels++=quantum[2];
167 *pixels++=quantum[3];
170 *pixels++=quantum[3];
171 *pixels++=quantum[2];
172 *pixels++=quantum[1];
173 *pixels++=quantum[0];
177 static inline unsigned char *PopQuantumPixel(
QuantumInfo *quantum_info,
178 const QuantumAny pixel,
unsigned char *magick_restrict pixels)
186 if (quantum_info->state.bits == 0UL)
187 quantum_info->state.bits=8U;
188 for (i=(ssize_t) quantum_info->depth; i > 0L; )
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;
196 if (quantum_info->state.bits == 8UL)
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)
204 quantum_info->state.bits=8UL;
210 static inline unsigned char *PopQuantumLongPixel(
QuantumInfo *quantum_info,
211 const size_t pixel,
unsigned char *magick_restrict pixels)
219 if (quantum_info->state.bits == 0U)
220 quantum_info->state.bits=32UL;
221 for (i=(ssize_t) quantum_info->depth; i > 0; )
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)
233 pixels=PopLongPixel(quantum_info->endian,quantum_info->state.pixel,
235 quantum_info->state.pixel=0U;
236 quantum_info->state.bits=32U;
242 static void ExportAlphaQuantum(
QuantumInfo *quantum_info,
243 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
244 unsigned char *magick_restrict q)
252 switch (quantum_info->depth)
259 for (x=0; x < (ssize_t) number_pixels; x++)
261 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
262 q=PopCharPixel(pixel,q);
264 q+=quantum_info->pad;
273 if (quantum_info->format == FloatingPointQuantumFormat)
275 for (x=0; x < (ssize_t) number_pixels; x++)
277 pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(p));
278 q=PopShortPixel(quantum_info->endian,pixel,q);
280 q+=quantum_info->pad;
284 for (x=0; x < (ssize_t) number_pixels; x++)
286 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetPixelOpacity(p)));
287 q=PopShortPixel(quantum_info->endian,pixel,q);
289 q+=quantum_info->pad;
298 if (quantum_info->format == FloatingPointQuantumFormat)
300 for (x=0; x < (ssize_t) number_pixels; x++)
305 pixel=(float) (GetPixelAlpha(p));
306 q=PopQuantumFloatPixel(quantum_info,pixel,q);
308 q+=quantum_info->pad;
312 for (x=0; x < (ssize_t) number_pixels; x++)
314 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetPixelOpacity(p)));
315 q=PopLongPixel(quantum_info->endian,pixel,q);
317 q+=quantum_info->pad;
323 if (quantum_info->format == FloatingPointQuantumFormat)
325 for (x=0; x < (ssize_t) number_pixels; x++)
330 pixel=(double) (GetPixelAlpha(p));
331 q=PopQuantumDoublePixel(quantum_info,pixel,q);
333 q+=quantum_info->pad;
340 range=GetQuantumRange(quantum_info->depth);
341 for (x=0; x < (ssize_t) number_pixels; x++)
343 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
344 (GetPixelAlpha(p)),range),q);
346 q+=quantum_info->pad;
353 static void ExportBGRQuantum(
QuantumInfo *quantum_info,
354 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
355 unsigned char *magick_restrict q)
366 switch (quantum_info->depth)
370 for (x=0; x < (ssize_t) number_pixels; x++)
372 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(p)),q);
373 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(p)),q);
374 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(p)),q);
376 q+=quantum_info->pad;
385 range=GetQuantumRange(quantum_info->depth);
386 if (quantum_info->pack == MagickFalse)
388 for (x=0; x < (ssize_t) number_pixels; x++)
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);
396 q+=quantum_info->pad;
400 if (quantum_info->quantum == 32UL)
402 for (x=0; x < (ssize_t) number_pixels; x++)
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);
411 q+=quantum_info->pad;
415 for (x=0; x < (ssize_t) number_pixels; x++)
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);
424 q+=quantum_info->pad;
433 range=GetQuantumRange(quantum_info->depth);
434 if (quantum_info->pack == MagickFalse)
436 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
443 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
448 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
453 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
458 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),q);
464 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
469 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
474 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
479 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),q);
480 q+=quantum_info->pad;
482 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
489 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
494 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
499 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
504 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),q);
505 q+=quantum_info->pad;
511 if (quantum_info->quantum == 32UL)
513 for (x=0; x < (ssize_t) number_pixels; x++)
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);
522 q+=quantum_info->pad;
526 for (x=0; x < (ssize_t) number_pixels; x++)
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);
535 q+=quantum_info->pad;
544 if (quantum_info->format == FloatingPointQuantumFormat)
546 for (x=0; x < (ssize_t) number_pixels; x++)
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);
555 q+=quantum_info->pad;
559 for (x=0; x < (ssize_t) number_pixels; x++)
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);
568 q+=quantum_info->pad;
577 if (quantum_info->format == FloatingPointQuantumFormat)
579 for (x=0; x < (ssize_t) number_pixels; x++)
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);
585 q+=quantum_info->pad;
589 for (x=0; x < (ssize_t) number_pixels; x++)
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);
598 q+=quantum_info->pad;
604 if (quantum_info->format == FloatingPointQuantumFormat)
606 for (x=0; x < (ssize_t) number_pixels; x++)
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);
612 q+=quantum_info->pad;
619 range=GetQuantumRange(quantum_info->depth);
620 for (x=0; x < (ssize_t) number_pixels; x++)
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);
629 q+=quantum_info->pad;
636 static void ExportBGRAQuantum(
QuantumInfo *quantum_info,
637 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
638 unsigned char *magick_restrict q)
646 switch (quantum_info->depth)
653 for (x=0; x < (ssize_t) number_pixels; x++)
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);
664 q+=quantum_info->pad;
673 range=GetQuantumRange(quantum_info->depth);
674 if (quantum_info->pack == MagickFalse)
688 for (x=0; x < (ssize_t) number_pixels; x++)
690 for (i=0; i < 4; i++)
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;
703 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
709 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
715 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
717 q=PopLongPixel(quantum_info->endian,pixel,q);
725 q+=quantum_info->pad;
729 if (quantum_info->quantum == 32UL)
731 for (x=0; x < (ssize_t) number_pixels; x++)
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),
741 q=PopQuantumLongPixel(quantum_info,pixel,q);
743 q+=quantum_info->pad;
747 for (x=0; x < (ssize_t) number_pixels; x++)
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),
757 q=PopQuantumPixel(quantum_info,pixel,q);
759 q+=quantum_info->pad;
768 if (quantum_info->format == FloatingPointQuantumFormat)
770 for (x=0; x < (ssize_t) number_pixels; x++)
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);
781 q+=quantum_info->pad;
785 for (x=0; x < (ssize_t) number_pixels; x++)
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);
796 q+=quantum_info->pad;
805 if (quantum_info->format == FloatingPointQuantumFormat)
807 for (x=0; x < (ssize_t) number_pixels; x++)
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);
818 q+=quantum_info->pad;
822 for (x=0; x < (ssize_t) number_pixels; x++)
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);
833 q+=quantum_info->pad;
839 if (quantum_info->format == FloatingPointQuantumFormat)
844 for (x=0; x < (ssize_t) number_pixels; x++)
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);
852 q+=quantum_info->pad;
859 range=GetQuantumRange(quantum_info->depth);
860 for (x=0; x < (ssize_t) number_pixels; x++)
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);
871 q+=quantum_info->pad;
878 static void ExportBGROQuantum(
QuantumInfo *quantum_info,
879 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
880 unsigned char *magick_restrict q)
888 switch (quantum_info->depth)
895 for (x=0; x < (ssize_t) number_pixels; x++)
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);
906 q+=quantum_info->pad;
915 range=GetQuantumRange(quantum_info->depth);
916 if (quantum_info->pack == MagickFalse)
930 for (x=0; x < (ssize_t) number_pixels; x++)
932 for (i=0; i < 4; i++)
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;
945 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
951 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
957 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
959 q=PopLongPixel(quantum_info->endian,pixel,q);
967 q+=quantum_info->pad;
971 if (quantum_info->quantum == 32UL)
973 for (x=0; x < (ssize_t) number_pixels; x++)
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);
984 q+=quantum_info->pad;
988 for (x=0; x < (ssize_t) number_pixels; x++)
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);
999 q+=quantum_info->pad;
1008 if (quantum_info->format == FloatingPointQuantumFormat)
1010 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1021 q+=quantum_info->pad;
1025 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1036 q+=quantum_info->pad;
1045 if (quantum_info->format == FloatingPointQuantumFormat)
1047 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1058 q+=quantum_info->pad;
1062 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1073 q+=quantum_info->pad;
1079 if (quantum_info->format == FloatingPointQuantumFormat)
1084 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1092 q+=quantum_info->pad;
1099 range=GetQuantumRange(quantum_info->depth);
1100 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1111 q+=quantum_info->pad;
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,
1126 if (image->colorspace != CMYKColorspace)
1128 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1129 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1132 switch (quantum_info->depth)
1139 for (x=0; x < (ssize_t) number_pixels; x++)
1141 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1142 q=PopCharPixel(pixel,q);
1144 q+=quantum_info->pad;
1153 if (quantum_info->format == FloatingPointQuantumFormat)
1155 for (x=0; x < (ssize_t) number_pixels; x++)
1157 pixel=SinglePrecisionToHalf(QuantumScale*GetPixelIndex(indexes+x));
1158 q=PopShortPixel(quantum_info->endian,pixel,q);
1160 q+=quantum_info->pad;
1164 for (x=0; x < (ssize_t) number_pixels; x++)
1166 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1167 q=PopShortPixel(quantum_info->endian,pixel,q);
1169 q+=quantum_info->pad;
1178 if (quantum_info->format == FloatingPointQuantumFormat)
1180 for (x=0; x < (ssize_t) number_pixels; x++)
1182 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
1184 q+=quantum_info->pad;
1188 for (x=0; x < (ssize_t) number_pixels; x++)
1190 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1191 q=PopLongPixel(quantum_info->endian,pixel,q);
1193 q+=quantum_info->pad;
1199 if (quantum_info->format == FloatingPointQuantumFormat)
1201 for (x=0; x < (ssize_t) number_pixels; x++)
1203 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(indexes+x),
1206 q+=quantum_info->pad;
1216 range=GetQuantumRange(quantum_info->depth);
1217 for (x=0; x < (ssize_t) number_pixels; x++)
1219 q=PopQuantumPixel(quantum_info,
1220 ScaleQuantumToAny((Quantum) GetPixelIndex(indexes+x),range),q);
1222 q+=quantum_info->pad;
1229 static void ExportBlueQuantum(
QuantumInfo *quantum_info,
1230 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1231 unsigned char *magick_restrict q)
1239 switch (quantum_info->depth)
1246 for (x=0; x < (ssize_t) number_pixels; x++)
1248 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1249 q=PopCharPixel(pixel,q);
1251 q+=quantum_info->pad;
1260 if (quantum_info->format == FloatingPointQuantumFormat)
1262 for (x=0; x < (ssize_t) number_pixels; x++)
1264 pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(p));
1265 q=PopShortPixel(quantum_info->endian,pixel,q);
1267 q+=quantum_info->pad;
1271 for (x=0; x < (ssize_t) number_pixels; x++)
1273 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1274 q=PopShortPixel(quantum_info->endian,pixel,q);
1276 q+=quantum_info->pad;
1285 if (quantum_info->format == FloatingPointQuantumFormat)
1287 for (x=0; x < (ssize_t) number_pixels; x++)
1289 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
1291 q+=quantum_info->pad;
1295 for (x=0; x < (ssize_t) number_pixels; x++)
1297 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1298 q=PopLongPixel(quantum_info->endian,pixel,q);
1300 q+=quantum_info->pad;
1306 if (quantum_info->format == FloatingPointQuantumFormat)
1308 for (x=0; x < (ssize_t) number_pixels; x++)
1310 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
1312 q+=quantum_info->pad;
1319 range=GetQuantumRange(quantum_info->depth);
1320 for (x=0; x < (ssize_t) number_pixels; x++)
1322 q=PopQuantumPixel(quantum_info,
1323 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1325 q+=quantum_info->pad;
1332 static void ExportCbYCrYQuantum(
QuantumInfo *quantum_info,
1333 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1334 unsigned char *magick_restrict q)
1357 range=GetQuantumRange(quantum_info->depth);
1358 switch (quantum_info->depth)
1362 if (quantum_info->pack == MagickFalse)
1364 for (x=0; x < (ssize_t) number_pixels; x+=2)
1366 for (i=0; i < 4; i++)
1372 quantum=(size_t) GetPixelRed(p);
1377 quantum=(size_t) GetPixelGreen(p);
1382 quantum=(size_t) GetPixelBlue(p);
1386 cbcr[i]=(Quantum) quantum;
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);
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);
1397 q+=quantum_info->pad;
1405 for (x=0; x < (ssize_t) number_pixels; x+=2)
1407 for (i=0; i < 4; i++)
1413 quantum=(size_t) GetPixelRed(p);
1418 quantum=(size_t) GetPixelGreen(p);
1423 quantum=(size_t) GetPixelBlue(p);
1427 cbcr[i]=(Quantum) quantum;
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);
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);
1444 q+=quantum_info->pad;
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,
1462 if (image->colorspace != CMYKColorspace)
1464 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1465 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1468 switch (quantum_info->depth)
1475 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1486 q+=quantum_info->pad;
1495 if (quantum_info->format == FloatingPointQuantumFormat)
1497 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1508 q+=quantum_info->pad;
1512 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1523 q+=quantum_info->pad;
1532 if (quantum_info->format == FloatingPointQuantumFormat)
1534 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1541 q+=quantum_info->pad;
1545 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1556 q+=quantum_info->pad;
1562 if (quantum_info->format == FloatingPointQuantumFormat)
1564 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1572 q+=quantum_info->pad;
1579 range=GetQuantumRange(quantum_info->depth);
1580 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1591 q+=quantum_info->pad;
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,
1609 if (image->colorspace != CMYKColorspace)
1611 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1612 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1615 switch (quantum_info->depth)
1622 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1635 q+=quantum_info->pad;
1644 if (quantum_info->format == FloatingPointQuantumFormat)
1646 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1659 q+=quantum_info->pad;
1663 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1676 q+=quantum_info->pad;
1685 if (quantum_info->format == FloatingPointQuantumFormat)
1687 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1699 q+=quantum_info->pad;
1703 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1716 q+=quantum_info->pad;
1722 if (quantum_info->format == FloatingPointQuantumFormat)
1727 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1737 q+=quantum_info->pad;
1744 range=GetQuantumRange(quantum_info->depth);
1745 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1758 q+=quantum_info->pad;
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,
1776 if (image->colorspace != CMYKColorspace)
1778 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1779 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1782 switch (quantum_info->depth)
1789 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1802 q+=quantum_info->pad;
1811 if (quantum_info->format == FloatingPointQuantumFormat)
1813 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1826 q+=quantum_info->pad;
1830 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1843 q+=quantum_info->pad;
1852 if (quantum_info->format == FloatingPointQuantumFormat)
1854 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1866 q+=quantum_info->pad;
1870 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1883 q+=quantum_info->pad;
1889 if (quantum_info->format == FloatingPointQuantumFormat)
1894 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1904 q+=quantum_info->pad;
1911 range=GetQuantumRange(quantum_info->depth);
1912 for (x=0; x < (ssize_t) number_pixels; x++)
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);
1925 q+=quantum_info->pad;
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)
1945 switch (quantum_info->depth)
1958 if (quantum_info->min_is_white != MagickFalse)
1963 threshold=QuantumRange/2.0;
1964 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1967 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
1969 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
1971 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
1973 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
1975 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
1977 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
1979 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
1981 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
1985 if ((number_pixels % 8) != 0)
1988 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1990 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
2002 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2004 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2005 *q=(((pixel >> 4) & 0xf) << 4);
2007 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2012 if ((number_pixels % 2) != 0)
2014 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2015 *q=(((pixel >> 4) & 0xf) << 4);
2026 for (x=0; x < (ssize_t) number_pixels; x++)
2028 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2029 q=PopCharPixel(pixel,q);
2031 q+=quantum_info->pad;
2037 range=GetQuantumRange(quantum_info->depth);
2038 if (quantum_info->pack == MagickFalse)
2043 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
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);
2051 q+=quantum_info->pad;
2053 if (x < (ssize_t) number_pixels)
2056 if (x++ < (ssize_t) (number_pixels-1))
2057 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
2059 if (x++ < (ssize_t) number_pixels)
2060 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
2062 q=PopLongPixel(quantum_info->endian,pixel,q);
2066 for (x=0; x < (ssize_t) number_pixels; x++)
2068 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2069 GetPixelLuma(image,p)),range),q);
2071 q+=quantum_info->pad;
2080 range=GetQuantumRange(quantum_info->depth);
2081 if (quantum_info->pack == MagickFalse)
2083 for (x=0; x < (ssize_t) number_pixels; x++)
2085 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2086 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel >> 4),q);
2088 q+=quantum_info->pad;
2092 for (x=0; x < (ssize_t) number_pixels; x++)
2094 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2095 GetPixelLuma(image,p)),range),q);
2097 q+=quantum_info->pad;
2106 if (quantum_info->format == FloatingPointQuantumFormat)
2108 for (x=0; x < (ssize_t) number_pixels; x++)
2110 pixel=SinglePrecisionToHalf(QuantumScale*GetPixelLuma(image,p));
2111 q=PopShortPixel(quantum_info->endian,pixel,q);
2113 q+=quantum_info->pad;
2117 for (x=0; x < (ssize_t) number_pixels; x++)
2119 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2120 q=PopShortPixel(quantum_info->endian,pixel,q);
2122 q+=quantum_info->pad;
2131 if (quantum_info->format == FloatingPointQuantumFormat)
2133 for (x=0; x < (ssize_t) number_pixels; x++)
2138 pixel=(float) GetPixelLuma(image,p);
2139 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2141 q+=quantum_info->pad;
2145 for (x=0; x < (ssize_t) number_pixels; x++)
2147 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2148 q=PopLongPixel(quantum_info->endian,pixel,q);
2150 q+=quantum_info->pad;
2156 if (quantum_info->format == FloatingPointQuantumFormat)
2158 for (x=0; x < (ssize_t) number_pixels; x++)
2163 pixel=(double) GetPixelLuma(image,p);
2164 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2166 q+=quantum_info->pad;
2173 range=GetQuantumRange(quantum_info->depth);
2174 for (x=0; x < (ssize_t) number_pixels; x++)
2176 q=PopQuantumPixel(quantum_info,
2177 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),range),q);
2179 q+=quantum_info->pad;
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)
2199 switch (quantum_info->depth)
2213 if (quantum_info->min_is_white != MagickFalse)
2218 threshold=QuantumRange/2.0;
2219 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2222 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
2223 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2225 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
2227 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
2228 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2230 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
2232 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
2233 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2235 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
2237 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
2238 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2240 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
2244 if ((number_pixels % 4) != 0)
2247 for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
2249 *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
2251 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ? 0x00 :
2253 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (
unsigned char) (7-bit-1));
2265 for (x=0; x < (ssize_t) number_pixels ; x++)
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);
2282 for (x=0; x < (ssize_t) number_pixels; x++)
2284 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2285 q=PopCharPixel(pixel,q);
2286 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
2287 q=PopCharPixel(pixel,q);
2289 q+=quantum_info->pad;
2298 if (quantum_info->format == FloatingPointQuantumFormat)
2300 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2307 q+=quantum_info->pad;
2311 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2318 q+=quantum_info->pad;
2327 if (quantum_info->format == FloatingPointQuantumFormat)
2329 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2339 q+=quantum_info->pad;
2343 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2350 q+=quantum_info->pad;
2356 if (quantum_info->format == FloatingPointQuantumFormat)
2358 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2368 q+=quantum_info->pad;
2375 range=GetQuantumRange(quantum_info->depth);
2376 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2383 q+=quantum_info->pad;
2390 static void ExportGreenQuantum(
QuantumInfo *quantum_info,
2391 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2392 unsigned char *magick_restrict q)
2400 switch (quantum_info->depth)
2407 for (x=0; x < (ssize_t) number_pixels; x++)
2409 pixel=ScaleQuantumToChar(GetPixelGreen(p));
2410 q=PopCharPixel(pixel,q);
2412 q+=quantum_info->pad;
2421 if (quantum_info->format == FloatingPointQuantumFormat)
2423 for (x=0; x < (ssize_t) number_pixels; x++)
2425 pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(p));
2426 q=PopShortPixel(quantum_info->endian,pixel,q);
2428 q+=quantum_info->pad;
2432 for (x=0; x < (ssize_t) number_pixels; x++)
2434 pixel=ScaleQuantumToShort(GetPixelGreen(p));
2435 q=PopShortPixel(quantum_info->endian,pixel,q);
2437 q+=quantum_info->pad;
2446 if (quantum_info->format == FloatingPointQuantumFormat)
2448 for (x=0; x < (ssize_t) number_pixels; x++)
2450 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
2452 q+=quantum_info->pad;
2456 for (x=0; x < (ssize_t) number_pixels; x++)
2458 pixel=ScaleQuantumToLong(GetPixelGreen(p));
2459 q=PopLongPixel(quantum_info->endian,pixel,q);
2461 q+=quantum_info->pad;
2467 if (quantum_info->format == FloatingPointQuantumFormat)
2469 for (x=0; x < (ssize_t) number_pixels; x++)
2471 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
2473 q+=quantum_info->pad;
2480 range=GetQuantumRange(quantum_info->depth);
2481 for (x=0; x < (ssize_t) number_pixels; x++)
2483 q=PopQuantumPixel(quantum_info,
2484 ScaleQuantumToAny(GetPixelGreen(p),range),q);
2486 q+=quantum_info->pad;
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,
2504 if (image->storage_class != PseudoClass)
2506 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2507 "ColormappedImageRequired",
"`%s'",image->filename);
2510 switch (quantum_info->depth)
2517 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
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);
2537 if ((number_pixels % 8) != 0)
2540 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2542 pixel=(
unsigned char) ((ssize_t) *indexes++);
2543 *q|=((pixel & 0x01) << (
unsigned char) bit);
2554 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2556 pixel=(
unsigned char) ((ssize_t) *indexes++);
2557 *q=((pixel & 0xf) << 4);
2558 pixel=(
unsigned char) ((ssize_t) *indexes++);
2559 *q|=((pixel & 0xf) << 0);
2562 if ((number_pixels % 2) != 0)
2564 pixel=(
unsigned char) ((ssize_t) *indexes++);
2565 *q=((pixel & 0xf) << 4);
2572 for (x=0; x < (ssize_t) number_pixels; x++)
2574 q=PopCharPixel((
unsigned char) GetPixelIndex(indexes+x),q);
2575 q+=quantum_info->pad;
2581 if (quantum_info->format == FloatingPointQuantumFormat)
2583 for (x=0; x < (ssize_t) number_pixels; x++)
2585 q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(QuantumScale*
2586 GetPixelIndex(indexes+x)),q);
2587 q+=quantum_info->pad;
2591 for (x=0; x < (ssize_t) number_pixels; x++)
2593 q=PopShortPixel(quantum_info->endian,(
unsigned short) GetPixelIndex(indexes+x),q);
2594 q+=quantum_info->pad;
2600 if (quantum_info->format == FloatingPointQuantumFormat)
2602 for (x=0; x < (ssize_t) number_pixels; x++)
2604 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
2606 q+=quantum_info->pad;
2610 for (x=0; x < (ssize_t) number_pixels; x++)
2612 q=PopLongPixel(quantum_info->endian,(
unsigned int) GetPixelIndex(indexes+x),q);
2613 q+=quantum_info->pad;
2619 if (quantum_info->format == FloatingPointQuantumFormat)
2621 for (x=0; x < (ssize_t) number_pixels; x++)
2623 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(indexes+x),
2626 q+=quantum_info->pad;
2633 for (x=0; x < (ssize_t) number_pixels; x++)
2635 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(indexes+x),q);
2637 q+=quantum_info->pad;
2644 static void ExportIndexAlphaQuantum(
const Image *image,
2645 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
2647 const IndexPacket *magick_restrict indexes,
unsigned char *magick_restrict q,
2656 if (image->storage_class != PseudoClass)
2658 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2659 "ColormappedImageRequired",
"`%s'",image->filename);
2662 switch (quantum_info->depth)
2669 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
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);
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);
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);
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);
2697 if ((number_pixels % 4) != 0)
2700 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
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));
2718 for (x=0; x < (ssize_t) number_pixels ; x++)
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);
2735 for (x=0; x < (ssize_t) number_pixels; x++)
2737 q=PopCharPixel((
unsigned char) GetPixelIndex(indexes+x),q);
2738 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
2739 q=PopCharPixel(pixel,q);
2741 q+=quantum_info->pad;
2750 if (quantum_info->format == FloatingPointQuantumFormat)
2752 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2759 q+=quantum_info->pad;
2763 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2770 q+=quantum_info->pad;
2779 if (quantum_info->format == FloatingPointQuantumFormat)
2781 for (x=0; x < (ssize_t) number_pixels; x++)
2786 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
2787 pixel=(float) (GetPixelAlpha(p));
2788 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2790 q+=quantum_info->pad;
2794 for (x=0; x < (ssize_t) number_pixels; x++)
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);
2801 q+=quantum_info->pad;
2807 if (quantum_info->format == FloatingPointQuantumFormat)
2809 for (x=0; x < (ssize_t) number_pixels; x++)
2814 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(indexes+x),
2816 pixel=(double) (GetPixelAlpha(p));
2817 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2819 q+=quantum_info->pad;
2829 range=GetQuantumRange(quantum_info->depth);
2830 for (x=0; x < (ssize_t) number_pixels; x++)
2832 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(indexes+x),q);
2833 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
2834 (GetPixelAlpha(p)),range),q);
2836 q+=quantum_info->pad;
2843 static void ExportOpacityQuantum(
QuantumInfo *quantum_info,
2844 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2845 unsigned char *magick_restrict q)
2853 switch (quantum_info->depth)
2860 for (x=0; x < (ssize_t) number_pixels; x++)
2862 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
2863 q=PopCharPixel(pixel,q);
2865 q+=quantum_info->pad;
2874 if (quantum_info->format == FloatingPointQuantumFormat)
2876 for (x=0; x < (ssize_t) number_pixels; x++)
2878 pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(p));
2879 q=PopShortPixel(quantum_info->endian,pixel,q);
2881 q+=quantum_info->pad;
2885 for (x=0; x < (ssize_t) number_pixels; x++)
2887 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
2888 q=PopShortPixel(quantum_info->endian,pixel,q);
2890 q+=quantum_info->pad;
2899 if (quantum_info->format == FloatingPointQuantumFormat)
2901 for (x=0; x < (ssize_t) number_pixels; x++)
2903 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelOpacity(p),q);
2905 q+=quantum_info->pad;
2909 for (x=0; x < (ssize_t) number_pixels; x++)
2911 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
2912 q=PopLongPixel(quantum_info->endian,pixel,q);
2914 q+=quantum_info->pad;
2920 if (quantum_info->format == FloatingPointQuantumFormat)
2922 for (x=0; x < (ssize_t) number_pixels; x++)
2924 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelOpacity(p),q);
2926 q+=quantum_info->pad;
2933 range=GetQuantumRange(quantum_info->depth);
2934 for (x=0; x < (ssize_t) number_pixels; x++)
2936 q=PopQuantumPixel(quantum_info,
2937 ScaleQuantumToAny(GetPixelOpacity(p),range),q);
2939 q+=quantum_info->pad;
2946 static void ExportRedQuantum(
QuantumInfo *quantum_info,
2947 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2948 unsigned char *magick_restrict q)
2956 switch (quantum_info->depth)
2963 for (x=0; x < (ssize_t) number_pixels; x++)
2965 pixel=ScaleQuantumToChar(GetPixelRed(p));
2966 q=PopCharPixel(pixel,q);
2968 q+=quantum_info->pad;
2977 if (quantum_info->format == FloatingPointQuantumFormat)
2979 for (x=0; x < (ssize_t) number_pixels; x++)
2981 pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(p));
2982 q=PopShortPixel(quantum_info->endian,pixel,q);
2984 q+=quantum_info->pad;
2988 for (x=0; x < (ssize_t) number_pixels; x++)
2990 pixel=ScaleQuantumToShort(GetPixelRed(p));
2991 q=PopShortPixel(quantum_info->endian,pixel,q);
2993 q+=quantum_info->pad;
3002 if (quantum_info->format == FloatingPointQuantumFormat)
3004 for (x=0; x < (ssize_t) number_pixels; x++)
3006 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
3008 q+=quantum_info->pad;
3012 for (x=0; x < (ssize_t) number_pixels; x++)
3014 pixel=ScaleQuantumToLong(GetPixelRed(p));
3015 q=PopLongPixel(quantum_info->endian,pixel,q);
3017 q+=quantum_info->pad;
3023 if (quantum_info->format == FloatingPointQuantumFormat)
3025 for (x=0; x < (ssize_t) number_pixels; x++)
3027 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
3029 q+=quantum_info->pad;
3036 range=GetQuantumRange(quantum_info->depth);
3037 for (x=0; x < (ssize_t) number_pixels; x++)
3039 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),range),
3042 q+=quantum_info->pad;
3049 static void ExportRGBQuantum(
QuantumInfo *quantum_info,
3050 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
3051 unsigned char *magick_restrict q)
3062 switch (quantum_info->depth)
3066 for (x=0; x < (ssize_t) number_pixels; x++)
3068 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(p)),q);
3069 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(p)),q);
3070 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(p)),q);
3072 q+=quantum_info->pad;
3081 range=GetQuantumRange(quantum_info->depth);
3082 if (quantum_info->pack == MagickFalse)
3084 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3092 q+=quantum_info->pad;
3096 if (quantum_info->quantum == 32UL)
3098 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3107 q+=quantum_info->pad;
3111 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3120 q+=quantum_info->pad;
3129 range=GetQuantumRange(quantum_info->depth);
3130 if (quantum_info->pack == MagickFalse)
3132 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
3139 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3144 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3149 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3154 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3161 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3166 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3171 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3176 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3178 q+=quantum_info->pad;
3180 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3182 switch ((x+bit) % 3)
3187 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3192 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3197 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3202 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3204 q+=quantum_info->pad;
3210 if (quantum_info->quantum == 32UL)
3212 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3221 q+=quantum_info->pad;
3225 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3234 q+=quantum_info->pad;
3243 if (quantum_info->format == FloatingPointQuantumFormat)
3245 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3254 q+=quantum_info->pad;
3258 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3267 q+=quantum_info->pad;
3276 if (quantum_info->format == FloatingPointQuantumFormat)
3278 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3284 q+=quantum_info->pad;
3288 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3297 q+=quantum_info->pad;
3303 if (quantum_info->format == FloatingPointQuantumFormat)
3305 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3311 q+=quantum_info->pad;
3318 range=GetQuantumRange(quantum_info->depth);
3319 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3328 q+=quantum_info->pad;
3335 static void ExportRGBAQuantum(
QuantumInfo *quantum_info,
3336 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
3337 unsigned char *magick_restrict q)
3345 switch (quantum_info->depth)
3352 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3363 q+=quantum_info->pad;
3372 range=GetQuantumRange(quantum_info->depth);
3373 if (quantum_info->pack == MagickFalse)
3387 for (x=0; x < (ssize_t) number_pixels; x++)
3389 for (i=0; i < 4; i++)
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;
3402 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3408 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3414 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3416 q=PopLongPixel(quantum_info->endian,pixel,q);
3424 q+=quantum_info->pad;
3428 if (quantum_info->quantum == 32UL)
3430 for (x=0; x < (ssize_t) number_pixels; x++)
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),
3440 q=PopQuantumLongPixel(quantum_info,pixel,q);
3442 q+=quantum_info->pad;
3446 for (x=0; x < (ssize_t) number_pixels; x++)
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),
3456 q=PopQuantumPixel(quantum_info,pixel,q);
3458 q+=quantum_info->pad;
3467 if (quantum_info->format == FloatingPointQuantumFormat)
3469 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3480 q+=quantum_info->pad;
3484 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3495 q+=quantum_info->pad;
3504 if (quantum_info->format == FloatingPointQuantumFormat)
3506 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3517 q+=quantum_info->pad;
3521 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3532 q+=quantum_info->pad;
3538 if (quantum_info->format == FloatingPointQuantumFormat)
3543 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3551 q+=quantum_info->pad;
3558 range=GetQuantumRange(quantum_info->depth);
3559 for (x=0; x < (ssize_t) number_pixels; x++)
3561 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),
3563 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(p),
3565 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(p),
3567 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
3568 GetPixelAlpha(p),range),q);
3570 q+=quantum_info->pad;
3577 static void ExportRGBOQuantum(
QuantumInfo *quantum_info,
3578 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
3579 unsigned char *magick_restrict q)
3587 switch (quantum_info->depth)
3594 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3605 q+=quantum_info->pad;
3614 range=GetQuantumRange(quantum_info->depth);
3615 if (quantum_info->pack == MagickFalse)
3629 for (x=0; x < (ssize_t) number_pixels; x++)
3631 for (i=0; i < 4; i++)
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;
3644 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3650 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3656 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3658 q=PopLongPixel(quantum_info->endian,pixel,q);
3666 q+=quantum_info->pad;
3670 if (quantum_info->quantum == 32UL)
3672 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3683 q+=quantum_info->pad;
3687 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3698 q+=quantum_info->pad;
3707 if (quantum_info->format == FloatingPointQuantumFormat)
3709 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3720 q+=quantum_info->pad;
3724 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3735 q+=quantum_info->pad;
3744 if (quantum_info->format == FloatingPointQuantumFormat)
3746 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3757 q+=quantum_info->pad;
3761 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3772 q+=quantum_info->pad;
3778 if (quantum_info->format == FloatingPointQuantumFormat)
3783 for (x=0; x < (ssize_t) number_pixels; x++)
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);
3791 q+=quantum_info->pad;
3798 range=GetQuantumRange(quantum_info->depth);
3799 for (x=0; x < (ssize_t) number_pixels; x++)
3801 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),
3803 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(p),
3805 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(p),
3807 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(p),
3810 q+=quantum_info->pad;
3817 MagickExport
size_t ExportQuantumPixels(
const Image *image,
3819 const QuantumType quantum_type,
unsigned char *magick_restrict pixels,
3829 *magick_restrict indexes;
3843 assert(image != (
Image *) NULL);
3844 assert(image->signature == MagickCoreSignature);
3845 if (IsEventLogging() != MagickFalse)
3846 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3848 assert(quantum_info->signature == MagickCoreSignature);
3849 if (pixels == (
unsigned char *) NULL)
3850 pixels=GetQuantumPixels(quantum_info);
3853 number_pixels=GetImageExtent(image);
3854 p=GetVirtualPixelQueue(image);
3855 indexes=GetVirtualIndexQueue(image);
3859 number_pixels=GetCacheViewExtent(image_view);
3860 p=GetCacheViewVirtualPixelQueue(image_view);
3861 indexes=GetCacheViewVirtualIndexQueue(image_view);
3863 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
3872 q=GetAuthenticPixelQueue(image);
3874 q=(
PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3875 for (x=0; x < (ssize_t) image->columns; x++)
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)));
3884 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3893 q=GetAuthenticPixelQueue(image);
3895 q=(
PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3896 for (x=0; x < (ssize_t) number_pixels; x++)
3898 quantum=GetPixelRed(q);
3899 SetPixelRed(q,GetPixelGreen(q));
3900 SetPixelGreen(q,quantum);
3907 extent=GetQuantumExtent(image,quantum_info,quantum_type);
3908 switch (quantum_type)
3912 ExportAlphaQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3917 ExportBGRQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3922 ExportBGRAQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3927 ExportBGROQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3932 ExportBlackQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3933 indexes,q,exception);
3939 ExportBlueQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3944 ExportCbYCrYQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3949 ExportCMYKQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3950 indexes,q,exception);
3955 ExportCMYKAQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3956 indexes,q,exception);
3961 ExportCMYKOQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3962 indexes,q,exception);
3967 ExportGrayQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,q);
3970 case GrayAlphaQuantum:
3972 ExportGrayAlphaQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,
3977 case MagentaQuantum:
3979 ExportGreenQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3984 ExportIndexQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3985 indexes,q,exception);
3988 case IndexAlphaQuantum:
3990 ExportIndexAlphaQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,
3991 p,indexes,q,exception);
3994 case OpacityQuantum:
3996 ExportOpacityQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4002 ExportRedQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4008 ExportRGBQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4014 ExportRGBAQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4019 ExportRGBOQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4025 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
4034 q=GetAuthenticPixelQueue(image);
4036 q=(
PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
4037 for (x=0; x < (ssize_t) number_pixels; x++)
4039 quantum=GetPixelRed(q);
4040 SetPixelRed(q,GetPixelGreen(q));
4041 SetPixelGreen(q,quantum);