47#include "MagickCore/studio.h"
48#include "MagickCore/property.h"
49#include "MagickCore/blob.h"
50#include "MagickCore/blob-private.h"
51#include "MagickCore/color-private.h"
52#include "MagickCore/exception.h"
53#include "MagickCore/exception-private.h"
54#include "MagickCore/cache.h"
55#include "MagickCore/constitute.h"
56#include "MagickCore/delegate.h"
57#include "MagickCore/geometry.h"
58#include "MagickCore/list.h"
59#include "MagickCore/magick.h"
60#include "MagickCore/memory_.h"
61#include "MagickCore/monitor.h"
62#include "MagickCore/option.h"
63#include "MagickCore/pixel.h"
64#include "MagickCore/pixel-accessor.h"
65#include "MagickCore/quantum.h"
66#include "MagickCore/quantum-private.h"
67#include "MagickCore/resource_.h"
68#include "MagickCore/semaphore.h"
69#include "MagickCore/statistic.h"
70#include "MagickCore/stream.h"
71#include "MagickCore/string_.h"
72#include "MagickCore/utility.h"
113static inline unsigned char *PopQuantumDoublePixel(
QuantumInfo *quantum_info,
114 const double pixel,
unsigned char *magick_restrict pixels)
122 (void) memset(quantum,0,
sizeof(quantum));
123 p=(
double *) quantum;
124 *p=(double) (pixel*quantum_info->state.inverse_scale+quantum_info->minimum);
125 if (quantum_info->endian == LSBEndian)
127 *pixels++=quantum[0];
128 *pixels++=quantum[1];
129 *pixels++=quantum[2];
130 *pixels++=quantum[3];
131 *pixels++=quantum[4];
132 *pixels++=quantum[5];
133 *pixels++=quantum[6];
134 *pixels++=quantum[7];
137 *pixels++=quantum[7];
138 *pixels++=quantum[6];
139 *pixels++=quantum[5];
140 *pixels++=quantum[4];
141 *pixels++=quantum[3];
142 *pixels++=quantum[2];
143 *pixels++=quantum[1];
144 *pixels++=quantum[0];
148static inline unsigned char *PopQuantumFloatPixel(
QuantumInfo *quantum_info,
149 const float pixel,
unsigned char *magick_restrict pixels)
157 (void) memset(quantum,0,
sizeof(quantum));
159 *p=(float) ((
double) pixel*quantum_info->state.inverse_scale+
160 quantum_info->minimum);
161 if (quantum_info->endian == LSBEndian)
163 *pixels++=quantum[0];
164 *pixels++=quantum[1];
165 *pixels++=quantum[2];
166 *pixels++=quantum[3];
169 *pixels++=quantum[3];
170 *pixels++=quantum[2];
171 *pixels++=quantum[1];
172 *pixels++=quantum[0];
176static inline unsigned char *PopQuantumPixel(
QuantumInfo *quantum_info,
177 const QuantumAny pixel,
unsigned char *magick_restrict pixels)
185 if (quantum_info->state.bits == 0UL)
186 quantum_info->state.bits=8U;
187 for (i=(ssize_t) quantum_info->depth; i > 0L; )
189 quantum_bits=(size_t) i;
190 if (quantum_bits > quantum_info->state.bits)
191 quantum_bits=quantum_info->state.bits;
192 i-=(ssize_t) quantum_bits;
195 if (quantum_info->state.bits == 8UL)
197 quantum_info->state.bits-=quantum_bits;
198 *pixels|=(((pixel >> i) &~ (((QuantumAny) ~0UL) << quantum_bits)) <<
199 quantum_info->state.bits);
200 if (quantum_info->state.bits == 0UL)
203 quantum_info->state.bits=8UL;
209static inline unsigned char *PopQuantumLongPixel(
QuantumInfo *quantum_info,
210 const size_t pixel,
unsigned char *magick_restrict pixels)
218 if (quantum_info->state.bits == 0U)
219 quantum_info->state.bits=32UL;
220 for (i=(ssize_t) quantum_info->depth; i > 0; )
222 quantum_bits=(size_t) i;
223 if (quantum_bits > quantum_info->state.bits)
224 quantum_bits=quantum_info->state.bits;
225 quantum_info->state.pixel|=(((pixel >> ((ssize_t) quantum_info->depth-i)) &
226 quantum_info->state.mask[quantum_bits]) << (32U-
227 quantum_info->state.bits));
228 i-=(ssize_t) quantum_bits;
229 quantum_info->state.bits-=quantum_bits;
230 if (quantum_info->state.bits == 0U)
232 pixels=PopLongPixel(quantum_info->endian,quantum_info->state.pixel,
234 quantum_info->state.pixel=0U;
235 quantum_info->state.bits=32U;
242 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
243 unsigned char *magick_restrict q)
251 switch (quantum_info->depth)
258 for (x=0; x < (ssize_t) number_pixels; x++)
260 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
261 q=PopCharPixel(pixel,q);
262 p+=GetPixelChannels(image);
263 q+=quantum_info->pad;
272 if (quantum_info->format == FloatingPointQuantumFormat)
274 for (x=0; x < (ssize_t) number_pixels; x++)
276 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
277 GetPixelAlpha(image,p));
278 q=PopShortPixel(quantum_info->endian,pixel,q);
279 p+=GetPixelChannels(image);
280 q+=quantum_info->pad;
284 for (x=0; x < (ssize_t) number_pixels; x++)
286 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
287 q=PopShortPixel(quantum_info->endian,pixel,q);
288 p+=GetPixelChannels(image);
289 q+=quantum_info->pad;
298 if (quantum_info->format == FloatingPointQuantumFormat)
300 for (x=0; x < (ssize_t) number_pixels; x++)
302 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelAlpha(image,p),q);
303 p+=GetPixelChannels(image);
304 q+=quantum_info->pad;
308 for (x=0; x < (ssize_t) number_pixels; x++)
310 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
311 q=PopLongPixel(quantum_info->endian,pixel,q);
312 p+=GetPixelChannels(image);
313 q+=quantum_info->pad;
319 if (quantum_info->format == FloatingPointQuantumFormat)
321 for (x=0; x < (ssize_t) number_pixels; x++)
323 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelAlpha(image,p),q);
324 p+=GetPixelChannels(image);
325 q+=quantum_info->pad;
333 range=GetQuantumRange(quantum_info->depth);
334 for (x=0; x < (ssize_t) number_pixels; x++)
336 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
338 p+=GetPixelChannels(image);
339 q+=quantum_info->pad;
347 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
348 unsigned char *magick_restrict q)
359 switch (quantum_info->depth)
363 for (x=0; x < (ssize_t) number_pixels; x++)
365 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
366 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
367 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
368 p+=GetPixelChannels(image);
369 q+=quantum_info->pad;
378 range=GetQuantumRange(quantum_info->depth);
379 if (quantum_info->pack == MagickFalse)
381 for (x=0; x < (ssize_t) number_pixels; x++)
383 pixel=(
unsigned int) (
384 ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
385 ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
386 ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
387 q=PopLongPixel(quantum_info->endian,pixel,q);
388 p+=GetPixelChannels(image);
389 q+=quantum_info->pad;
393 if (quantum_info->quantum == 32UL)
395 for (x=0; x < (ssize_t) number_pixels; x++)
397 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
398 q=PopQuantumLongPixel(quantum_info,pixel,q);
399 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
401 q=PopQuantumLongPixel(quantum_info,pixel,q);
402 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
403 q=PopQuantumLongPixel(quantum_info,pixel,q);
404 p+=GetPixelChannels(image);
405 q+=quantum_info->pad;
409 for (x=0; x < (ssize_t) number_pixels; x++)
411 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
412 q=PopQuantumPixel(quantum_info,pixel,q);
413 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
414 q=PopQuantumPixel(quantum_info,pixel,q);
415 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
416 q=PopQuantumPixel(quantum_info,pixel,q);
417 p+=GetPixelChannels(image);
418 q+=quantum_info->pad;
427 range=GetQuantumRange(quantum_info->depth);
428 if (quantum_info->pack == MagickFalse)
430 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
437 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
443 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
449 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
451 p+=GetPixelChannels(image);
455 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
462 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
468 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
474 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
476 p+=GetPixelChannels(image);
480 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
482 q+=quantum_info->pad;
484 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
491 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
497 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
503 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
505 p+=GetPixelChannels(image);
509 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
511 q+=quantum_info->pad;
514 p+=GetPixelChannels(image);
517 if (quantum_info->quantum == 32UL)
519 for (x=0; x < (ssize_t) number_pixels; x++)
521 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
522 q=PopQuantumLongPixel(quantum_info,pixel,q);
523 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
525 q=PopQuantumLongPixel(quantum_info,pixel,q);
526 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
527 q=PopQuantumLongPixel(quantum_info,pixel,q);
528 p+=GetPixelChannels(image);
529 q+=quantum_info->pad;
533 for (x=0; x < (ssize_t) number_pixels; x++)
535 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
536 q=PopQuantumPixel(quantum_info,pixel,q);
537 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
538 q=PopQuantumPixel(quantum_info,pixel,q);
539 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
540 q=PopQuantumPixel(quantum_info,pixel,q);
541 p+=GetPixelChannels(image);
542 q+=quantum_info->pad;
551 if (quantum_info->format == FloatingPointQuantumFormat)
553 for (x=0; x < (ssize_t) number_pixels; x++)
555 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
556 GetPixelBlue(image,p));
557 q=PopShortPixel(quantum_info->endian,pixel,q);
558 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
559 GetPixelGreen(image,p));
560 q=PopShortPixel(quantum_info->endian,pixel,q);
561 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
562 GetPixelRed(image,p));
563 q=PopShortPixel(quantum_info->endian,pixel,q);
564 p+=GetPixelChannels(image);
565 q+=quantum_info->pad;
569 for (x=0; x < (ssize_t) number_pixels; x++)
571 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
572 q=PopShortPixel(quantum_info->endian,pixel,q);
573 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
574 q=PopShortPixel(quantum_info->endian,pixel,q);
575 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
576 q=PopShortPixel(quantum_info->endian,pixel,q);
577 p+=GetPixelChannels(image);
578 q+=quantum_info->pad;
587 if (quantum_info->format == FloatingPointQuantumFormat)
589 for (x=0; x < (ssize_t) number_pixels; x++)
591 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
592 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
593 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
594 p+=GetPixelChannels(image);
595 q+=quantum_info->pad;
599 for (x=0; x < (ssize_t) number_pixels; x++)
601 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
602 q=PopLongPixel(quantum_info->endian,pixel,q);
603 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
604 q=PopLongPixel(quantum_info->endian,pixel,q);
605 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
606 q=PopLongPixel(quantum_info->endian,pixel,q);
607 p+=GetPixelChannels(image);
608 q+=quantum_info->pad;
614 if (quantum_info->format == FloatingPointQuantumFormat)
616 for (x=0; x < (ssize_t) number_pixels; x++)
618 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
619 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
620 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
621 p+=GetPixelChannels(image);
622 q+=quantum_info->pad;
630 range=GetQuantumRange(quantum_info->depth);
631 for (x=0; x < (ssize_t) number_pixels; x++)
633 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
635 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
637 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
639 p+=GetPixelChannels(image);
640 q+=quantum_info->pad;
648 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
649 unsigned char *magick_restrict q)
657 switch (quantum_info->depth)
664 for (x=0; x < (ssize_t) number_pixels; x++)
666 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
667 q=PopCharPixel(pixel,q);
668 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
669 q=PopCharPixel(pixel,q);
670 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
671 q=PopCharPixel(pixel,q);
672 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
673 q=PopCharPixel(pixel,q);
674 p+=GetPixelChannels(image);
675 q+=quantum_info->pad;
684 range=GetQuantumRange(quantum_info->depth);
685 if (quantum_info->pack == MagickFalse)
699 for (x=0; x < (ssize_t) number_pixels; x++)
701 for (i=0; i < 4; i++)
705 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
706 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
707 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
708 case 3: quantum=(size_t) GetPixelAlpha(image,p);
break;
714 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
720 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
726 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
728 q=PopLongPixel(quantum_info->endian,pixel,q);
735 p+=GetPixelChannels(image);
736 q+=quantum_info->pad;
740 if (quantum_info->quantum == 32UL)
742 for (x=0; x < (ssize_t) number_pixels; x++)
744 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
745 q=PopQuantumLongPixel(quantum_info,pixel,q);
746 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
748 q=PopQuantumLongPixel(quantum_info,pixel,q);
749 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
750 q=PopQuantumLongPixel(quantum_info,pixel,q);
751 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
753 q=PopQuantumLongPixel(quantum_info,pixel,q);
754 p+=GetPixelChannels(image);
755 q+=quantum_info->pad;
759 for (x=0; x < (ssize_t) number_pixels; x++)
761 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
762 q=PopQuantumPixel(quantum_info,pixel,q);
763 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
764 q=PopQuantumPixel(quantum_info,pixel,q);
765 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
766 q=PopQuantumPixel(quantum_info,pixel,q);
767 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
768 q=PopQuantumPixel(quantum_info,pixel,q);
769 p+=GetPixelChannels(image);
770 q+=quantum_info->pad;
779 if (quantum_info->format == FloatingPointQuantumFormat)
781 for (x=0; x < (ssize_t) number_pixels; x++)
783 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
784 GetPixelBlue(image,p));
785 q=PopShortPixel(quantum_info->endian,pixel,q);
786 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
787 GetPixelGreen(image,p));
788 q=PopShortPixel(quantum_info->endian,pixel,q);
789 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
790 GetPixelRed(image,p));
791 q=PopShortPixel(quantum_info->endian,pixel,q);
792 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
793 GetPixelAlpha(image,p));
794 q=PopShortPixel(quantum_info->endian,pixel,q);
795 p+=GetPixelChannels(image);
796 q+=quantum_info->pad;
800 for (x=0; x < (ssize_t) number_pixels; x++)
802 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
803 q=PopShortPixel(quantum_info->endian,pixel,q);
804 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
805 q=PopShortPixel(quantum_info->endian,pixel,q);
806 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
807 q=PopShortPixel(quantum_info->endian,pixel,q);
808 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
809 q=PopShortPixel(quantum_info->endian,pixel,q);
810 p+=GetPixelChannels(image);
811 q+=quantum_info->pad;
820 if (quantum_info->format == FloatingPointQuantumFormat)
822 for (x=0; x < (ssize_t) number_pixels; x++)
827 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
828 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
829 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
830 float_pixel=(float) GetPixelAlpha(image,p);
831 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
832 p+=GetPixelChannels(image);
833 q+=quantum_info->pad;
837 for (x=0; x < (ssize_t) number_pixels; x++)
839 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
840 q=PopLongPixel(quantum_info->endian,pixel,q);
841 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
842 q=PopLongPixel(quantum_info->endian,pixel,q);
843 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
844 q=PopLongPixel(quantum_info->endian,pixel,q);
845 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
846 q=PopLongPixel(quantum_info->endian,pixel,q);
847 p+=GetPixelChannels(image);
848 q+=quantum_info->pad;
854 if (quantum_info->format == FloatingPointQuantumFormat)
859 for (x=0; x < (ssize_t) number_pixels; x++)
861 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
862 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
863 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
864 pixel=(double) GetPixelAlpha(image,p);
865 q=PopQuantumDoublePixel(quantum_info,pixel,q);
866 p+=GetPixelChannels(image);
867 q+=quantum_info->pad;
875 range=GetQuantumRange(quantum_info->depth);
876 for (x=0; x < (ssize_t) number_pixels; x++)
878 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
880 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
882 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
884 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
886 p+=GetPixelChannels(image);
887 q+=quantum_info->pad;
895 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
896 unsigned char *magick_restrict q)
904 switch (quantum_info->depth)
911 for (x=0; x < (ssize_t) number_pixels; x++)
913 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
914 q=PopCharPixel(pixel,q);
915 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
916 q=PopCharPixel(pixel,q);
917 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
918 q=PopCharPixel(pixel,q);
919 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
920 q=PopCharPixel(pixel,q);
921 p+=GetPixelChannels(image);
922 q+=quantum_info->pad;
931 range=GetQuantumRange(quantum_info->depth);
932 if (quantum_info->pack == MagickFalse)
946 for (x=0; x < (ssize_t) number_pixels; x++)
948 for (i=0; i < 4; i++)
952 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
953 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
954 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
955 case 3: quantum=(size_t) GetPixelOpacity(image,p);
break;
961 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
967 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
973 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
975 q=PopLongPixel(quantum_info->endian,pixel,q);
982 p+=GetPixelChannels(image);
983 q+=quantum_info->pad;
987 if (quantum_info->quantum == 32UL)
989 for (x=0; x < (ssize_t) number_pixels; x++)
991 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
992 q=PopQuantumLongPixel(quantum_info,pixel,q);
993 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
995 q=PopQuantumLongPixel(quantum_info,pixel,q);
996 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
997 q=PopQuantumLongPixel(quantum_info,pixel,q);
998 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
1000 q=PopQuantumLongPixel(quantum_info,pixel,q);
1001 p+=GetPixelChannels(image);
1002 q+=quantum_info->pad;
1006 for (x=0; x < (ssize_t) number_pixels; x++)
1008 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
1009 q=PopQuantumPixel(quantum_info,pixel,q);
1010 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
1011 q=PopQuantumPixel(quantum_info,pixel,q);
1012 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
1013 q=PopQuantumPixel(quantum_info,pixel,q);
1014 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
1015 q=PopQuantumPixel(quantum_info,pixel,q);
1016 p+=GetPixelChannels(image);
1017 q+=quantum_info->pad;
1026 if (quantum_info->format == FloatingPointQuantumFormat)
1028 for (x=0; x < (ssize_t) number_pixels; x++)
1030 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1031 GetPixelBlue(image,p));
1032 q=PopShortPixel(quantum_info->endian,pixel,q);
1033 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1034 GetPixelGreen(image,p));
1035 q=PopShortPixel(quantum_info->endian,pixel,q);
1036 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1037 GetPixelRed(image,p));
1038 q=PopShortPixel(quantum_info->endian,pixel,q);
1039 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1040 GetPixelOpacity(image,p));
1041 q=PopShortPixel(quantum_info->endian,pixel,q);
1042 p+=GetPixelChannels(image);
1043 q+=quantum_info->pad;
1047 for (x=0; x < (ssize_t) number_pixels; x++)
1049 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1050 q=PopShortPixel(quantum_info->endian,pixel,q);
1051 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1052 q=PopShortPixel(quantum_info->endian,pixel,q);
1053 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1054 q=PopShortPixel(quantum_info->endian,pixel,q);
1055 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
1056 q=PopShortPixel(quantum_info->endian,pixel,q);
1057 p+=GetPixelChannels(image);
1058 q+=quantum_info->pad;
1067 if (quantum_info->format == FloatingPointQuantumFormat)
1069 for (x=0; x < (ssize_t) number_pixels; x++)
1074 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
1075 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
1076 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
1077 float_pixel=(float) GetPixelOpacity(image,p);
1078 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1079 p+=GetPixelChannels(image);
1080 q+=quantum_info->pad;
1084 for (x=0; x < (ssize_t) number_pixels; x++)
1086 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1087 q=PopLongPixel(quantum_info->endian,pixel,q);
1088 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1089 q=PopLongPixel(quantum_info->endian,pixel,q);
1090 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1091 q=PopLongPixel(quantum_info->endian,pixel,q);
1092 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
1093 q=PopLongPixel(quantum_info->endian,pixel,q);
1094 p+=GetPixelChannels(image);
1095 q+=quantum_info->pad;
1101 if (quantum_info->format == FloatingPointQuantumFormat)
1106 for (x=0; x < (ssize_t) number_pixels; x++)
1108 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
1109 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
1110 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
1111 pixel=(double) GetPixelOpacity(image,p);
1112 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1113 p+=GetPixelChannels(image);
1114 q+=quantum_info->pad;
1122 range=GetQuantumRange(quantum_info->depth);
1123 for (x=0; x < (ssize_t) number_pixels; x++)
1125 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1127 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1129 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1131 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
1133 p+=GetPixelChannels(image);
1134 q+=quantum_info->pad;
1141static void ExportBlackQuantum(
const Image *image,
QuantumInfo *quantum_info,
1142 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1152 assert(exception->signature == MagickCoreSignature);
1153 if (image->colorspace != CMYKColorspace)
1155 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1156 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1159 switch (quantum_info->depth)
1166 for (x=0; x < (ssize_t) number_pixels; x++)
1168 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1169 q=PopCharPixel(pixel,q);
1170 p+=GetPixelChannels(image);
1171 q+=quantum_info->pad;
1180 if (quantum_info->format == FloatingPointQuantumFormat)
1182 for (x=0; x < (ssize_t) number_pixels; x++)
1184 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1185 GetPixelBlack(image,p));
1186 q=PopShortPixel(quantum_info->endian,pixel,q);
1187 p+=GetPixelChannels(image);
1188 q+=quantum_info->pad;
1192 for (x=0; x < (ssize_t) number_pixels; x++)
1194 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1195 q=PopShortPixel(quantum_info->endian,pixel,q);
1196 p+=GetPixelChannels(image);
1197 q+=quantum_info->pad;
1206 if (quantum_info->format == FloatingPointQuantumFormat)
1208 for (x=0; x < (ssize_t) number_pixels; x++)
1210 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlack(image,p),q);
1211 p+=GetPixelChannels(image);
1212 q+=quantum_info->pad;
1216 for (x=0; x < (ssize_t) number_pixels; x++)
1218 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1219 q=PopLongPixel(quantum_info->endian,pixel,q);
1220 p+=GetPixelChannels(image);
1221 q+=quantum_info->pad;
1227 if (quantum_info->format == FloatingPointQuantumFormat)
1229 for (x=0; x < (ssize_t) number_pixels; x++)
1231 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlack(image,p),q);
1232 p+=GetPixelChannels(image);
1233 q+=quantum_info->pad;
1241 range=GetQuantumRange(quantum_info->depth);
1242 for (x=0; x < (ssize_t) number_pixels; x++)
1244 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1246 p+=GetPixelChannels(image);
1247 q+=quantum_info->pad;
1255 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1256 unsigned char *magick_restrict q)
1264 switch (quantum_info->depth)
1271 for (x=0; x < (ssize_t) number_pixels; x++)
1273 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1274 q=PopCharPixel(pixel,q);
1275 p+=GetPixelChannels(image);
1276 q+=quantum_info->pad;
1285 if (quantum_info->format == FloatingPointQuantumFormat)
1287 for (x=0; x < (ssize_t) number_pixels; x++)
1289 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1290 GetPixelBlue(image,p));
1291 q=PopShortPixel(quantum_info->endian,pixel,q);
1292 p+=GetPixelChannels(image);
1293 q+=quantum_info->pad;
1297 for (x=0; x < (ssize_t) number_pixels; x++)
1299 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1300 q=PopShortPixel(quantum_info->endian,pixel,q);
1301 p+=GetPixelChannels(image);
1302 q+=quantum_info->pad;
1311 if (quantum_info->format == FloatingPointQuantumFormat)
1313 for (x=0; x < (ssize_t) number_pixels; x++)
1315 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
1316 p+=GetPixelChannels(image);
1317 q+=quantum_info->pad;
1321 for (x=0; x < (ssize_t) number_pixels; x++)
1323 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1324 q=PopLongPixel(quantum_info->endian,pixel,q);
1325 p+=GetPixelChannels(image);
1326 q+=quantum_info->pad;
1332 if (quantum_info->format == FloatingPointQuantumFormat)
1334 for (x=0; x < (ssize_t) number_pixels; x++)
1336 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
1337 p+=GetPixelChannels(image);
1338 q+=quantum_info->pad;
1346 range=GetQuantumRange(quantum_info->depth);
1347 for (x=0; x < (ssize_t) number_pixels; x++)
1349 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1351 p+=GetPixelChannels(image);
1352 q+=quantum_info->pad;
1359static void ExportCbYCrYQuantum(
const Image *image,
QuantumInfo *quantum_info,
1360 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1361 unsigned char *magick_restrict q)
1381 switch (quantum_info->depth)
1385 if (quantum_info->pack == MagickFalse)
1387 for (x=0; x < (ssize_t) number_pixels; x+=2)
1389 for (i=0; i < 4; i++)
1395 quantum=(size_t) GetPixelRed(image,p);
1400 quantum=(size_t) GetPixelGreen(image,p);
1405 quantum=(size_t) GetPixelBlue(image,p);
1409 cbcr[i]=(Quantum) quantum;
1412 pixel=(
unsigned int) ((
size_t) (cbcr[1]) << 22 | (
size_t)
1413 (cbcr[0]) << 12 | (
size_t) (cbcr[2]) << 2);
1414 q=PopLongPixel(quantum_info->endian,pixel,q);
1415 p+=GetPixelChannels(image);
1416 pixel=(
unsigned int) ((
size_t) (cbcr[3]) << 22 | (
size_t)
1417 (cbcr[0]) << 12 | (
size_t) (cbcr[2]) << 2);
1418 q=PopLongPixel(quantum_info->endian,pixel,q);
1419 p+=GetPixelChannels(image);
1420 q+=quantum_info->pad;
1431 for (x=0; x < (ssize_t) number_pixels; x+=2)
1433 for (i=0; i < 4; i++)
1439 quantum=(size_t) GetPixelRed(image,p);
1444 quantum=(size_t) GetPixelGreen(image,p);
1449 quantum=(size_t) GetPixelBlue(image,p);
1453 cbcr[i]=(Quantum) quantum;
1456 range=GetQuantumRange(quantum_info->depth);
1457 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[1],range),q);
1458 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
1459 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
1460 p+=GetPixelChannels(image);
1461 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[3],range),q);
1462 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
1463 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
1464 p+=GetPixelChannels(image);
1465 q+=quantum_info->pad;
1473 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1480 assert(exception->signature == MagickCoreSignature);
1481 if (image->colorspace != CMYKColorspace)
1483 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1484 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1487 switch (quantum_info->depth)
1494 for (x=0; x < (ssize_t) number_pixels; x++)
1496 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1497 q=PopCharPixel(pixel,q);
1498 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1499 q=PopCharPixel(pixel,q);
1500 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1501 q=PopCharPixel(pixel,q);
1502 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1503 q=PopCharPixel(pixel,q);
1504 p+=GetPixelChannels(image);
1505 q+=quantum_info->pad;
1514 if (quantum_info->format == FloatingPointQuantumFormat)
1516 for (x=0; x < (ssize_t) number_pixels; x++)
1518 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1519 GetPixelRed(image,p));
1520 q=PopShortPixel(quantum_info->endian,pixel,q);
1521 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1522 GetPixelGreen(image,p));
1523 q=PopShortPixel(quantum_info->endian,pixel,q);
1524 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1525 GetPixelBlue(image,p));
1526 q=PopShortPixel(quantum_info->endian,pixel,q);
1527 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1528 GetPixelBlack(image,p));
1529 q=PopShortPixel(quantum_info->endian,pixel,q);
1530 p+=GetPixelChannels(image);
1531 q+=quantum_info->pad;
1535 for (x=0; x < (ssize_t) number_pixels; x++)
1537 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1538 q=PopShortPixel(quantum_info->endian,pixel,q);
1539 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1540 q=PopShortPixel(quantum_info->endian,pixel,q);
1541 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1542 q=PopShortPixel(quantum_info->endian,pixel,q);
1543 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1544 q=PopShortPixel(quantum_info->endian,pixel,q);
1545 p+=GetPixelChannels(image);
1546 q+=quantum_info->pad;
1555 if (quantum_info->format == FloatingPointQuantumFormat)
1557 for (x=0; x < (ssize_t) number_pixels; x++)
1559 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
1560 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
1561 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
1562 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlack(image,p),q);
1563 p+=GetPixelChannels(image);
1564 q+=quantum_info->pad;
1568 for (x=0; x < (ssize_t) number_pixels; x++)
1570 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1571 q=PopLongPixel(quantum_info->endian,pixel,q);
1572 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1573 q=PopLongPixel(quantum_info->endian,pixel,q);
1574 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1575 q=PopLongPixel(quantum_info->endian,pixel,q);
1576 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1577 q=PopLongPixel(quantum_info->endian,pixel,q);
1578 p+=GetPixelChannels(image);
1579 q+=quantum_info->pad;
1585 if (quantum_info->format == FloatingPointQuantumFormat)
1587 for (x=0; x < (ssize_t) number_pixels; x++)
1589 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
1590 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
1591 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
1592 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlack(image,p),q);
1593 p+=GetPixelChannels(image);
1594 q+=quantum_info->pad;
1605 range=GetQuantumRange(quantum_info->depth);
1606 for (x=0; x < (ssize_t) number_pixels; x++)
1608 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1610 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1612 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1614 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1616 p+=GetPixelChannels(image);
1617 q+=quantum_info->pad;
1624static void ExportCMYKAQuantum(
const Image *image,
QuantumInfo *quantum_info,
1625 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1632 assert(exception->signature == MagickCoreSignature);
1633 if (image->colorspace != CMYKColorspace)
1635 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1636 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1639 switch (quantum_info->depth)
1646 for (x=0; x < (ssize_t) number_pixels; x++)
1648 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1649 q=PopCharPixel(pixel,q);
1650 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1651 q=PopCharPixel(pixel,q);
1652 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1653 q=PopCharPixel(pixel,q);
1654 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1655 q=PopCharPixel(pixel,q);
1656 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
1657 q=PopCharPixel(pixel,q);
1658 p+=GetPixelChannels(image);
1659 q+=quantum_info->pad;
1668 if (quantum_info->format == FloatingPointQuantumFormat)
1670 for (x=0; x < (ssize_t) number_pixels; x++)
1672 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1673 GetPixelRed(image,p));
1674 q=PopShortPixel(quantum_info->endian,pixel,q);
1675 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1676 GetPixelGreen(image,p));
1677 q=PopShortPixel(quantum_info->endian,pixel,q);
1678 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1679 GetPixelBlue(image,p));
1680 q=PopShortPixel(quantum_info->endian,pixel,q);
1681 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1682 GetPixelBlack(image,p));
1683 q=PopShortPixel(quantum_info->endian,pixel,q);
1684 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1685 GetPixelAlpha(image,p));
1686 q=PopShortPixel(quantum_info->endian,pixel,q);
1687 p+=GetPixelChannels(image);
1688 q+=quantum_info->pad;
1692 for (x=0; x < (ssize_t) number_pixels; x++)
1694 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1695 q=PopShortPixel(quantum_info->endian,pixel,q);
1696 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1697 q=PopShortPixel(quantum_info->endian,pixel,q);
1698 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1699 q=PopShortPixel(quantum_info->endian,pixel,q);
1700 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1701 q=PopShortPixel(quantum_info->endian,pixel,q);
1702 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
1703 q=PopShortPixel(quantum_info->endian,pixel,q);
1704 p+=GetPixelChannels(image);
1705 q+=quantum_info->pad;
1714 if (quantum_info->format == FloatingPointQuantumFormat)
1716 for (x=0; x < (ssize_t) number_pixels; x++)
1718 q=PopQuantumFloatPixel(quantum_info,(
float)
1719 GetPixelRed(image,p),q);
1720 q=PopQuantumFloatPixel(quantum_info,(
float)
1721 GetPixelGreen(image,p),q);
1722 q=PopQuantumFloatPixel(quantum_info,(
float)
1723 GetPixelBlue(image,p),q);
1724 q=PopQuantumFloatPixel(quantum_info,(
float)
1725 GetPixelBlack(image,p),q);
1726 q=PopQuantumFloatPixel(quantum_info,(
float)
1727 GetPixelAlpha(image,p),q);
1728 p+=GetPixelChannels(image);
1729 q+=quantum_info->pad;
1733 for (x=0; x < (ssize_t) number_pixels; x++)
1735 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1736 q=PopLongPixel(quantum_info->endian,pixel,q);
1737 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1738 q=PopLongPixel(quantum_info->endian,pixel,q);
1739 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1740 q=PopLongPixel(quantum_info->endian,pixel,q);
1741 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1742 q=PopLongPixel(quantum_info->endian,pixel,q);
1743 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
1744 q=PopLongPixel(quantum_info->endian,pixel,q);
1745 p+=GetPixelChannels(image);
1746 q+=quantum_info->pad;
1752 if (quantum_info->format == FloatingPointQuantumFormat)
1754 for (x=0; x < (ssize_t) number_pixels; x++)
1756 q=PopQuantumDoublePixel(quantum_info,(
double)
1757 GetPixelRed(image,p),q);
1758 q=PopQuantumDoublePixel(quantum_info,(
double)
1759 GetPixelGreen(image,p),q);
1760 q=PopQuantumDoublePixel(quantum_info,(
double)
1761 GetPixelBlue(image,p),q);
1762 q=PopQuantumDoublePixel(quantum_info,(
double)
1763 GetPixelBlack(image,p),q);
1764 q=PopQuantumDoublePixel(quantum_info,(
double)
1765 GetPixelAlpha(image,p),q);
1766 p+=GetPixelChannels(image);
1767 q+=quantum_info->pad;
1778 range=GetQuantumRange(quantum_info->depth);
1779 for (x=0; x < (ssize_t) number_pixels; x++)
1781 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1783 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1785 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1787 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1789 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
1791 p+=GetPixelChannels(image);
1792 q+=quantum_info->pad;
1799static void ExportCMYKOQuantum(
const Image *image,
QuantumInfo *quantum_info,
1800 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1807 assert(exception->signature == MagickCoreSignature);
1808 if (image->colorspace != CMYKColorspace)
1810 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1811 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1814 switch (quantum_info->depth)
1821 for (x=0; x < (ssize_t) number_pixels; x++)
1823 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1824 q=PopCharPixel(pixel,q);
1825 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1826 q=PopCharPixel(pixel,q);
1827 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1828 q=PopCharPixel(pixel,q);
1829 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1830 q=PopCharPixel(pixel,q);
1831 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
1832 q=PopCharPixel(pixel,q);
1833 p+=GetPixelChannels(image);
1834 q+=quantum_info->pad;
1843 if (quantum_info->format == FloatingPointQuantumFormat)
1845 for (x=0; x < (ssize_t) number_pixels; x++)
1847 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1848 GetPixelRed(image,p));
1849 q=PopShortPixel(quantum_info->endian,pixel,q);
1850 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1851 GetPixelGreen(image,p));
1852 q=PopShortPixel(quantum_info->endian,pixel,q);
1853 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1854 GetPixelBlue(image,p));
1855 q=PopShortPixel(quantum_info->endian,pixel,q);
1856 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1857 GetPixelBlack(image,p));
1858 q=PopShortPixel(quantum_info->endian,pixel,q);
1859 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1860 GetPixelOpacity(image,p));
1861 q=PopShortPixel(quantum_info->endian,pixel,q);
1862 p+=GetPixelChannels(image);
1863 q+=quantum_info->pad;
1867 for (x=0; x < (ssize_t) number_pixels; x++)
1869 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1870 q=PopShortPixel(quantum_info->endian,pixel,q);
1871 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1872 q=PopShortPixel(quantum_info->endian,pixel,q);
1873 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1874 q=PopShortPixel(quantum_info->endian,pixel,q);
1875 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1876 q=PopShortPixel(quantum_info->endian,pixel,q);
1877 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
1878 q=PopShortPixel(quantum_info->endian,pixel,q);
1879 p+=GetPixelChannels(image);
1880 q+=quantum_info->pad;
1889 if (quantum_info->format == FloatingPointQuantumFormat)
1891 for (x=0; x < (ssize_t) number_pixels; x++)
1896 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
1897 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
1898 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
1899 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlack(image,p),q);
1900 float_pixel=(float) (GetPixelOpacity(image,p));
1901 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1902 p+=GetPixelChannels(image);
1903 q+=quantum_info->pad;
1907 for (x=0; x < (ssize_t) number_pixels; x++)
1909 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1910 q=PopLongPixel(quantum_info->endian,pixel,q);
1911 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1912 q=PopLongPixel(quantum_info->endian,pixel,q);
1913 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1914 q=PopLongPixel(quantum_info->endian,pixel,q);
1915 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1916 q=PopLongPixel(quantum_info->endian,pixel,q);
1917 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
1918 q=PopLongPixel(quantum_info->endian,pixel,q);
1919 p+=GetPixelChannels(image);
1920 q+=quantum_info->pad;
1926 if (quantum_info->format == FloatingPointQuantumFormat)
1931 for (x=0; x < (ssize_t) number_pixels; x++)
1933 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
1934 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
1935 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
1936 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlack(image,p),q);
1937 pixel=(double) (GetPixelOpacity(image,p));
1938 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1939 p+=GetPixelChannels(image);
1940 q+=quantum_info->pad;
1951 range=GetQuantumRange(quantum_info->depth);
1952 for (x=0; x < (ssize_t) number_pixels; x++)
1954 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1956 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1958 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1960 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1962 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
1964 p+=GetPixelChannels(image);
1965 q+=quantum_info->pad;
1973 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1974 unsigned char *magick_restrict q)
1982 switch (quantum_info->depth)
1998 if (quantum_info->min_is_white != MagickFalse)
2003 threshold=(double) QuantumRange/2.0;
2004 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
2007 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
2008 p+=GetPixelChannels(image);
2009 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
2010 p+=GetPixelChannels(image);
2011 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
2012 p+=GetPixelChannels(image);
2013 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
2014 p+=GetPixelChannels(image);
2015 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
2016 p+=GetPixelChannels(image);
2017 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
2018 p+=GetPixelChannels(image);
2019 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
2020 p+=GetPixelChannels(image);
2021 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
2022 p+=GetPixelChannels(image);
2025 if ((number_pixels % 8) != 0)
2028 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2030 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
2031 p+=GetPixelChannels(image);
2042 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2044 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2045 *q=(((pixel >> 4) & 0xf) << 4);
2046 p+=GetPixelChannels(image);
2047 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2049 p+=GetPixelChannels(image);
2052 if ((number_pixels % 2) != 0)
2054 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2055 *q=(((pixel >> 4) & 0xf) << 4);
2056 p+=GetPixelChannels(image);
2066 for (x=0; x < (ssize_t) number_pixels; x++)
2068 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2069 q=PopCharPixel(pixel,q);
2070 p+=GetPixelChannels(image);
2071 q+=quantum_info->pad;
2077 range=GetQuantumRange(quantum_info->depth);
2078 if (quantum_info->pack == MagickFalse)
2083 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2085 pixel=(
unsigned int) (ScaleQuantumToAny(ClampToQuantum(
2086 GetPixelLuma(image,p+2*GetPixelChannels(image))),range) << 22 |
2087 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
2088 GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
2089 ClampToQuantum(GetPixelLuma(image,p)),range) << 2);
2090 q=PopLongPixel(quantum_info->endian,pixel,q);
2091 p+=3*GetPixelChannels(image);
2092 q+=quantum_info->pad;
2094 if (x < (ssize_t) number_pixels)
2097 if (x++ < (ssize_t) (number_pixels-1))
2098 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
2099 GetPixelChannels(image))),range) << 12;
2100 if (x++ < (ssize_t) number_pixels)
2101 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),
2103 q=PopLongPixel(quantum_info->endian,pixel,q);
2107 for (x=0; x < (ssize_t) number_pixels; x++)
2109 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2110 GetPixelLuma(image,p)),range),q);
2111 p+=GetPixelChannels(image);
2112 q+=quantum_info->pad;
2121 range=GetQuantumRange(quantum_info->depth);
2122 if (quantum_info->pack == MagickFalse)
2124 for (x=0; x < (ssize_t) number_pixels; x++)
2126 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2127 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel >> 4),
2129 p+=GetPixelChannels(image);
2130 q+=quantum_info->pad;
2134 for (x=0; x < (ssize_t) number_pixels; x++)
2136 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2137 GetPixelLuma(image,p)),range),q);
2138 p+=GetPixelChannels(image);
2139 q+=quantum_info->pad;
2148 if (quantum_info->format == FloatingPointQuantumFormat)
2150 for (x=0; x < (ssize_t) number_pixels; x++)
2152 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2153 GetPixelLuma(image,p));
2154 q=PopShortPixel(quantum_info->endian,pixel,q);
2155 p+=GetPixelChannels(image);
2156 q+=quantum_info->pad;
2160 for (x=0; x < (ssize_t) number_pixels; x++)
2162 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2163 q=PopShortPixel(quantum_info->endian,pixel,q);
2164 p+=GetPixelChannels(image);
2165 q+=quantum_info->pad;
2174 if (quantum_info->format == FloatingPointQuantumFormat)
2176 for (x=0; x < (ssize_t) number_pixels; x++)
2181 float_pixel=(float) GetPixelLuma(image,p);
2182 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2183 p+=GetPixelChannels(image);
2184 q+=quantum_info->pad;
2188 for (x=0; x < (ssize_t) number_pixels; x++)
2190 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2191 q=PopLongPixel(quantum_info->endian,pixel,q);
2192 p+=GetPixelChannels(image);
2193 q+=quantum_info->pad;
2199 if (quantum_info->format == FloatingPointQuantumFormat)
2201 for (x=0; x < (ssize_t) number_pixels; x++)
2206 pixel=GetPixelLuma(image,p);
2207 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2208 p+=GetPixelChannels(image);
2209 q+=quantum_info->pad;
2217 range=GetQuantumRange(quantum_info->depth);
2218 for (x=0; x < (ssize_t) number_pixels; x++)
2220 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2221 GetPixelLuma(image,p)),range),q);
2222 p+=GetPixelChannels(image);
2223 q+=quantum_info->pad;
2230static void ExportGrayAlphaQuantum(
const Image *image,
QuantumInfo *quantum_info,
2231 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
2232 unsigned char *magick_restrict q)
2240 switch (quantum_info->depth)
2257 if (quantum_info->min_is_white != MagickFalse)
2262 threshold=(double) QuantumRange/2.0;
2263 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2266 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
2267 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2269 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
2270 p+=GetPixelChannels(image);
2271 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
2272 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2274 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
2275 p+=GetPixelChannels(image);
2276 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
2277 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2279 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
2280 p+=GetPixelChannels(image);
2281 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
2282 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2284 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
2285 p+=GetPixelChannels(image);
2288 if ((number_pixels % 4) != 0)
2291 for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
2293 *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
2295 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2297 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
2299 p+=GetPixelChannels(image);
2310 for (x=0; x < (ssize_t) number_pixels ; x++)
2312 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2313 *q=(((pixel >> 4) & 0xf) << 4);
2314 pixel=(
unsigned char) (16.0*QuantumScale*(
double)
2315 GetPixelAlpha(image,p)+0.5);
2317 p+=GetPixelChannels(image);
2327 for (x=0; x < (ssize_t) number_pixels; x++)
2329 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2330 q=PopCharPixel(pixel,q);
2331 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2332 q=PopCharPixel(pixel,q);
2333 p+=GetPixelChannels(image);
2334 q+=quantum_info->pad;
2343 if (quantum_info->format == FloatingPointQuantumFormat)
2345 for (x=0; x < (ssize_t) number_pixels; x++)
2347 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2348 GetPixelLuma(image,p));
2349 q=PopShortPixel(quantum_info->endian,pixel,q);
2350 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2351 GetPixelAlpha(image,p));
2352 q=PopShortPixel(quantum_info->endian,pixel,q);
2353 p+=GetPixelChannels(image);
2354 q+=quantum_info->pad;
2358 for (x=0; x < (ssize_t) number_pixels; x++)
2360 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2361 q=PopShortPixel(quantum_info->endian,pixel,q);
2362 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2363 q=PopShortPixel(quantum_info->endian,pixel,q);
2364 p+=GetPixelChannels(image);
2365 q+=quantum_info->pad;
2374 if (quantum_info->format == FloatingPointQuantumFormat)
2376 for (x=0; x < (ssize_t) number_pixels; x++)
2381 float_pixel=(float) GetPixelLuma(image,p);
2382 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2383 float_pixel=(float) (GetPixelAlpha(image,p));
2384 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2385 p+=GetPixelChannels(image);
2386 q+=quantum_info->pad;
2390 for (x=0; x < (ssize_t) number_pixels; x++)
2392 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2393 q=PopLongPixel(quantum_info->endian,pixel,q);
2394 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2395 q=PopLongPixel(quantum_info->endian,pixel,q);
2396 p+=GetPixelChannels(image);
2397 q+=quantum_info->pad;
2403 if (quantum_info->format == FloatingPointQuantumFormat)
2405 for (x=0; x < (ssize_t) number_pixels; x++)
2410 pixel=GetPixelLuma(image,p);
2411 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2412 pixel=(double) (GetPixelAlpha(image,p));
2413 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2414 p+=GetPixelChannels(image);
2415 q+=quantum_info->pad;
2423 range=GetQuantumRange(quantum_info->depth);
2424 for (x=0; x < (ssize_t) number_pixels; x++)
2426 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2427 GetPixelLuma(image,p)),range),q);
2428 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2430 p+=GetPixelChannels(image);
2431 q+=quantum_info->pad;
2438static void ExportGreenQuantum(
const Image *image,
QuantumInfo *quantum_info,
2439 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
2440 unsigned char *magick_restrict q)
2448 switch (quantum_info->depth)
2455 for (x=0; x < (ssize_t) number_pixels; x++)
2457 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
2458 q=PopCharPixel(pixel,q);
2459 p+=GetPixelChannels(image);
2460 q+=quantum_info->pad;
2469 if (quantum_info->format == FloatingPointQuantumFormat)
2471 for (x=0; x < (ssize_t) number_pixels; x++)
2473 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2474 GetPixelGreen(image,p));
2475 q=PopShortPixel(quantum_info->endian,pixel,q);
2476 p+=GetPixelChannels(image);
2477 q+=quantum_info->pad;
2481 for (x=0; x < (ssize_t) number_pixels; x++)
2483 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
2484 q=PopShortPixel(quantum_info->endian,pixel,q);
2485 p+=GetPixelChannels(image);
2486 q+=quantum_info->pad;
2495 if (quantum_info->format == FloatingPointQuantumFormat)
2497 for (x=0; x < (ssize_t) number_pixels; x++)
2499 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
2500 p+=GetPixelChannels(image);
2501 q+=quantum_info->pad;
2505 for (x=0; x < (ssize_t) number_pixels; x++)
2507 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
2508 q=PopLongPixel(quantum_info->endian,pixel,q);
2509 p+=GetPixelChannels(image);
2510 q+=quantum_info->pad;
2516 if (quantum_info->format == FloatingPointQuantumFormat)
2518 for (x=0; x < (ssize_t) number_pixels; x++)
2520 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
2521 p+=GetPixelChannels(image);
2522 q+=quantum_info->pad;
2530 range=GetQuantumRange(quantum_info->depth);
2531 for (x=0; x < (ssize_t) number_pixels; x++)
2533 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
2535 p+=GetPixelChannels(image);
2536 q+=quantum_info->pad;
2543static void ExportIndexQuantum(
const Image *image,
QuantumInfo *quantum_info,
2544 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
2553 if (image->storage_class != PseudoClass)
2555 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2556 "ColormappedImageRequired",
"`%s'",image->filename);
2559 switch (quantum_info->depth)
2566 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
2568 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2569 *q=((pixel & 0x01) << 7);
2570 p+=GetPixelChannels(image);
2571 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2572 *q|=((pixel & 0x01) << 6);
2573 p+=GetPixelChannels(image);
2574 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2575 *q|=((pixel & 0x01) << 5);
2576 p+=GetPixelChannels(image);
2577 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2578 *q|=((pixel & 0x01) << 4);
2579 p+=GetPixelChannels(image);
2580 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2581 *q|=((pixel & 0x01) << 3);
2582 p+=GetPixelChannels(image);
2583 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2584 *q|=((pixel & 0x01) << 2);
2585 p+=GetPixelChannels(image);
2586 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2587 *q|=((pixel & 0x01) << 1);
2588 p+=GetPixelChannels(image);
2589 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2590 *q|=((pixel & 0x01) << 0);
2591 p+=GetPixelChannels(image);
2594 if ((number_pixels % 8) != 0)
2597 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2599 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2600 *q|=((pixel & 0x01) << (
unsigned char) bit);
2601 p+=GetPixelChannels(image);
2612 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
2614 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2615 *q=((pixel & 0xf) << 4);
2616 p+=GetPixelChannels(image);
2617 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2618 *q|=((pixel & 0xf) << 0);
2619 p+=GetPixelChannels(image);
2622 if ((number_pixels % 2) != 0)
2624 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2625 *q=((pixel & 0xf) << 4);
2626 p+=GetPixelChannels(image);
2633 for (x=0; x < (ssize_t) number_pixels; x++)
2635 q=PopCharPixel((
unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2636 p+=GetPixelChannels(image);
2637 q+=quantum_info->pad;
2643 if (quantum_info->format == FloatingPointQuantumFormat)
2645 for (x=0; x < (ssize_t) number_pixels; x++)
2647 q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
2648 QuantumScale*(
double) GetPixelIndex(image,p)),q);
2649 p+=GetPixelChannels(image);
2650 q+=quantum_info->pad;
2654 for (x=0; x < (ssize_t) number_pixels; x++)
2656 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2657 GetPixelIndex(image,p),q);
2658 p+=GetPixelChannels(image);
2659 q+=quantum_info->pad;
2665 if (quantum_info->format == FloatingPointQuantumFormat)
2667 for (x=0; x < (ssize_t) number_pixels; x++)
2669 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(image,p),q);
2670 p+=GetPixelChannels(image);
2671 q+=quantum_info->pad;
2675 for (x=0; x < (ssize_t) number_pixels; x++)
2677 q=PopLongPixel(quantum_info->endian,(
unsigned int)
2678 GetPixelIndex(image,p),q);
2679 p+=GetPixelChannels(image);
2680 q+=quantum_info->pad;
2686 if (quantum_info->format == FloatingPointQuantumFormat)
2688 for (x=0; x < (ssize_t) number_pixels; x++)
2690 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(image,p),q);
2691 p+=GetPixelChannels(image);
2692 q+=quantum_info->pad;
2700 for (x=0; x < (ssize_t) number_pixels; x++)
2702 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2703 p+=GetPixelChannels(image);
2704 q+=quantum_info->pad;
2711static void ExportIndexAlphaQuantum(
const Image *image,
2712 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
2713 const Quantum *magick_restrict p,
unsigned char *magick_restrict q,
2722 if (image->storage_class != PseudoClass)
2724 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2725 "ColormappedImageRequired",
"`%s'",image->filename);
2728 switch (quantum_info->depth)
2735 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2737 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2738 *q=((pixel & 0x01) << 7);
2739 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2740 TransparentAlpha ? 1 : 0);
2741 *q|=((pixel & 0x01) << 6);
2742 p+=GetPixelChannels(image);
2743 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2744 *q|=((pixel & 0x01) << 5);
2745 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2746 TransparentAlpha ? 1 : 0);
2747 *q|=((pixel & 0x01) << 4);
2748 p+=GetPixelChannels(image);
2749 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2750 *q|=((pixel & 0x01) << 3);
2751 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2752 TransparentAlpha ? 1 : 0);
2753 *q|=((pixel & 0x01) << 2);
2754 p+=GetPixelChannels(image);
2755 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2756 *q|=((pixel & 0x01) << 1);
2757 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2758 TransparentAlpha ? 1 : 0);
2759 *q|=((pixel & 0x01) << 0);
2760 p+=GetPixelChannels(image);
2763 if ((number_pixels % 4) != 0)
2766 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2768 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2769 *q|=((pixel & 0x01) << (
unsigned char) (bit+4));
2770 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2771 TransparentAlpha ? 1 : 0);
2772 *q|=((pixel & 0x01) << (
unsigned char) (bit+4-1));
2773 p+=GetPixelChannels(image);
2784 for (x=0; x < (ssize_t) number_pixels ; x++)
2786 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2787 *q=((pixel & 0xf) << 4);
2788 pixel=(
unsigned char) (16.0*QuantumScale*(
double)
2789 GetPixelAlpha(image,p)+0.5);
2790 *q|=((pixel & 0xf) << 0);
2791 p+=GetPixelChannels(image);
2801 for (x=0; x < (ssize_t) number_pixels; x++)
2803 q=PopCharPixel((
unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2804 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2805 q=PopCharPixel(pixel,q);
2806 p+=GetPixelChannels(image);
2807 q+=quantum_info->pad;
2816 if (quantum_info->format == FloatingPointQuantumFormat)
2818 for (x=0; x < (ssize_t) number_pixels; x++)
2820 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2821 ((ssize_t) GetPixelIndex(image,p)),q);
2822 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2823 GetPixelAlpha(image,p));
2824 q=PopShortPixel(quantum_info->endian,pixel,q);
2825 p+=GetPixelChannels(image);
2826 q+=quantum_info->pad;
2830 for (x=0; x < (ssize_t) number_pixels; x++)
2832 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2833 ((ssize_t) GetPixelIndex(image,p)),q);
2834 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2835 q=PopShortPixel(quantum_info->endian,pixel,q);
2836 p+=GetPixelChannels(image);
2837 q+=quantum_info->pad;
2846 if (quantum_info->format == FloatingPointQuantumFormat)
2848 for (x=0; x < (ssize_t) number_pixels; x++)
2853 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(image,p),q);
2854 float_pixel=(float) GetPixelAlpha(image,p);
2855 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2856 p+=GetPixelChannels(image);
2857 q+=quantum_info->pad;
2861 for (x=0; x < (ssize_t) number_pixels; x++)
2863 q=PopLongPixel(quantum_info->endian,(
unsigned int)
2864 GetPixelIndex(image,p),q);
2865 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2866 q=PopLongPixel(quantum_info->endian,pixel,q);
2867 p+=GetPixelChannels(image);
2868 q+=quantum_info->pad;
2874 if (quantum_info->format == FloatingPointQuantumFormat)
2876 for (x=0; x < (ssize_t) number_pixels; x++)
2881 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(image,p),q);
2882 pixel=(double) GetPixelAlpha(image,p);
2883 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2884 p+=GetPixelChannels(image);
2885 q+=quantum_info->pad;
2896 range=GetQuantumRange(quantum_info->depth);
2897 for (x=0; x < (ssize_t) number_pixels; x++)
2899 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2900 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2902 p+=GetPixelChannels(image);
2903 q+=quantum_info->pad;
2910static void ExportMultispectralQuantum(
const Image *image,
2911 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
2912 const Quantum *magick_restrict p,
unsigned char *magick_restrict q,
2919 if (image->number_meta_channels == 0)
2921 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2922 "MultispectralImageRequired",
"`%s'",image->filename);
2925 switch (quantum_info->depth)
2932 for (x=0; x < (ssize_t) number_pixels; x++)
2934 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2936 pixel=ScaleQuantumToChar(p[i]);
2937 q=PopCharPixel(pixel,q);
2939 p+=GetPixelChannels(image);
2940 q+=quantum_info->pad;
2949 if (quantum_info->format == FloatingPointQuantumFormat)
2951 for (x=0; x < (ssize_t) number_pixels; x++)
2953 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2955 pixel=SinglePrecisionToHalf(QuantumScale*(
double) p[i]);
2956 q=PopShortPixel(quantum_info->endian,pixel,q);
2958 p+=GetPixelChannels(image);
2959 q+=quantum_info->pad;
2963 for (x=0; x < (ssize_t) number_pixels; x++)
2965 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2967 pixel=ScaleQuantumToShort(p[i]);
2968 q=PopShortPixel(quantum_info->endian,pixel,q);
2970 p+=GetPixelChannels(image);
2971 q+=quantum_info->pad;
2980 if (quantum_info->format == FloatingPointQuantumFormat)
2982 for (x=0; x < (ssize_t) number_pixels; x++)
2984 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2985 q=PopQuantumFloatPixel(quantum_info,(
float) p[i],q);
2986 p+=GetPixelChannels(image);
2987 q+=quantum_info->pad;
2991 for (x=0; x < (ssize_t) number_pixels; x++)
2993 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2995 pixel=ScaleQuantumToLong(p[i]);
2996 q=PopLongPixel(quantum_info->endian,pixel,q);
2998 p+=GetPixelChannels(image);
2999 q+=quantum_info->pad;
3005 if (quantum_info->format == FloatingPointQuantumFormat)
3007 for (x=0; x < (ssize_t) number_pixels; x++)
3009 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3010 q=PopQuantumDoublePixel(quantum_info,(
double) p[i],q);
3011 p+=GetPixelChannels(image);
3012 q+=quantum_info->pad;
3023 range=GetQuantumRange(quantum_info->depth);
3024 for (x=0; x < (ssize_t) number_pixels; x++)
3026 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3027 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(p[i],range),q);
3028 p+=GetPixelChannels(image);
3029 q+=quantum_info->pad;
3036static void ExportOpacityQuantum(
const Image *image,
QuantumInfo *quantum_info,
3037 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
3038 unsigned char *magick_restrict q)
3046 switch (quantum_info->depth)
3053 for (x=0; x < (ssize_t) number_pixels; x++)
3055 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
3056 q=PopCharPixel(pixel,q);
3057 p+=GetPixelChannels(image);
3058 q+=quantum_info->pad;
3067 if (quantum_info->format == FloatingPointQuantumFormat)
3069 for (x=0; x < (ssize_t) number_pixels; x++)
3071 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3072 GetPixelOpacity(image,p));
3073 q=PopShortPixel(quantum_info->endian,pixel,q);
3074 p+=GetPixelChannels(image);
3075 q+=quantum_info->pad;
3079 for (x=0; x < (ssize_t) number_pixels; x++)
3081 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
3082 q=PopShortPixel(quantum_info->endian,pixel,q);
3083 p+=GetPixelChannels(image);
3084 q+=quantum_info->pad;
3093 if (quantum_info->format == FloatingPointQuantumFormat)
3095 for (x=0; x < (ssize_t) number_pixels; x++)
3097 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelOpacity(image,p),q);
3098 p+=GetPixelChannels(image);
3099 q+=quantum_info->pad;
3103 for (x=0; x < (ssize_t) number_pixels; x++)
3105 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
3106 q=PopLongPixel(quantum_info->endian,pixel,q);
3107 p+=GetPixelChannels(image);
3108 q+=quantum_info->pad;
3114 if (quantum_info->format == FloatingPointQuantumFormat)
3116 for (x=0; x < (ssize_t) number_pixels; x++)
3118 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelOpacity(image,p),q);
3119 p+=GetPixelChannels(image);
3120 q+=quantum_info->pad;
3128 range=GetQuantumRange(quantum_info->depth);
3129 for (x=0; x < (ssize_t) number_pixels; x++)
3131 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
3132 GetPixelOpacity(image,p),range),q);
3133 p+=GetPixelChannels(image);
3134 q+=quantum_info->pad;
3142 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
3143 unsigned char *magick_restrict q)
3151 switch (quantum_info->depth)
3158 for (x=0; x < (ssize_t) number_pixels; x++)
3160 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3161 q=PopCharPixel(pixel,q);
3162 p+=GetPixelChannels(image);
3163 q+=quantum_info->pad;
3172 if (quantum_info->format == FloatingPointQuantumFormat)
3174 for (x=0; x < (ssize_t) number_pixels; x++)
3176 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3177 GetPixelRed(image,p));
3178 q=PopShortPixel(quantum_info->endian,pixel,q);
3179 p+=GetPixelChannels(image);
3180 q+=quantum_info->pad;
3184 for (x=0; x < (ssize_t) number_pixels; x++)
3186 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3187 q=PopShortPixel(quantum_info->endian,pixel,q);
3188 p+=GetPixelChannels(image);
3189 q+=quantum_info->pad;
3198 if (quantum_info->format == FloatingPointQuantumFormat)
3200 for (x=0; x < (ssize_t) number_pixels; x++)
3202 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
3203 p+=GetPixelChannels(image);
3204 q+=quantum_info->pad;
3208 for (x=0; x < (ssize_t) number_pixels; x++)
3210 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3211 q=PopLongPixel(quantum_info->endian,pixel,q);
3212 p+=GetPixelChannels(image);
3213 q+=quantum_info->pad;
3219 if (quantum_info->format == FloatingPointQuantumFormat)
3221 for (x=0; x < (ssize_t) number_pixels; x++)
3223 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
3224 p+=GetPixelChannels(image);
3225 q+=quantum_info->pad;
3233 range=GetQuantumRange(quantum_info->depth);
3234 for (x=0; x < (ssize_t) number_pixels; x++)
3236 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3238 p+=GetPixelChannels(image);
3239 q+=quantum_info->pad;
3247 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
3248 unsigned char *magick_restrict q)
3259 switch (quantum_info->depth)
3263 for (x=0; x < (ssize_t) number_pixels; x++)
3265 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
3266 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
3267 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
3268 p+=GetPixelChannels(image);
3269 q+=quantum_info->pad;
3278 range=GetQuantumRange(quantum_info->depth);
3279 if (quantum_info->pack == MagickFalse)
3281 for (x=0; x < (ssize_t) number_pixels; x++)
3283 pixel=(
unsigned int) (
3284 ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
3285 ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
3286 ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
3287 q=PopLongPixel(quantum_info->endian,pixel,q);
3288 p+=GetPixelChannels(image);
3289 q+=quantum_info->pad;
3293 if (quantum_info->quantum == 32UL)
3295 for (x=0; x < (ssize_t) number_pixels; x++)
3297 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3298 q=PopQuantumLongPixel(quantum_info,pixel,q);
3299 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3301 q=PopQuantumLongPixel(quantum_info,pixel,q);
3302 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3303 q=PopQuantumLongPixel(quantum_info,pixel,q);
3304 p+=GetPixelChannels(image);
3305 q+=quantum_info->pad;
3309 for (x=0; x < (ssize_t) number_pixels; x++)
3311 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3312 q=PopQuantumPixel(quantum_info,pixel,q);
3313 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3314 q=PopQuantumPixel(quantum_info,pixel,q);
3315 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3316 q=PopQuantumPixel(quantum_info,pixel,q);
3317 p+=GetPixelChannels(image);
3318 q+=quantum_info->pad;
3327 range=GetQuantumRange(quantum_info->depth);
3328 if (quantum_info->pack == MagickFalse)
3330 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
3337 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3343 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3349 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3351 p+=GetPixelChannels(image);
3355 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3362 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3368 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3374 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3376 p+=GetPixelChannels(image);
3380 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3382 q+=quantum_info->pad;
3384 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3386 switch ((x+bit) % 3)
3391 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3397 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3403 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3405 p+=GetPixelChannels(image);
3409 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3411 q+=quantum_info->pad;
3414 p+=GetPixelChannels(image);
3417 if (quantum_info->quantum == 32UL)
3419 for (x=0; x < (ssize_t) number_pixels; x++)
3421 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3422 q=PopQuantumLongPixel(quantum_info,pixel,q);
3423 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3425 q=PopQuantumLongPixel(quantum_info,pixel,q);
3426 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3427 q=PopQuantumLongPixel(quantum_info,pixel,q);
3428 p+=GetPixelChannels(image);
3429 q+=quantum_info->pad;
3433 for (x=0; x < (ssize_t) number_pixels; x++)
3435 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3436 q=PopQuantumPixel(quantum_info,pixel,q);
3437 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3438 q=PopQuantumPixel(quantum_info,pixel,q);
3439 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3440 q=PopQuantumPixel(quantum_info,pixel,q);
3441 p+=GetPixelChannels(image);
3442 q+=quantum_info->pad;
3451 if (quantum_info->format == FloatingPointQuantumFormat)
3453 for (x=0; x < (ssize_t) number_pixels; x++)
3455 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3456 GetPixelRed(image,p));
3457 q=PopShortPixel(quantum_info->endian,pixel,q);
3458 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3459 GetPixelGreen(image,p));
3460 q=PopShortPixel(quantum_info->endian,pixel,q);
3461 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3462 GetPixelBlue(image,p));
3463 q=PopShortPixel(quantum_info->endian,pixel,q);
3464 p+=GetPixelChannels(image);
3465 q+=quantum_info->pad;
3469 for (x=0; x < (ssize_t) number_pixels; x++)
3471 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3472 q=PopShortPixel(quantum_info->endian,pixel,q);
3473 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3474 q=PopShortPixel(quantum_info->endian,pixel,q);
3475 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3476 q=PopShortPixel(quantum_info->endian,pixel,q);
3477 p+=GetPixelChannels(image);
3478 q+=quantum_info->pad;
3487 if (quantum_info->format == FloatingPointQuantumFormat)
3489 for (x=0; x < (ssize_t) number_pixels; x++)
3491 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),
3493 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),
3495 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),
3497 p+=GetPixelChannels(image);
3498 q+=quantum_info->pad;
3502 for (x=0; x < (ssize_t) number_pixels; x++)
3504 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3505 q=PopLongPixel(quantum_info->endian,pixel,q);
3506 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3507 q=PopLongPixel(quantum_info->endian,pixel,q);
3508 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3509 q=PopLongPixel(quantum_info->endian,pixel,q);
3510 p+=GetPixelChannels(image);
3511 q+=quantum_info->pad;
3517 if (quantum_info->format == FloatingPointQuantumFormat)
3519 for (x=0; x < (ssize_t) number_pixels; x++)
3521 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
3522 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
3523 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
3524 p+=GetPixelChannels(image);
3525 q+=quantum_info->pad;
3533 range=GetQuantumRange(quantum_info->depth);
3534 for (x=0; x < (ssize_t) number_pixels; x++)
3536 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3538 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3540 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3542 p+=GetPixelChannels(image);
3543 q+=quantum_info->pad;
3551 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
3552 unsigned char *magick_restrict q)
3560 switch (quantum_info->depth)
3567 for (x=0; x < (ssize_t) number_pixels; x++)
3569 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3570 q=PopCharPixel(pixel,q);
3571 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3572 q=PopCharPixel(pixel,q);
3573 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3574 q=PopCharPixel(pixel,q);
3575 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
3576 q=PopCharPixel(pixel,q);
3577 p+=GetPixelChannels(image);
3578 q+=quantum_info->pad;
3587 range=GetQuantumRange(quantum_info->depth);
3588 if (quantum_info->pack == MagickFalse)
3602 for (x=0; x < (ssize_t) number_pixels; x++)
3604 for (i=0; i < 4; i++)
3608 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
3609 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
3610 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
3611 case 3: quantum=(size_t) GetPixelAlpha(image,p);
break;
3617 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3623 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3629 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3631 q=PopLongPixel(quantum_info->endian,pixel,q);
3638 p+=GetPixelChannels(image);
3639 q+=quantum_info->pad;
3643 if (quantum_info->quantum == 32UL)
3645 for (x=0; x < (ssize_t) number_pixels; x++)
3647 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3648 q=PopQuantumLongPixel(quantum_info,pixel,q);
3649 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3651 q=PopQuantumLongPixel(quantum_info,pixel,q);
3652 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3653 q=PopQuantumLongPixel(quantum_info,pixel,q);
3654 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
3656 q=PopQuantumLongPixel(quantum_info,pixel,q);
3657 p+=GetPixelChannels(image);
3658 q+=quantum_info->pad;
3662 for (x=0; x < (ssize_t) number_pixels; x++)
3664 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3665 q=PopQuantumPixel(quantum_info,pixel,q);
3666 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3667 q=PopQuantumPixel(quantum_info,pixel,q);
3668 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3669 q=PopQuantumPixel(quantum_info,pixel,q);
3670 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
3671 q=PopQuantumPixel(quantum_info,pixel,q);
3672 p+=GetPixelChannels(image);
3673 q+=quantum_info->pad;
3682 if (quantum_info->format == FloatingPointQuantumFormat)
3684 for (x=0; x < (ssize_t) number_pixels; x++)
3686 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3687 GetPixelRed(image,p));
3688 q=PopShortPixel(quantum_info->endian,pixel,q);
3689 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3690 GetPixelGreen(image,p));
3691 q=PopShortPixel(quantum_info->endian,pixel,q);
3692 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3693 GetPixelBlue(image,p));
3694 q=PopShortPixel(quantum_info->endian,pixel,q);
3695 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3696 GetPixelAlpha(image,p));
3697 q=PopShortPixel(quantum_info->endian,pixel,q);
3698 p+=GetPixelChannels(image);
3699 q+=quantum_info->pad;
3703 for (x=0; x < (ssize_t) number_pixels; x++)
3705 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3706 q=PopShortPixel(quantum_info->endian,pixel,q);
3707 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3708 q=PopShortPixel(quantum_info->endian,pixel,q);
3709 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3710 q=PopShortPixel(quantum_info->endian,pixel,q);
3711 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
3712 q=PopShortPixel(quantum_info->endian,pixel,q);
3713 p+=GetPixelChannels(image);
3714 q+=quantum_info->pad;
3723 if (quantum_info->format == FloatingPointQuantumFormat)
3725 for (x=0; x < (ssize_t) number_pixels; x++)
3730 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
3731 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
3732 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
3733 float_pixel=(float) GetPixelAlpha(image,p);
3734 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3735 p+=GetPixelChannels(image);
3736 q+=quantum_info->pad;
3740 for (x=0; x < (ssize_t) number_pixels; x++)
3742 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3743 q=PopLongPixel(quantum_info->endian,pixel,q);
3744 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3745 q=PopLongPixel(quantum_info->endian,pixel,q);
3746 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3747 q=PopLongPixel(quantum_info->endian,pixel,q);
3748 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
3749 q=PopLongPixel(quantum_info->endian,pixel,q);
3750 p+=GetPixelChannels(image);
3751 q+=quantum_info->pad;
3757 if (quantum_info->format == FloatingPointQuantumFormat)
3762 for (x=0; x < (ssize_t) number_pixels; x++)
3764 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
3765 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
3766 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
3767 pixel=(double) GetPixelAlpha(image,p);
3768 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3769 p+=GetPixelChannels(image);
3770 q+=quantum_info->pad;
3778 range=GetQuantumRange(quantum_info->depth);
3779 for (x=0; x < (ssize_t) number_pixels; x++)
3781 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3783 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3785 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3787 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
3789 p+=GetPixelChannels(image);
3790 q+=quantum_info->pad;
3798 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
3799 unsigned char *magick_restrict q)
3807 switch (quantum_info->depth)
3814 for (x=0; x < (ssize_t) number_pixels; x++)
3816 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3817 q=PopCharPixel(pixel,q);
3818 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3819 q=PopCharPixel(pixel,q);
3820 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3821 q=PopCharPixel(pixel,q);
3822 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
3823 q=PopCharPixel(pixel,q);
3824 p+=GetPixelChannels(image);
3825 q+=quantum_info->pad;
3834 range=GetQuantumRange(quantum_info->depth);
3835 if (quantum_info->pack == MagickFalse)
3849 for (x=0; x < (ssize_t) number_pixels; x++)
3851 for (i=0; i < 4; i++)
3855 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
3856 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
3857 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
3858 case 3: quantum=(size_t) GetPixelOpacity(image,p);
break;
3864 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3870 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3876 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3878 q=PopLongPixel(quantum_info->endian,pixel,q);
3885 p+=GetPixelChannels(image);
3886 q+=quantum_info->pad;
3890 if (quantum_info->quantum == 32UL)
3892 for (x=0; x < (ssize_t) number_pixels; x++)
3894 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3895 q=PopQuantumLongPixel(quantum_info,pixel,q);
3896 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3898 q=PopQuantumLongPixel(quantum_info,pixel,q);
3899 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3900 q=PopQuantumLongPixel(quantum_info,pixel,q);
3901 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
3903 q=PopQuantumLongPixel(quantum_info,pixel,q);
3904 p+=GetPixelChannels(image);
3905 q+=quantum_info->pad;
3909 for (x=0; x < (ssize_t) number_pixels; x++)
3911 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3912 q=PopQuantumPixel(quantum_info,pixel,q);
3913 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3914 q=PopQuantumPixel(quantum_info,pixel,q);
3915 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3916 q=PopQuantumPixel(quantum_info,pixel,q);
3917 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
3918 q=PopQuantumPixel(quantum_info,pixel,q);
3919 p+=GetPixelChannels(image);
3920 q+=quantum_info->pad;
3929 if (quantum_info->format == FloatingPointQuantumFormat)
3931 for (x=0; x < (ssize_t) number_pixels; x++)
3933 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3934 GetPixelRed(image,p));
3935 q=PopShortPixel(quantum_info->endian,pixel,q);
3936 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3937 GetPixelGreen(image,p));
3938 q=PopShortPixel(quantum_info->endian,pixel,q);
3939 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3940 GetPixelBlue(image,p));
3941 q=PopShortPixel(quantum_info->endian,pixel,q);
3942 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3943 GetPixelOpacity(image,p));
3944 q=PopShortPixel(quantum_info->endian,pixel,q);
3945 p+=GetPixelChannels(image);
3946 q+=quantum_info->pad;
3950 for (x=0; x < (ssize_t) number_pixels; x++)
3952 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3953 q=PopShortPixel(quantum_info->endian,pixel,q);
3954 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3955 q=PopShortPixel(quantum_info->endian,pixel,q);
3956 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3957 q=PopShortPixel(quantum_info->endian,pixel,q);
3958 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
3959 q=PopShortPixel(quantum_info->endian,pixel,q);
3960 p+=GetPixelChannels(image);
3961 q+=quantum_info->pad;
3970 if (quantum_info->format == FloatingPointQuantumFormat)
3972 for (x=0; x < (ssize_t) number_pixels; x++)
3977 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),
3979 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),
3981 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),
3983 float_pixel=(float) GetPixelOpacity(image,p);
3984 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3985 p+=GetPixelChannels(image);
3986 q+=quantum_info->pad;
3990 for (x=0; x < (ssize_t) number_pixels; x++)
3992 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3993 q=PopLongPixel(quantum_info->endian,pixel,q);
3994 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3995 q=PopLongPixel(quantum_info->endian,pixel,q);
3996 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3997 q=PopLongPixel(quantum_info->endian,pixel,q);
3998 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
3999 q=PopLongPixel(quantum_info->endian,pixel,q);
4000 p+=GetPixelChannels(image);
4001 q+=quantum_info->pad;
4007 if (quantum_info->format == FloatingPointQuantumFormat)
4012 for (x=0; x < (ssize_t) number_pixels; x++)
4014 q=PopQuantumDoublePixel(quantum_info,(
double)
4015 GetPixelRed(image,p),q);
4016 q=PopQuantumDoublePixel(quantum_info,(
double)
4017 GetPixelGreen(image,p),q);
4018 q=PopQuantumDoublePixel(quantum_info,(
double)
4019 GetPixelBlue(image,p),q);
4020 pixel=(double) GetPixelOpacity(image,p);
4021 q=PopQuantumDoublePixel(quantum_info,pixel,q);
4022 p+=GetPixelChannels(image);
4023 q+=quantum_info->pad;
4031 range=GetQuantumRange(quantum_info->depth);
4032 for (x=0; x < (ssize_t) number_pixels; x++)
4034 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
4036 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
4038 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
4040 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
4042 p+=GetPixelChannels(image);
4043 q+=quantum_info->pad;
4050MagickExport
size_t ExportQuantumPixels(
const Image *image,
4052 const QuantumType quantum_type,
unsigned char *magick_restrict pixels,
4070 assert(image != (
Image *) NULL);
4071 assert(image->signature == MagickCoreSignature);
4073 assert(quantum_info->signature == MagickCoreSignature);
4074 if (IsEventLogging() != MagickFalse)
4075 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4076 if (pixels == (
unsigned char *) NULL)
4077 pixels=(
unsigned char *) GetQuantumPixels(quantum_info);
4080 number_pixels=GetImageExtent(image);
4081 p=GetVirtualPixelQueue(image);
4085 number_pixels=GetCacheViewExtent(image_view);
4086 p=GetCacheViewVirtualPixelQueue(image_view);
4088 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
4100 r=GetAuthenticPixelQueue(image);
4102 r=GetCacheViewAuthenticPixelQueue(image_view);
4103 for (x=0; x < (ssize_t) image->columns; x++)
4108 Sa=QuantumScale*(double) GetPixelAlpha(image,r);
4109 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
4111 PixelChannel channel = GetPixelChannelChannel(image,i);
4112 PixelTrait traits = GetPixelChannelTraits(image,channel);
4113 if ((traits & UpdatePixelTrait) == 0)
4115 r[i]=ClampToQuantum(Sa*(
double) r[i]);
4117 r+=GetPixelChannels(image);
4120 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
4129 r=GetAuthenticPixelQueue(image);
4131 r=GetCacheViewAuthenticPixelQueue(image_view);
4132 for (x=0; x < (ssize_t) number_pixels; x++)
4134 quantum=GetPixelRed(image,r);
4135 SetPixelRed(image,GetPixelGreen(image,r),r);
4136 SetPixelGreen(image,quantum,r);
4137 r+=GetPixelChannels(image);
4141 ResetQuantumState(quantum_info);
4142 extent=GetQuantumExtent(image,quantum_info,quantum_type);
4143 switch (quantum_type)
4147 ExportAlphaQuantum(image,quantum_info,number_pixels,p,q);
4152 ExportBGRQuantum(image,quantum_info,number_pixels,p,q);
4157 ExportBGRAQuantum(image,quantum_info,number_pixels,p,q);
4162 ExportBGROQuantum(image,quantum_info,number_pixels,p,q);
4167 ExportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
4173 ExportBlueQuantum(image,quantum_info,number_pixels,p,q);
4178 ExportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
4183 ExportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
4186 case MultispectralQuantum:
4188 ExportMultispectralQuantum(image,quantum_info,number_pixels,p,q,exception);
4193 ExportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
4198 ExportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
4203 ExportGrayQuantum(image,quantum_info,number_pixels,p,q);
4206 case GrayAlphaQuantum:
4208 ExportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
4212 case MagentaQuantum:
4214 ExportGreenQuantum(image,quantum_info,number_pixels,p,q);
4219 ExportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
4222 case IndexAlphaQuantum:
4224 ExportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
4230 ExportRedQuantum(image,quantum_info,number_pixels,p,q);
4233 case OpacityQuantum:
4235 ExportOpacityQuantum(image,quantum_info,number_pixels,p,q);
4241 ExportRGBQuantum(image,quantum_info,number_pixels,p,q);
4247 ExportRGBAQuantum(image,quantum_info,number_pixels,p,q);
4252 ExportRGBOQuantum(image,quantum_info,number_pixels,p,q);
4258 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
4267 r=GetAuthenticPixelQueue(image);
4269 r=GetCacheViewAuthenticPixelQueue(image_view);
4270 for (x=0; x < (ssize_t) number_pixels; x++)
4272 quantum=GetPixelRed(image,r);
4273 SetPixelRed(image,GetPixelGreen(image,r),r);
4274 SetPixelGreen(image,quantum,r);
4275 r+=GetPixelChannels(image);