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*(MagickRealType) 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;
341 range=GetQuantumRange(quantum_info->depth);
342 for (x=0; x < (ssize_t) number_pixels; x++)
344 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
345 (GetPixelAlpha(p)),range),q);
347 q+=quantum_info->pad;
354 static void ExportBGRQuantum(
QuantumInfo *quantum_info,
355 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
356 unsigned char *magick_restrict q)
367 switch (quantum_info->depth)
371 for (x=0; x < (ssize_t) number_pixels; x++)
373 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(p)),q);
374 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(p)),q);
375 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(p)),q);
377 q+=quantum_info->pad;
386 range=GetQuantumRange(quantum_info->depth);
387 if (quantum_info->pack == MagickFalse)
389 for (x=0; x < (ssize_t) number_pixels; x++)
391 pixel=(
unsigned int) (
392 ScaleQuantumToAny(GetPixelRed(p),range) << 22 |
393 ScaleQuantumToAny(GetPixelGreen(p),range) << 12 |
394 ScaleQuantumToAny(GetPixelBlue(p),range) << 2);
395 q=PopLongPixel(quantum_info->endian,pixel,q);
397 q+=quantum_info->pad;
401 if (quantum_info->quantum == 32UL)
403 for (x=0; x < (ssize_t) number_pixels; x++)
405 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
406 q=PopQuantumLongPixel(quantum_info,pixel,q);
407 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
408 q=PopQuantumLongPixel(quantum_info,pixel,q);
409 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
410 q=PopQuantumLongPixel(quantum_info,pixel,q);
412 q+=quantum_info->pad;
416 for (x=0; x < (ssize_t) number_pixels; x++)
418 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
419 q=PopQuantumPixel(quantum_info,pixel,q);
420 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
421 q=PopQuantumPixel(quantum_info,pixel,q);
422 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
423 q=PopQuantumPixel(quantum_info,pixel,q);
425 q+=quantum_info->pad;
434 range=GetQuantumRange(quantum_info->depth);
435 if (quantum_info->pack == MagickFalse)
437 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
444 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
449 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
454 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
459 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),q);
465 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
470 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
475 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
480 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),q);
481 q+=quantum_info->pad;
483 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
490 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
495 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
500 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
505 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),q);
506 q+=quantum_info->pad;
512 if (quantum_info->quantum == 32UL)
514 for (x=0; x < (ssize_t) number_pixels; x++)
516 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
517 q=PopQuantumLongPixel(quantum_info,pixel,q);
518 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
519 q=PopQuantumLongPixel(quantum_info,pixel,q);
520 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
521 q=PopQuantumLongPixel(quantum_info,pixel,q);
523 q+=quantum_info->pad;
527 for (x=0; x < (ssize_t) number_pixels; x++)
529 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
530 q=PopQuantumPixel(quantum_info,pixel,q);
531 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
532 q=PopQuantumPixel(quantum_info,pixel,q);
533 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
534 q=PopQuantumPixel(quantum_info,pixel,q);
536 q+=quantum_info->pad;
545 if (quantum_info->format == FloatingPointQuantumFormat)
547 for (x=0; x < (ssize_t) number_pixels; x++)
549 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
550 q=PopShortPixel(quantum_info->endian,pixel,q);
551 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
552 q=PopShortPixel(quantum_info->endian,pixel,q);
553 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
554 q=PopShortPixel(quantum_info->endian,pixel,q);
556 q+=quantum_info->pad;
560 for (x=0; x < (ssize_t) number_pixels; x++)
562 pixel=ScaleQuantumToShort(GetPixelBlue(p));
563 q=PopShortPixel(quantum_info->endian,pixel,q);
564 pixel=ScaleQuantumToShort(GetPixelGreen(p));
565 q=PopShortPixel(quantum_info->endian,pixel,q);
566 pixel=ScaleQuantumToShort(GetPixelRed(p));
567 q=PopShortPixel(quantum_info->endian,pixel,q);
569 q+=quantum_info->pad;
578 if (quantum_info->format == FloatingPointQuantumFormat)
580 for (x=0; x < (ssize_t) number_pixels; x++)
582 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
583 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
584 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
586 q+=quantum_info->pad;
590 for (x=0; x < (ssize_t) number_pixels; x++)
592 pixel=ScaleQuantumToLong(GetPixelBlue(p));
593 q=PopLongPixel(quantum_info->endian,pixel,q);
594 pixel=ScaleQuantumToLong(GetPixelGreen(p));
595 q=PopLongPixel(quantum_info->endian,pixel,q);
596 pixel=ScaleQuantumToLong(GetPixelRed(p));
597 q=PopLongPixel(quantum_info->endian,pixel,q);
599 q+=quantum_info->pad;
605 if (quantum_info->format == FloatingPointQuantumFormat)
607 for (x=0; x < (ssize_t) number_pixels; x++)
609 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
610 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
611 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
613 q+=quantum_info->pad;
621 range=GetQuantumRange(quantum_info->depth);
622 for (x=0; x < (ssize_t) number_pixels; x++)
624 q=PopQuantumPixel(quantum_info,
625 ScaleQuantumToAny(GetPixelRed(p),range),q);
626 q=PopQuantumPixel(quantum_info,
627 ScaleQuantumToAny(GetPixelGreen(p),range),q);
628 q=PopQuantumPixel(quantum_info,
629 ScaleQuantumToAny(GetPixelBlue(p),range),q);
631 q+=quantum_info->pad;
638 static void ExportBGRAQuantum(
QuantumInfo *quantum_info,
639 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
640 unsigned char *magick_restrict q)
648 switch (quantum_info->depth)
655 for (x=0; x < (ssize_t) number_pixels; x++)
657 pixel=ScaleQuantumToChar(GetPixelBlue(p));
658 q=PopCharPixel(pixel,q);
659 pixel=ScaleQuantumToChar(GetPixelGreen(p));
660 q=PopCharPixel(pixel,q);
661 pixel=ScaleQuantumToChar(GetPixelRed(p));
662 q=PopCharPixel(pixel,q);
663 pixel=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
664 q=PopCharPixel(pixel,q);
666 q+=quantum_info->pad;
675 range=GetQuantumRange(quantum_info->depth);
676 if (quantum_info->pack == MagickFalse)
690 for (x=0; x < (ssize_t) number_pixels; x++)
692 for (i=0; i < 4; i++)
696 case 0: quantum=(size_t) GetPixelRed(p);
break;
697 case 1: quantum=(size_t) GetPixelGreen(p);
break;
698 case 2: quantum=(size_t) GetPixelBlue(p);
break;
699 case 3: quantum=(size_t) GetPixelAlpha(p);
break;
705 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
711 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
717 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
719 q=PopLongPixel(quantum_info->endian,pixel,q);
727 q+=quantum_info->pad;
731 if (quantum_info->quantum == 32UL)
733 for (x=0; x < (ssize_t) number_pixels; x++)
735 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
736 q=PopQuantumLongPixel(quantum_info,pixel,q);
737 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
738 q=PopQuantumLongPixel(quantum_info,pixel,q);
739 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
740 q=PopQuantumLongPixel(quantum_info,pixel,q);
741 pixel=(
unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
743 q=PopQuantumLongPixel(quantum_info,pixel,q);
745 q+=quantum_info->pad;
749 for (x=0; x < (ssize_t) number_pixels; x++)
751 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
752 q=PopQuantumPixel(quantum_info,pixel,q);
753 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
754 q=PopQuantumPixel(quantum_info,pixel,q);
755 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
756 q=PopQuantumPixel(quantum_info,pixel,q);
757 pixel=(
unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
759 q=PopQuantumPixel(quantum_info,pixel,q);
761 q+=quantum_info->pad;
770 if (quantum_info->format == FloatingPointQuantumFormat)
772 for (x=0; x < (ssize_t) number_pixels; x++)
774 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
775 q=PopShortPixel(quantum_info->endian,pixel,q);
776 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
777 q=PopShortPixel(quantum_info->endian,pixel,q);
778 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
779 q=PopShortPixel(quantum_info->endian,pixel,q);
780 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
781 q=PopShortPixel(quantum_info->endian,pixel,q);
783 q+=quantum_info->pad;
787 for (x=0; x < (ssize_t) number_pixels; x++)
789 pixel=ScaleQuantumToShort(GetPixelBlue(p));
790 q=PopShortPixel(quantum_info->endian,pixel,q);
791 pixel=ScaleQuantumToShort(GetPixelGreen(p));
792 q=PopShortPixel(quantum_info->endian,pixel,q);
793 pixel=ScaleQuantumToShort(GetPixelRed(p));
794 q=PopShortPixel(quantum_info->endian,pixel,q);
795 pixel=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
796 q=PopShortPixel(quantum_info->endian,pixel,q);
798 q+=quantum_info->pad;
807 if (quantum_info->format == FloatingPointQuantumFormat)
809 for (x=0; x < (ssize_t) number_pixels; x++)
814 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
815 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
816 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
817 pixel=(float) GetPixelAlpha(p);
818 q=PopQuantumFloatPixel(quantum_info,pixel,q);
820 q+=quantum_info->pad;
824 for (x=0; x < (ssize_t) number_pixels; x++)
826 pixel=ScaleQuantumToLong(GetPixelBlue(p));
827 q=PopLongPixel(quantum_info->endian,pixel,q);
828 pixel=ScaleQuantumToLong(GetPixelGreen(p));
829 q=PopLongPixel(quantum_info->endian,pixel,q);
830 pixel=ScaleQuantumToLong(GetPixelRed(p));
831 q=PopLongPixel(quantum_info->endian,pixel,q);
832 pixel=ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
833 q=PopLongPixel(quantum_info->endian,pixel,q);
835 q+=quantum_info->pad;
841 if (quantum_info->format == FloatingPointQuantumFormat)
846 for (x=0; x < (ssize_t) number_pixels; x++)
848 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
849 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
850 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
851 pixel=(double) GetPixelAlpha(p);
852 q=PopQuantumDoublePixel(quantum_info,pixel,q);
854 q+=quantum_info->pad;
862 range=GetQuantumRange(quantum_info->depth);
863 for (x=0; x < (ssize_t) number_pixels; x++)
865 q=PopQuantumPixel(quantum_info,
866 ScaleQuantumToAny(GetPixelBlue(p),range),q);
867 q=PopQuantumPixel(quantum_info,
868 ScaleQuantumToAny(GetPixelGreen(p),range),q);
869 q=PopQuantumPixel(quantum_info,
870 ScaleQuantumToAny(GetPixelRed(p),range),q);
871 q=PopQuantumPixel(quantum_info,
872 ScaleQuantumToAny((Quantum) GetPixelAlpha(p),range),q);
874 q+=quantum_info->pad;
881 static void ExportBGROQuantum(
QuantumInfo *quantum_info,
882 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
883 unsigned char *magick_restrict q)
891 switch (quantum_info->depth)
898 for (x=0; x < (ssize_t) number_pixels; x++)
900 pixel=ScaleQuantumToChar(GetPixelBlue(p));
901 q=PopCharPixel(pixel,q);
902 pixel=ScaleQuantumToChar(GetPixelGreen(p));
903 q=PopCharPixel(pixel,q);
904 pixel=ScaleQuantumToChar(GetPixelRed(p));
905 q=PopCharPixel(pixel,q);
906 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
907 q=PopCharPixel(pixel,q);
909 q+=quantum_info->pad;
918 range=GetQuantumRange(quantum_info->depth);
919 if (quantum_info->pack == MagickFalse)
933 for (x=0; x < (ssize_t) number_pixels; x++)
935 for (i=0; i < 4; i++)
939 case 0: quantum=(size_t) GetPixelRed(p);
break;
940 case 1: quantum=(size_t) GetPixelGreen(p);
break;
941 case 2: quantum=(size_t) GetPixelBlue(p);
break;
942 case 3: quantum=(size_t) GetPixelOpacity(p);
break;
948 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
954 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
960 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
962 q=PopLongPixel(quantum_info->endian,pixel,q);
970 q+=quantum_info->pad;
974 if (quantum_info->quantum == 32UL)
976 for (x=0; x < (ssize_t) number_pixels; x++)
978 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
979 q=PopQuantumLongPixel(quantum_info,pixel,q);
980 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
981 q=PopQuantumLongPixel(quantum_info,pixel,q);
982 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
983 q=PopQuantumLongPixel(quantum_info,pixel,q);
984 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
985 q=PopQuantumLongPixel(quantum_info,pixel,q);
987 q+=quantum_info->pad;
991 for (x=0; x < (ssize_t) number_pixels; x++)
993 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
994 q=PopQuantumPixel(quantum_info,pixel,q);
995 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
996 q=PopQuantumPixel(quantum_info,pixel,q);
997 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
998 q=PopQuantumPixel(quantum_info,pixel,q);
999 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
1000 q=PopQuantumPixel(quantum_info,pixel,q);
1002 q+=quantum_info->pad;
1011 if (quantum_info->format == FloatingPointQuantumFormat)
1013 for (x=0; x < (ssize_t) number_pixels; x++)
1015 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1016 q=PopShortPixel(quantum_info->endian,pixel,q);
1017 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1018 q=PopShortPixel(quantum_info->endian,pixel,q);
1019 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1020 q=PopShortPixel(quantum_info->endian,pixel,q);
1021 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
1022 q=PopShortPixel(quantum_info->endian,pixel,q);
1024 q+=quantum_info->pad;
1028 for (x=0; x < (ssize_t) number_pixels; x++)
1030 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1031 q=PopShortPixel(quantum_info->endian,pixel,q);
1032 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1033 q=PopShortPixel(quantum_info->endian,pixel,q);
1034 pixel=ScaleQuantumToShort(GetPixelRed(p));
1035 q=PopShortPixel(quantum_info->endian,pixel,q);
1036 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
1037 q=PopShortPixel(quantum_info->endian,pixel,q);
1039 q+=quantum_info->pad;
1048 if (quantum_info->format == FloatingPointQuantumFormat)
1050 for (x=0; x < (ssize_t) number_pixels; x++)
1055 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
1056 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
1057 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
1058 pixel=(float) GetPixelOpacity(p);
1059 q=PopQuantumFloatPixel(quantum_info,pixel,q);
1061 q+=quantum_info->pad;
1065 for (x=0; x < (ssize_t) number_pixels; x++)
1067 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1068 q=PopLongPixel(quantum_info->endian,pixel,q);
1069 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1070 q=PopLongPixel(quantum_info->endian,pixel,q);
1071 pixel=ScaleQuantumToLong(GetPixelRed(p));
1072 q=PopLongPixel(quantum_info->endian,pixel,q);
1073 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
1074 q=PopLongPixel(quantum_info->endian,pixel,q);
1076 q+=quantum_info->pad;
1082 if (quantum_info->format == FloatingPointQuantumFormat)
1087 for (x=0; x < (ssize_t) number_pixels; x++)
1089 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
1090 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
1091 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
1092 pixel=(double) GetPixelOpacity(p);
1093 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1095 q+=quantum_info->pad;
1103 range=GetQuantumRange(quantum_info->depth);
1104 for (x=0; x < (ssize_t) number_pixels; x++)
1106 q=PopQuantumPixel(quantum_info,
1107 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1108 q=PopQuantumPixel(quantum_info,
1109 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1110 q=PopQuantumPixel(quantum_info,
1111 ScaleQuantumToAny(GetPixelRed(p),range),q);
1112 q=PopQuantumPixel(quantum_info,
1113 ScaleQuantumToAny(GetPixelOpacity(p),range),q);
1115 q+=quantum_info->pad;
1122 static void ExportBlackQuantum(
const Image *image,
QuantumInfo *quantum_info,
1123 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1124 const IndexPacket *magick_restrict indexes,
unsigned char *magick_restrict q,
1130 if (image->colorspace != CMYKColorspace)
1132 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1133 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1136 switch (quantum_info->depth)
1143 for (x=0; x < (ssize_t) number_pixels; x++)
1145 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1146 q=PopCharPixel(pixel,q);
1148 q+=quantum_info->pad;
1157 if (quantum_info->format == FloatingPointQuantumFormat)
1159 for (x=0; x < (ssize_t) number_pixels; x++)
1161 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1162 q=PopShortPixel(quantum_info->endian,pixel,q);
1164 q+=quantum_info->pad;
1168 for (x=0; x < (ssize_t) number_pixels; x++)
1170 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1171 q=PopShortPixel(quantum_info->endian,pixel,q);
1173 q+=quantum_info->pad;
1182 if (quantum_info->format == FloatingPointQuantumFormat)
1184 for (x=0; x < (ssize_t) number_pixels; x++)
1186 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
1188 q+=quantum_info->pad;
1192 for (x=0; x < (ssize_t) number_pixels; x++)
1194 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1195 q=PopLongPixel(quantum_info->endian,pixel,q);
1197 q+=quantum_info->pad;
1203 if (quantum_info->format == FloatingPointQuantumFormat)
1205 for (x=0; x < (ssize_t) number_pixels; x++)
1207 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(indexes+x),
1210 q+=quantum_info->pad;
1221 range=GetQuantumRange(quantum_info->depth);
1222 for (x=0; x < (ssize_t) number_pixels; x++)
1224 q=PopQuantumPixel(quantum_info,
1225 ScaleQuantumToAny((Quantum) GetPixelIndex(indexes+x),range),q);
1227 q+=quantum_info->pad;
1234 static void ExportBlueQuantum(
QuantumInfo *quantum_info,
1235 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1236 unsigned char *magick_restrict q)
1244 switch (quantum_info->depth)
1251 for (x=0; x < (ssize_t) number_pixels; x++)
1253 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1254 q=PopCharPixel(pixel,q);
1256 q+=quantum_info->pad;
1265 if (quantum_info->format == FloatingPointQuantumFormat)
1267 for (x=0; x < (ssize_t) number_pixels; x++)
1269 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1270 q=PopShortPixel(quantum_info->endian,pixel,q);
1272 q+=quantum_info->pad;
1276 for (x=0; x < (ssize_t) number_pixels; x++)
1278 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1279 q=PopShortPixel(quantum_info->endian,pixel,q);
1281 q+=quantum_info->pad;
1290 if (quantum_info->format == FloatingPointQuantumFormat)
1292 for (x=0; x < (ssize_t) number_pixels; x++)
1294 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
1296 q+=quantum_info->pad;
1300 for (x=0; x < (ssize_t) number_pixels; x++)
1302 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1303 q=PopLongPixel(quantum_info->endian,pixel,q);
1305 q+=quantum_info->pad;
1311 if (quantum_info->format == FloatingPointQuantumFormat)
1313 for (x=0; x < (ssize_t) number_pixels; x++)
1315 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
1317 q+=quantum_info->pad;
1325 range=GetQuantumRange(quantum_info->depth);
1326 for (x=0; x < (ssize_t) number_pixels; x++)
1328 q=PopQuantumPixel(quantum_info,
1329 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1331 q+=quantum_info->pad;
1338 static void ExportCbYCrYQuantum(
QuantumInfo *quantum_info,
1339 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1340 unsigned char *magick_restrict q)
1363 range=GetQuantumRange(quantum_info->depth);
1364 switch (quantum_info->depth)
1368 if (quantum_info->pack == MagickFalse)
1370 for (x=0; x < (ssize_t) number_pixels; x+=2)
1372 for (i=0; i < 4; i++)
1378 quantum=(size_t) GetPixelRed(p);
1383 quantum=(size_t) GetPixelGreen(p);
1388 quantum=(size_t) GetPixelBlue(p);
1392 cbcr[i]=(Quantum) quantum;
1395 pixel=(
unsigned int) ((
size_t) (cbcr[1]) << 22 | (
size_t)
1396 (cbcr[0]) << 12 | (
size_t) (cbcr[2]) << 2);
1397 q=PopLongPixel(quantum_info->endian,pixel,q);
1399 pixel=(
unsigned int) ((
size_t) (cbcr[3]) << 22 | (
size_t)
1400 (cbcr[0]) << 12 | (
size_t) (cbcr[2]) << 2);
1401 q=PopLongPixel(quantum_info->endian,pixel,q);
1403 q+=quantum_info->pad;
1411 for (x=0; x < (ssize_t) number_pixels; x+=2)
1413 for (i=0; i < 4; i++)
1419 quantum=(size_t) GetPixelRed(p);
1424 quantum=(size_t) GetPixelGreen(p);
1429 quantum=(size_t) GetPixelBlue(p);
1433 cbcr[i]=(Quantum) quantum;
1436 q=PopQuantumPixel(quantum_info,
1437 ScaleQuantumToAny(cbcr[1],range),q);
1438 q=PopQuantumPixel(quantum_info,
1439 ScaleQuantumToAny(cbcr[0],range),q);
1440 q=PopQuantumPixel(quantum_info,
1441 ScaleQuantumToAny(cbcr[2],range),q);
1443 q=PopQuantumPixel(quantum_info,
1444 ScaleQuantumToAny(cbcr[3],range),q);
1445 q=PopQuantumPixel(quantum_info,
1446 ScaleQuantumToAny(cbcr[0],range),q);
1447 q=PopQuantumPixel(quantum_info,
1448 ScaleQuantumToAny(cbcr[2],range),q);
1450 q+=quantum_info->pad;
1457 static void ExportCMYKQuantum(
const Image *image,
QuantumInfo *quantum_info,
1458 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1459 const IndexPacket *magick_restrict indexes,
unsigned char *magick_restrict q,
1468 if (image->colorspace != CMYKColorspace)
1470 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1471 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1474 switch (quantum_info->depth)
1481 for (x=0; x < (ssize_t) number_pixels; x++)
1483 pixel=ScaleQuantumToChar(GetPixelRed(p));
1484 q=PopCharPixel(pixel,q);
1485 pixel=ScaleQuantumToChar(GetPixelGreen(p));
1486 q=PopCharPixel(pixel,q);
1487 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1488 q=PopCharPixel(pixel,q);
1489 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1490 q=PopCharPixel(pixel,q);
1492 q+=quantum_info->pad;
1501 if (quantum_info->format == FloatingPointQuantumFormat)
1503 for (x=0; x < (ssize_t) number_pixels; x++)
1505 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1506 q=PopShortPixel(quantum_info->endian,pixel,q);
1507 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1508 q=PopShortPixel(quantum_info->endian,pixel,q);
1509 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1510 q=PopShortPixel(quantum_info->endian,pixel,q);
1511 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1512 q=PopShortPixel(quantum_info->endian,pixel,q);
1514 q+=quantum_info->pad;
1518 for (x=0; x < (ssize_t) number_pixels; x++)
1520 pixel=ScaleQuantumToShort(GetPixelRed(p));
1521 q=PopShortPixel(quantum_info->endian,pixel,q);
1522 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1523 q=PopShortPixel(quantum_info->endian,pixel,q);
1524 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1525 q=PopShortPixel(quantum_info->endian,pixel,q);
1526 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1527 q=PopShortPixel(quantum_info->endian,pixel,q);
1529 q+=quantum_info->pad;
1538 if (quantum_info->format == FloatingPointQuantumFormat)
1540 for (x=0; x < (ssize_t) number_pixels; x++)
1542 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
1543 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
1544 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
1545 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
1547 q+=quantum_info->pad;
1551 for (x=0; x < (ssize_t) number_pixels; x++)
1553 pixel=ScaleQuantumToLong(GetPixelRed(p));
1554 q=PopLongPixel(quantum_info->endian,pixel,q);
1555 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1556 q=PopLongPixel(quantum_info->endian,pixel,q);
1557 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1558 q=PopLongPixel(quantum_info->endian,pixel,q);
1559 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1560 q=PopLongPixel(quantum_info->endian,pixel,q);
1562 q+=quantum_info->pad;
1568 if (quantum_info->format == FloatingPointQuantumFormat)
1570 for (x=0; x < (ssize_t) number_pixels; x++)
1572 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
1573 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
1574 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
1575 q=PopQuantumDoublePixel(quantum_info,(
double)
1576 GetPixelIndex(indexes+x),q);
1578 q+=quantum_info->pad;
1586 range=GetQuantumRange(quantum_info->depth);
1587 for (x=0; x < (ssize_t) number_pixels; x++)
1589 q=PopQuantumPixel(quantum_info,
1590 ScaleQuantumToAny(GetPixelRed(p),range),q);
1591 q=PopQuantumPixel(quantum_info,
1592 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1593 q=PopQuantumPixel(quantum_info,
1594 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1595 q=PopQuantumPixel(quantum_info,
1596 ScaleQuantumToAny(GetPixelIndex(indexes+x),range),q);
1598 q+=quantum_info->pad;
1605 static void ExportCMYKAQuantum(
const Image *image,
QuantumInfo *quantum_info,
1606 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1607 const IndexPacket *magick_restrict indexes,
unsigned char *magick_restrict q,
1616 if (image->colorspace != CMYKColorspace)
1618 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1619 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1622 switch (quantum_info->depth)
1629 for (x=0; x < (ssize_t) number_pixels; x++)
1631 pixel=ScaleQuantumToChar(GetPixelRed(p));
1632 q=PopCharPixel(pixel,q);
1633 pixel=ScaleQuantumToChar(GetPixelGreen(p));
1634 q=PopCharPixel(pixel,q);
1635 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1636 q=PopCharPixel(pixel,q);
1637 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1638 q=PopCharPixel(pixel,q);
1639 pixel=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
1640 q=PopCharPixel(pixel,q);
1642 q+=quantum_info->pad;
1651 if (quantum_info->format == FloatingPointQuantumFormat)
1653 for (x=0; x < (ssize_t) number_pixels; x++)
1655 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1656 q=PopShortPixel(quantum_info->endian,pixel,q);
1657 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1658 q=PopShortPixel(quantum_info->endian,pixel,q);
1659 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1660 q=PopShortPixel(quantum_info->endian,pixel,q);
1661 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1662 q=PopShortPixel(quantum_info->endian,pixel,q);
1663 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
1664 q=PopShortPixel(quantum_info->endian,pixel,q);
1666 q+=quantum_info->pad;
1670 for (x=0; x < (ssize_t) number_pixels; x++)
1672 pixel=ScaleQuantumToShort(GetPixelRed(p));
1673 q=PopShortPixel(quantum_info->endian,pixel,q);
1674 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1675 q=PopShortPixel(quantum_info->endian,pixel,q);
1676 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1677 q=PopShortPixel(quantum_info->endian,pixel,q);
1678 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1679 q=PopShortPixel(quantum_info->endian,pixel,q);
1680 pixel=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
1681 q=PopShortPixel(quantum_info->endian,pixel,q);
1683 q+=quantum_info->pad;
1692 if (quantum_info->format == FloatingPointQuantumFormat)
1694 for (x=0; x < (ssize_t) number_pixels; x++)
1699 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
1700 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
1701 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
1702 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
1703 pixel=(float) (GetPixelAlpha(p));
1704 q=PopQuantumFloatPixel(quantum_info,pixel,q);
1706 q+=quantum_info->pad;
1710 for (x=0; x < (ssize_t) number_pixels; x++)
1712 pixel=ScaleQuantumToLong(GetPixelRed(p));
1713 q=PopLongPixel(quantum_info->endian,pixel,q);
1714 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1715 q=PopLongPixel(quantum_info->endian,pixel,q);
1716 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1717 q=PopLongPixel(quantum_info->endian,pixel,q);
1718 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1719 q=PopLongPixel(quantum_info->endian,pixel,q);
1720 pixel=ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
1721 q=PopLongPixel(quantum_info->endian,pixel,q);
1723 q+=quantum_info->pad;
1729 if (quantum_info->format == FloatingPointQuantumFormat)
1734 for (x=0; x < (ssize_t) number_pixels; x++)
1736 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
1737 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
1738 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
1739 q=PopQuantumDoublePixel(quantum_info,(
double)
1740 GetPixelIndex(indexes+x),q);
1741 pixel=(double) (GetPixelAlpha(p));
1742 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1744 q+=quantum_info->pad;
1752 range=GetQuantumRange(quantum_info->depth);
1753 for (x=0; x < (ssize_t) number_pixels; x++)
1755 q=PopQuantumPixel(quantum_info,
1756 ScaleQuantumToAny(GetPixelRed(p),range),q);
1757 q=PopQuantumPixel(quantum_info,
1758 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1759 q=PopQuantumPixel(quantum_info,
1760 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1761 q=PopQuantumPixel(quantum_info,
1762 ScaleQuantumToAny(GetPixelIndex(indexes+x),range),q);
1763 q=PopQuantumPixel(quantum_info,
1764 ScaleQuantumToAny((Quantum) GetPixelAlpha(p),range),q);
1766 q+=quantum_info->pad;
1773 static void ExportCMYKOQuantum(
const Image *image,
QuantumInfo *quantum_info,
1774 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1775 const IndexPacket *magick_restrict indexes,
unsigned char *magick_restrict q,
1784 if (image->colorspace != CMYKColorspace)
1786 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1787 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1790 switch (quantum_info->depth)
1797 for (x=0; x < (ssize_t) number_pixels; x++)
1799 pixel=ScaleQuantumToChar(GetPixelRed(p));
1800 q=PopCharPixel(pixel,q);
1801 pixel=ScaleQuantumToChar(GetPixelGreen(p));
1802 q=PopCharPixel(pixel,q);
1803 pixel=ScaleQuantumToChar(GetPixelBlue(p));
1804 q=PopCharPixel(pixel,q);
1805 pixel=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1806 q=PopCharPixel(pixel,q);
1807 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
1808 q=PopCharPixel(pixel,q);
1810 q+=quantum_info->pad;
1819 if (quantum_info->format == FloatingPointQuantumFormat)
1821 for (x=0; x < (ssize_t) number_pixels; x++)
1823 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
1824 q=PopShortPixel(quantum_info->endian,pixel,q);
1825 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
1826 q=PopShortPixel(quantum_info->endian,pixel,q);
1827 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
1828 q=PopShortPixel(quantum_info->endian,pixel,q);
1829 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelIndex(indexes+x));
1830 q=PopShortPixel(quantum_info->endian,pixel,q);
1831 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
1832 q=PopShortPixel(quantum_info->endian,pixel,q);
1834 q+=quantum_info->pad;
1838 for (x=0; x < (ssize_t) number_pixels; x++)
1840 pixel=ScaleQuantumToShort(GetPixelRed(p));
1841 q=PopShortPixel(quantum_info->endian,pixel,q);
1842 pixel=ScaleQuantumToShort(GetPixelGreen(p));
1843 q=PopShortPixel(quantum_info->endian,pixel,q);
1844 pixel=ScaleQuantumToShort(GetPixelBlue(p));
1845 q=PopShortPixel(quantum_info->endian,pixel,q);
1846 pixel=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1847 q=PopShortPixel(quantum_info->endian,pixel,q);
1848 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
1849 q=PopShortPixel(quantum_info->endian,pixel,q);
1851 q+=quantum_info->pad;
1860 if (quantum_info->format == FloatingPointQuantumFormat)
1862 for (x=0; x < (ssize_t) number_pixels; x++)
1867 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
1868 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
1869 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
1870 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
1871 pixel=(float) (GetPixelOpacity(p));
1872 q=PopQuantumFloatPixel(quantum_info,pixel,q);
1874 q+=quantum_info->pad;
1878 for (x=0; x < (ssize_t) number_pixels; x++)
1880 pixel=ScaleQuantumToLong(GetPixelRed(p));
1881 q=PopLongPixel(quantum_info->endian,pixel,q);
1882 pixel=ScaleQuantumToLong(GetPixelGreen(p));
1883 q=PopLongPixel(quantum_info->endian,pixel,q);
1884 pixel=ScaleQuantumToLong(GetPixelBlue(p));
1885 q=PopLongPixel(quantum_info->endian,pixel,q);
1886 pixel=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1887 q=PopLongPixel(quantum_info->endian,pixel,q);
1888 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
1889 q=PopLongPixel(quantum_info->endian,pixel,q);
1891 q+=quantum_info->pad;
1897 if (quantum_info->format == FloatingPointQuantumFormat)
1902 for (x=0; x < (ssize_t) number_pixels; x++)
1904 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
1905 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
1906 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
1907 q=PopQuantumDoublePixel(quantum_info,(
double)
1908 GetPixelIndex(indexes+x),q);
1909 pixel=(double) (GetPixelOpacity(p));
1910 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1912 q+=quantum_info->pad;
1920 range=GetQuantumRange(quantum_info->depth);
1921 for (x=0; x < (ssize_t) number_pixels; x++)
1923 q=PopQuantumPixel(quantum_info,
1924 ScaleQuantumToAny(GetPixelRed(p),range),q);
1925 q=PopQuantumPixel(quantum_info,
1926 ScaleQuantumToAny(GetPixelGreen(p),range),q);
1927 q=PopQuantumPixel(quantum_info,
1928 ScaleQuantumToAny(GetPixelBlue(p),range),q);
1929 q=PopQuantumPixel(quantum_info,
1930 ScaleQuantumToAny(GetPixelIndex(indexes+x),range),q);
1931 q=PopQuantumPixel(quantum_info,
1932 ScaleQuantumToAny(GetPixelOpacity(p),range),q);
1934 q+=quantum_info->pad;
1941 static void ExportGrayQuantum(
const Image *image,
QuantumInfo *quantum_info,
1942 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
1943 unsigned char *magick_restrict q)
1954 switch (quantum_info->depth)
1967 if (quantum_info->min_is_white != MagickFalse)
1972 threshold=(MagickRealType) QuantumRange/2.0;
1973 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1976 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
1978 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
1980 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
1982 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
1984 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
1986 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
1988 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
1990 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
1994 if ((number_pixels % 8) != 0)
1997 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1999 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
2011 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2013 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2014 *q=(((pixel >> 4) & 0xf) << 4);
2016 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2021 if ((number_pixels % 2) != 0)
2023 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2024 *q=(((pixel >> 4) & 0xf) << 4);
2035 for (x=0; x < (ssize_t) number_pixels; x++)
2037 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2038 q=PopCharPixel(pixel,q);
2040 q+=quantum_info->pad;
2046 range=GetQuantumRange(quantum_info->depth);
2047 if (quantum_info->pack == MagickFalse)
2052 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2054 pixel=(
unsigned int) (
2055 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+2)),range) << 22 |
2056 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+1)),range) << 12 |
2057 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+0)),range) << 2);
2058 q=PopLongPixel(quantum_info->endian,pixel,q);
2060 q+=quantum_info->pad;
2062 if (x < (ssize_t) number_pixels)
2065 if (x++ < (ssize_t) (number_pixels-1))
2066 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
2068 if (x++ < (ssize_t) number_pixels)
2069 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
2071 q=PopLongPixel(quantum_info->endian,pixel,q);
2075 for (x=0; x < (ssize_t) number_pixels; x++)
2077 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2078 GetPixelLuma(image,p)),range),q);
2080 q+=quantum_info->pad;
2089 range=GetQuantumRange(quantum_info->depth);
2090 if (quantum_info->pack == MagickFalse)
2092 for (x=0; x < (ssize_t) number_pixels; x++)
2094 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2095 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel >> 4),q);
2097 q+=quantum_info->pad;
2101 for (x=0; x < (ssize_t) number_pixels; x++)
2103 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2104 GetPixelLuma(image,p)),range),q);
2106 q+=quantum_info->pad;
2115 if (quantum_info->format == FloatingPointQuantumFormat)
2117 for (x=0; x < (ssize_t) number_pixels; x++)
2119 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelLuma(image,p));
2120 q=PopShortPixel(quantum_info->endian,pixel,q);
2122 q+=quantum_info->pad;
2126 for (x=0; x < (ssize_t) number_pixels; x++)
2128 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2129 q=PopShortPixel(quantum_info->endian,pixel,q);
2131 q+=quantum_info->pad;
2140 if (quantum_info->format == FloatingPointQuantumFormat)
2142 for (x=0; x < (ssize_t) number_pixels; x++)
2147 pixel=(float) GetPixelLuma(image,p);
2148 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2150 q+=quantum_info->pad;
2154 for (x=0; x < (ssize_t) number_pixels; x++)
2156 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2157 q=PopLongPixel(quantum_info->endian,pixel,q);
2159 q+=quantum_info->pad;
2165 if (quantum_info->format == FloatingPointQuantumFormat)
2167 for (x=0; x < (ssize_t) number_pixels; x++)
2172 pixel=(double) GetPixelLuma(image,p);
2173 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2175 q+=quantum_info->pad;
2183 range=GetQuantumRange(quantum_info->depth);
2184 for (x=0; x < (ssize_t) number_pixels; x++)
2186 q=PopQuantumPixel(quantum_info,
2187 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),range),q);
2189 q+=quantum_info->pad;
2196 static void ExportGrayAlphaQuantum(
const Image *image,
QuantumInfo *quantum_info,
2197 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2198 unsigned char *magick_restrict q)
2209 switch (quantum_info->depth)
2223 if (quantum_info->min_is_white != MagickFalse)
2228 threshold=(MagickRealType) QuantumRange/2.0;
2229 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2232 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
2233 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2235 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
2237 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
2238 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2240 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
2242 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
2243 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2245 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
2247 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
2248 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ?
2250 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
2254 if ((number_pixels % 4) != 0)
2257 for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
2259 *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
2261 pixel=(
unsigned char) (GetPixelOpacity(p) == OpaqueOpacity ? 0x00 :
2263 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (
unsigned char) (7-bit-1));
2275 for (x=0; x < (ssize_t) number_pixels ; x++)
2277 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2278 *q=(((pixel >> 4) & 0xf) << 4);
2279 pixel=(
unsigned char) (16*QuantumScale*((MagickRealType) QuantumRange-
2280 (MagickRealType) GetPixelOpacity(p))+0.5);
2292 for (x=0; x < (ssize_t) number_pixels; x++)
2294 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2295 q=PopCharPixel(pixel,q);
2296 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
2297 q=PopCharPixel(pixel,q);
2299 q+=quantum_info->pad;
2308 if (quantum_info->format == FloatingPointQuantumFormat)
2310 for (x=0; x < (ssize_t) number_pixels; x++)
2312 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelLuma(image,p));
2313 q=PopShortPixel(quantum_info->endian,pixel,q);
2314 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
2315 q=PopShortPixel(quantum_info->endian,pixel,q);
2317 q+=quantum_info->pad;
2321 for (x=0; x < (ssize_t) number_pixels; x++)
2323 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2324 q=PopShortPixel(quantum_info->endian,pixel,q);
2325 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetPixelOpacity(p)));
2326 q=PopShortPixel(quantum_info->endian,pixel,q);
2328 q+=quantum_info->pad;
2337 if (quantum_info->format == FloatingPointQuantumFormat)
2339 for (x=0; x < (ssize_t) number_pixels; x++)
2344 pixel=(float) GetPixelLuma(image,p);
2345 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2346 pixel=(float) (GetPixelAlpha(p));
2347 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2349 q+=quantum_info->pad;
2353 for (x=0; x < (ssize_t) number_pixels; x++)
2355 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2356 q=PopLongPixel(quantum_info->endian,pixel,q);
2357 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetPixelOpacity(p)));
2358 q=PopLongPixel(quantum_info->endian,pixel,q);
2360 q+=quantum_info->pad;
2366 if (quantum_info->format == FloatingPointQuantumFormat)
2368 for (x=0; x < (ssize_t) number_pixels; x++)
2373 pixel=(double) GetPixelLuma(image,p);
2374 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2375 pixel=(double) (GetPixelAlpha(p));
2376 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2378 q+=quantum_info->pad;
2386 range=GetQuantumRange(quantum_info->depth);
2387 for (x=0; x < (ssize_t) number_pixels; x++)
2389 q=PopQuantumPixel(quantum_info,
2390 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),range),q);
2391 q=PopQuantumPixel(quantum_info,
2392 ScaleQuantumToAny((Quantum) (GetPixelAlpha(p)),range),q);
2394 q+=quantum_info->pad;
2401 static void ExportGreenQuantum(
QuantumInfo *quantum_info,
2402 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2403 unsigned char *magick_restrict q)
2411 switch (quantum_info->depth)
2418 for (x=0; x < (ssize_t) number_pixels; x++)
2420 pixel=ScaleQuantumToChar(GetPixelGreen(p));
2421 q=PopCharPixel(pixel,q);
2423 q+=quantum_info->pad;
2432 if (quantum_info->format == FloatingPointQuantumFormat)
2434 for (x=0; x < (ssize_t) number_pixels; x++)
2436 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
2437 q=PopShortPixel(quantum_info->endian,pixel,q);
2439 q+=quantum_info->pad;
2443 for (x=0; x < (ssize_t) number_pixels; x++)
2445 pixel=ScaleQuantumToShort(GetPixelGreen(p));
2446 q=PopShortPixel(quantum_info->endian,pixel,q);
2448 q+=quantum_info->pad;
2457 if (quantum_info->format == FloatingPointQuantumFormat)
2459 for (x=0; x < (ssize_t) number_pixels; x++)
2461 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
2463 q+=quantum_info->pad;
2467 for (x=0; x < (ssize_t) number_pixels; x++)
2469 pixel=ScaleQuantumToLong(GetPixelGreen(p));
2470 q=PopLongPixel(quantum_info->endian,pixel,q);
2472 q+=quantum_info->pad;
2478 if (quantum_info->format == FloatingPointQuantumFormat)
2480 for (x=0; x < (ssize_t) number_pixels; x++)
2482 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
2484 q+=quantum_info->pad;
2492 range=GetQuantumRange(quantum_info->depth);
2493 for (x=0; x < (ssize_t) number_pixels; x++)
2495 q=PopQuantumPixel(quantum_info,
2496 ScaleQuantumToAny(GetPixelGreen(p),range),q);
2498 q+=quantum_info->pad;
2505 static void ExportIndexQuantum(
const Image *image,
QuantumInfo *quantum_info,
2506 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2507 const IndexPacket *magick_restrict indexes,
unsigned char *magick_restrict q,
2516 if (image->storage_class != PseudoClass)
2518 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2519 "ColormappedImageRequired",
"`%s'",image->filename);
2522 switch (quantum_info->depth)
2529 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
2531 pixel=(
unsigned char) ((ssize_t) *indexes++);
2532 *q=((pixel & 0x01) << 7);
2533 pixel=(
unsigned char) ((ssize_t) *indexes++);
2534 *q|=((pixel & 0x01) << 6);
2535 pixel=(
unsigned char) ((ssize_t) *indexes++);
2536 *q|=((pixel & 0x01) << 5);
2537 pixel=(
unsigned char) ((ssize_t) *indexes++);
2538 *q|=((pixel & 0x01) << 4);
2539 pixel=(
unsigned char) ((ssize_t) *indexes++);
2540 *q|=((pixel & 0x01) << 3);
2541 pixel=(
unsigned char) ((ssize_t) *indexes++);
2542 *q|=((pixel & 0x01) << 2);
2543 pixel=(
unsigned char) ((ssize_t) *indexes++);
2544 *q|=((pixel & 0x01) << 1);
2545 pixel=(
unsigned char) ((ssize_t) *indexes++);
2546 *q|=((pixel & 0x01) << 0);
2549 if ((number_pixels % 8) != 0)
2552 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2554 pixel=(
unsigned char) ((ssize_t) *indexes++);
2555 *q|=((pixel & 0x01) << (
unsigned char) bit);
2566 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2568 pixel=(
unsigned char) ((ssize_t) *indexes++);
2569 *q=((pixel & 0xf) << 4);
2570 pixel=(
unsigned char) ((ssize_t) *indexes++);
2571 *q|=((pixel & 0xf) << 0);
2574 if ((number_pixels % 2) != 0)
2576 pixel=(
unsigned char) ((ssize_t) *indexes++);
2577 *q=((pixel & 0xf) << 4);
2584 for (x=0; x < (ssize_t) number_pixels; x++)
2586 q=PopCharPixel((
unsigned char) GetPixelIndex(indexes+x),q);
2587 q+=quantum_info->pad;
2593 if (quantum_info->format == FloatingPointQuantumFormat)
2595 for (x=0; x < (ssize_t) number_pixels; x++)
2597 q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
2598 QuantumScale*(MagickRealType) GetPixelIndex(indexes+x)),q);
2599 q+=quantum_info->pad;
2603 for (x=0; x < (ssize_t) number_pixels; x++)
2605 q=PopShortPixel(quantum_info->endian,(
unsigned short) GetPixelIndex(indexes+x),q);
2606 q+=quantum_info->pad;
2612 if (quantum_info->format == FloatingPointQuantumFormat)
2614 for (x=0; x < (ssize_t) number_pixels; x++)
2616 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
2618 q+=quantum_info->pad;
2622 for (x=0; x < (ssize_t) number_pixels; x++)
2624 q=PopLongPixel(quantum_info->endian,(
unsigned int) GetPixelIndex(indexes+x),q);
2625 q+=quantum_info->pad;
2631 if (quantum_info->format == FloatingPointQuantumFormat)
2633 for (x=0; x < (ssize_t) number_pixels; x++)
2635 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(indexes+x),
2638 q+=quantum_info->pad;
2646 for (x=0; x < (ssize_t) number_pixels; x++)
2648 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(indexes+x),q);
2650 q+=quantum_info->pad;
2657 static void ExportIndexAlphaQuantum(
const Image *image,
2658 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
2660 const IndexPacket *magick_restrict indexes,
unsigned char *magick_restrict q,
2669 if (image->storage_class != PseudoClass)
2671 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2672 "ColormappedImageRequired",
"`%s'",image->filename);
2675 switch (quantum_info->depth)
2682 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2684 pixel=(
unsigned char) ((ssize_t) *indexes++);
2685 *q=((pixel & 0x01) << 7);
2686 pixel=(
unsigned char) (GetPixelOpacity(p) == (Quantum)
2687 TransparentOpacity ? 1 : 0);
2688 *q|=((pixel & 0x01) << 6);
2690 pixel=(
unsigned char) ((ssize_t) *indexes++);
2691 *q|=((pixel & 0x01) << 5);
2692 pixel=(
unsigned char) (GetPixelOpacity(p) == (Quantum)
2693 TransparentOpacity ? 1 : 0);
2694 *q|=((pixel & 0x01) << 4);
2696 pixel=(
unsigned char) ((ssize_t) *indexes++);
2697 *q|=((pixel & 0x01) << 3);
2698 pixel=(
unsigned char) (GetPixelOpacity(p) == (Quantum)
2699 TransparentOpacity ? 1 : 0);
2700 *q|=((pixel & 0x01) << 2);
2702 pixel=(
unsigned char) ((ssize_t) *indexes++);
2703 *q|=((pixel & 0x01) << 1);
2704 pixel=(
unsigned char) (GetPixelOpacity(p) == (Quantum)
2705 TransparentOpacity ? 1 : 0);
2706 *q|=((pixel & 0x01) << 0);
2710 if ((number_pixels % 4) != 0)
2713 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2715 pixel=(
unsigned char) ((ssize_t) *indexes++);
2716 *q|=((pixel & 0x01) << (
unsigned char) (bit+4));
2717 pixel=(
unsigned char) (GetPixelOpacity(p) == (Quantum)
2718 TransparentOpacity ? 1 : 0);
2719 *q|=((pixel & 0x01) << (
unsigned char) (bit+4-1));
2731 for (x=0; x < (ssize_t) number_pixels ; x++)
2733 pixel=(
unsigned char) ((ssize_t) *indexes++);
2734 *q=((pixel & 0xf) << 4);
2735 pixel=(
unsigned char) ((ssize_t) (16*QuantumScale*((MagickRealType)
2736 QuantumRange-(MagickRealType) GetPixelOpacity(p))+0.5));
2737 *q|=((pixel & 0xf) << 0);
2748 for (x=0; x < (ssize_t) number_pixels; x++)
2750 q=PopCharPixel((
unsigned char) GetPixelIndex(indexes+x),q);
2751 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-GetPixelOpacity(p)));
2752 q=PopCharPixel(pixel,q);
2754 q+=quantum_info->pad;
2763 if (quantum_info->format == FloatingPointQuantumFormat)
2765 for (x=0; x < (ssize_t) number_pixels; x++)
2767 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2768 ((ssize_t) GetPixelIndex(indexes+x)),q);
2769 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
2770 q=PopShortPixel(quantum_info->endian,pixel,q);
2772 q+=quantum_info->pad;
2776 for (x=0; x < (ssize_t) number_pixels; x++)
2778 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2779 ((ssize_t) GetPixelIndex(indexes+x)),q);
2780 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-GetPixelOpacity(p)));
2781 q=PopShortPixel(quantum_info->endian,pixel,q);
2783 q+=quantum_info->pad;
2792 if (quantum_info->format == FloatingPointQuantumFormat)
2794 for (x=0; x < (ssize_t) number_pixels; x++)
2799 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(indexes+x),q);
2800 pixel=(float) (GetPixelAlpha(p));
2801 q=PopQuantumFloatPixel(quantum_info,pixel,q);
2803 q+=quantum_info->pad;
2807 for (x=0; x < (ssize_t) number_pixels; x++)
2809 q=PopLongPixel(quantum_info->endian,(
unsigned int)
2810 GetPixelIndex(indexes+x),q);
2811 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-GetPixelOpacity(p)));
2812 q=PopLongPixel(quantum_info->endian,pixel,q);
2814 q+=quantum_info->pad;
2820 if (quantum_info->format == FloatingPointQuantumFormat)
2822 for (x=0; x < (ssize_t) number_pixels; x++)
2827 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(indexes+x),
2829 pixel=(double) (GetPixelAlpha(p));
2830 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2832 q+=quantum_info->pad;
2843 range=GetQuantumRange(quantum_info->depth);
2844 for (x=0; x < (ssize_t) number_pixels; x++)
2846 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(indexes+x),q);
2847 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
2848 (GetPixelAlpha(p)),range),q);
2850 q+=quantum_info->pad;
2857 static void ExportOpacityQuantum(
QuantumInfo *quantum_info,
2858 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2859 unsigned char *magick_restrict q)
2867 switch (quantum_info->depth)
2874 for (x=0; x < (ssize_t) number_pixels; x++)
2876 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
2877 q=PopCharPixel(pixel,q);
2879 q+=quantum_info->pad;
2888 if (quantum_info->format == FloatingPointQuantumFormat)
2890 for (x=0; x < (ssize_t) number_pixels; x++)
2892 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
2893 q=PopShortPixel(quantum_info->endian,pixel,q);
2895 q+=quantum_info->pad;
2899 for (x=0; x < (ssize_t) number_pixels; x++)
2901 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
2902 q=PopShortPixel(quantum_info->endian,pixel,q);
2904 q+=quantum_info->pad;
2913 if (quantum_info->format == FloatingPointQuantumFormat)
2915 for (x=0; x < (ssize_t) number_pixels; x++)
2917 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelOpacity(p),q);
2919 q+=quantum_info->pad;
2923 for (x=0; x < (ssize_t) number_pixels; x++)
2925 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
2926 q=PopLongPixel(quantum_info->endian,pixel,q);
2928 q+=quantum_info->pad;
2934 if (quantum_info->format == FloatingPointQuantumFormat)
2936 for (x=0; x < (ssize_t) number_pixels; x++)
2938 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelOpacity(p),q);
2940 q+=quantum_info->pad;
2948 range=GetQuantumRange(quantum_info->depth);
2949 for (x=0; x < (ssize_t) number_pixels; x++)
2951 q=PopQuantumPixel(quantum_info,
2952 ScaleQuantumToAny(GetPixelOpacity(p),range),q);
2954 q+=quantum_info->pad;
2961 static void ExportRedQuantum(
QuantumInfo *quantum_info,
2962 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
2963 unsigned char *magick_restrict q)
2971 switch (quantum_info->depth)
2978 for (x=0; x < (ssize_t) number_pixels; x++)
2980 pixel=ScaleQuantumToChar(GetPixelRed(p));
2981 q=PopCharPixel(pixel,q);
2983 q+=quantum_info->pad;
2992 if (quantum_info->format == FloatingPointQuantumFormat)
2994 for (x=0; x < (ssize_t) number_pixels; x++)
2996 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
2997 q=PopShortPixel(quantum_info->endian,pixel,q);
2999 q+=quantum_info->pad;
3003 for (x=0; x < (ssize_t) number_pixels; x++)
3005 pixel=ScaleQuantumToShort(GetPixelRed(p));
3006 q=PopShortPixel(quantum_info->endian,pixel,q);
3008 q+=quantum_info->pad;
3017 if (quantum_info->format == FloatingPointQuantumFormat)
3019 for (x=0; x < (ssize_t) number_pixels; x++)
3021 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
3023 q+=quantum_info->pad;
3027 for (x=0; x < (ssize_t) number_pixels; x++)
3029 pixel=ScaleQuantumToLong(GetPixelRed(p));
3030 q=PopLongPixel(quantum_info->endian,pixel,q);
3032 q+=quantum_info->pad;
3038 if (quantum_info->format == FloatingPointQuantumFormat)
3040 for (x=0; x < (ssize_t) number_pixels; x++)
3042 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
3044 q+=quantum_info->pad;
3052 range=GetQuantumRange(quantum_info->depth);
3053 for (x=0; x < (ssize_t) number_pixels; x++)
3055 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),range),
3058 q+=quantum_info->pad;
3065 static void ExportRGBQuantum(
QuantumInfo *quantum_info,
3066 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
3067 unsigned char *magick_restrict q)
3078 switch (quantum_info->depth)
3082 for (x=0; x < (ssize_t) number_pixels; x++)
3084 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(p)),q);
3085 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(p)),q);
3086 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(p)),q);
3088 q+=quantum_info->pad;
3097 range=GetQuantumRange(quantum_info->depth);
3098 if (quantum_info->pack == MagickFalse)
3100 for (x=0; x < (ssize_t) number_pixels; x++)
3102 pixel=(
unsigned int) (
3103 ScaleQuantumToAny(GetPixelRed(p),range) << 22 |
3104 ScaleQuantumToAny(GetPixelGreen(p),range) << 12 |
3105 ScaleQuantumToAny(GetPixelBlue(p),range) << 2);
3106 q=PopLongPixel(quantum_info->endian,pixel,q);
3108 q+=quantum_info->pad;
3112 if (quantum_info->quantum == 32UL)
3114 for (x=0; x < (ssize_t) number_pixels; x++)
3116 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3117 q=PopQuantumLongPixel(quantum_info,pixel,q);
3118 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3119 q=PopQuantumLongPixel(quantum_info,pixel,q);
3120 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3121 q=PopQuantumLongPixel(quantum_info,pixel,q);
3123 q+=quantum_info->pad;
3127 for (x=0; x < (ssize_t) number_pixels; x++)
3129 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3130 q=PopQuantumPixel(quantum_info,pixel,q);
3131 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3132 q=PopQuantumPixel(quantum_info,pixel,q);
3133 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3134 q=PopQuantumPixel(quantum_info,pixel,q);
3136 q+=quantum_info->pad;
3145 range=GetQuantumRange(quantum_info->depth);
3146 if (quantum_info->pack == MagickFalse)
3148 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
3155 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3160 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3165 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3170 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3177 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3182 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3187 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3192 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3194 q+=quantum_info->pad;
3196 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3198 switch ((x+bit) % 3)
3203 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3208 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3213 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3218 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3220 q+=quantum_info->pad;
3226 if (quantum_info->quantum == 32UL)
3228 for (x=0; x < (ssize_t) number_pixels; x++)
3230 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3231 q=PopQuantumLongPixel(quantum_info,pixel,q);
3232 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3233 q=PopQuantumLongPixel(quantum_info,pixel,q);
3234 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3235 q=PopQuantumLongPixel(quantum_info,pixel,q);
3237 q+=quantum_info->pad;
3241 for (x=0; x < (ssize_t) number_pixels; x++)
3243 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3244 q=PopQuantumPixel(quantum_info,pixel,q);
3245 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3246 q=PopQuantumPixel(quantum_info,pixel,q);
3247 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3248 q=PopQuantumPixel(quantum_info,pixel,q);
3250 q+=quantum_info->pad;
3259 if (quantum_info->format == FloatingPointQuantumFormat)
3261 for (x=0; x < (ssize_t) number_pixels; x++)
3263 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
3264 q=PopShortPixel(quantum_info->endian,pixel,q);
3265 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
3266 q=PopShortPixel(quantum_info->endian,pixel,q);
3267 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
3268 q=PopShortPixel(quantum_info->endian,pixel,q);
3270 q+=quantum_info->pad;
3274 for (x=0; x < (ssize_t) number_pixels; x++)
3276 pixel=ScaleQuantumToShort(GetPixelRed(p));
3277 q=PopShortPixel(quantum_info->endian,pixel,q);
3278 pixel=ScaleQuantumToShort(GetPixelGreen(p));
3279 q=PopShortPixel(quantum_info->endian,pixel,q);
3280 pixel=ScaleQuantumToShort(GetPixelBlue(p));
3281 q=PopShortPixel(quantum_info->endian,pixel,q);
3283 q+=quantum_info->pad;
3292 if (quantum_info->format == FloatingPointQuantumFormat)
3294 for (x=0; x < (ssize_t) number_pixels; x++)
3296 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
3297 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
3298 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
3300 q+=quantum_info->pad;
3304 for (x=0; x < (ssize_t) number_pixels; x++)
3306 pixel=ScaleQuantumToLong(GetPixelRed(p));
3307 q=PopLongPixel(quantum_info->endian,pixel,q);
3308 pixel=ScaleQuantumToLong(GetPixelGreen(p));
3309 q=PopLongPixel(quantum_info->endian,pixel,q);
3310 pixel=ScaleQuantumToLong(GetPixelBlue(p));
3311 q=PopLongPixel(quantum_info->endian,pixel,q);
3313 q+=quantum_info->pad;
3319 if (quantum_info->format == FloatingPointQuantumFormat)
3321 for (x=0; x < (ssize_t) number_pixels; x++)
3323 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
3324 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
3325 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
3327 q+=quantum_info->pad;
3335 range=GetQuantumRange(quantum_info->depth);
3336 for (x=0; x < (ssize_t) number_pixels; x++)
3338 q=PopQuantumPixel(quantum_info,
3339 ScaleQuantumToAny(GetPixelRed(p),range),q);
3340 q=PopQuantumPixel(quantum_info,
3341 ScaleQuantumToAny(GetPixelGreen(p),range),q);
3342 q=PopQuantumPixel(quantum_info,
3343 ScaleQuantumToAny(GetPixelBlue(p),range),q);
3345 q+=quantum_info->pad;
3352 static void ExportRGBAQuantum(
QuantumInfo *quantum_info,
3353 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
3354 unsigned char *magick_restrict q)
3362 switch (quantum_info->depth)
3369 for (x=0; x < (ssize_t) number_pixels; x++)
3371 pixel=ScaleQuantumToChar(GetPixelRed(p));
3372 q=PopCharPixel(pixel,q);
3373 pixel=ScaleQuantumToChar(GetPixelGreen(p));
3374 q=PopCharPixel(pixel,q);
3375 pixel=ScaleQuantumToChar(GetPixelBlue(p));
3376 q=PopCharPixel(pixel,q);
3377 pixel=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
3378 q=PopCharPixel(pixel,q);
3380 q+=quantum_info->pad;
3389 range=GetQuantumRange(quantum_info->depth);
3390 if (quantum_info->pack == MagickFalse)
3404 for (x=0; x < (ssize_t) number_pixels; x++)
3406 for (i=0; i < 4; i++)
3410 case 0: quantum=(size_t) GetPixelRed(p);
break;
3411 case 1: quantum=(size_t) GetPixelGreen(p);
break;
3412 case 2: quantum=(size_t) GetPixelBlue(p);
break;
3413 case 3: quantum=(size_t) GetPixelAlpha(p);
break;
3419 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3425 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3431 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3433 q=PopLongPixel(quantum_info->endian,pixel,q);
3441 q+=quantum_info->pad;
3445 if (quantum_info->quantum == 32UL)
3447 for (x=0; x < (ssize_t) number_pixels; x++)
3449 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3450 q=PopQuantumLongPixel(quantum_info,pixel,q);
3451 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3452 q=PopQuantumLongPixel(quantum_info,pixel,q);
3453 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3454 q=PopQuantumLongPixel(quantum_info,pixel,q);
3455 pixel=(
unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
3457 q=PopQuantumLongPixel(quantum_info,pixel,q);
3459 q+=quantum_info->pad;
3463 for (x=0; x < (ssize_t) number_pixels; x++)
3465 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3466 q=PopQuantumPixel(quantum_info,pixel,q);
3467 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3468 q=PopQuantumPixel(quantum_info,pixel,q);
3469 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3470 q=PopQuantumPixel(quantum_info,pixel,q);
3471 pixel=(
unsigned int) ScaleQuantumToAny((Quantum) GetPixelAlpha(p),
3473 q=PopQuantumPixel(quantum_info,pixel,q);
3475 q+=quantum_info->pad;
3484 if (quantum_info->format == FloatingPointQuantumFormat)
3486 for (x=0; x < (ssize_t) number_pixels; x++)
3488 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
3489 q=PopShortPixel(quantum_info->endian,pixel,q);
3490 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
3491 q=PopShortPixel(quantum_info->endian,pixel,q);
3492 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
3493 q=PopShortPixel(quantum_info->endian,pixel,q);
3494 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelAlpha(p));
3495 q=PopShortPixel(quantum_info->endian,pixel,q);
3497 q+=quantum_info->pad;
3501 for (x=0; x < (ssize_t) number_pixels; x++)
3503 pixel=ScaleQuantumToShort(GetPixelRed(p));
3504 q=PopShortPixel(quantum_info->endian,pixel,q);
3505 pixel=ScaleQuantumToShort(GetPixelGreen(p));
3506 q=PopShortPixel(quantum_info->endian,pixel,q);
3507 pixel=ScaleQuantumToShort(GetPixelBlue(p));
3508 q=PopShortPixel(quantum_info->endian,pixel,q);
3509 pixel=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
3510 q=PopShortPixel(quantum_info->endian,pixel,q);
3512 q+=quantum_info->pad;
3521 if (quantum_info->format == FloatingPointQuantumFormat)
3523 for (x=0; x < (ssize_t) number_pixels; x++)
3528 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
3529 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
3530 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
3531 pixel=(float) GetPixelAlpha(p);
3532 q=PopQuantumFloatPixel(quantum_info,pixel,q);
3534 q+=quantum_info->pad;
3538 for (x=0; x < (ssize_t) number_pixels; x++)
3540 pixel=ScaleQuantumToLong(GetPixelRed(p));
3541 q=PopLongPixel(quantum_info->endian,pixel,q);
3542 pixel=ScaleQuantumToLong(GetPixelGreen(p));
3543 q=PopLongPixel(quantum_info->endian,pixel,q);
3544 pixel=ScaleQuantumToLong(GetPixelBlue(p));
3545 q=PopLongPixel(quantum_info->endian,pixel,q);
3546 pixel=ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
3547 q=PopLongPixel(quantum_info->endian,pixel,q);
3549 q+=quantum_info->pad;
3555 if (quantum_info->format == FloatingPointQuantumFormat)
3560 for (x=0; x < (ssize_t) number_pixels; x++)
3562 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
3563 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
3564 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
3565 pixel=(double) GetPixelAlpha(p);
3566 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3568 q+=quantum_info->pad;
3576 range=GetQuantumRange(quantum_info->depth);
3577 for (x=0; x < (ssize_t) number_pixels; x++)
3579 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),
3581 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(p),
3583 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(p),
3585 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny((Quantum)
3586 GetPixelAlpha(p),range),q);
3588 q+=quantum_info->pad;
3595 static void ExportRGBOQuantum(
QuantumInfo *quantum_info,
3596 const MagickSizeType number_pixels,
const PixelPacket *magick_restrict p,
3597 unsigned char *magick_restrict q)
3605 switch (quantum_info->depth)
3612 for (x=0; x < (ssize_t) number_pixels; x++)
3614 pixel=ScaleQuantumToChar(GetPixelRed(p));
3615 q=PopCharPixel(pixel,q);
3616 pixel=ScaleQuantumToChar(GetPixelGreen(p));
3617 q=PopCharPixel(pixel,q);
3618 pixel=ScaleQuantumToChar(GetPixelBlue(p));
3619 q=PopCharPixel(pixel,q);
3620 pixel=ScaleQuantumToChar(GetPixelOpacity(p));
3621 q=PopCharPixel(pixel,q);
3623 q+=quantum_info->pad;
3632 range=GetQuantumRange(quantum_info->depth);
3633 if (quantum_info->pack == MagickFalse)
3647 for (x=0; x < (ssize_t) number_pixels; x++)
3649 for (i=0; i < 4; i++)
3653 case 0: quantum=(size_t) GetPixelRed(p);
break;
3654 case 1: quantum=(size_t) GetPixelGreen(p);
break;
3655 case 2: quantum=(size_t) GetPixelBlue(p);
break;
3656 case 3: quantum=(size_t) GetPixelOpacity(p);
break;
3662 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3668 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3674 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3676 q=PopLongPixel(quantum_info->endian,pixel,q);
3684 q+=quantum_info->pad;
3688 if (quantum_info->quantum == 32UL)
3690 for (x=0; x < (ssize_t) number_pixels; x++)
3692 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3693 q=PopQuantumLongPixel(quantum_info,pixel,q);
3694 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3695 q=PopQuantumLongPixel(quantum_info,pixel,q);
3696 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3697 q=PopQuantumLongPixel(quantum_info,pixel,q);
3698 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
3699 q=PopQuantumLongPixel(quantum_info,pixel,q);
3701 q+=quantum_info->pad;
3705 for (x=0; x < (ssize_t) number_pixels; x++)
3707 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(p),range);
3708 q=PopQuantumPixel(quantum_info,pixel,q);
3709 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(p),range);
3710 q=PopQuantumPixel(quantum_info,pixel,q);
3711 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(p),range);
3712 q=PopQuantumPixel(quantum_info,pixel,q);
3713 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(p),range);
3714 q=PopQuantumPixel(quantum_info,pixel,q);
3716 q+=quantum_info->pad;
3725 if (quantum_info->format == FloatingPointQuantumFormat)
3727 for (x=0; x < (ssize_t) number_pixels; x++)
3729 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelRed(p));
3730 q=PopShortPixel(quantum_info->endian,pixel,q);
3731 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelGreen(p));
3732 q=PopShortPixel(quantum_info->endian,pixel,q);
3733 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelBlue(p));
3734 q=PopShortPixel(quantum_info->endian,pixel,q);
3735 pixel=SinglePrecisionToHalf(QuantumScale*(MagickRealType) GetPixelOpacity(p));
3736 q=PopShortPixel(quantum_info->endian,pixel,q);
3738 q+=quantum_info->pad;
3742 for (x=0; x < (ssize_t) number_pixels; x++)
3744 pixel=ScaleQuantumToShort(GetPixelRed(p));
3745 q=PopShortPixel(quantum_info->endian,pixel,q);
3746 pixel=ScaleQuantumToShort(GetPixelGreen(p));
3747 q=PopShortPixel(quantum_info->endian,pixel,q);
3748 pixel=ScaleQuantumToShort(GetPixelBlue(p));
3749 q=PopShortPixel(quantum_info->endian,pixel,q);
3750 pixel=ScaleQuantumToShort(GetPixelOpacity(p));
3751 q=PopShortPixel(quantum_info->endian,pixel,q);
3753 q+=quantum_info->pad;
3762 if (quantum_info->format == FloatingPointQuantumFormat)
3764 for (x=0; x < (ssize_t) number_pixels; x++)
3769 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(p),q);
3770 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(p),q);
3771 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(p),q);
3772 pixel=(float) GetPixelOpacity(p);
3773 q=PopQuantumFloatPixel(quantum_info,pixel,q);
3775 q+=quantum_info->pad;
3779 for (x=0; x < (ssize_t) number_pixels; x++)
3781 pixel=ScaleQuantumToLong(GetPixelRed(p));
3782 q=PopLongPixel(quantum_info->endian,pixel,q);
3783 pixel=ScaleQuantumToLong(GetPixelGreen(p));
3784 q=PopLongPixel(quantum_info->endian,pixel,q);
3785 pixel=ScaleQuantumToLong(GetPixelBlue(p));
3786 q=PopLongPixel(quantum_info->endian,pixel,q);
3787 pixel=ScaleQuantumToLong(GetPixelOpacity(p));
3788 q=PopLongPixel(quantum_info->endian,pixel,q);
3790 q+=quantum_info->pad;
3796 if (quantum_info->format == FloatingPointQuantumFormat)
3801 for (x=0; x < (ssize_t) number_pixels; x++)
3803 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(p),q);
3804 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(p),q);
3805 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(p),q);
3806 pixel=(double) GetPixelOpacity(p);
3807 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3809 q+=quantum_info->pad;
3817 range=GetQuantumRange(quantum_info->depth);
3818 for (x=0; x < (ssize_t) number_pixels; x++)
3820 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(p),
3822 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(p),
3824 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(p),
3826 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(p),
3829 q+=quantum_info->pad;
3836 MagickExport
size_t ExportQuantumPixels(
const Image *image,
3838 const QuantumType quantum_type,
unsigned char *magick_restrict pixels,
3848 *magick_restrict indexes;
3862 assert(image != (
Image *) NULL);
3863 assert(image->signature == MagickCoreSignature);
3864 if (IsEventLogging() != MagickFalse)
3865 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3867 assert(quantum_info->signature == MagickCoreSignature);
3868 if (pixels == (
unsigned char *) NULL)
3869 pixels=GetQuantumPixels(quantum_info);
3872 number_pixels=GetImageExtent(image);
3873 p=GetVirtualPixelQueue(image);
3874 indexes=GetVirtualIndexQueue(image);
3878 number_pixels=GetCacheViewExtent(image_view);
3879 p=GetCacheViewVirtualPixelQueue(image_view);
3880 indexes=GetCacheViewVirtualIndexQueue(image_view);
3882 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
3891 q=GetAuthenticPixelQueue(image);
3893 q=(
PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3894 for (x=0; x < (ssize_t) image->columns; x++)
3896 alpha=QuantumScale*(MagickRealType) GetPixelAlpha(q);
3897 SetPixelRed(q,ClampToQuantum(alpha*(MagickRealType) GetPixelRed(q)));
3898 SetPixelGreen(q,ClampToQuantum(alpha*(MagickRealType)
3900 SetPixelBlue(q,ClampToQuantum(alpha*(MagickRealType) GetPixelBlue(q)));
3904 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3913 q=GetAuthenticPixelQueue(image);
3915 q=(
PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3916 for (x=0; x < (ssize_t) number_pixels; x++)
3918 quantum=GetPixelRed(q);
3919 SetPixelRed(q,GetPixelGreen(q));
3920 SetPixelGreen(q,quantum);
3927 extent=GetQuantumExtent(image,quantum_info,quantum_type);
3928 switch (quantum_type)
3932 ExportAlphaQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3937 ExportBGRQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3942 ExportBGRAQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3947 ExportBGROQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3952 ExportBlackQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3953 indexes,q,exception);
3959 ExportBlueQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3964 ExportCbYCrYQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
3969 ExportCMYKQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3970 indexes,q,exception);
3975 ExportCMYKAQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3976 indexes,q,exception);
3981 ExportCMYKOQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
3982 indexes,q,exception);
3987 ExportGrayQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,q);
3990 case GrayAlphaQuantum:
3992 ExportGrayAlphaQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,
3997 case MagentaQuantum:
3999 ExportGreenQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4004 ExportIndexQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,p,
4005 indexes,q,exception);
4008 case IndexAlphaQuantum:
4010 ExportIndexAlphaQuantum(image,(
QuantumInfo *) quantum_info,number_pixels,
4011 p,indexes,q,exception);
4014 case OpacityQuantum:
4016 ExportOpacityQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4022 ExportRedQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4028 ExportRGBQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4034 ExportRGBAQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4039 ExportRGBOQuantum((
QuantumInfo *) quantum_info,number_pixels,p,q);
4045 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
4054 q=GetAuthenticPixelQueue(image);
4056 q=(
PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
4057 for (x=0; x < (ssize_t) number_pixels; x++)
4059 quantum=GetPixelRed(q);
4060 SetPixelRed(q,GetPixelGreen(q));
4061 SetPixelGreen(q,quantum);