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"
112static inline unsigned char *PopQuantumDoublePixel(QuantumInfo *quantum_info,
113 const double pixel,
unsigned char *magick_restrict pixels)
121 (void) memset(quantum,0,
sizeof(quantum));
122 p=(
double *) quantum;
123 *p=(double) (pixel*quantum_info->state.inverse_scale+quantum_info->minimum);
124 if (quantum_info->endian == LSBEndian)
126 *pixels++=quantum[0];
127 *pixels++=quantum[1];
128 *pixels++=quantum[2];
129 *pixels++=quantum[3];
130 *pixels++=quantum[4];
131 *pixels++=quantum[5];
132 *pixels++=quantum[6];
133 *pixels++=quantum[7];
136 *pixels++=quantum[7];
137 *pixels++=quantum[6];
138 *pixels++=quantum[5];
139 *pixels++=quantum[4];
140 *pixels++=quantum[3];
141 *pixels++=quantum[2];
142 *pixels++=quantum[1];
143 *pixels++=quantum[0];
147static inline unsigned char *PopQuantumFloatPixel(QuantumInfo *quantum_info,
148 const float pixel,
unsigned char *magick_restrict pixels)
156 (void) memset(quantum,0,
sizeof(quantum));
158 *p=(float) ((
double) pixel*quantum_info->state.inverse_scale+
159 quantum_info->minimum);
160 if (quantum_info->endian == LSBEndian)
162 *pixels++=quantum[0];
163 *pixels++=quantum[1];
164 *pixels++=quantum[2];
165 *pixels++=quantum[3];
168 *pixels++=quantum[3];
169 *pixels++=quantum[2];
170 *pixels++=quantum[1];
171 *pixels++=quantum[0];
175static inline unsigned char *PopQuantumFloat24Pixel(QuantumInfo *quantum_info,
176 const float pixel,
unsigned char *magick_restrict pixels)
196 scaled_pixel=(double) pixel*quantum_info->state.inverse_scale;
197 if (quantum_info->minimum != 0.0)
198 scaled_pixel+=quantum_info->minimum;
199 map.single_precision=(float) scaled_pixel;
200 sign_bit=(map.fixed_point >> 8) & 0x00800000U;
201 exponent=(map.fixed_point >> 23) & 0xffU;
202 significand=map.fixed_point & 0x007fffffU;
206 if (exponent == 255U)
208 value=0x007f0000U | (significand >> 7);
209 if ((significand != 0U) && ((value & 0xffffU) == 0U))
221 significand|=0x00800000U;
223 value=(significand+((1U << (shift-1))-1U)+
224 ((significand >> shift) & 1U)) >> shift;
230 significand=(significand+0x3fU+((significand >> 7) & 1U)) >> 7;
231 if (significand == 0x10000U)
236 value=exponent >= 127U ? 0x007f0000U :
237 (exponent << 16) | significand;
240 if (quantum_info->endian == LSBEndian)
242 *pixels++=(
unsigned char) value;
243 *pixels++=(
unsigned char) (value >> 8);
244 *pixels++=(
unsigned char) (value >> 16);
247 *pixels++=(
unsigned char) (value >> 16);
248 *pixels++=(
unsigned char) (value >> 8);
249 *pixels++=(
unsigned char) value;
253static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
254 const QuantumAny pixel,
unsigned char *magick_restrict pixels)
262 if (quantum_info->state.bits == 0UL)
263 quantum_info->state.bits=8U;
264 for (i=(ssize_t) quantum_info->depth; i > 0L; )
266 quantum_bits=(size_t) i;
267 if (quantum_bits > quantum_info->state.bits)
268 quantum_bits=quantum_info->state.bits;
269 i-=(ssize_t) quantum_bits;
272 if (quantum_info->state.bits == 8UL)
274 quantum_info->state.bits-=quantum_bits;
275 *pixels|=(((pixel >> i) &~ (((QuantumAny) ~0UL) << quantum_bits)) <<
276 quantum_info->state.bits);
277 if (quantum_info->state.bits == 0UL)
280 quantum_info->state.bits=8UL;
286static inline unsigned char *PopQuantumLongPixel(QuantumInfo *quantum_info,
287 const size_t pixel,
unsigned char *magick_restrict pixels)
295 if (quantum_info->state.bits == 0U)
296 quantum_info->state.bits=32UL;
297 for (i=(ssize_t) quantum_info->depth; i > 0; )
299 quantum_bits=(size_t) i;
300 if (quantum_bits > quantum_info->state.bits)
301 quantum_bits=quantum_info->state.bits;
302 quantum_info->state.pixel|=(((pixel >> ((ssize_t) quantum_info->depth-i)) &
303 quantum_info->state.mask[quantum_bits]) << (32U-
304 quantum_info->state.bits));
305 i-=(ssize_t) quantum_bits;
306 quantum_info->state.bits-=quantum_bits;
307 if (quantum_info->state.bits == 0U)
309 pixels=PopLongPixel(quantum_info->endian,quantum_info->state.pixel,
311 quantum_info->state.pixel=0U;
312 quantum_info->state.bits=32U;
318static void ExportPixelChannel(
const Image *image,QuantumInfo *quantum_info,
319 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
320 unsigned char *magick_restrict q,PixelChannel channel)
328 p+=(ptrdiff_t) image->channel_map[channel].offset;
329 switch (quantum_info->depth)
336 for (x=0; x < (ssize_t) number_pixels; x++)
338 pixel=ScaleQuantumToChar(*p);
339 q=PopCharPixel(pixel,q);
340 p+=(ptrdiff_t) GetPixelChannels(image);
341 q+=(ptrdiff_t) quantum_info->pad;
350 if (quantum_info->format == FloatingPointQuantumFormat)
352 for (x=0; x < (ssize_t) number_pixels; x++)
354 pixel=SinglePrecisionToHalf(QuantumScale*(*p));
355 q=PopShortPixel(quantum_info->endian,pixel,q);
356 p+=(ptrdiff_t) GetPixelChannels(image);
357 q+=(ptrdiff_t) quantum_info->pad;
361 for (x=0; x < (ssize_t) number_pixels; x++)
363 pixel=ScaleQuantumToShort(*p);
364 q=PopShortPixel(quantum_info->endian,pixel,q);
365 p+=(ptrdiff_t) GetPixelChannels(image);
366 q+=(ptrdiff_t) quantum_info->pad;
375 if (quantum_info->format == FloatingPointQuantumFormat)
377 for (x=0; x < (ssize_t) number_pixels; x++)
379 q=PopQuantumFloatPixel(quantum_info,(
float) *p,q);
380 p+=(ptrdiff_t) GetPixelChannels(image);
381 q+=(ptrdiff_t) quantum_info->pad;
385 for (x=0; x < (ssize_t) number_pixels; x++)
387 pixel=ScaleQuantumToLong(*p);
388 q=PopLongPixel(quantum_info->endian,pixel,q);
389 p+=(ptrdiff_t) GetPixelChannels(image);
390 q+=(ptrdiff_t) quantum_info->pad;
396 if (quantum_info->format == FloatingPointQuantumFormat)
398 for (x=0; x < (ssize_t) number_pixels; x++)
400 q=PopQuantumFloat24Pixel(quantum_info,(
float) *p,q);
401 p+=(ptrdiff_t) GetPixelChannels(image);
402 q+=(ptrdiff_t) quantum_info->pad;
410 if (quantum_info->format == FloatingPointQuantumFormat)
412 for (x=0; x < (ssize_t) number_pixels; x++)
414 q=PopQuantumDoublePixel(quantum_info,(
double) *p,q);
415 p+=(ptrdiff_t) GetPixelChannels(image);
416 q+=(ptrdiff_t) quantum_info->pad;
420 for (x=0; x < (ssize_t) number_pixels; x++)
422 q=PopLongLongPixel(quantum_info->endian,ScaleQuantumToLongLong(*p),q);
423 p+=(ptrdiff_t) GetPixelChannels(image);
424 q+=(ptrdiff_t) quantum_info->pad;
430 range=GetQuantumRange(quantum_info->depth);
431 for (x=0; x < (ssize_t) number_pixels; x++)
433 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(*p,range),q);
434 p+=(ptrdiff_t) GetPixelChannels(image);
435 q+=(ptrdiff_t) quantum_info->pad;
442static void ExportAlphaQuantum(
const Image *image,QuantumInfo *quantum_info,
443 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
444 unsigned char *magick_restrict q,ExceptionInfo *exception)
446 if (image->alpha_trait == UndefinedPixelTrait)
448 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
449 "ImageDoesNotHaveAnAlphaChannel",
"`%s'",image->filename);
452 ExportPixelChannel(image,quantum_info,number_pixels,p,q,AlphaPixelChannel);
455static void ExportBGRQuantum(
const Image *image,QuantumInfo *quantum_info,
456 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
457 unsigned char *magick_restrict q)
468 switch (quantum_info->depth)
472 for (x=0; x < (ssize_t) number_pixels; x++)
474 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
475 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
476 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
477 p+=(ptrdiff_t) GetPixelChannels(image);
478 q+=(ptrdiff_t) quantum_info->pad;
487 range=GetQuantumRange(quantum_info->depth);
488 if (quantum_info->pack == MagickFalse)
490 for (x=0; x < (ssize_t) number_pixels; x++)
492 pixel=(
unsigned int) (
493 ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
494 ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
495 ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
496 q=PopLongPixel(quantum_info->endian,pixel,q);
497 p+=(ptrdiff_t) GetPixelChannels(image);
498 q+=(ptrdiff_t) quantum_info->pad;
502 if (quantum_info->quantum == 32UL)
504 for (x=0; x < (ssize_t) number_pixels; x++)
506 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
507 q=PopQuantumLongPixel(quantum_info,pixel,q);
508 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
510 q=PopQuantumLongPixel(quantum_info,pixel,q);
511 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
512 q=PopQuantumLongPixel(quantum_info,pixel,q);
513 p+=(ptrdiff_t) GetPixelChannels(image);
514 q+=(ptrdiff_t) quantum_info->pad;
518 for (x=0; x < (ssize_t) number_pixels; x++)
520 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
521 q=PopQuantumPixel(quantum_info,pixel,q);
522 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
523 q=PopQuantumPixel(quantum_info,pixel,q);
524 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
525 q=PopQuantumPixel(quantum_info,pixel,q);
526 p+=(ptrdiff_t) GetPixelChannels(image);
527 q+=(ptrdiff_t) quantum_info->pad;
536 range=GetQuantumRange(quantum_info->depth);
537 if (quantum_info->pack == MagickFalse)
539 for (x=0; x < (3*(ssize_t) number_pixels-1); x+=2)
546 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
552 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
558 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
560 p+=(ptrdiff_t) GetPixelChannels(image);
564 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
567 q+=(ptrdiff_t) quantum_info->pad;
573 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
579 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
585 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
587 p+=(ptrdiff_t) GetPixelChannels(image);
591 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
593 if (((x+1) % 3) == 2)
594 q+=(ptrdiff_t) quantum_info->pad;
596 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
603 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
609 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
615 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
617 p+=(ptrdiff_t) GetPixelChannels(image);
621 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
623 if (((x+bit) % 3) == 2)
624 q+=(ptrdiff_t) quantum_info->pad;
627 p+=(ptrdiff_t) GetPixelChannels(image);
630 if (quantum_info->quantum == 32UL)
632 for (x=0; x < (ssize_t) number_pixels; x++)
634 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
635 q=PopQuantumLongPixel(quantum_info,pixel,q);
636 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
638 q=PopQuantumLongPixel(quantum_info,pixel,q);
639 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
640 q=PopQuantumLongPixel(quantum_info,pixel,q);
641 p+=(ptrdiff_t) GetPixelChannels(image);
642 q+=(ptrdiff_t) quantum_info->pad;
646 for (x=0; x < (ssize_t) number_pixels; x++)
648 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
649 q=PopQuantumPixel(quantum_info,pixel,q);
650 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
651 q=PopQuantumPixel(quantum_info,pixel,q);
652 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
653 q=PopQuantumPixel(quantum_info,pixel,q);
654 p+=(ptrdiff_t) GetPixelChannels(image);
655 q+=(ptrdiff_t) quantum_info->pad;
664 if (quantum_info->format == FloatingPointQuantumFormat)
666 for (x=0; x < (ssize_t) number_pixels; x++)
668 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
669 GetPixelBlue(image,p));
670 q=PopShortPixel(quantum_info->endian,pixel,q);
671 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
672 GetPixelGreen(image,p));
673 q=PopShortPixel(quantum_info->endian,pixel,q);
674 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
675 GetPixelRed(image,p));
676 q=PopShortPixel(quantum_info->endian,pixel,q);
677 p+=(ptrdiff_t) GetPixelChannels(image);
678 q+=(ptrdiff_t) quantum_info->pad;
682 for (x=0; x < (ssize_t) number_pixels; x++)
684 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
685 q=PopShortPixel(quantum_info->endian,pixel,q);
686 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
687 q=PopShortPixel(quantum_info->endian,pixel,q);
688 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
689 q=PopShortPixel(quantum_info->endian,pixel,q);
690 p+=(ptrdiff_t) GetPixelChannels(image);
691 q+=(ptrdiff_t) quantum_info->pad;
700 if (quantum_info->format == FloatingPointQuantumFormat)
702 for (x=0; x < (ssize_t) number_pixels; x++)
704 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
705 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
706 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
707 p+=(ptrdiff_t) GetPixelChannels(image);
708 q+=(ptrdiff_t) quantum_info->pad;
712 for (x=0; x < (ssize_t) number_pixels; x++)
714 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
715 q=PopLongPixel(quantum_info->endian,pixel,q);
716 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
717 q=PopLongPixel(quantum_info->endian,pixel,q);
718 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
719 q=PopLongPixel(quantum_info->endian,pixel,q);
720 p+=(ptrdiff_t) GetPixelChannels(image);
721 q+=(ptrdiff_t) quantum_info->pad;
727 if (quantum_info->format == FloatingPointQuantumFormat)
729 for (x=0; x < (ssize_t) number_pixels; x++)
731 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
732 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
733 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
734 p+=(ptrdiff_t) GetPixelChannels(image);
735 q+=(ptrdiff_t) quantum_info->pad;
743 range=GetQuantumRange(quantum_info->depth);
744 for (x=0; x < (ssize_t) number_pixels; x++)
746 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
748 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
750 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
752 p+=(ptrdiff_t) GetPixelChannels(image);
753 q+=(ptrdiff_t) quantum_info->pad;
760static void ExportBGRAQuantum(
const Image *image,QuantumInfo *quantum_info,
761 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
762 unsigned char *magick_restrict q)
770 switch (quantum_info->depth)
777 for (x=0; x < (ssize_t) number_pixels; x++)
779 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
780 q=PopCharPixel(pixel,q);
781 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
782 q=PopCharPixel(pixel,q);
783 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
784 q=PopCharPixel(pixel,q);
785 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
786 q=PopCharPixel(pixel,q);
787 p+=(ptrdiff_t) GetPixelChannels(image);
788 q+=(ptrdiff_t) quantum_info->pad;
797 range=GetQuantumRange(quantum_info->depth);
798 if (quantum_info->pack == MagickFalse)
812 for (x=0; x < (ssize_t) number_pixels; x++)
814 for (i=0; i < 4; i++)
818 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
819 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
820 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
821 case 3: quantum=(size_t) GetPixelAlpha(image,p);
break;
827 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
833 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
839 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
841 q=PopLongPixel(quantum_info->endian,pixel,q);
848 p+=(ptrdiff_t) GetPixelChannels(image);
849 q+=(ptrdiff_t) quantum_info->pad;
853 if (quantum_info->quantum == 32UL)
855 for (x=0; x < (ssize_t) number_pixels; x++)
857 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
858 q=PopQuantumLongPixel(quantum_info,pixel,q);
859 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
861 q=PopQuantumLongPixel(quantum_info,pixel,q);
862 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
863 q=PopQuantumLongPixel(quantum_info,pixel,q);
864 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
866 q=PopQuantumLongPixel(quantum_info,pixel,q);
867 p+=(ptrdiff_t) GetPixelChannels(image);
868 q+=(ptrdiff_t) quantum_info->pad;
872 for (x=0; x < (ssize_t) number_pixels; x++)
874 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
875 q=PopQuantumPixel(quantum_info,pixel,q);
876 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
877 q=PopQuantumPixel(quantum_info,pixel,q);
878 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
879 q=PopQuantumPixel(quantum_info,pixel,q);
880 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
881 q=PopQuantumPixel(quantum_info,pixel,q);
882 p+=(ptrdiff_t) GetPixelChannels(image);
883 q+=(ptrdiff_t) quantum_info->pad;
892 if (quantum_info->format == FloatingPointQuantumFormat)
894 for (x=0; x < (ssize_t) number_pixels; x++)
896 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
897 GetPixelBlue(image,p));
898 q=PopShortPixel(quantum_info->endian,pixel,q);
899 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
900 GetPixelGreen(image,p));
901 q=PopShortPixel(quantum_info->endian,pixel,q);
902 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
903 GetPixelRed(image,p));
904 q=PopShortPixel(quantum_info->endian,pixel,q);
905 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
906 GetPixelAlpha(image,p));
907 q=PopShortPixel(quantum_info->endian,pixel,q);
908 p+=(ptrdiff_t) GetPixelChannels(image);
909 q+=(ptrdiff_t) quantum_info->pad;
913 for (x=0; x < (ssize_t) number_pixels; x++)
915 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
916 q=PopShortPixel(quantum_info->endian,pixel,q);
917 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
918 q=PopShortPixel(quantum_info->endian,pixel,q);
919 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
920 q=PopShortPixel(quantum_info->endian,pixel,q);
921 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
922 q=PopShortPixel(quantum_info->endian,pixel,q);
923 p+=(ptrdiff_t) GetPixelChannels(image);
924 q+=(ptrdiff_t) quantum_info->pad;
933 if (quantum_info->format == FloatingPointQuantumFormat)
935 for (x=0; x < (ssize_t) number_pixels; x++)
940 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
941 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
942 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
943 float_pixel=(float) GetPixelAlpha(image,p);
944 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
945 p+=(ptrdiff_t) GetPixelChannels(image);
946 q+=(ptrdiff_t) quantum_info->pad;
950 for (x=0; x < (ssize_t) number_pixels; x++)
952 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
953 q=PopLongPixel(quantum_info->endian,pixel,q);
954 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
955 q=PopLongPixel(quantum_info->endian,pixel,q);
956 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
957 q=PopLongPixel(quantum_info->endian,pixel,q);
958 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
959 q=PopLongPixel(quantum_info->endian,pixel,q);
960 p+=(ptrdiff_t) GetPixelChannels(image);
961 q+=(ptrdiff_t) quantum_info->pad;
967 if (quantum_info->format == FloatingPointQuantumFormat)
972 for (x=0; x < (ssize_t) number_pixels; x++)
974 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
975 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
976 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
977 pixel=(double) GetPixelAlpha(image,p);
978 q=PopQuantumDoublePixel(quantum_info,pixel,q);
979 p+=(ptrdiff_t) GetPixelChannels(image);
980 q+=(ptrdiff_t) quantum_info->pad;
988 range=GetQuantumRange(quantum_info->depth);
989 for (x=0; x < (ssize_t) number_pixels; x++)
991 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
993 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
995 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
997 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
999 p+=(ptrdiff_t) GetPixelChannels(image);
1000 q+=(ptrdiff_t) quantum_info->pad;
1007static void ExportBGROQuantum(
const Image *image,QuantumInfo *quantum_info,
1008 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1009 unsigned char *magick_restrict q)
1017 switch (quantum_info->depth)
1024 for (x=0; x < (ssize_t) number_pixels; x++)
1026 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1027 q=PopCharPixel(pixel,q);
1028 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1029 q=PopCharPixel(pixel,q);
1030 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1031 q=PopCharPixel(pixel,q);
1032 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
1033 q=PopCharPixel(pixel,q);
1034 p+=(ptrdiff_t) GetPixelChannels(image);
1035 q+=(ptrdiff_t) quantum_info->pad;
1044 range=GetQuantumRange(quantum_info->depth);
1045 if (quantum_info->pack == MagickFalse)
1059 for (x=0; x < (ssize_t) number_pixels; x++)
1061 for (i=0; i < 4; i++)
1065 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
1066 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
1067 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
1068 case 3: quantum=(size_t) GetPixelOpacity(image,p);
break;
1074 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1080 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1086 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1088 q=PopLongPixel(quantum_info->endian,pixel,q);
1095 p+=(ptrdiff_t) GetPixelChannels(image);
1096 q+=(ptrdiff_t) quantum_info->pad;
1100 if (quantum_info->quantum == 32UL)
1102 for (x=0; x < (ssize_t) number_pixels; x++)
1104 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
1105 q=PopQuantumLongPixel(quantum_info,pixel,q);
1106 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
1108 q=PopQuantumLongPixel(quantum_info,pixel,q);
1109 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
1110 q=PopQuantumLongPixel(quantum_info,pixel,q);
1111 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
1113 q=PopQuantumLongPixel(quantum_info,pixel,q);
1114 p+=(ptrdiff_t) GetPixelChannels(image);
1115 q+=(ptrdiff_t) quantum_info->pad;
1119 for (x=0; x < (ssize_t) number_pixels; x++)
1121 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
1122 q=PopQuantumPixel(quantum_info,pixel,q);
1123 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
1124 q=PopQuantumPixel(quantum_info,pixel,q);
1125 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
1126 q=PopQuantumPixel(quantum_info,pixel,q);
1127 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
1128 q=PopQuantumPixel(quantum_info,pixel,q);
1129 p+=(ptrdiff_t) GetPixelChannels(image);
1130 q+=(ptrdiff_t) quantum_info->pad;
1139 if (quantum_info->format == FloatingPointQuantumFormat)
1141 for (x=0; x < (ssize_t) number_pixels; x++)
1143 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1144 GetPixelBlue(image,p));
1145 q=PopShortPixel(quantum_info->endian,pixel,q);
1146 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1147 GetPixelGreen(image,p));
1148 q=PopShortPixel(quantum_info->endian,pixel,q);
1149 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1150 GetPixelRed(image,p));
1151 q=PopShortPixel(quantum_info->endian,pixel,q);
1152 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1153 GetPixelOpacity(image,p));
1154 q=PopShortPixel(quantum_info->endian,pixel,q);
1155 p+=(ptrdiff_t) GetPixelChannels(image);
1156 q+=(ptrdiff_t) quantum_info->pad;
1160 for (x=0; x < (ssize_t) number_pixels; x++)
1162 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1163 q=PopShortPixel(quantum_info->endian,pixel,q);
1164 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1165 q=PopShortPixel(quantum_info->endian,pixel,q);
1166 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1167 q=PopShortPixel(quantum_info->endian,pixel,q);
1168 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
1169 q=PopShortPixel(quantum_info->endian,pixel,q);
1170 p+=(ptrdiff_t) GetPixelChannels(image);
1171 q+=(ptrdiff_t) quantum_info->pad;
1180 if (quantum_info->format == FloatingPointQuantumFormat)
1182 for (x=0; x < (ssize_t) number_pixels; x++)
1187 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
1188 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
1189 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
1190 float_pixel=(float) GetPixelOpacity(image,p);
1191 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1192 p+=(ptrdiff_t) GetPixelChannels(image);
1193 q+=(ptrdiff_t) quantum_info->pad;
1197 for (x=0; x < (ssize_t) number_pixels; x++)
1199 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1200 q=PopLongPixel(quantum_info->endian,pixel,q);
1201 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1202 q=PopLongPixel(quantum_info->endian,pixel,q);
1203 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1204 q=PopLongPixel(quantum_info->endian,pixel,q);
1205 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
1206 q=PopLongPixel(quantum_info->endian,pixel,q);
1207 p+=(ptrdiff_t) GetPixelChannels(image);
1208 q+=(ptrdiff_t) quantum_info->pad;
1214 if (quantum_info->format == FloatingPointQuantumFormat)
1219 for (x=0; x < (ssize_t) number_pixels; x++)
1221 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
1222 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
1223 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
1224 pixel=(double) GetPixelOpacity(image,p);
1225 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1226 p+=(ptrdiff_t) GetPixelChannels(image);
1227 q+=(ptrdiff_t) quantum_info->pad;
1235 range=GetQuantumRange(quantum_info->depth);
1236 for (x=0; x < (ssize_t) number_pixels; x++)
1238 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1240 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1242 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1244 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
1246 p+=(ptrdiff_t) GetPixelChannels(image);
1247 q+=(ptrdiff_t) quantum_info->pad;
1254static void ExportBlackQuantum(
const Image *image,QuantumInfo *quantum_info,
1255 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1256 unsigned char *magick_restrict q,ExceptionInfo *exception)
1258 if (image->colorspace != CMYKColorspace)
1260 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1261 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1264 ExportPixelChannel(image,quantum_info,number_pixels,p,q,BlackPixelChannel);
1267static void ExportCbYCrYQuantum(
const Image *image,QuantumInfo *quantum_info,
1268 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1269 unsigned char *magick_restrict q)
1289 switch (quantum_info->depth)
1293 if (quantum_info->pack == MagickFalse)
1295 for (x=0; x < (ssize_t) number_pixels; x+=2)
1297 for (i=0; i < 4; i++)
1303 quantum=(size_t) GetPixelRed(image,p);
1308 quantum=(size_t) GetPixelGreen(image,p);
1313 quantum=(size_t) GetPixelBlue(image,p);
1317 cbcr[i]=(Quantum) quantum;
1320 pixel=(
unsigned int) ((
size_t) (cbcr[1]) << 22 | (
size_t)
1321 (cbcr[0]) << 12 | (
size_t) (cbcr[2]) << 2);
1322 q=PopLongPixel(quantum_info->endian,pixel,q);
1323 p+=(ptrdiff_t) GetPixelChannels(image);
1324 pixel=(
unsigned int) ((
size_t) (cbcr[3]) << 22 | (
size_t)
1325 (cbcr[0]) << 12 | (
size_t) (cbcr[2]) << 2);
1326 q=PopLongPixel(quantum_info->endian,pixel,q);
1327 p+=(ptrdiff_t) GetPixelChannels(image);
1328 q+=(ptrdiff_t) quantum_info->pad;
1339 for (x=0; x < (ssize_t) number_pixels; x+=2)
1341 for (i=0; i < 4; i++)
1347 quantum=(size_t) GetPixelRed(image,p);
1352 quantum=(size_t) GetPixelGreen(image,p);
1357 quantum=(size_t) GetPixelBlue(image,p);
1361 cbcr[i]=(Quantum) quantum;
1364 range=GetQuantumRange(quantum_info->depth);
1365 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[1],range),q);
1366 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
1367 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
1368 p+=(ptrdiff_t) GetPixelChannels(image);
1369 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[3],range),q);
1370 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[0],range),q);
1371 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(cbcr[2],range),q);
1372 p+=(ptrdiff_t) GetPixelChannels(image);
1373 q+=(ptrdiff_t) quantum_info->pad;
1380static void ExportCMYKQuantum(
const Image *image,QuantumInfo *quantum_info,
1381 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1382 unsigned char *magick_restrict q,ExceptionInfo *exception)
1387 if (image->colorspace != CMYKColorspace)
1389 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1390 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1393 switch (quantum_info->depth)
1400 for (x=0; x < (ssize_t) number_pixels; x++)
1402 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1403 q=PopCharPixel(pixel,q);
1404 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1405 q=PopCharPixel(pixel,q);
1406 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1407 q=PopCharPixel(pixel,q);
1408 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1409 q=PopCharPixel(pixel,q);
1410 p+=(ptrdiff_t) GetPixelChannels(image);
1411 q+=(ptrdiff_t) quantum_info->pad;
1420 if (quantum_info->format == FloatingPointQuantumFormat)
1422 for (x=0; x < (ssize_t) number_pixels; x++)
1424 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1425 GetPixelRed(image,p));
1426 q=PopShortPixel(quantum_info->endian,pixel,q);
1427 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1428 GetPixelGreen(image,p));
1429 q=PopShortPixel(quantum_info->endian,pixel,q);
1430 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1431 GetPixelBlue(image,p));
1432 q=PopShortPixel(quantum_info->endian,pixel,q);
1433 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1434 GetPixelBlack(image,p));
1435 q=PopShortPixel(quantum_info->endian,pixel,q);
1436 p+=(ptrdiff_t) GetPixelChannels(image);
1437 q+=(ptrdiff_t) quantum_info->pad;
1441 for (x=0; x < (ssize_t) number_pixels; x++)
1443 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1444 q=PopShortPixel(quantum_info->endian,pixel,q);
1445 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1446 q=PopShortPixel(quantum_info->endian,pixel,q);
1447 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1448 q=PopShortPixel(quantum_info->endian,pixel,q);
1449 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1450 q=PopShortPixel(quantum_info->endian,pixel,q);
1451 p+=(ptrdiff_t) GetPixelChannels(image);
1452 q+=(ptrdiff_t) quantum_info->pad;
1461 if (quantum_info->format == FloatingPointQuantumFormat)
1463 for (x=0; x < (ssize_t) number_pixels; x++)
1465 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),
1467 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),
1469 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),
1471 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlack(image,p),
1473 p+=(ptrdiff_t) GetPixelChannels(image);
1474 q+=(ptrdiff_t) quantum_info->pad;
1478 for (x=0; x < (ssize_t) number_pixels; x++)
1480 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1481 q=PopLongPixel(quantum_info->endian,pixel,q);
1482 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1483 q=PopLongPixel(quantum_info->endian,pixel,q);
1484 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1485 q=PopLongPixel(quantum_info->endian,pixel,q);
1486 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1487 q=PopLongPixel(quantum_info->endian,pixel,q);
1488 p+=(ptrdiff_t) GetPixelChannels(image);
1489 q+=(ptrdiff_t) quantum_info->pad;
1495 if (quantum_info->format == FloatingPointQuantumFormat)
1497 for (x=0; x < (ssize_t) number_pixels; x++)
1499 q=PopQuantumDoublePixel(quantum_info,(
double)
1500 GetPixelRed(image,p),q);
1501 q=PopQuantumDoublePixel(quantum_info,(
double)
1502 GetPixelGreen(image,p),q);
1503 q=PopQuantumDoublePixel(quantum_info,(
double)
1504 GetPixelBlue(image,p),q);
1505 q=PopQuantumDoublePixel(quantum_info,(
double)
1506 GetPixelBlack(image,p),q);
1507 p+=(ptrdiff_t) GetPixelChannels(image);
1508 q+=(ptrdiff_t) quantum_info->pad;
1519 range=GetQuantumRange(quantum_info->depth);
1520 for (x=0; x < (ssize_t) number_pixels; x++)
1522 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1524 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1526 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1528 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1530 p+=(ptrdiff_t) GetPixelChannels(image);
1531 q+=(ptrdiff_t) quantum_info->pad;
1538static void ExportCMYKAQuantum(
const Image *image,QuantumInfo *quantum_info,
1539 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1540 unsigned char *magick_restrict q,ExceptionInfo *exception)
1545 if (image->colorspace != CMYKColorspace)
1547 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1548 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1551 switch (quantum_info->depth)
1558 for (x=0; x < (ssize_t) number_pixels; x++)
1560 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1561 q=PopCharPixel(pixel,q);
1562 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1563 q=PopCharPixel(pixel,q);
1564 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1565 q=PopCharPixel(pixel,q);
1566 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1567 q=PopCharPixel(pixel,q);
1568 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
1569 q=PopCharPixel(pixel,q);
1570 p+=(ptrdiff_t) GetPixelChannels(image);
1571 q+=(ptrdiff_t) quantum_info->pad;
1580 if (quantum_info->format == FloatingPointQuantumFormat)
1582 for (x=0; x < (ssize_t) number_pixels; x++)
1584 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1585 GetPixelRed(image,p));
1586 q=PopShortPixel(quantum_info->endian,pixel,q);
1587 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1588 GetPixelGreen(image,p));
1589 q=PopShortPixel(quantum_info->endian,pixel,q);
1590 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1591 GetPixelBlue(image,p));
1592 q=PopShortPixel(quantum_info->endian,pixel,q);
1593 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1594 GetPixelBlack(image,p));
1595 q=PopShortPixel(quantum_info->endian,pixel,q);
1596 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1597 GetPixelAlpha(image,p));
1598 q=PopShortPixel(quantum_info->endian,pixel,q);
1599 p+=(ptrdiff_t) GetPixelChannels(image);
1600 q+=(ptrdiff_t) quantum_info->pad;
1604 for (x=0; x < (ssize_t) number_pixels; x++)
1606 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1607 q=PopShortPixel(quantum_info->endian,pixel,q);
1608 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1609 q=PopShortPixel(quantum_info->endian,pixel,q);
1610 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1611 q=PopShortPixel(quantum_info->endian,pixel,q);
1612 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1613 q=PopShortPixel(quantum_info->endian,pixel,q);
1614 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
1615 q=PopShortPixel(quantum_info->endian,pixel,q);
1616 p+=(ptrdiff_t) GetPixelChannels(image);
1617 q+=(ptrdiff_t) quantum_info->pad;
1626 if (quantum_info->format == FloatingPointQuantumFormat)
1628 for (x=0; x < (ssize_t) number_pixels; x++)
1630 q=PopQuantumFloatPixel(quantum_info,(
float)
1631 GetPixelRed(image,p),q);
1632 q=PopQuantumFloatPixel(quantum_info,(
float)
1633 GetPixelGreen(image,p),q);
1634 q=PopQuantumFloatPixel(quantum_info,(
float)
1635 GetPixelBlue(image,p),q);
1636 q=PopQuantumFloatPixel(quantum_info,(
float)
1637 GetPixelBlack(image,p),q);
1638 q=PopQuantumFloatPixel(quantum_info,(
float)
1639 GetPixelAlpha(image,p),q);
1640 p+=(ptrdiff_t) GetPixelChannels(image);
1641 q+=(ptrdiff_t) quantum_info->pad;
1645 for (x=0; x < (ssize_t) number_pixels; x++)
1647 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1648 q=PopLongPixel(quantum_info->endian,pixel,q);
1649 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1650 q=PopLongPixel(quantum_info->endian,pixel,q);
1651 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1652 q=PopLongPixel(quantum_info->endian,pixel,q);
1653 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1654 q=PopLongPixel(quantum_info->endian,pixel,q);
1655 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
1656 q=PopLongPixel(quantum_info->endian,pixel,q);
1657 p+=(ptrdiff_t) GetPixelChannels(image);
1658 q+=(ptrdiff_t) quantum_info->pad;
1664 if (quantum_info->format == FloatingPointQuantumFormat)
1666 for (x=0; x < (ssize_t) number_pixels; x++)
1668 q=PopQuantumDoublePixel(quantum_info,(
double)
1669 GetPixelRed(image,p),q);
1670 q=PopQuantumDoublePixel(quantum_info,(
double)
1671 GetPixelGreen(image,p),q);
1672 q=PopQuantumDoublePixel(quantum_info,(
double)
1673 GetPixelBlue(image,p),q);
1674 q=PopQuantumDoublePixel(quantum_info,(
double)
1675 GetPixelBlack(image,p),q);
1676 q=PopQuantumDoublePixel(quantum_info,(
double)
1677 GetPixelAlpha(image,p),q);
1678 p+=(ptrdiff_t) GetPixelChannels(image);
1679 q+=(ptrdiff_t) quantum_info->pad;
1690 range=GetQuantumRange(quantum_info->depth);
1691 for (x=0; x < (ssize_t) number_pixels; x++)
1693 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1695 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1697 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1699 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1701 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
1703 p+=(ptrdiff_t) GetPixelChannels(image);
1704 q+=(ptrdiff_t) quantum_info->pad;
1711static void ExportCMYKOQuantum(
const Image *image,QuantumInfo *quantum_info,
1712 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1713 unsigned char *magick_restrict q,ExceptionInfo *exception)
1718 if (image->colorspace != CMYKColorspace)
1720 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1721 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1724 switch (quantum_info->depth)
1731 for (x=0; x < (ssize_t) number_pixels; x++)
1733 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
1734 q=PopCharPixel(pixel,q);
1735 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
1736 q=PopCharPixel(pixel,q);
1737 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
1738 q=PopCharPixel(pixel,q);
1739 pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
1740 q=PopCharPixel(pixel,q);
1741 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
1742 q=PopCharPixel(pixel,q);
1743 p+=(ptrdiff_t) GetPixelChannels(image);
1744 q+=(ptrdiff_t) quantum_info->pad;
1753 if (quantum_info->format == FloatingPointQuantumFormat)
1755 for (x=0; x < (ssize_t) number_pixels; x++)
1757 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1758 GetPixelRed(image,p));
1759 q=PopShortPixel(quantum_info->endian,pixel,q);
1760 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1761 GetPixelGreen(image,p));
1762 q=PopShortPixel(quantum_info->endian,pixel,q);
1763 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1764 GetPixelBlue(image,p));
1765 q=PopShortPixel(quantum_info->endian,pixel,q);
1766 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1767 GetPixelBlack(image,p));
1768 q=PopShortPixel(quantum_info->endian,pixel,q);
1769 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
1770 GetPixelOpacity(image,p));
1771 q=PopShortPixel(quantum_info->endian,pixel,q);
1772 p+=(ptrdiff_t) GetPixelChannels(image);
1773 q+=(ptrdiff_t) quantum_info->pad;
1777 for (x=0; x < (ssize_t) number_pixels; x++)
1779 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
1780 q=PopShortPixel(quantum_info->endian,pixel,q);
1781 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
1782 q=PopShortPixel(quantum_info->endian,pixel,q);
1783 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
1784 q=PopShortPixel(quantum_info->endian,pixel,q);
1785 pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
1786 q=PopShortPixel(quantum_info->endian,pixel,q);
1787 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
1788 q=PopShortPixel(quantum_info->endian,pixel,q);
1789 p+=(ptrdiff_t) GetPixelChannels(image);
1790 q+=(ptrdiff_t) quantum_info->pad;
1799 if (quantum_info->format == FloatingPointQuantumFormat)
1801 for (x=0; x < (ssize_t) number_pixels; x++)
1806 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
1807 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),
1809 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),
1811 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlack(image,p),
1813 float_pixel=(float) (GetPixelOpacity(image,p));
1814 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
1815 p+=(ptrdiff_t) GetPixelChannels(image);
1816 q+=(ptrdiff_t) quantum_info->pad;
1820 for (x=0; x < (ssize_t) number_pixels; x++)
1822 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
1823 q=PopLongPixel(quantum_info->endian,pixel,q);
1824 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
1825 q=PopLongPixel(quantum_info->endian,pixel,q);
1826 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
1827 q=PopLongPixel(quantum_info->endian,pixel,q);
1828 pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
1829 q=PopLongPixel(quantum_info->endian,pixel,q);
1830 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
1831 q=PopLongPixel(quantum_info->endian,pixel,q);
1832 p+=(ptrdiff_t) GetPixelChannels(image);
1833 q+=(ptrdiff_t) quantum_info->pad;
1839 if (quantum_info->format == FloatingPointQuantumFormat)
1844 for (x=0; x < (ssize_t) number_pixels; x++)
1846 q=PopQuantumDoublePixel(quantum_info,(
double)
1847 GetPixelRed(image,p),q);
1848 q=PopQuantumDoublePixel(quantum_info,(
double)
1849 GetPixelGreen(image,p),q);
1850 q=PopQuantumDoublePixel(quantum_info,(
double)
1851 GetPixelBlue(image,p),q);
1852 q=PopQuantumDoublePixel(quantum_info,(
double)
1853 GetPixelBlack(image,p),q);
1854 pixel=(double) (GetPixelOpacity(image,p));
1855 q=PopQuantumDoublePixel(quantum_info,pixel,q);
1856 p+=(ptrdiff_t) GetPixelChannels(image);
1857 q+=(ptrdiff_t) quantum_info->pad;
1868 range=GetQuantumRange(quantum_info->depth);
1869 for (x=0; x < (ssize_t) number_pixels; x++)
1871 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
1873 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
1875 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
1877 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
1879 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
1880 GetPixelOpacity(image,p),range),q);
1881 p+=(ptrdiff_t) GetPixelChannels(image);
1882 q+=(ptrdiff_t) quantum_info->pad;
1889static void ExportGrayQuantum(
const Image *image,QuantumInfo *quantum_info,
1890 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
1891 unsigned char *magick_restrict q)
1899 switch (quantum_info->depth)
1915 if (quantum_info->min_is_white != MagickFalse)
1920 threshold=(double) QuantumRange/2.0;
1921 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1924 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
1925 p+=(ptrdiff_t) GetPixelChannels(image);
1926 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
1927 p+=(ptrdiff_t) GetPixelChannels(image);
1928 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
1929 p+=(ptrdiff_t) GetPixelChannels(image);
1930 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
1931 p+=(ptrdiff_t) GetPixelChannels(image);
1932 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
1933 p+=(ptrdiff_t) GetPixelChannels(image);
1934 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
1935 p+=(ptrdiff_t) GetPixelChannels(image);
1936 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
1937 p+=(ptrdiff_t) GetPixelChannels(image);
1938 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
1939 p+=(ptrdiff_t) GetPixelChannels(image);
1942 if ((number_pixels % 8) != 0)
1945 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1947 *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
1948 p+=(ptrdiff_t) GetPixelChannels(image);
1959 for (x=0; x < ((ssize_t) number_pixels-1) ; x+=2)
1961 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1962 *q=(((pixel >> 4) & 0xf) << 4);
1963 p+=(ptrdiff_t) GetPixelChannels(image);
1964 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1966 p+=(ptrdiff_t) GetPixelChannels(image);
1969 if ((number_pixels % 2) != 0)
1971 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1972 *q=(((pixel >> 4) & 0xf) << 4);
1973 p+=(ptrdiff_t) GetPixelChannels(image);
1983 for (x=0; x < (ssize_t) number_pixels; x++)
1985 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
1986 q=PopCharPixel(pixel,q);
1987 p+=(ptrdiff_t) GetPixelChannels(image);
1988 q+=(ptrdiff_t) quantum_info->pad;
1994 range=GetQuantumRange(quantum_info->depth);
1995 if (quantum_info->pack == MagickFalse)
2000 for (x=0; x < ((ssize_t) number_pixels-2); x+=3)
2002 pixel=(
unsigned int) (ScaleQuantumToAny(ClampToQuantum(
2003 GetPixelLuma(image,p+2*GetPixelChannels(image))),range) << 22 |
2004 ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
2005 GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
2006 ClampToQuantum(GetPixelLuma(image,p)),range) << 2);
2007 q=PopLongPixel(quantum_info->endian,pixel,q);
2008 p+=(ptrdiff_t) 3*GetPixelChannels(image);
2009 q+=(ptrdiff_t) quantum_info->pad;
2011 if (x < (ssize_t) number_pixels)
2014 if (x++ < ((ssize_t) number_pixels-1))
2015 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
2016 GetPixelChannels(image))),range) << 12;
2017 if (x++ < (ssize_t) number_pixels)
2018 pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),
2020 q=PopLongPixel(quantum_info->endian,pixel,q);
2024 for (x=0; x < (ssize_t) number_pixels; x++)
2026 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2027 GetPixelLuma(image,p)),range),q);
2028 p+=(ptrdiff_t) GetPixelChannels(image);
2029 q+=(ptrdiff_t) quantum_info->pad;
2038 range=GetQuantumRange(quantum_info->depth);
2039 if (quantum_info->pack == MagickFalse)
2041 for (x=0; x < (ssize_t) number_pixels; x++)
2043 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2044 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel >> 4),
2046 p+=(ptrdiff_t) GetPixelChannels(image);
2047 q+=(ptrdiff_t) quantum_info->pad;
2051 for (x=0; x < (ssize_t) number_pixels; x++)
2053 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2054 GetPixelLuma(image,p)),range),q);
2055 p+=(ptrdiff_t) GetPixelChannels(image);
2056 q+=(ptrdiff_t) quantum_info->pad;
2065 if (quantum_info->format == FloatingPointQuantumFormat)
2067 for (x=0; x < (ssize_t) number_pixels; x++)
2069 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2070 GetPixelLuma(image,p));
2071 q=PopShortPixel(quantum_info->endian,pixel,q);
2072 p+=(ptrdiff_t) GetPixelChannels(image);
2073 q+=(ptrdiff_t) quantum_info->pad;
2077 for (x=0; x < (ssize_t) number_pixels; x++)
2079 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2080 q=PopShortPixel(quantum_info->endian,pixel,q);
2081 p+=(ptrdiff_t) GetPixelChannels(image);
2082 q+=(ptrdiff_t) quantum_info->pad;
2091 if (quantum_info->format == FloatingPointQuantumFormat)
2093 for (x=0; x < (ssize_t) number_pixels; x++)
2098 float_pixel=(float) GetPixelLuma(image,p);
2099 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2100 p+=(ptrdiff_t) GetPixelChannels(image);
2101 q+=(ptrdiff_t) quantum_info->pad;
2105 for (x=0; x < (ssize_t) number_pixels; x++)
2107 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2108 q=PopLongPixel(quantum_info->endian,pixel,q);
2109 p+=(ptrdiff_t) GetPixelChannels(image);
2110 q+=(ptrdiff_t) quantum_info->pad;
2116 if (quantum_info->format == FloatingPointQuantumFormat)
2118 for (x=0; x < (ssize_t) number_pixels; x++)
2123 pixel=GetPixelLuma(image,p);
2124 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2125 p+=(ptrdiff_t) GetPixelChannels(image);
2126 q+=(ptrdiff_t) quantum_info->pad;
2134 range=GetQuantumRange(quantum_info->depth);
2135 for (x=0; x < (ssize_t) number_pixels; x++)
2137 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2138 GetPixelLuma(image,p)),range),q);
2139 p+=(ptrdiff_t) GetPixelChannels(image);
2140 q+=(ptrdiff_t) quantum_info->pad;
2147static void ExportGrayAlphaQuantum(
const Image *image,QuantumInfo *quantum_info,
2148 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
2149 unsigned char *magick_restrict q)
2157 switch (quantum_info->depth)
2174 if (quantum_info->min_is_white != MagickFalse)
2179 threshold=(double) QuantumRange/2.0;
2180 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2183 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 7;
2184 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2186 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
2187 p+=(ptrdiff_t) GetPixelChannels(image);
2188 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 5;
2189 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2191 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
2192 p+=(ptrdiff_t) GetPixelChannels(image);
2193 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 3;
2194 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2196 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
2197 p+=(ptrdiff_t) GetPixelChannels(image);
2198 *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
2199 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2201 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
2202 p+=(ptrdiff_t) GetPixelChannels(image);
2205 if ((number_pixels % 4) != 0)
2208 for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
2210 *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
2212 pixel=(
unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
2214 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (
unsigned char)
2216 p+=(ptrdiff_t) GetPixelChannels(image);
2227 for (x=0; x < (ssize_t) number_pixels ; x++)
2229 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2230 *q=(((pixel >> 4) & 0xf) << 4);
2231 pixel=(
unsigned char) (16.0*QuantumScale*(
double)
2232 GetPixelAlpha(image,p)+0.5);
2234 p+=(ptrdiff_t) GetPixelChannels(image);
2244 for (x=0; x < (ssize_t) number_pixels; x++)
2246 pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
2247 q=PopCharPixel(pixel,q);
2248 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2249 q=PopCharPixel(pixel,q);
2250 p+=(ptrdiff_t) GetPixelChannels(image);
2251 q+=(ptrdiff_t) quantum_info->pad;
2260 if (quantum_info->format == FloatingPointQuantumFormat)
2262 for (x=0; x < (ssize_t) number_pixels; x++)
2264 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2265 GetPixelLuma(image,p));
2266 q=PopShortPixel(quantum_info->endian,pixel,q);
2267 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2268 GetPixelAlpha(image,p));
2269 q=PopShortPixel(quantum_info->endian,pixel,q);
2270 p+=(ptrdiff_t) GetPixelChannels(image);
2271 q+=(ptrdiff_t) quantum_info->pad;
2275 for (x=0; x < (ssize_t) number_pixels; x++)
2277 pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
2278 q=PopShortPixel(quantum_info->endian,pixel,q);
2279 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2280 q=PopShortPixel(quantum_info->endian,pixel,q);
2281 p+=(ptrdiff_t) GetPixelChannels(image);
2282 q+=(ptrdiff_t) quantum_info->pad;
2291 if (quantum_info->format == FloatingPointQuantumFormat)
2293 for (x=0; x < (ssize_t) number_pixels; x++)
2298 float_pixel=(float) GetPixelLuma(image,p);
2299 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2300 float_pixel=(float) (GetPixelAlpha(image,p));
2301 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2302 p+=(ptrdiff_t) GetPixelChannels(image);
2303 q+=(ptrdiff_t) quantum_info->pad;
2307 for (x=0; x < (ssize_t) number_pixels; x++)
2309 pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
2310 q=PopLongPixel(quantum_info->endian,pixel,q);
2311 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2312 q=PopLongPixel(quantum_info->endian,pixel,q);
2313 p+=(ptrdiff_t) GetPixelChannels(image);
2314 q+=(ptrdiff_t) quantum_info->pad;
2320 if (quantum_info->format == FloatingPointQuantumFormat)
2322 for (x=0; x < (ssize_t) number_pixels; x++)
2327 pixel=GetPixelLuma(image,p);
2328 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2329 pixel=(double) (GetPixelAlpha(image,p));
2330 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2331 p+=(ptrdiff_t) GetPixelChannels(image);
2332 q+=(ptrdiff_t) quantum_info->pad;
2340 range=GetQuantumRange(quantum_info->depth);
2341 for (x=0; x < (ssize_t) number_pixels; x++)
2343 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
2344 GetPixelLuma(image,p)),range),q);
2345 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2347 p+=(ptrdiff_t) GetPixelChannels(image);
2348 q+=(ptrdiff_t) quantum_info->pad;
2355static void ExportIndexQuantum(
const Image *image,QuantumInfo *quantum_info,
2356 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
2357 unsigned char *magick_restrict q,ExceptionInfo *exception)
2365 if (image->storage_class != PseudoClass)
2367 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2368 "ColormappedImageRequired",
"`%s'",image->filename);
2371 switch (quantum_info->depth)
2378 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
2380 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2381 *q=((pixel & 0x01) << 7);
2382 p+=(ptrdiff_t) GetPixelChannels(image);
2383 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2384 *q|=((pixel & 0x01) << 6);
2385 p+=(ptrdiff_t) GetPixelChannels(image);
2386 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2387 *q|=((pixel & 0x01) << 5);
2388 p+=(ptrdiff_t) GetPixelChannels(image);
2389 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2390 *q|=((pixel & 0x01) << 4);
2391 p+=(ptrdiff_t) GetPixelChannels(image);
2392 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2393 *q|=((pixel & 0x01) << 3);
2394 p+=(ptrdiff_t) GetPixelChannels(image);
2395 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2396 *q|=((pixel & 0x01) << 2);
2397 p+=(ptrdiff_t) GetPixelChannels(image);
2398 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2399 *q|=((pixel & 0x01) << 1);
2400 p+=(ptrdiff_t) GetPixelChannels(image);
2401 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2402 *q|=((pixel & 0x01) << 0);
2403 p+=(ptrdiff_t) GetPixelChannels(image);
2406 if ((number_pixels % 8) != 0)
2409 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
2411 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2412 *q|=((pixel & 0x01) << (
unsigned char) bit);
2413 p+=(ptrdiff_t) GetPixelChannels(image);
2424 for (x=0; x < ((ssize_t) number_pixels-1) ; x+=2)
2426 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2427 *q=((pixel & 0xf) << 4);
2428 p+=(ptrdiff_t) GetPixelChannels(image);
2429 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2430 *q|=((pixel & 0xf) << 0);
2431 p+=(ptrdiff_t) GetPixelChannels(image);
2434 if ((number_pixels % 2) != 0)
2436 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2437 *q=((pixel & 0xf) << 4);
2438 p+=(ptrdiff_t) GetPixelChannels(image);
2445 for (x=0; x < (ssize_t) number_pixels; x++)
2447 q=PopCharPixel((
unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2448 p+=(ptrdiff_t) GetPixelChannels(image);
2449 q+=(ptrdiff_t) quantum_info->pad;
2455 if (quantum_info->format == FloatingPointQuantumFormat)
2457 for (x=0; x < (ssize_t) number_pixels; x++)
2459 q=PopShortPixel(quantum_info->endian,SinglePrecisionToHalf(
2460 QuantumScale*(
double) GetPixelIndex(image,p)),q);
2461 p+=(ptrdiff_t) GetPixelChannels(image);
2462 q+=(ptrdiff_t) quantum_info->pad;
2466 for (x=0; x < (ssize_t) number_pixels; x++)
2468 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2469 GetPixelIndex(image,p),q);
2470 p+=(ptrdiff_t) GetPixelChannels(image);
2471 q+=(ptrdiff_t) quantum_info->pad;
2477 if (quantum_info->format == FloatingPointQuantumFormat)
2479 for (x=0; x < (ssize_t) number_pixels; x++)
2481 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(image,p),q);
2482 p+=(ptrdiff_t) GetPixelChannels(image);
2483 q+=(ptrdiff_t) quantum_info->pad;
2487 for (x=0; x < (ssize_t) number_pixels; x++)
2489 q=PopLongPixel(quantum_info->endian,(
unsigned int)
2490 GetPixelIndex(image,p),q);
2491 p+=(ptrdiff_t) GetPixelChannels(image);
2492 q+=(ptrdiff_t) quantum_info->pad;
2498 if (quantum_info->format == FloatingPointQuantumFormat)
2500 for (x=0; x < (ssize_t) number_pixels; x++)
2502 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(image,p),q);
2503 p+=(ptrdiff_t) GetPixelChannels(image);
2504 q+=(ptrdiff_t) quantum_info->pad;
2512 for (x=0; x < (ssize_t) number_pixels; x++)
2514 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2515 p+=(ptrdiff_t) GetPixelChannels(image);
2516 q+=(ptrdiff_t) quantum_info->pad;
2523static void ExportIndexAlphaQuantum(
const Image *image,
2524 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
2525 const Quantum *magick_restrict p,
unsigned char *magick_restrict q,
2526 ExceptionInfo *exception)
2534 if (image->storage_class != PseudoClass)
2536 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2537 "ColormappedImageRequired",
"`%s'",image->filename);
2540 switch (quantum_info->depth)
2547 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2549 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2550 *q=((pixel & 0x01) << 7);
2551 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2552 TransparentAlpha ? 1 : 0);
2553 *q|=((pixel & 0x01) << 6);
2554 p+=(ptrdiff_t) GetPixelChannels(image);
2555 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2556 *q|=((pixel & 0x01) << 5);
2557 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2558 TransparentAlpha ? 1 : 0);
2559 *q|=((pixel & 0x01) << 4);
2560 p+=(ptrdiff_t) GetPixelChannels(image);
2561 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2562 *q|=((pixel & 0x01) << 3);
2563 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2564 TransparentAlpha ? 1 : 0);
2565 *q|=((pixel & 0x01) << 2);
2566 p+=(ptrdiff_t) GetPixelChannels(image);
2567 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2568 *q|=((pixel & 0x01) << 1);
2569 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2570 TransparentAlpha ? 1 : 0);
2571 *q|=((pixel & 0x01) << 0);
2572 p+=(ptrdiff_t) GetPixelChannels(image);
2575 if ((number_pixels % 4) != 0)
2578 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2580 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2581 *q|=((pixel & 0x01) << (
unsigned char) (bit+4));
2582 pixel=(
unsigned char) (GetPixelAlpha(image,p) == (Quantum)
2583 TransparentAlpha ? 1 : 0);
2584 *q|=((pixel & 0x01) << (
unsigned char) (bit+4-1));
2585 p+=(ptrdiff_t) GetPixelChannels(image);
2596 for (x=0; x < (ssize_t) number_pixels ; x++)
2598 pixel=(
unsigned char) ((ssize_t) GetPixelIndex(image,p));
2599 *q=((pixel & 0xf) << 4);
2600 pixel=(
unsigned char) (16.0*QuantumScale*(
double)
2601 GetPixelAlpha(image,p)+0.5);
2602 *q|=((pixel & 0xf) << 0);
2603 p+=(ptrdiff_t) GetPixelChannels(image);
2613 for (x=0; x < (ssize_t) number_pixels; x++)
2615 q=PopCharPixel((
unsigned char) ((ssize_t) GetPixelIndex(image,p)),q);
2616 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
2617 q=PopCharPixel(pixel,q);
2618 p+=(ptrdiff_t) GetPixelChannels(image);
2619 q+=(ptrdiff_t) quantum_info->pad;
2628 if (quantum_info->format == FloatingPointQuantumFormat)
2630 for (x=0; x < (ssize_t) number_pixels; x++)
2632 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2633 ((ssize_t) GetPixelIndex(image,p)),q);
2634 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2635 GetPixelAlpha(image,p));
2636 q=PopShortPixel(quantum_info->endian,pixel,q);
2637 p+=(ptrdiff_t) GetPixelChannels(image);
2638 q+=(ptrdiff_t) quantum_info->pad;
2642 for (x=0; x < (ssize_t) number_pixels; x++)
2644 q=PopShortPixel(quantum_info->endian,(
unsigned short)
2645 ((ssize_t) GetPixelIndex(image,p)),q);
2646 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
2647 q=PopShortPixel(quantum_info->endian,pixel,q);
2648 p+=(ptrdiff_t) GetPixelChannels(image);
2649 q+=(ptrdiff_t) quantum_info->pad;
2658 if (quantum_info->format == FloatingPointQuantumFormat)
2660 for (x=0; x < (ssize_t) number_pixels; x++)
2665 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelIndex(image,p),q);
2666 float_pixel=(float) GetPixelAlpha(image,p);
2667 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
2668 p+=(ptrdiff_t) GetPixelChannels(image);
2669 q+=(ptrdiff_t) quantum_info->pad;
2673 for (x=0; x < (ssize_t) number_pixels; x++)
2675 q=PopLongPixel(quantum_info->endian,(
unsigned int)
2676 GetPixelIndex(image,p),q);
2677 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
2678 q=PopLongPixel(quantum_info->endian,pixel,q);
2679 p+=(ptrdiff_t) GetPixelChannels(image);
2680 q+=(ptrdiff_t) quantum_info->pad;
2686 if (quantum_info->format == FloatingPointQuantumFormat)
2688 for (x=0; x < (ssize_t) number_pixels; x++)
2693 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelIndex(image,p),q);
2694 pixel=(double) GetPixelAlpha(image,p);
2695 q=PopQuantumDoublePixel(quantum_info,pixel,q);
2696 p+=(ptrdiff_t) GetPixelChannels(image);
2697 q+=(ptrdiff_t) quantum_info->pad;
2708 range=GetQuantumRange(quantum_info->depth);
2709 for (x=0; x < (ssize_t) number_pixels; x++)
2711 q=PopQuantumPixel(quantum_info,(QuantumAny) GetPixelIndex(image,p),q);
2712 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
2714 p+=(ptrdiff_t) GetPixelChannels(image);
2715 q+=(ptrdiff_t) quantum_info->pad;
2722static void ExportMultispectralQuantum(
const Image *image,
2723 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
2724 const Quantum *magick_restrict p,
unsigned char *magick_restrict q,
2725 ExceptionInfo *exception)
2731 if (image->number_meta_channels == 0)
2733 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2734 "MultispectralImageRequired",
"`%s'",image->filename);
2737 if (quantum_info->meta_channel != 0)
2739 ExportPixelChannel(image,quantum_info,number_pixels,p,q,
2740 (PixelChannel) (MetaPixelChannels+quantum_info->meta_channel-1));
2743 switch (quantum_info->depth)
2750 for (x=0; x < (ssize_t) number_pixels; x++)
2752 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2754 pixel=ScaleQuantumToChar(p[i]);
2755 q=PopCharPixel(pixel,q);
2757 p+=(ptrdiff_t) GetPixelChannels(image);
2758 q+=(ptrdiff_t) quantum_info->pad;
2767 if (quantum_info->format == FloatingPointQuantumFormat)
2769 for (x=0; x < (ssize_t) number_pixels; x++)
2771 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2773 pixel=SinglePrecisionToHalf(QuantumScale*(
double) p[i]);
2774 q=PopShortPixel(quantum_info->endian,pixel,q);
2776 p+=(ptrdiff_t) GetPixelChannels(image);
2777 q+=(ptrdiff_t) quantum_info->pad;
2781 for (x=0; x < (ssize_t) number_pixels; x++)
2783 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2785 pixel=ScaleQuantumToShort(p[i]);
2786 q=PopShortPixel(quantum_info->endian,pixel,q);
2788 p+=(ptrdiff_t) GetPixelChannels(image);
2789 q+=(ptrdiff_t) quantum_info->pad;
2798 if (quantum_info->format == FloatingPointQuantumFormat)
2800 for (x=0; x < (ssize_t) number_pixels; x++)
2802 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2803 q=PopQuantumFloatPixel(quantum_info,(
float) p[i],q);
2804 p+=(ptrdiff_t) GetPixelChannels(image);
2805 q+=(ptrdiff_t) quantum_info->pad;
2809 for (x=0; x < (ssize_t) number_pixels; x++)
2811 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2813 pixel=ScaleQuantumToLong(p[i]);
2814 q=PopLongPixel(quantum_info->endian,pixel,q);
2816 p+=(ptrdiff_t) GetPixelChannels(image);
2817 q+=(ptrdiff_t) quantum_info->pad;
2823 if (quantum_info->format == FloatingPointQuantumFormat)
2825 for (x=0; x < (ssize_t) number_pixels; x++)
2827 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2828 q=PopQuantumDoublePixel(quantum_info,(
double) p[i],q);
2829 p+=(ptrdiff_t) GetPixelChannels(image);
2830 q+=(ptrdiff_t) quantum_info->pad;
2841 range=GetQuantumRange(quantum_info->depth);
2842 for (x=0; x < (ssize_t) number_pixels; x++)
2844 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
2845 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(p[i],range),q);
2846 p+=(ptrdiff_t) GetPixelChannels(image);
2847 q+=(ptrdiff_t) quantum_info->pad;
2854static void ExportOpacityQuantum(
const Image *image,QuantumInfo *quantum_info,
2855 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
2856 unsigned char *magick_restrict q,ExceptionInfo *exception)
2864 if (image->alpha_trait == UndefinedPixelTrait)
2866 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2867 "ImageDoesNotHaveAnAlphaChannel",
"`%s'",image->filename);
2870 switch (quantum_info->depth)
2877 for (x=0; x < (ssize_t) number_pixels; x++)
2879 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
2880 q=PopCharPixel(pixel,q);
2881 p+=(ptrdiff_t) GetPixelChannels(image);
2882 q+=(ptrdiff_t) quantum_info->pad;
2891 if (quantum_info->format == FloatingPointQuantumFormat)
2893 for (x=0; x < (ssize_t) number_pixels; x++)
2895 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
2896 GetPixelOpacity(image,p));
2897 q=PopShortPixel(quantum_info->endian,pixel,q);
2898 p+=(ptrdiff_t) GetPixelChannels(image);
2899 q+=(ptrdiff_t) quantum_info->pad;
2903 for (x=0; x < (ssize_t) number_pixels; x++)
2905 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
2906 q=PopShortPixel(quantum_info->endian,pixel,q);
2907 p+=(ptrdiff_t) GetPixelChannels(image);
2908 q+=(ptrdiff_t) quantum_info->pad;
2917 if (quantum_info->format == FloatingPointQuantumFormat)
2919 for (x=0; x < (ssize_t) number_pixels; x++)
2921 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelOpacity(image,p),q);
2922 p+=(ptrdiff_t) GetPixelChannels(image);
2923 q+=(ptrdiff_t) quantum_info->pad;
2927 for (x=0; x < (ssize_t) number_pixels; x++)
2929 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
2930 q=PopLongPixel(quantum_info->endian,pixel,q);
2931 p+=(ptrdiff_t) GetPixelChannels(image);
2932 q+=(ptrdiff_t) quantum_info->pad;
2938 if (quantum_info->format == FloatingPointQuantumFormat)
2940 for (x=0; x < (ssize_t) number_pixels; x++)
2942 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelOpacity(image,p),q);
2943 p+=(ptrdiff_t) GetPixelChannels(image);
2944 q+=(ptrdiff_t) quantum_info->pad;
2952 range=GetQuantumRange(quantum_info->depth);
2953 for (x=0; x < (ssize_t) number_pixels; x++)
2955 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
2956 GetPixelOpacity(image,p),range),q);
2957 p+=(ptrdiff_t) GetPixelChannels(image);
2958 q+=(ptrdiff_t) quantum_info->pad;
2965static void ExportRGBQuantum(
const Image *image,QuantumInfo *quantum_info,
2966 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
2967 unsigned char *magick_restrict q)
2978 switch (quantum_info->depth)
2982 for (x=0; x < (ssize_t) number_pixels; x++)
2984 q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
2985 q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
2986 q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
2987 p+=(ptrdiff_t) GetPixelChannels(image);
2988 q+=(ptrdiff_t) quantum_info->pad;
2997 range=GetQuantumRange(quantum_info->depth);
2998 if (quantum_info->pack == MagickFalse)
3000 for (x=0; x < (ssize_t) number_pixels; x++)
3002 pixel=(
unsigned int) (
3003 ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
3004 ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
3005 ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
3006 q=PopLongPixel(quantum_info->endian,pixel,q);
3007 p+=(ptrdiff_t) GetPixelChannels(image);
3008 q+=(ptrdiff_t) quantum_info->pad;
3012 if (quantum_info->quantum == 32UL)
3014 for (x=0; x < (ssize_t) number_pixels; x++)
3016 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3017 q=PopQuantumLongPixel(quantum_info,pixel,q);
3018 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3020 q=PopQuantumLongPixel(quantum_info,pixel,q);
3021 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3022 q=PopQuantumLongPixel(quantum_info,pixel,q);
3023 p+=(ptrdiff_t) GetPixelChannels(image);
3024 q+=(ptrdiff_t) quantum_info->pad;
3028 for (x=0; x < (ssize_t) number_pixels; x++)
3030 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3031 q=PopQuantumPixel(quantum_info,pixel,q);
3032 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3033 q=PopQuantumPixel(quantum_info,pixel,q);
3034 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3035 q=PopQuantumPixel(quantum_info,pixel,q);
3036 p+=(ptrdiff_t) GetPixelChannels(image);
3037 q+=(ptrdiff_t) quantum_info->pad;
3046 range=GetQuantumRange(quantum_info->depth);
3047 if (quantum_info->pack == MagickFalse)
3049 for (x=0; x < (3*(ssize_t) number_pixels-1); x+=2)
3056 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3062 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3068 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3070 p+=(ptrdiff_t) GetPixelChannels(image);
3074 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3077 q+=(ptrdiff_t) quantum_info->pad;
3083 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3089 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3095 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3097 p+=(ptrdiff_t) GetPixelChannels(image);
3101 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3103 if (((x+1) % 3) == 2)
3104 q+=(ptrdiff_t) quantum_info->pad;
3106 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3108 switch ((x+bit) % 3)
3113 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
3119 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3125 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
3127 p+=(ptrdiff_t) GetPixelChannels(image);
3131 q=PopShortPixel(quantum_info->endian,(
unsigned short) (pixel << 4),
3133 if (((x+bit) % 3) == 2)
3134 q+=(ptrdiff_t) quantum_info->pad;
3137 p+=(ptrdiff_t) GetPixelChannels(image);
3140 if (quantum_info->quantum == 32UL)
3142 for (x=0; x < (ssize_t) number_pixels; x++)
3144 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3145 q=PopQuantumLongPixel(quantum_info,pixel,q);
3146 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3148 q=PopQuantumLongPixel(quantum_info,pixel,q);
3149 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3150 q=PopQuantumLongPixel(quantum_info,pixel,q);
3151 p+=(ptrdiff_t) GetPixelChannels(image);
3152 q+=(ptrdiff_t) quantum_info->pad;
3156 for (x=0; x < (ssize_t) number_pixels; x++)
3158 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3159 q=PopQuantumPixel(quantum_info,pixel,q);
3160 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3161 q=PopQuantumPixel(quantum_info,pixel,q);
3162 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3163 q=PopQuantumPixel(quantum_info,pixel,q);
3164 p+=(ptrdiff_t) GetPixelChannels(image);
3165 q+=(ptrdiff_t) quantum_info->pad;
3174 if (quantum_info->format == FloatingPointQuantumFormat)
3176 for (x=0; x < (ssize_t) number_pixels; x++)
3178 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3179 GetPixelRed(image,p));
3180 q=PopShortPixel(quantum_info->endian,pixel,q);
3181 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3182 GetPixelGreen(image,p));
3183 q=PopShortPixel(quantum_info->endian,pixel,q);
3184 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3185 GetPixelBlue(image,p));
3186 q=PopShortPixel(quantum_info->endian,pixel,q);
3187 p+=(ptrdiff_t) GetPixelChannels(image);
3188 q+=(ptrdiff_t) quantum_info->pad;
3192 for (x=0; x < (ssize_t) number_pixels; x++)
3194 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3195 q=PopShortPixel(quantum_info->endian,pixel,q);
3196 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3197 q=PopShortPixel(quantum_info->endian,pixel,q);
3198 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3199 q=PopShortPixel(quantum_info->endian,pixel,q);
3200 p+=(ptrdiff_t) GetPixelChannels(image);
3201 q+=(ptrdiff_t) quantum_info->pad;
3210 if (quantum_info->format == FloatingPointQuantumFormat)
3212 for (x=0; x < (ssize_t) number_pixels; x++)
3214 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),
3216 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),
3218 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),
3220 p+=(ptrdiff_t) GetPixelChannels(image);
3221 q+=(ptrdiff_t) quantum_info->pad;
3225 for (x=0; x < (ssize_t) number_pixels; x++)
3227 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3228 q=PopLongPixel(quantum_info->endian,pixel,q);
3229 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3230 q=PopLongPixel(quantum_info->endian,pixel,q);
3231 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3232 q=PopLongPixel(quantum_info->endian,pixel,q);
3233 p+=(ptrdiff_t) GetPixelChannels(image);
3234 q+=(ptrdiff_t) quantum_info->pad;
3240 if (quantum_info->format == FloatingPointQuantumFormat)
3242 for (x=0; x < (ssize_t) number_pixels; x++)
3244 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
3245 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
3246 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
3247 p+=(ptrdiff_t) GetPixelChannels(image);
3248 q+=(ptrdiff_t) quantum_info->pad;
3256 range=GetQuantumRange(quantum_info->depth);
3257 for (x=0; x < (ssize_t) number_pixels; x++)
3259 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3261 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3263 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3265 p+=(ptrdiff_t) GetPixelChannels(image);
3266 q+=(ptrdiff_t) quantum_info->pad;
3273static void ExportRGBAQuantum(
const Image *image,QuantumInfo *quantum_info,
3274 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
3275 unsigned char *magick_restrict q)
3283 switch (quantum_info->depth)
3290 for (x=0; x < (ssize_t) number_pixels; x++)
3292 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3293 q=PopCharPixel(pixel,q);
3294 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3295 q=PopCharPixel(pixel,q);
3296 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3297 q=PopCharPixel(pixel,q);
3298 pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
3299 q=PopCharPixel(pixel,q);
3300 p+=(ptrdiff_t) GetPixelChannels(image);
3301 q+=(ptrdiff_t) quantum_info->pad;
3310 range=GetQuantumRange(quantum_info->depth);
3311 if (quantum_info->pack == MagickFalse)
3325 for (x=0; x < (ssize_t) number_pixels; x++)
3327 for (i=0; i < 4; i++)
3331 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
3332 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
3333 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
3334 case 3: quantum=(size_t) GetPixelAlpha(image,p);
break;
3340 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3346 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3352 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3354 q=PopLongPixel(quantum_info->endian,pixel,q);
3361 p+=(ptrdiff_t) GetPixelChannels(image);
3362 q+=(ptrdiff_t) quantum_info->pad;
3366 if (quantum_info->quantum == 32UL)
3368 for (x=0; x < (ssize_t) number_pixels; x++)
3370 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3371 q=PopQuantumLongPixel(quantum_info,pixel,q);
3372 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3374 q=PopQuantumLongPixel(quantum_info,pixel,q);
3375 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3376 q=PopQuantumLongPixel(quantum_info,pixel,q);
3377 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
3379 q=PopQuantumLongPixel(quantum_info,pixel,q);
3380 p+=(ptrdiff_t) GetPixelChannels(image);
3381 q+=(ptrdiff_t) quantum_info->pad;
3385 for (x=0; x < (ssize_t) number_pixels; x++)
3387 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3388 q=PopQuantumPixel(quantum_info,pixel,q);
3389 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3390 q=PopQuantumPixel(quantum_info,pixel,q);
3391 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3392 q=PopQuantumPixel(quantum_info,pixel,q);
3393 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
3394 q=PopQuantumPixel(quantum_info,pixel,q);
3395 p+=(ptrdiff_t) GetPixelChannels(image);
3396 q+=(ptrdiff_t) quantum_info->pad;
3405 if (quantum_info->format == FloatingPointQuantumFormat)
3407 for (x=0; x < (ssize_t) number_pixels; x++)
3409 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3410 GetPixelRed(image,p));
3411 q=PopShortPixel(quantum_info->endian,pixel,q);
3412 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3413 GetPixelGreen(image,p));
3414 q=PopShortPixel(quantum_info->endian,pixel,q);
3415 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3416 GetPixelBlue(image,p));
3417 q=PopShortPixel(quantum_info->endian,pixel,q);
3418 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3419 GetPixelAlpha(image,p));
3420 q=PopShortPixel(quantum_info->endian,pixel,q);
3421 p+=(ptrdiff_t) GetPixelChannels(image);
3422 q+=(ptrdiff_t) quantum_info->pad;
3426 for (x=0; x < (ssize_t) number_pixels; x++)
3428 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3429 q=PopShortPixel(quantum_info->endian,pixel,q);
3430 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3431 q=PopShortPixel(quantum_info->endian,pixel,q);
3432 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3433 q=PopShortPixel(quantum_info->endian,pixel,q);
3434 pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
3435 q=PopShortPixel(quantum_info->endian,pixel,q);
3436 p+=(ptrdiff_t) GetPixelChannels(image);
3437 q+=(ptrdiff_t) quantum_info->pad;
3446 if (quantum_info->format == FloatingPointQuantumFormat)
3448 for (x=0; x < (ssize_t) number_pixels; x++)
3453 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),q);
3454 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),q);
3455 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),q);
3456 float_pixel=(float) GetPixelAlpha(image,p);
3457 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3458 p+=(ptrdiff_t) GetPixelChannels(image);
3459 q+=(ptrdiff_t) quantum_info->pad;
3463 for (x=0; x < (ssize_t) number_pixels; x++)
3465 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3466 q=PopLongPixel(quantum_info->endian,pixel,q);
3467 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3468 q=PopLongPixel(quantum_info->endian,pixel,q);
3469 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3470 q=PopLongPixel(quantum_info->endian,pixel,q);
3471 pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
3472 q=PopLongPixel(quantum_info->endian,pixel,q);
3473 p+=(ptrdiff_t) GetPixelChannels(image);
3474 q+=(ptrdiff_t) quantum_info->pad;
3480 if (quantum_info->format == FloatingPointQuantumFormat)
3485 for (x=0; x < (ssize_t) number_pixels; x++)
3487 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelRed(image,p),q);
3488 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelGreen(image,p),q);
3489 q=PopQuantumDoublePixel(quantum_info,(
double) GetPixelBlue(image,p),q);
3490 pixel=(double) GetPixelAlpha(image,p);
3491 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3492 p+=(ptrdiff_t) GetPixelChannels(image);
3493 q+=(ptrdiff_t) quantum_info->pad;
3501 range=GetQuantumRange(quantum_info->depth);
3502 for (x=0; x < (ssize_t) number_pixels; x++)
3504 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3506 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3508 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3510 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
3512 p+=(ptrdiff_t) GetPixelChannels(image);
3513 q+=(ptrdiff_t) quantum_info->pad;
3520static void ExportRGBOQuantum(
const Image *image,QuantumInfo *quantum_info,
3521 const MagickSizeType number_pixels,
const Quantum *magick_restrict p,
3522 unsigned char *magick_restrict q)
3530 switch (quantum_info->depth)
3537 for (x=0; x < (ssize_t) number_pixels; x++)
3539 pixel=ScaleQuantumToChar(GetPixelRed(image,p));
3540 q=PopCharPixel(pixel,q);
3541 pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
3542 q=PopCharPixel(pixel,q);
3543 pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
3544 q=PopCharPixel(pixel,q);
3545 pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
3546 q=PopCharPixel(pixel,q);
3547 p+=(ptrdiff_t) GetPixelChannels(image);
3548 q+=(ptrdiff_t) quantum_info->pad;
3557 range=GetQuantumRange(quantum_info->depth);
3558 if (quantum_info->pack == MagickFalse)
3572 for (x=0; x < (ssize_t) number_pixels; x++)
3574 for (i=0; i < 4; i++)
3578 case 0: quantum=(size_t) GetPixelRed(image,p);
break;
3579 case 1: quantum=(size_t) GetPixelGreen(image,p);
break;
3580 case 2: quantum=(size_t) GetPixelBlue(image,p);
break;
3581 case 3: quantum=(size_t) GetPixelOpacity(image,p);
break;
3587 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3593 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3599 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
3601 q=PopLongPixel(quantum_info->endian,pixel,q);
3608 p+=(ptrdiff_t) GetPixelChannels(image);
3609 q+=(ptrdiff_t) quantum_info->pad;
3613 if (quantum_info->quantum == 32UL)
3615 for (x=0; x < (ssize_t) number_pixels; x++)
3617 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3618 q=PopQuantumLongPixel(quantum_info,pixel,q);
3619 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
3621 q=PopQuantumLongPixel(quantum_info,pixel,q);
3622 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3623 q=PopQuantumLongPixel(quantum_info,pixel,q);
3624 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),
3626 q=PopQuantumLongPixel(quantum_info,pixel,q);
3627 p+=(ptrdiff_t) GetPixelChannels(image);
3628 q+=(ptrdiff_t) quantum_info->pad;
3632 for (x=0; x < (ssize_t) number_pixels; x++)
3634 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
3635 q=PopQuantumPixel(quantum_info,pixel,q);
3636 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
3637 q=PopQuantumPixel(quantum_info,pixel,q);
3638 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
3639 q=PopQuantumPixel(quantum_info,pixel,q);
3640 pixel=(
unsigned int) ScaleQuantumToAny(GetPixelOpacity(image,p),range);
3641 q=PopQuantumPixel(quantum_info,pixel,q);
3642 p+=(ptrdiff_t) GetPixelChannels(image);
3643 q+=(ptrdiff_t) quantum_info->pad;
3652 if (quantum_info->format == FloatingPointQuantumFormat)
3654 for (x=0; x < (ssize_t) number_pixels; x++)
3656 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3657 GetPixelRed(image,p));
3658 q=PopShortPixel(quantum_info->endian,pixel,q);
3659 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3660 GetPixelGreen(image,p));
3661 q=PopShortPixel(quantum_info->endian,pixel,q);
3662 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3663 GetPixelBlue(image,p));
3664 q=PopShortPixel(quantum_info->endian,pixel,q);
3665 pixel=SinglePrecisionToHalf(QuantumScale*(
double)
3666 GetPixelOpacity(image,p));
3667 q=PopShortPixel(quantum_info->endian,pixel,q);
3668 p+=(ptrdiff_t) GetPixelChannels(image);
3669 q+=(ptrdiff_t) quantum_info->pad;
3673 for (x=0; x < (ssize_t) number_pixels; x++)
3675 pixel=ScaleQuantumToShort(GetPixelRed(image,p));
3676 q=PopShortPixel(quantum_info->endian,pixel,q);
3677 pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
3678 q=PopShortPixel(quantum_info->endian,pixel,q);
3679 pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
3680 q=PopShortPixel(quantum_info->endian,pixel,q);
3681 pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
3682 q=PopShortPixel(quantum_info->endian,pixel,q);
3683 p+=(ptrdiff_t) GetPixelChannels(image);
3684 q+=(ptrdiff_t) quantum_info->pad;
3693 if (quantum_info->format == FloatingPointQuantumFormat)
3695 for (x=0; x < (ssize_t) number_pixels; x++)
3700 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelRed(image,p),
3702 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelGreen(image,p),
3704 q=PopQuantumFloatPixel(quantum_info,(
float) GetPixelBlue(image,p),
3706 float_pixel=(float) GetPixelOpacity(image,p);
3707 q=PopQuantumFloatPixel(quantum_info,float_pixel,q);
3708 p+=(ptrdiff_t) GetPixelChannels(image);
3709 q+=(ptrdiff_t) quantum_info->pad;
3713 for (x=0; x < (ssize_t) number_pixels; x++)
3715 pixel=ScaleQuantumToLong(GetPixelRed(image,p));
3716 q=PopLongPixel(quantum_info->endian,pixel,q);
3717 pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
3718 q=PopLongPixel(quantum_info->endian,pixel,q);
3719 pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
3720 q=PopLongPixel(quantum_info->endian,pixel,q);
3721 pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
3722 q=PopLongPixel(quantum_info->endian,pixel,q);
3723 p+=(ptrdiff_t) GetPixelChannels(image);
3724 q+=(ptrdiff_t) quantum_info->pad;
3730 if (quantum_info->format == FloatingPointQuantumFormat)
3735 for (x=0; x < (ssize_t) number_pixels; x++)
3737 q=PopQuantumDoublePixel(quantum_info,(
double)
3738 GetPixelRed(image,p),q);
3739 q=PopQuantumDoublePixel(quantum_info,(
double)
3740 GetPixelGreen(image,p),q);
3741 q=PopQuantumDoublePixel(quantum_info,(
double)
3742 GetPixelBlue(image,p),q);
3743 pixel=(double) GetPixelOpacity(image,p);
3744 q=PopQuantumDoublePixel(quantum_info,pixel,q);
3745 p+=(ptrdiff_t) GetPixelChannels(image);
3746 q+=(ptrdiff_t) quantum_info->pad;
3754 range=GetQuantumRange(quantum_info->depth);
3755 for (x=0; x < (ssize_t) number_pixels; x++)
3757 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),
3759 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),
3761 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),
3763 q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
3765 p+=(ptrdiff_t) GetPixelChannels(image);
3766 q+=(ptrdiff_t) quantum_info->pad;
3773MagickExport
size_t ExportQuantumPixels(
const Image *image,
3774 CacheView *image_view,QuantumInfo *quantum_info,
3775 const QuantumType quantum_type,
unsigned char *magick_restrict pixels,
3776 ExceptionInfo *exception)
3793 assert(image != (Image *) NULL);
3794 assert(image->signature == MagickCoreSignature);
3795 assert(quantum_info != (QuantumInfo *) NULL);
3796 assert(quantum_info->signature == MagickCoreSignature);
3797 assert(exception != (ExceptionInfo *) NULL);
3798 assert(exception->signature == MagickCoreSignature);
3799 if (IsEventLogging() != MagickFalse)
3800 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3801 if (pixels == (
unsigned char *) NULL)
3802 pixels=(
unsigned char *) GetQuantumPixels(quantum_info);
3803 if (image_view == (CacheView *) NULL)
3805 number_pixels=GetImageExtent(image);
3806 p=GetVirtualPixelQueue(image);
3810 number_pixels=GetCacheViewExtent(image_view);
3811 p=GetCacheViewVirtualPixelQueue(image_view);
3813 if (p == (Quantum *) NULL)
3815 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
3826 if (image_view == (CacheView *) NULL)
3827 r=GetAuthenticPixelQueue(image);
3829 r=GetCacheViewAuthenticPixelQueue(image_view);
3830 for (x=0; x < (ssize_t) image->columns; x++)
3835 Sa=QuantumScale*(double) GetPixelAlpha(image,r);
3836 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
3838 PixelChannel channel = GetPixelChannelChannel(image,i);
3839 PixelTrait traits = GetPixelChannelTraits(image,channel);
3840 if ((traits & UpdatePixelTrait) == 0)
3842 r[i]=ClampToQuantum(Sa*(
double) r[i]);
3844 r+=(ptrdiff_t) GetPixelChannels(image);
3847 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3855 if (image_view == (CacheView *) NULL)
3856 r=GetAuthenticPixelQueue(image);
3858 r=GetCacheViewAuthenticPixelQueue(image_view);
3859 for (x=0; x < (ssize_t) number_pixels; x++)
3861 quantum=GetPixelRed(image,r);
3862 SetPixelRed(image,GetPixelGreen(image,r),r);
3863 SetPixelGreen(image,quantum,r);
3864 r+=(ptrdiff_t) GetPixelChannels(image);
3868 ResetQuantumState(quantum_info);
3869 extent=GetQuantumExtent(image,quantum_info,quantum_type);
3870 switch (quantum_type)
3874 ExportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
3879 ExportBGRQuantum(image,quantum_info,number_pixels,p,q);
3884 ExportBGRAQuantum(image,quantum_info,number_pixels,p,q);
3889 ExportBGROQuantum(image,quantum_info,number_pixels,p,q);
3894 ExportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
3900 ExportPixelChannel(image,quantum_info,number_pixels,p,q,BluePixelChannel);
3905 ExportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
3910 ExportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
3913 case MultispectralQuantum:
3915 ExportMultispectralQuantum(image,quantum_info,number_pixels,p,q,exception);
3920 ExportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
3925 ExportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
3930 ExportGrayQuantum(image,quantum_info,number_pixels,p,q);
3933 case GrayAlphaQuantum:
3935 ExportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
3939 case MagentaQuantum:
3941 ExportPixelChannel(image,quantum_info,number_pixels,p,q,
3947 ExportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
3950 case IndexAlphaQuantum:
3952 ExportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
3958 ExportPixelChannel(image,quantum_info,number_pixels,p,q,RedPixelChannel);
3961 case OpacityQuantum:
3963 ExportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
3969 ExportRGBQuantum(image,quantum_info,number_pixels,p,q);
3975 ExportRGBAQuantum(image,quantum_info,number_pixels,p,q);
3980 ExportRGBOQuantum(image,quantum_info,number_pixels,p,q);
3986 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3994 if (image_view == (CacheView *) NULL)
3995 r=GetAuthenticPixelQueue(image);
3997 r=GetCacheViewAuthenticPixelQueue(image_view);
3998 for (x=0; x < (ssize_t) number_pixels; x++)
4000 quantum=GetPixelRed(image,r);
4001 SetPixelRed(image,GetPixelGreen(image,r),r);
4002 SetPixelGreen(image,quantum,r);
4003 r+=(ptrdiff_t) GetPixelChannels(image);