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 Quantum PushColormapIndex(
const Image *image,
const size_t index,
113 MagickBooleanType *range_exception)
115 if (index < image->colors)
116 return((Quantum) index);
117 *range_exception=MagickTrue;
121static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
122 const unsigned char *magick_restrict pixels,
double *pixel)
130 if (quantum_info->endian == LSBEndian)
132 quantum[0]=(*pixels++);
133 quantum[1]=(*pixels++);
134 quantum[2]=(*pixels++);
135 quantum[3]=(*pixels++);
136 quantum[4]=(*pixels++);
137 quantum[5]=(*pixels++);
138 quantum[6]=(*pixels++);
139 quantum[7]=(*pixels++);
143 quantum[7]=(*pixels++);
144 quantum[6]=(*pixels++);
145 quantum[5]=(*pixels++);
146 quantum[4]=(*pixels++);
147 quantum[3]=(*pixels++);
148 quantum[2]=(*pixels++);
149 quantum[1]=(*pixels++);
150 quantum[0]=(*pixels++);
152 p=(
double *) quantum;
154 *pixel-=quantum_info->minimum;
155 *pixel*=quantum_info->scale;
159static inline float ScaleFloatPixel(
const QuantumInfo *quantum_info,
160 const unsigned char *quantum)
165 pixel=(double) (*((
float *) quantum));
166 pixel-=quantum_info->minimum;
167 pixel*=quantum_info->scale;
168 if (pixel < (
double) -FLT_MAX)
170 if (pixel > (
double) FLT_MAX)
172 return((
float) pixel);
175static inline const unsigned char *PushQuantumFloatPixel(
176 const QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,
182 if (quantum_info->endian == LSBEndian)
184 quantum[0]=(*pixels++);
185 quantum[1]=(*pixels++);
186 quantum[2]=(*pixels++);
187 quantum[3]=(*pixels++);
191 quantum[3]=(*pixels++);
192 quantum[2]=(*pixels++);
193 quantum[1]=(*pixels++);
194 quantum[0]=(*pixels++);
196 *pixel=ScaleFloatPixel(quantum_info,quantum);
200static inline const unsigned char *PushQuantumFloat24Pixel(
201 const QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,
220 if (quantum_info->endian == LSBEndian)
222 value=(
unsigned int) *pixels++;
223 value|=(
unsigned int) *pixels++ << 8;
224 value|=(
unsigned int) *pixels++ << 16;
228 value=(
unsigned int) *pixels++ << 16;
229 value|=(
unsigned int) *pixels++ << 8;
230 value|=(
unsigned int) *pixels++;
232 sign_bit=(value & 0x00800000U) << 8;
233 exponent=(value >> 16) & 0x7fU;
234 significand=value & 0xffffU;
237 if (significand != 0U)
240 while ((significand & 0x10000U) == 0U)
245 significand&=0xffffU;
249 exponent=exponent == 127U ? 255U : exponent+64U;
250 map.fixed_point=sign_bit | (exponent << 23) | (significand << 7);
251 *pixel=ScaleFloatPixel(quantum_info,(
const unsigned char *)
252 &map.single_precision);
256static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
257 const unsigned char *magick_restrict pixels,
unsigned int *quantum)
265 *quantum=(QuantumAny) 0;
266 for (i=(ssize_t) quantum_info->depth; i > 0L; )
268 if (quantum_info->state.bits == 0UL)
270 quantum_info->state.pixel=(*pixels++);
271 quantum_info->state.bits=8UL;
273 quantum_bits=(size_t) i;
274 if (quantum_bits > quantum_info->state.bits)
275 quantum_bits=quantum_info->state.bits;
276 i-=(ssize_t) quantum_bits;
277 quantum_info->state.bits-=quantum_bits;
278 if (quantum_bits < 64)
279 *quantum=(
unsigned int) (((MagickSizeType) *quantum << quantum_bits) |
280 ((quantum_info->state.pixel >> quantum_info->state.bits) &~
281 ((~0UL) << quantum_bits)));
286static inline const unsigned char *PushQuantumLongPixel(
287 QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,
288 unsigned int *quantum)
297 for (i=(ssize_t) quantum_info->depth; i > 0; )
299 if (quantum_info->state.bits == 0)
301 pixels=PushLongPixel(quantum_info->endian,pixels,
302 &quantum_info->state.pixel);
303 quantum_info->state.bits=32U;
305 quantum_bits=(size_t) i;
306 if (quantum_bits > quantum_info->state.bits)
307 quantum_bits=quantum_info->state.bits;
308 *quantum|=(((quantum_info->state.pixel >> (32U-quantum_info->state.bits)) &
309 quantum_info->state.mask[quantum_bits]) << ((ssize_t)
310 quantum_info->depth-i));
311 i-=(ssize_t) quantum_bits;
312 quantum_info->state.bits-=quantum_bits;
317static void ImportPixelChannel(
const Image *image,QuantumInfo *quantum_info,
318 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
319 Quantum *magick_restrict q,PixelChannel channel)
327 q+=(ptrdiff_t) image->channel_map[channel].offset;
328 switch (quantum_info->depth)
335 for (x=0; x < (ssize_t) number_pixels; x++)
337 p=PushCharPixel(p,&pixel);
338 *q=ScaleCharToQuantum(pixel);
339 p+=(ptrdiff_t) quantum_info->pad;
340 q+=(ptrdiff_t) GetPixelChannels(image);
349 if (quantum_info->format == FloatingPointQuantumFormat)
351 for (x=0; x < (ssize_t) number_pixels; x++)
353 p=PushShortPixel(quantum_info->endian,p,&pixel);
354 *q=ClampToQuantum((
double) QuantumRange*(
double)
355 HalfToSinglePrecision(pixel));
356 p+=(ptrdiff_t) quantum_info->pad;
357 q+=(ptrdiff_t) GetPixelChannels(image);
361 for (x=0; x < (ssize_t) number_pixels; x++)
363 p=PushShortPixel(quantum_info->endian,p,&pixel);
364 *q=ScaleShortToQuantum(pixel);
365 p+=(ptrdiff_t) quantum_info->pad;
366 q+=(ptrdiff_t) GetPixelChannels(image);
372 if (quantum_info->format == FloatingPointQuantumFormat)
377 for (x=0; x < (ssize_t) number_pixels; x++)
379 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
380 *q=ClampToQuantum(pixel);
381 p+=(ptrdiff_t) quantum_info->pad;
382 q+=(ptrdiff_t) GetPixelChannels(image);
391 for (x=0; x < (ssize_t) number_pixels; x++)
393 p=PushLongPixel(quantum_info->endian,p,&pixel);
394 *q=ScaleLongToQuantum(pixel);
395 p+=(ptrdiff_t) quantum_info->pad;
396 q+=(ptrdiff_t) GetPixelChannels(image);
403 if (quantum_info->format == FloatingPointQuantumFormat)
408 for (x=0; x < (ssize_t) number_pixels; x++)
410 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
411 *q=ClampToQuantum(pixel);
412 p+=(ptrdiff_t) quantum_info->pad;
413 q+=(ptrdiff_t) GetPixelChannels(image);
421 if (quantum_info->format == FloatingPointQuantumFormat)
426 for (x=0; x < (ssize_t) number_pixels; x++)
428 p=PushDoublePixel(quantum_info,p,&pixel);
429 *q=ClampToQuantum(pixel);
430 p+=(ptrdiff_t) quantum_info->pad;
431 q+=(ptrdiff_t) GetPixelChannels(image);
440 for (x=0; x < (ssize_t) number_pixels; x++)
442 p=PushLongLongPixel(quantum_info->endian,p,&pixel);
443 *q=ScaleLongLongToQuantum(pixel);
444 p+=(ptrdiff_t) quantum_info->pad;
445 q+=(ptrdiff_t) GetPixelChannels(image);
455 range=GetQuantumRange(quantum_info->depth);
456 for (x=0; x < (ssize_t) number_pixels; x++)
458 p=PushQuantumPixel(quantum_info,p,&pixel);
459 *q=ScaleAnyToQuantum(pixel,range);
460 p+=(ptrdiff_t) quantum_info->pad;
461 q+=(ptrdiff_t) GetPixelChannels(image);
468static void ImportAlphaQuantum(
const Image *image,QuantumInfo *quantum_info,
469 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
470 Quantum *magick_restrict q,ExceptionInfo *exception)
472 if (image->alpha_trait == UndefinedPixelTrait)
474 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
475 "ImageDoesNotHaveAnAlphaChannel",
"`%s'",image->filename);
478 ImportPixelChannel(image,quantum_info,number_pixels,p,q,AlphaPixelChannel);
481static void ImportBGRQuantum(
const Image *image,QuantumInfo *quantum_info,
482 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
483 Quantum *magick_restrict q)
494 assert(image != (Image *) NULL);
495 assert(image->signature == MagickCoreSignature);
496 switch (quantum_info->depth)
503 for (x=0; x < (ssize_t) number_pixels; x++)
505 p=PushCharPixel(p,&pixel);
506 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
507 p=PushCharPixel(p,&pixel);
508 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
509 p=PushCharPixel(p,&pixel);
510 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
511 SetPixelAlpha(image,OpaqueAlpha,q);
512 p+=(ptrdiff_t) quantum_info->pad;
513 q+=(ptrdiff_t) GetPixelChannels(image);
522 range=GetQuantumRange(quantum_info->depth);
523 if (quantum_info->pack == MagickFalse)
525 for (x=0; x < (ssize_t) number_pixels; x++)
527 p=PushLongPixel(quantum_info->endian,p,&pixel);
528 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
529 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
531 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
532 p+=(ptrdiff_t) quantum_info->pad;
533 q+=(ptrdiff_t) GetPixelChannels(image);
537 if (quantum_info->quantum == 32U)
539 for (x=0; x < (ssize_t) number_pixels; x++)
541 p=PushQuantumLongPixel(quantum_info,p,&pixel);
542 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
543 p=PushQuantumLongPixel(quantum_info,p,&pixel);
544 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
545 p=PushQuantumLongPixel(quantum_info,p,&pixel);
546 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
547 q+=(ptrdiff_t) GetPixelChannels(image);
551 for (x=0; x < (ssize_t) number_pixels; x++)
553 p=PushQuantumPixel(quantum_info,p,&pixel);
554 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
555 p=PushQuantumPixel(quantum_info,p,&pixel);
556 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
557 p=PushQuantumPixel(quantum_info,p,&pixel);
558 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
559 q+=(ptrdiff_t) GetPixelChannels(image);
565 range=GetQuantumRange(quantum_info->depth);
566 if (quantum_info->pack == MagickFalse)
571 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
573 p=PushShortPixel(quantum_info->endian,p,&pixel);
579 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
585 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
591 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
593 q+=(ptrdiff_t) GetPixelChannels(image);
594 p+=(ptrdiff_t) quantum_info->pad;
598 p=PushShortPixel(quantum_info->endian,p,&pixel);
604 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
610 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
616 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
618 q+=(ptrdiff_t) GetPixelChannels(image);
619 p+=(ptrdiff_t) quantum_info->pad;
624 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
626 p=PushShortPixel(quantum_info->endian,p,&pixel);
632 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
638 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
644 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
646 q+=(ptrdiff_t) GetPixelChannels(image);
647 p+=(ptrdiff_t) quantum_info->pad;
661 if (quantum_info->quantum == 32U)
663 for (x=0; x < (ssize_t) number_pixels; x++)
665 p=PushQuantumLongPixel(quantum_info,p,&pixel);
666 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
667 p=PushQuantumLongPixel(quantum_info,p,&pixel);
668 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
669 p=PushQuantumLongPixel(quantum_info,p,&pixel);
670 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
671 q+=(ptrdiff_t) GetPixelChannels(image);
675 for (x=0; x < (ssize_t) number_pixels; x++)
677 p=PushQuantumPixel(quantum_info,p,&pixel);
678 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
679 p=PushQuantumPixel(quantum_info,p,&pixel);
680 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
681 p=PushQuantumPixel(quantum_info,p,&pixel);
682 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
683 q+=(ptrdiff_t) GetPixelChannels(image);
693 if (quantum_info->format == FloatingPointQuantumFormat)
695 for (x=0; x < (ssize_t) number_pixels; x++)
697 p=PushShortPixel(quantum_info->endian,p,&pixel);
698 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
699 HalfToSinglePrecision(pixel)),q);
700 p=PushShortPixel(quantum_info->endian,p,&pixel);
701 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
702 HalfToSinglePrecision(pixel)),q);
703 p=PushShortPixel(quantum_info->endian,p,&pixel);
704 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
705 HalfToSinglePrecision(pixel)),q);
706 p+=(ptrdiff_t) quantum_info->pad;
707 q+=(ptrdiff_t) GetPixelChannels(image);
711 for (x=0; x < (ssize_t) number_pixels; x++)
713 p=PushShortPixel(quantum_info->endian,p,&pixel);
714 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
715 p=PushShortPixel(quantum_info->endian,p,&pixel);
716 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
717 p=PushShortPixel(quantum_info->endian,p,&pixel);
718 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
719 p+=(ptrdiff_t) quantum_info->pad;
720 q+=(ptrdiff_t) GetPixelChannels(image);
726 if (quantum_info->format == FloatingPointQuantumFormat)
731 for (x=0; x < (ssize_t) number_pixels; x++)
733 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
734 SetPixelRed(image,ClampToQuantum(pixel),q);
735 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
736 SetPixelGreen(image,ClampToQuantum(pixel),q);
737 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
738 SetPixelBlue(image,ClampToQuantum(pixel),q);
739 p+=(ptrdiff_t) quantum_info->pad;
740 q+=(ptrdiff_t) GetPixelChannels(image);
749 for (x=0; x < (ssize_t) number_pixels; x++)
751 p=PushLongPixel(quantum_info->endian,p,&pixel);
752 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
753 p=PushLongPixel(quantum_info->endian,p,&pixel);
754 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
755 p=PushLongPixel(quantum_info->endian,p,&pixel);
756 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
757 p+=(ptrdiff_t) quantum_info->pad;
758 q+=(ptrdiff_t) GetPixelChannels(image);
765 if (quantum_info->format == FloatingPointQuantumFormat)
770 for (x=0; x < (ssize_t) number_pixels; x++)
772 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
773 SetPixelRed(image,ClampToQuantum(pixel),q);
774 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
775 SetPixelGreen(image,ClampToQuantum(pixel),q);
776 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
777 SetPixelBlue(image,ClampToQuantum(pixel),q);
778 p+=(ptrdiff_t) quantum_info->pad;
779 q+=(ptrdiff_t) GetPixelChannels(image);
787 if (quantum_info->format == FloatingPointQuantumFormat)
792 for (x=0; x < (ssize_t) number_pixels; x++)
794 p=PushDoublePixel(quantum_info,p,&pixel);
795 SetPixelRed(image,ClampToQuantum(pixel),q);
796 p=PushDoublePixel(quantum_info,p,&pixel);
797 SetPixelGreen(image,ClampToQuantum(pixel),q);
798 p=PushDoublePixel(quantum_info,p,&pixel);
799 SetPixelBlue(image,ClampToQuantum(pixel),q);
800 p+=(ptrdiff_t) quantum_info->pad;
801 q+=(ptrdiff_t) GetPixelChannels(image);
812 range=GetQuantumRange(quantum_info->depth);
813 for (x=0; x < (ssize_t) number_pixels; x++)
815 p=PushQuantumPixel(quantum_info,p,&pixel);
816 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
817 p=PushQuantumPixel(quantum_info,p,&pixel);
818 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
819 p=PushQuantumPixel(quantum_info,p,&pixel);
820 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
821 q+=(ptrdiff_t) GetPixelChannels(image);
828static void ImportBGRAQuantum(
const Image *image,QuantumInfo *quantum_info,
829 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
830 Quantum *magick_restrict q)
838 assert(image != (Image *) NULL);
839 assert(image->signature == MagickCoreSignature);
840 switch (quantum_info->depth)
847 for (x=0; x < (ssize_t) number_pixels; x++)
849 p=PushCharPixel(p,&pixel);
850 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
851 p=PushCharPixel(p,&pixel);
852 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
853 p=PushCharPixel(p,&pixel);
854 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
855 p=PushCharPixel(p,&pixel);
856 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
857 p+=(ptrdiff_t) quantum_info->pad;
858 q+=(ptrdiff_t) GetPixelChannels(image);
868 if (quantum_info->pack == MagickFalse)
881 for (x=0; x < (ssize_t) number_pixels; x++)
883 for (i=0; i < 4; i++)
889 p=PushLongPixel(quantum_info->endian,p,&pixel);
890 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
891 (((pixel >> 22) & 0x3ff) << 6)));
896 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
897 (((pixel >> 12) & 0x3ff) << 6)));
902 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
903 (((pixel >> 2) & 0x3ff) << 6)));
909 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
910 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
911 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
912 case 3: SetPixelAlpha(image,(Quantum) quantum,q);
break;
916 p+=(ptrdiff_t) quantum_info->pad;
917 q+=(ptrdiff_t) GetPixelChannels(image);
921 for (x=0; x < (ssize_t) number_pixels; x++)
923 p=PushQuantumPixel(quantum_info,p,&pixel);
924 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
925 p=PushQuantumPixel(quantum_info,p,&pixel);
926 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
928 p=PushQuantumPixel(quantum_info,p,&pixel);
929 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
931 p=PushQuantumPixel(quantum_info,p,&pixel);
932 SetPixelAlpha(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
934 q+=(ptrdiff_t) GetPixelChannels(image);
943 if (quantum_info->format == FloatingPointQuantumFormat)
945 for (x=0; x < (ssize_t) number_pixels; x++)
947 p=PushShortPixel(quantum_info->endian,p,&pixel);
948 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
949 HalfToSinglePrecision(pixel)),q);
950 p=PushShortPixel(quantum_info->endian,p,&pixel);
951 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
952 HalfToSinglePrecision(pixel)),q);
953 p=PushShortPixel(quantum_info->endian,p,&pixel);
954 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
955 HalfToSinglePrecision(pixel)),q);
956 p=PushShortPixel(quantum_info->endian,p,&pixel);
957 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
958 HalfToSinglePrecision(pixel)),q);
959 p+=(ptrdiff_t) quantum_info->pad;
960 q+=(ptrdiff_t) GetPixelChannels(image);
964 for (x=0; x < (ssize_t) number_pixels; x++)
966 p=PushShortPixel(quantum_info->endian,p,&pixel);
967 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
968 p=PushShortPixel(quantum_info->endian,p,&pixel);
969 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
970 p=PushShortPixel(quantum_info->endian,p,&pixel);
971 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
972 p=PushShortPixel(quantum_info->endian,p,&pixel);
973 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
974 p+=(ptrdiff_t) quantum_info->pad;
975 q+=(ptrdiff_t) GetPixelChannels(image);
981 if (quantum_info->format == FloatingPointQuantumFormat)
986 for (x=0; x < (ssize_t) number_pixels; x++)
988 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
989 SetPixelRed(image,ClampToQuantum(pixel),q);
990 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
991 SetPixelGreen(image,ClampToQuantum(pixel),q);
992 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
993 SetPixelBlue(image,ClampToQuantum(pixel),q);
994 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
995 SetPixelAlpha(image,ClampToQuantum(pixel),q);
996 p+=(ptrdiff_t) quantum_info->pad;
997 q+=(ptrdiff_t) GetPixelChannels(image);
1006 for (x=0; x < (ssize_t) number_pixels; x++)
1008 p=PushLongPixel(quantum_info->endian,p,&pixel);
1009 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1010 p=PushLongPixel(quantum_info->endian,p,&pixel);
1011 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1012 p=PushLongPixel(quantum_info->endian,p,&pixel);
1013 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1014 p=PushLongPixel(quantum_info->endian,p,&pixel);
1015 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
1016 p+=(ptrdiff_t) quantum_info->pad;
1017 q+=(ptrdiff_t) GetPixelChannels(image);
1024 if (quantum_info->format == FloatingPointQuantumFormat)
1029 for (x=0; x < (ssize_t) number_pixels; x++)
1031 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1032 SetPixelRed(image,ClampToQuantum(pixel),q);
1033 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1034 SetPixelGreen(image,ClampToQuantum(pixel),q);
1035 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1036 SetPixelBlue(image,ClampToQuantum(pixel),q);
1037 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1038 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1039 p+=(ptrdiff_t) quantum_info->pad;
1040 q+=(ptrdiff_t) GetPixelChannels(image);
1048 if (quantum_info->format == FloatingPointQuantumFormat)
1053 for (x=0; x < (ssize_t) number_pixels; x++)
1055 p=PushDoublePixel(quantum_info,p,&pixel);
1056 SetPixelRed(image,ClampToQuantum(pixel),q);
1057 p=PushDoublePixel(quantum_info,p,&pixel);
1058 SetPixelGreen(image,ClampToQuantum(pixel),q);
1059 p=PushDoublePixel(quantum_info,p,&pixel);
1060 SetPixelBlue(image,ClampToQuantum(pixel),q);
1061 p=PushDoublePixel(quantum_info,p,&pixel);
1062 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1063 p+=(ptrdiff_t) quantum_info->pad;
1064 q+=(ptrdiff_t) GetPixelChannels(image);
1075 range=GetQuantumRange(quantum_info->depth);
1076 for (x=0; x < (ssize_t) number_pixels; x++)
1078 p=PushQuantumPixel(quantum_info,p,&pixel);
1079 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1080 p=PushQuantumPixel(quantum_info,p,&pixel);
1081 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1082 p=PushQuantumPixel(quantum_info,p,&pixel);
1083 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1084 p=PushQuantumPixel(quantum_info,p,&pixel);
1085 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1086 q+=(ptrdiff_t) GetPixelChannels(image);
1093static void ImportBGROQuantum(
const Image *image,QuantumInfo *quantum_info,
1094 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1095 Quantum *magick_restrict q)
1103 assert(image != (Image *) NULL);
1104 assert(image->signature == MagickCoreSignature);
1105 switch (quantum_info->depth)
1112 for (x=0; x < (ssize_t) number_pixels; x++)
1114 p=PushCharPixel(p,&pixel);
1115 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1116 p=PushCharPixel(p,&pixel);
1117 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1118 p=PushCharPixel(p,&pixel);
1119 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1120 p=PushCharPixel(p,&pixel);
1121 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
1122 p+=(ptrdiff_t) quantum_info->pad;
1123 q+=(ptrdiff_t) GetPixelChannels(image);
1133 if (quantum_info->pack == MagickFalse)
1146 for (x=0; x < (ssize_t) number_pixels; x++)
1148 for (i=0; i < 4; i++)
1154 p=PushLongPixel(quantum_info->endian,p,&pixel);
1155 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1156 (((pixel >> 22) & 0x3ff) << 6)));
1161 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1162 (((pixel >> 12) & 0x3ff) << 6)));
1167 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1168 (((pixel >> 2) & 0x3ff) << 6)));
1174 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
1175 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
1176 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
1177 case 3: SetPixelOpacity(image,(Quantum) quantum,q);
break;
1181 p+=(ptrdiff_t) quantum_info->pad;
1182 q+=(ptrdiff_t) GetPixelChannels(image);
1186 for (x=0; x < (ssize_t) number_pixels; x++)
1188 p=PushQuantumPixel(quantum_info,p,&pixel);
1189 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
1190 p=PushQuantumPixel(quantum_info,p,&pixel);
1191 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
1193 p=PushQuantumPixel(quantum_info,p,&pixel);
1194 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
1196 p=PushQuantumPixel(quantum_info,p,&pixel);
1197 SetPixelOpacity(image,ScaleShortToQuantum((
unsigned short)
1199 q+=(ptrdiff_t) GetPixelChannels(image);
1208 if (quantum_info->format == FloatingPointQuantumFormat)
1210 for (x=0; x < (ssize_t) number_pixels; x++)
1212 p=PushShortPixel(quantum_info->endian,p,&pixel);
1213 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
1214 HalfToSinglePrecision(pixel)),q);
1215 p=PushShortPixel(quantum_info->endian,p,&pixel);
1216 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
1217 HalfToSinglePrecision(pixel)),q);
1218 p=PushShortPixel(quantum_info->endian,p,&pixel);
1219 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1220 HalfToSinglePrecision(pixel)),q);
1221 p=PushShortPixel(quantum_info->endian,p,&pixel);
1222 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
1223 HalfToSinglePrecision(pixel)),q);
1224 p+=(ptrdiff_t) quantum_info->pad;
1225 q+=(ptrdiff_t) GetPixelChannels(image);
1229 for (x=0; x < (ssize_t) number_pixels; x++)
1231 p=PushShortPixel(quantum_info->endian,p,&pixel);
1232 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1233 p=PushShortPixel(quantum_info->endian,p,&pixel);
1234 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1235 p=PushShortPixel(quantum_info->endian,p,&pixel);
1236 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1237 p=PushShortPixel(quantum_info->endian,p,&pixel);
1238 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
1239 p+=(ptrdiff_t) quantum_info->pad;
1240 q+=(ptrdiff_t) GetPixelChannels(image);
1246 if (quantum_info->format == FloatingPointQuantumFormat)
1251 for (x=0; x < (ssize_t) number_pixels; x++)
1253 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1254 SetPixelRed(image,ClampToQuantum(pixel),q);
1255 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1256 SetPixelGreen(image,ClampToQuantum(pixel),q);
1257 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1258 SetPixelBlue(image,ClampToQuantum(pixel),q);
1259 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1260 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1261 p+=(ptrdiff_t) quantum_info->pad;
1262 q+=(ptrdiff_t) GetPixelChannels(image);
1271 for (x=0; x < (ssize_t) number_pixels; x++)
1273 p=PushLongPixel(quantum_info->endian,p,&pixel);
1274 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1275 p=PushLongPixel(quantum_info->endian,p,&pixel);
1276 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1277 p=PushLongPixel(quantum_info->endian,p,&pixel);
1278 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1279 p=PushLongPixel(quantum_info->endian,p,&pixel);
1280 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
1281 p+=(ptrdiff_t) quantum_info->pad;
1282 q+=(ptrdiff_t) GetPixelChannels(image);
1289 if (quantum_info->format == FloatingPointQuantumFormat)
1294 for (x=0; x < (ssize_t) number_pixels; x++)
1296 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1297 SetPixelRed(image,ClampToQuantum(pixel),q);
1298 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1299 SetPixelGreen(image,ClampToQuantum(pixel),q);
1300 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1301 SetPixelBlue(image,ClampToQuantum(pixel),q);
1302 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1303 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1304 p+=(ptrdiff_t) quantum_info->pad;
1305 q+=(ptrdiff_t) GetPixelChannels(image);
1313 if (quantum_info->format == FloatingPointQuantumFormat)
1318 for (x=0; x < (ssize_t) number_pixels; x++)
1320 p=PushDoublePixel(quantum_info,p,&pixel);
1321 SetPixelRed(image,ClampToQuantum(pixel),q);
1322 p=PushDoublePixel(quantum_info,p,&pixel);
1323 SetPixelGreen(image,ClampToQuantum(pixel),q);
1324 p=PushDoublePixel(quantum_info,p,&pixel);
1325 SetPixelBlue(image,ClampToQuantum(pixel),q);
1326 p=PushDoublePixel(quantum_info,p,&pixel);
1327 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1328 p+=(ptrdiff_t) quantum_info->pad;
1329 q+=(ptrdiff_t) GetPixelChannels(image);
1340 range=GetQuantumRange(quantum_info->depth);
1341 for (x=0; x < (ssize_t) number_pixels; x++)
1343 p=PushQuantumPixel(quantum_info,p,&pixel);
1344 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1345 p=PushQuantumPixel(quantum_info,p,&pixel);
1346 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1347 p=PushQuantumPixel(quantum_info,p,&pixel);
1348 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1349 p=PushQuantumPixel(quantum_info,p,&pixel);
1350 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
1351 q+=(ptrdiff_t) GetPixelChannels(image);
1358static void ImportBlackQuantum(
const Image *image,QuantumInfo *quantum_info,
1359 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1360 Quantum *magick_restrict q,ExceptionInfo *exception)
1362 if (image->colorspace != CMYKColorspace)
1364 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1365 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1368 ImportPixelChannel(image,quantum_info,number_pixels,p,q,BlackPixelChannel);
1371static void ImportCbYCrYQuantum(
const Image *image,QuantumInfo *quantum_info,
1372 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1373 Quantum *magick_restrict q)
1384 assert(image != (Image *) NULL);
1385 assert(image->signature == MagickCoreSignature);
1386 switch (quantum_info->depth)
1394 if (quantum_info->pack == MagickFalse)
1407 for (x=0; x < ((ssize_t) number_pixels-3); x+=4)
1409 for (i=0; i < 4; i++)
1415 p=PushLongPixel(quantum_info->endian,p,&pixel);
1416 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1417 (((pixel >> 22) & 0x3ff) << 6)));
1422 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1423 (((pixel >> 12) & 0x3ff) << 6)));
1428 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1429 (((pixel >> 2) & 0x3ff) << 6)));
1433 cbcr[i]=(Quantum) (quantum);
1436 p+=(ptrdiff_t) quantum_info->pad;
1437 SetPixelRed(image,cbcr[1],q);
1438 SetPixelGreen(image,cbcr[0],q);
1439 SetPixelBlue(image,cbcr[2],q);
1440 q+=(ptrdiff_t) GetPixelChannels(image);
1441 SetPixelRed(image,cbcr[3],q);
1442 SetPixelGreen(image,cbcr[0],q);
1443 SetPixelBlue(image,cbcr[2],q);
1444 q+=(ptrdiff_t) GetPixelChannels(image);
1452 range=GetQuantumRange(quantum_info->depth);
1453 for (x=0; x < (ssize_t) number_pixels; x++)
1455 p=PushQuantumPixel(quantum_info,p,&pixel);
1456 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1457 p=PushQuantumPixel(quantum_info,p,&pixel);
1458 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1459 q+=(ptrdiff_t) GetPixelChannels(image);
1466static void ImportCMYKQuantum(
const Image *image,QuantumInfo *quantum_info,
1467 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1468 Quantum *magick_restrict q,ExceptionInfo *exception)
1476 if (image->colorspace != CMYKColorspace)
1478 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1479 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1482 switch (quantum_info->depth)
1489 for (x=0; x < (ssize_t) number_pixels; x++)
1491 p=PushCharPixel(p,&pixel);
1492 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1493 p=PushCharPixel(p,&pixel);
1494 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1495 p=PushCharPixel(p,&pixel);
1496 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1497 p=PushCharPixel(p,&pixel);
1498 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1499 p+=(ptrdiff_t) quantum_info->pad;
1500 q+=(ptrdiff_t) GetPixelChannels(image);
1509 if (quantum_info->format == FloatingPointQuantumFormat)
1511 for (x=0; x < (ssize_t) number_pixels; x++)
1513 p=PushShortPixel(quantum_info->endian,p,&pixel);
1514 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
1515 HalfToSinglePrecision(pixel)),q);
1516 p=PushShortPixel(quantum_info->endian,p,&pixel);
1517 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
1518 HalfToSinglePrecision(pixel)),q);
1519 p=PushShortPixel(quantum_info->endian,p,&pixel);
1520 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1521 HalfToSinglePrecision(pixel)),q);
1522 p=PushShortPixel(quantum_info->endian,p,&pixel);
1523 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*(
double)
1524 HalfToSinglePrecision(pixel)),q);
1525 p+=(ptrdiff_t) quantum_info->pad;
1526 q+=(ptrdiff_t) GetPixelChannels(image);
1530 for (x=0; x < (ssize_t) number_pixels; x++)
1532 p=PushShortPixel(quantum_info->endian,p,&pixel);
1533 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1534 p=PushShortPixel(quantum_info->endian,p,&pixel);
1535 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1536 p=PushShortPixel(quantum_info->endian,p,&pixel);
1537 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1538 p=PushShortPixel(quantum_info->endian,p,&pixel);
1539 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1540 p+=(ptrdiff_t) quantum_info->pad;
1541 q+=(ptrdiff_t) GetPixelChannels(image);
1547 if (quantum_info->format == FloatingPointQuantumFormat)
1552 for (x=0; x < (ssize_t) number_pixels; x++)
1554 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1555 SetPixelRed(image,ClampToQuantum(pixel),q);
1556 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1557 SetPixelGreen(image,ClampToQuantum(pixel),q);
1558 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1559 SetPixelBlue(image,ClampToQuantum(pixel),q);
1560 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1561 SetPixelBlack(image,ClampToQuantum(pixel),q);
1562 p+=(ptrdiff_t) quantum_info->pad;
1563 q+=(ptrdiff_t) GetPixelChannels(image);
1572 for (x=0; x < (ssize_t) number_pixels; x++)
1574 p=PushLongPixel(quantum_info->endian,p,&pixel);
1575 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1576 p=PushLongPixel(quantum_info->endian,p,&pixel);
1577 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1578 p=PushLongPixel(quantum_info->endian,p,&pixel);
1579 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1580 p=PushLongPixel(quantum_info->endian,p,&pixel);
1581 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1582 p+=(ptrdiff_t) quantum_info->pad;
1583 q+=(ptrdiff_t) GetPixelChannels(image);
1590 if (quantum_info->format == FloatingPointQuantumFormat)
1595 for (x=0; x < (ssize_t) number_pixels; x++)
1597 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1598 SetPixelRed(image,ClampToQuantum(pixel),q);
1599 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1600 SetPixelGreen(image,ClampToQuantum(pixel),q);
1601 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1602 SetPixelBlue(image,ClampToQuantum(pixel),q);
1603 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1604 SetPixelBlack(image,ClampToQuantum(pixel),q);
1605 p+=(ptrdiff_t) quantum_info->pad;
1606 q+=(ptrdiff_t) GetPixelChannels(image);
1614 if (quantum_info->format == FloatingPointQuantumFormat)
1619 for (x=0; x < (ssize_t) number_pixels; x++)
1621 p=PushDoublePixel(quantum_info,p,&pixel);
1622 SetPixelRed(image,ClampToQuantum(pixel),q);
1623 p=PushDoublePixel(quantum_info,p,&pixel);
1624 SetPixelGreen(image,ClampToQuantum(pixel),q);
1625 p=PushDoublePixel(quantum_info,p,&pixel);
1626 SetPixelBlue(image,ClampToQuantum(pixel),q);
1627 p=PushDoublePixel(quantum_info,p,&pixel);
1628 SetPixelBlack(image,ClampToQuantum(pixel),q);
1629 p+=(ptrdiff_t) quantum_info->pad;
1630 q+=(ptrdiff_t) GetPixelChannels(image);
1641 range=GetQuantumRange(quantum_info->depth);
1642 for (x=0; x < (ssize_t) number_pixels; x++)
1644 p=PushQuantumPixel(quantum_info,p,&pixel);
1645 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1646 p=PushQuantumPixel(quantum_info,p,&pixel);
1647 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1648 p=PushQuantumPixel(quantum_info,p,&pixel);
1649 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1650 p=PushQuantumPixel(quantum_info,p,&pixel);
1651 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1652 q+=(ptrdiff_t) GetPixelChannels(image);
1659static void ImportCMYKAQuantum(
const Image *image,QuantumInfo *quantum_info,
1660 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1661 Quantum *magick_restrict q,ExceptionInfo *exception)
1669 if (image->colorspace != CMYKColorspace)
1671 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1672 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1675 switch (quantum_info->depth)
1682 for (x=0; x < (ssize_t) number_pixels; x++)
1684 p=PushCharPixel(p,&pixel);
1685 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1686 p=PushCharPixel(p,&pixel);
1687 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1688 p=PushCharPixel(p,&pixel);
1689 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1690 p=PushCharPixel(p,&pixel);
1691 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1692 p=PushCharPixel(p,&pixel);
1693 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
1694 p+=(ptrdiff_t) quantum_info->pad;
1695 q+=(ptrdiff_t) GetPixelChannels(image);
1704 if (quantum_info->format == FloatingPointQuantumFormat)
1706 for (x=0; x < (ssize_t) number_pixels; x++)
1708 p=PushShortPixel(quantum_info->endian,p,&pixel);
1709 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
1710 HalfToSinglePrecision(pixel)),q);
1711 p=PushShortPixel(quantum_info->endian,p,&pixel);
1712 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
1713 HalfToSinglePrecision(pixel)),q);
1714 p=PushShortPixel(quantum_info->endian,p,&pixel);
1715 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1716 HalfToSinglePrecision(pixel)),q);
1717 p=PushShortPixel(quantum_info->endian,p,&pixel);
1718 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*(
double)
1719 HalfToSinglePrecision(pixel)),q);
1720 p=PushShortPixel(quantum_info->endian,p,&pixel);
1721 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
1722 HalfToSinglePrecision(pixel)),q);
1723 p+=(ptrdiff_t) quantum_info->pad;
1724 q+=(ptrdiff_t) GetPixelChannels(image);
1728 for (x=0; x < (ssize_t) number_pixels; x++)
1730 p=PushShortPixel(quantum_info->endian,p,&pixel);
1731 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1732 p=PushShortPixel(quantum_info->endian,p,&pixel);
1733 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1734 p=PushShortPixel(quantum_info->endian,p,&pixel);
1735 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1736 p=PushShortPixel(quantum_info->endian,p,&pixel);
1737 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1738 p=PushShortPixel(quantum_info->endian,p,&pixel);
1739 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
1740 p+=(ptrdiff_t) quantum_info->pad;
1741 q+=(ptrdiff_t) GetPixelChannels(image);
1747 if (quantum_info->format == FloatingPointQuantumFormat)
1752 for (x=0; x < (ssize_t) number_pixels; x++)
1754 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1755 SetPixelRed(image,ClampToQuantum(pixel),q);
1756 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1757 SetPixelGreen(image,ClampToQuantum(pixel),q);
1758 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1759 SetPixelBlue(image,ClampToQuantum(pixel),q);
1760 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1761 SetPixelBlack(image,ClampToQuantum(pixel),q);
1762 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1763 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1764 p+=(ptrdiff_t) quantum_info->pad;
1765 q+=(ptrdiff_t) GetPixelChannels(image);
1774 for (x=0; x < (ssize_t) number_pixels; x++)
1776 p=PushLongPixel(quantum_info->endian,p,&pixel);
1777 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1778 p=PushLongPixel(quantum_info->endian,p,&pixel);
1779 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1780 p=PushLongPixel(quantum_info->endian,p,&pixel);
1781 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1782 p=PushLongPixel(quantum_info->endian,p,&pixel);
1783 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1784 p=PushLongPixel(quantum_info->endian,p,&pixel);
1785 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
1786 p+=(ptrdiff_t) quantum_info->pad;
1787 q+=(ptrdiff_t) GetPixelChannels(image);
1794 if (quantum_info->format == FloatingPointQuantumFormat)
1799 for (x=0; x < (ssize_t) number_pixels; x++)
1801 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1802 SetPixelRed(image,ClampToQuantum(pixel),q);
1803 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1804 SetPixelGreen(image,ClampToQuantum(pixel),q);
1805 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1806 SetPixelBlue(image,ClampToQuantum(pixel),q);
1807 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1808 SetPixelBlack(image,ClampToQuantum(pixel),q);
1809 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1810 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1811 p+=(ptrdiff_t) quantum_info->pad;
1812 q+=(ptrdiff_t) GetPixelChannels(image);
1820 if (quantum_info->format == FloatingPointQuantumFormat)
1825 for (x=0; x < (ssize_t) number_pixels; x++)
1827 p=PushDoublePixel(quantum_info,p,&pixel);
1828 SetPixelRed(image,ClampToQuantum(pixel),q);
1829 p=PushDoublePixel(quantum_info,p,&pixel);
1830 SetPixelGreen(image,ClampToQuantum(pixel),q);
1831 p=PushDoublePixel(quantum_info,p,&pixel);
1832 SetPixelBlue(image,ClampToQuantum(pixel),q);
1833 p=PushDoublePixel(quantum_info,p,&pixel);
1834 SetPixelBlack(image,ClampToQuantum(pixel),q);
1835 p=PushDoublePixel(quantum_info,p,&pixel);
1836 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1837 p+=(ptrdiff_t) quantum_info->pad;
1838 q+=(ptrdiff_t) GetPixelChannels(image);
1849 range=GetQuantumRange(quantum_info->depth);
1850 for (x=0; x < (ssize_t) number_pixels; x++)
1852 p=PushQuantumPixel(quantum_info,p,&pixel);
1853 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1854 p=PushQuantumPixel(quantum_info,p,&pixel);
1855 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1856 p=PushQuantumPixel(quantum_info,p,&pixel);
1857 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1858 p=PushQuantumPixel(quantum_info,p,&pixel);
1859 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1860 p=PushQuantumPixel(quantum_info,p,&pixel);
1861 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1862 q+=(ptrdiff_t) GetPixelChannels(image);
1869static void ImportCMYKOQuantum(
const Image *image,QuantumInfo *quantum_info,
1870 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1871 Quantum *magick_restrict q,ExceptionInfo *exception)
1879 if (image->colorspace != CMYKColorspace)
1881 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1882 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1885 switch (quantum_info->depth)
1892 for (x=0; x < (ssize_t) number_pixels; x++)
1894 p=PushCharPixel(p,&pixel);
1895 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1896 p=PushCharPixel(p,&pixel);
1897 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1898 p=PushCharPixel(p,&pixel);
1899 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1900 p=PushCharPixel(p,&pixel);
1901 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1902 p=PushCharPixel(p,&pixel);
1903 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
1904 p+=(ptrdiff_t) quantum_info->pad;
1905 q+=(ptrdiff_t) GetPixelChannels(image);
1914 if (quantum_info->format == FloatingPointQuantumFormat)
1916 for (x=0; x < (ssize_t) number_pixels; x++)
1918 p=PushShortPixel(quantum_info->endian,p,&pixel);
1919 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
1920 HalfToSinglePrecision(pixel)),q);
1921 p=PushShortPixel(quantum_info->endian,p,&pixel);
1922 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
1923 HalfToSinglePrecision(pixel)),q);
1924 p=PushShortPixel(quantum_info->endian,p,&pixel);
1925 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1926 HalfToSinglePrecision(pixel)),q);
1927 p=PushShortPixel(quantum_info->endian,p,&pixel);
1928 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*(
double)
1929 HalfToSinglePrecision(pixel)),q);
1930 p=PushShortPixel(quantum_info->endian,p,&pixel);
1931 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
1932 HalfToSinglePrecision(pixel)),q);
1933 p+=(ptrdiff_t) quantum_info->pad;
1934 q+=(ptrdiff_t) GetPixelChannels(image);
1938 for (x=0; x < (ssize_t) number_pixels; x++)
1940 p=PushShortPixel(quantum_info->endian,p,&pixel);
1941 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1942 p=PushShortPixel(quantum_info->endian,p,&pixel);
1943 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1944 p=PushShortPixel(quantum_info->endian,p,&pixel);
1945 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1946 p=PushShortPixel(quantum_info->endian,p,&pixel);
1947 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1948 p=PushShortPixel(quantum_info->endian,p,&pixel);
1949 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
1950 p+=(ptrdiff_t) quantum_info->pad;
1951 q+=(ptrdiff_t) GetPixelChannels(image);
1957 if (quantum_info->format == FloatingPointQuantumFormat)
1962 for (x=0; x < (ssize_t) number_pixels; x++)
1964 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1965 SetPixelRed(image,ClampToQuantum(pixel),q);
1966 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1967 SetPixelGreen(image,ClampToQuantum(pixel),q);
1968 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1969 SetPixelBlue(image,ClampToQuantum(pixel),q);
1970 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1971 SetPixelBlack(image,ClampToQuantum(pixel),q);
1972 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1973 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1974 p+=(ptrdiff_t) quantum_info->pad;
1975 q+=(ptrdiff_t) GetPixelChannels(image);
1984 for (x=0; x < (ssize_t) number_pixels; x++)
1986 p=PushLongPixel(quantum_info->endian,p,&pixel);
1987 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1988 p=PushLongPixel(quantum_info->endian,p,&pixel);
1989 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1990 p=PushLongPixel(quantum_info->endian,p,&pixel);
1991 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1992 p=PushLongPixel(quantum_info->endian,p,&pixel);
1993 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1994 p=PushLongPixel(quantum_info->endian,p,&pixel);
1995 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
1996 p+=(ptrdiff_t) quantum_info->pad;
1997 q+=(ptrdiff_t) GetPixelChannels(image);
2004 if (quantum_info->format == FloatingPointQuantumFormat)
2009 for (x=0; x < (ssize_t) number_pixels; x++)
2011 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2012 SetPixelRed(image,ClampToQuantum(pixel),q);
2013 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2014 SetPixelGreen(image,ClampToQuantum(pixel),q);
2015 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2016 SetPixelBlue(image,ClampToQuantum(pixel),q);
2017 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2018 SetPixelBlack(image,ClampToQuantum(pixel),q);
2019 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2020 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2021 p+=(ptrdiff_t) quantum_info->pad;
2022 q+=(ptrdiff_t) GetPixelChannels(image);
2030 if (quantum_info->format == FloatingPointQuantumFormat)
2035 for (x=0; x < (ssize_t) number_pixels; x++)
2037 p=PushDoublePixel(quantum_info,p,&pixel);
2038 SetPixelRed(image,ClampToQuantum(pixel),q);
2039 p=PushDoublePixel(quantum_info,p,&pixel);
2040 SetPixelGreen(image,ClampToQuantum(pixel),q);
2041 p=PushDoublePixel(quantum_info,p,&pixel);
2042 SetPixelBlue(image,ClampToQuantum(pixel),q);
2043 p=PushDoublePixel(quantum_info,p,&pixel);
2044 SetPixelBlack(image,ClampToQuantum(pixel),q);
2045 p=PushDoublePixel(quantum_info,p,&pixel);
2046 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2047 p+=(ptrdiff_t) quantum_info->pad;
2048 q+=(ptrdiff_t) GetPixelChannels(image);
2059 range=GetQuantumRange(quantum_info->depth);
2060 for (x=0; x < (ssize_t) number_pixels; x++)
2062 p=PushQuantumPixel(quantum_info,p,&pixel);
2063 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2064 p=PushQuantumPixel(quantum_info,p,&pixel);
2065 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2066 p=PushQuantumPixel(quantum_info,p,&pixel);
2067 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2068 p=PushQuantumPixel(quantum_info,p,&pixel);
2069 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
2070 p=PushQuantumPixel(quantum_info,p,&pixel);
2071 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
2072 q+=(ptrdiff_t) GetPixelChannels(image);
2079static void ImportGrayQuantum(
const Image *image,QuantumInfo *quantum_info,
2080 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
2081 Quantum *magick_restrict q)
2092 assert(image != (Image *) NULL);
2093 assert(image->signature == MagickCoreSignature);
2094 switch (quantum_info->depth)
2104 if (quantum_info->min_is_white != MagickFalse)
2109 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
2111 for (bit=0; bit < 8; bit++)
2113 SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black : white,q);
2114 q+=(ptrdiff_t) GetPixelChannels(image);
2118 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
2120 SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black : white,q);
2121 q+=(ptrdiff_t) GetPixelChannels(image);
2132 range=GetQuantumRange(quantum_info->depth);
2133 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
2135 pixel=(
unsigned char) ((*p >> 4) & 0xf);
2136 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2137 q+=(ptrdiff_t) GetPixelChannels(image);
2138 pixel=(
unsigned char) ((*p) & 0xf);
2139 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2141 q+=(ptrdiff_t) GetPixelChannels(image);
2143 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2145 pixel=(
unsigned char) (*p++ >> 4);
2146 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2147 q+=(ptrdiff_t) GetPixelChannels(image);
2156 if (quantum_info->min_is_white != MagickFalse)
2158 for (x=0; x < (ssize_t) number_pixels; x++)
2160 p=PushCharPixel(p,&pixel);
2161 SetPixelGray(image,QuantumRange-ScaleCharToQuantum(pixel),q);
2162 SetPixelAlpha(image,OpaqueAlpha,q);
2163 p+=(ptrdiff_t) quantum_info->pad;
2164 q+=(ptrdiff_t) GetPixelChannels(image);
2168 for (x=0; x < (ssize_t) number_pixels; x++)
2170 p=PushCharPixel(p,&pixel);
2171 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2172 SetPixelAlpha(image,OpaqueAlpha,q);
2173 p+=(ptrdiff_t) quantum_info->pad;
2174 q+=(ptrdiff_t) GetPixelChannels(image);
2184 range=GetQuantumRange(quantum_info->depth);
2185 if (quantum_info->pack == MagickFalse)
2187 if (image->endian == LSBEndian)
2189 for (x=0; x < ((ssize_t) number_pixels-2); x+=3)
2191 p=PushLongPixel(quantum_info->endian,p,&pixel);
2192 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2194 q+=(ptrdiff_t) GetPixelChannels(image);
2195 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2197 q+=(ptrdiff_t) GetPixelChannels(image);
2198 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2200 p+=(ptrdiff_t) quantum_info->pad;
2201 q+=(ptrdiff_t) GetPixelChannels(image);
2203 if (x++ < ((ssize_t) number_pixels-1))
2205 p=PushLongPixel(quantum_info->endian,p,&pixel);
2206 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2208 q+=(ptrdiff_t) GetPixelChannels(image);
2210 if (x++ < (ssize_t) number_pixels)
2212 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2214 q+=(ptrdiff_t) GetPixelChannels(image);
2218 for (x=0; x < ((ssize_t) number_pixels-2); x+=3)
2220 p=PushLongPixel(quantum_info->endian,p,&pixel);
2221 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
2223 q+=(ptrdiff_t) GetPixelChannels(image);
2224 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
2226 q+=(ptrdiff_t) GetPixelChannels(image);
2227 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
2229 p+=(ptrdiff_t) quantum_info->pad;
2230 q+=(ptrdiff_t) GetPixelChannels(image);
2232 if (x++ < ((ssize_t) number_pixels-1))
2234 p=PushLongPixel(quantum_info->endian,p,&pixel);
2235 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2237 q+=(ptrdiff_t) GetPixelChannels(image);
2239 if (x++ < (ssize_t) number_pixels)
2241 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2243 q+=(ptrdiff_t) GetPixelChannels(image);
2247 for (x=0; x < (ssize_t) number_pixels; x++)
2249 p=PushQuantumPixel(quantum_info,p,&pixel);
2250 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2251 p+=(ptrdiff_t) quantum_info->pad;
2252 q+=(ptrdiff_t) GetPixelChannels(image);
2258 range=GetQuantumRange(quantum_info->depth);
2259 if (quantum_info->pack == MagickFalse)
2264 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
2266 p=PushShortPixel(quantum_info->endian,p,&pixel);
2267 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2269 q+=(ptrdiff_t) GetPixelChannels(image);
2270 p=PushShortPixel(quantum_info->endian,p,&pixel);
2271 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2273 p+=(ptrdiff_t) quantum_info->pad;
2274 q+=(ptrdiff_t) GetPixelChannels(image);
2276 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2278 p=PushShortPixel(quantum_info->endian,p,&pixel);
2279 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2281 p+=(ptrdiff_t) quantum_info->pad;
2282 q+=(ptrdiff_t) GetPixelChannels(image);
2293 for (x=0; x < (ssize_t) number_pixels; x++)
2295 p=PushQuantumPixel(quantum_info,p,&pixel);
2296 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2297 p+=(ptrdiff_t) quantum_info->pad;
2298 q+=(ptrdiff_t) GetPixelChannels(image);
2308 if (quantum_info->min_is_white != MagickFalse)
2310 for (x=0; x < (ssize_t) number_pixels; x++)
2312 p=PushShortPixel(quantum_info->endian,p,&pixel);
2313 SetPixelGray(image,QuantumRange-ScaleShortToQuantum(pixel),q);
2314 p+=(ptrdiff_t) quantum_info->pad;
2315 q+=(ptrdiff_t) GetPixelChannels(image);
2319 if (quantum_info->format == FloatingPointQuantumFormat)
2321 for (x=0; x < (ssize_t) number_pixels; x++)
2323 p=PushShortPixel(quantum_info->endian,p,&pixel);
2324 SetPixelGray(image,ClampToQuantum((
double) QuantumRange*(
double)
2325 HalfToSinglePrecision(pixel)),q);
2326 p+=(ptrdiff_t) quantum_info->pad;
2327 q+=(ptrdiff_t) GetPixelChannels(image);
2331 for (x=0; x < (ssize_t) number_pixels; x++)
2333 p=PushShortPixel(quantum_info->endian,p,&pixel);
2334 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2335 p+=(ptrdiff_t) quantum_info->pad;
2336 q+=(ptrdiff_t) GetPixelChannels(image);
2342 if (quantum_info->format == FloatingPointQuantumFormat)
2347 for (x=0; x < (ssize_t) number_pixels; x++)
2349 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2350 SetPixelGray(image,ClampToQuantum(pixel),q);
2351 p+=(ptrdiff_t) quantum_info->pad;
2352 q+=(ptrdiff_t) GetPixelChannels(image);
2361 for (x=0; x < (ssize_t) number_pixels; x++)
2363 p=PushLongPixel(quantum_info->endian,p,&pixel);
2364 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2365 p+=(ptrdiff_t) quantum_info->pad;
2366 q+=(ptrdiff_t) GetPixelChannels(image);
2373 if (quantum_info->format == FloatingPointQuantumFormat)
2378 for (x=0; x < (ssize_t) number_pixels; x++)
2380 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2381 SetPixelGray(image,ClampToQuantum(pixel),q);
2382 p+=(ptrdiff_t) quantum_info->pad;
2383 q+=(ptrdiff_t) GetPixelChannels(image);
2391 if (quantum_info->format == FloatingPointQuantumFormat)
2396 for (x=0; x < (ssize_t) number_pixels; x++)
2398 p=PushDoublePixel(quantum_info,p,&pixel);
2399 SetPixelGray(image,ClampToQuantum(pixel),q);
2400 p+=(ptrdiff_t) quantum_info->pad;
2401 q+=(ptrdiff_t) GetPixelChannels(image);
2412 range=GetQuantumRange(quantum_info->depth);
2413 for (x=0; x < (ssize_t) number_pixels; x++)
2415 p=PushQuantumPixel(quantum_info,p,&pixel);
2416 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2417 p+=(ptrdiff_t) quantum_info->pad;
2418 q+=(ptrdiff_t) GetPixelChannels(image);
2425static void ImportGrayAlphaQuantum(
const Image *image,QuantumInfo *quantum_info,
2426 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
2427 Quantum *magick_restrict q)
2438 assert(image != (Image *) NULL);
2439 assert(image->signature == MagickCoreSignature);
2440 switch (quantum_info->depth)
2448 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2450 for (bit=0; bit < 8; bit+=2)
2452 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2453 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2454 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
2455 TransparentAlpha : OpaqueAlpha,q);
2456 q+=(ptrdiff_t) GetPixelChannels(image);
2460 if ((number_pixels % 4) != 0)
2461 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2463 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2464 SetPixelGray(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
2465 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
2466 TransparentAlpha : OpaqueAlpha,q);
2467 q+=(ptrdiff_t) GetPixelChannels(image);
2478 range=GetQuantumRange(quantum_info->depth);
2479 for (x=0; x < (ssize_t) number_pixels; x++)
2481 pixel=(
unsigned char) ((*p >> 4) & 0xf);
2482 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2483 pixel=(
unsigned char) ((*p) & 0xf);
2484 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2486 q+=(ptrdiff_t) GetPixelChannels(image);
2495 for (x=0; x < (ssize_t) number_pixels; x++)
2497 p=PushCharPixel(p,&pixel);
2498 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2499 p=PushCharPixel(p,&pixel);
2500 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2501 p+=(ptrdiff_t) quantum_info->pad;
2502 q+=(ptrdiff_t) GetPixelChannels(image);
2511 range=GetQuantumRange(quantum_info->depth);
2512 for (x=0; x < (ssize_t) number_pixels; x++)
2514 p=PushQuantumPixel(quantum_info,p,&pixel);
2515 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2516 p=PushQuantumPixel(quantum_info,p,&pixel);
2517 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2518 p+=(ptrdiff_t) quantum_info->pad;
2519 q+=(ptrdiff_t) GetPixelChannels(image);
2528 range=GetQuantumRange(quantum_info->depth);
2529 for (x=0; x < (ssize_t) number_pixels; x++)
2531 p=PushQuantumPixel(quantum_info,p,&pixel);
2532 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2533 p=PushQuantumPixel(quantum_info,p,&pixel);
2534 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2535 p+=(ptrdiff_t) quantum_info->pad;
2536 q+=(ptrdiff_t) GetPixelChannels(image);
2545 if (quantum_info->format == FloatingPointQuantumFormat)
2547 for (x=0; x < (ssize_t) number_pixels; x++)
2549 p=PushShortPixel(quantum_info->endian,p,&pixel);
2550 SetPixelGray(image,ClampToQuantum((
double) QuantumRange*(
double)
2551 HalfToSinglePrecision(pixel)),q);
2552 p=PushShortPixel(quantum_info->endian,p,&pixel);
2553 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
2554 HalfToSinglePrecision(pixel)),q);
2555 p+=(ptrdiff_t) quantum_info->pad;
2556 q+=(ptrdiff_t) GetPixelChannels(image);
2560 for (x=0; x < (ssize_t) number_pixels; x++)
2562 p=PushShortPixel(quantum_info->endian,p,&pixel);
2563 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2564 p=PushShortPixel(quantum_info->endian,p,&pixel);
2565 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
2566 p+=(ptrdiff_t) quantum_info->pad;
2567 q+=(ptrdiff_t) GetPixelChannels(image);
2573 if (quantum_info->format == FloatingPointQuantumFormat)
2578 for (x=0; x < (ssize_t) number_pixels; x++)
2580 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2581 SetPixelGray(image,ClampToQuantum(pixel),q);
2582 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2583 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2584 p+=(ptrdiff_t) quantum_info->pad;
2585 q+=(ptrdiff_t) GetPixelChannels(image);
2594 for (x=0; x < (ssize_t) number_pixels; x++)
2596 p=PushLongPixel(quantum_info->endian,p,&pixel);
2597 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2598 p=PushLongPixel(quantum_info->endian,p,&pixel);
2599 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2600 p+=(ptrdiff_t) quantum_info->pad;
2601 q+=(ptrdiff_t) GetPixelChannels(image);
2608 if (quantum_info->format == FloatingPointQuantumFormat)
2613 for (x=0; x < (ssize_t) number_pixels; x++)
2615 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2616 SetPixelGray(image,ClampToQuantum(pixel),q);
2617 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2618 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2619 p+=(ptrdiff_t) quantum_info->pad;
2620 q+=(ptrdiff_t) GetPixelChannels(image);
2628 if (quantum_info->format == FloatingPointQuantumFormat)
2633 for (x=0; x < (ssize_t) number_pixels; x++)
2635 p=PushDoublePixel(quantum_info,p,&pixel);
2636 SetPixelGray(image,ClampToQuantum(pixel),q);
2637 p=PushDoublePixel(quantum_info,p,&pixel);
2638 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2639 p+=(ptrdiff_t) quantum_info->pad;
2640 q+=(ptrdiff_t) GetPixelChannels(image);
2651 range=GetQuantumRange(quantum_info->depth);
2652 for (x=0; x < (ssize_t) number_pixels; x++)
2654 p=PushQuantumPixel(quantum_info,p,&pixel);
2655 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2656 p=PushQuantumPixel(quantum_info,p,&pixel);
2657 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2658 p+=(ptrdiff_t) quantum_info->pad;
2659 q+=(ptrdiff_t) GetPixelChannels(image);
2666static void ImportIndexQuantum(
const Image *image,QuantumInfo *quantum_info,
2667 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
2668 Quantum *magick_restrict q,ExceptionInfo *exception)
2679 if (image->storage_class != PseudoClass)
2681 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2682 "ColormappedImageRequired",
"`%s'",image->filename);
2685 range_exception=MagickFalse;
2686 switch (quantum_info->depth)
2693 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
2695 for (bit=0; bit < 8; bit++)
2697 if (quantum_info->min_is_white == MagickFalse)
2698 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
2701 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
2703 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
2705 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2706 GetPixelIndex(image,q),q);
2707 q+=(ptrdiff_t) GetPixelChannels(image);
2711 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
2713 if (quantum_info->min_is_white == MagickFalse)
2714 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
2716 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2717 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2718 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2719 GetPixelIndex(image,q),q);
2720 q+=(ptrdiff_t) GetPixelChannels(image);
2729 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
2731 pixel=(
unsigned char) ((*p >> 4) & 0xf);
2732 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2733 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2734 GetPixelIndex(image,q),q);
2735 q+=(ptrdiff_t) GetPixelChannels(image);
2736 pixel=(
unsigned char) ((*p) & 0xf);
2737 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2738 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2739 GetPixelIndex(image,q),q);
2741 q+=(ptrdiff_t) GetPixelChannels(image);
2743 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2745 pixel=(
unsigned char) ((*p++ >> 4) & 0xf);
2746 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2747 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2748 GetPixelIndex(image,q),q);
2749 q+=(ptrdiff_t) GetPixelChannels(image);
2758 for (x=0; x < (ssize_t) number_pixels; x++)
2760 p=PushCharPixel(p,&pixel);
2761 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2762 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2763 GetPixelIndex(image,q),q);
2764 p+=(ptrdiff_t) quantum_info->pad;
2765 q+=(ptrdiff_t) GetPixelChannels(image);
2774 if (quantum_info->format == FloatingPointQuantumFormat)
2776 for (x=0; x < (ssize_t) number_pixels; x++)
2778 p=PushShortPixel(quantum_info->endian,p,&pixel);
2779 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
2780 ClampToQuantum((
double) QuantumRange*(
double)
2781 HalfToSinglePrecision(pixel)),&range_exception),q);
2782 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2783 GetPixelIndex(image,q),q);
2784 p+=(ptrdiff_t) quantum_info->pad;
2785 q+=(ptrdiff_t) GetPixelChannels(image);
2789 for (x=0; x < (ssize_t) number_pixels; x++)
2791 p=PushShortPixel(quantum_info->endian,p,&pixel);
2792 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2793 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2794 GetPixelIndex(image,q),q);
2795 p+=(ptrdiff_t) quantum_info->pad;
2796 q+=(ptrdiff_t) GetPixelChannels(image);
2802 if (quantum_info->format == FloatingPointQuantumFormat)
2807 for (x=0; x < (ssize_t) number_pixels; x++)
2809 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2810 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
2811 ClampToQuantum(pixel),&range_exception),q);
2812 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2813 GetPixelIndex(image,q),q);
2814 p+=(ptrdiff_t) quantum_info->pad;
2815 q+=(ptrdiff_t) GetPixelChannels(image);
2824 for (x=0; x < (ssize_t) number_pixels; x++)
2826 p=PushLongPixel(quantum_info->endian,p,&pixel);
2827 SetPixelIndex(image,PushColormapIndex(image,pixel,
2828 &range_exception),q);
2829 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2830 GetPixelIndex(image,q),q);
2831 p+=(ptrdiff_t) quantum_info->pad;
2832 q+=(ptrdiff_t) GetPixelChannels(image);
2839 if (quantum_info->format == FloatingPointQuantumFormat)
2844 for (x=0; x < (ssize_t) number_pixels; x++)
2846 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2847 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
2848 ClampToQuantum(pixel),&range_exception),q);
2849 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2850 GetPixelIndex(image,q),q);
2851 p+=(ptrdiff_t) quantum_info->pad;
2852 q+=(ptrdiff_t) GetPixelChannels(image);
2860 if (quantum_info->format == FloatingPointQuantumFormat)
2865 for (x=0; x < (ssize_t) number_pixels; x++)
2867 p=PushDoublePixel(quantum_info,p,&pixel);
2868 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
2869 ClampToQuantum(pixel),&range_exception),q);
2870 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2871 GetPixelIndex(image,q),q);
2872 p+=(ptrdiff_t) quantum_info->pad;
2873 q+=(ptrdiff_t) GetPixelChannels(image);
2884 for (x=0; x < (ssize_t) number_pixels; x++)
2886 p=PushQuantumPixel(quantum_info,p,&pixel);
2887 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2888 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2889 GetPixelIndex(image,q),q);
2890 p+=(ptrdiff_t) quantum_info->pad;
2891 q+=(ptrdiff_t) GetPixelChannels(image);
2896 if (range_exception != MagickFalse)
2897 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
2898 "InvalidColormapIndex",
"`%s'",image->filename);
2901static void ImportIndexAlphaQuantum(
const Image *image,
2902 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
2903 const unsigned char *magick_restrict p,Quantum *magick_restrict q,
2904 ExceptionInfo *exception)
2918 if (image->storage_class != PseudoClass)
2920 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2921 "ColormappedImageRequired",
"`%s'",image->filename);
2924 range_exception=MagickFalse;
2925 switch (quantum_info->depth)
2932 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2934 for (bit=0; bit < 8; bit+=2)
2936 if (quantum_info->min_is_white == MagickFalse)
2937 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
2939 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2940 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2941 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
2942 TransparentAlpha : OpaqueAlpha,q);
2943 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
2944 q+=(ptrdiff_t) GetPixelChannels(image);
2947 if ((number_pixels % 4) != 0)
2948 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2950 if (quantum_info->min_is_white == MagickFalse)
2951 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
2953 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2954 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
2955 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2956 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
2957 TransparentAlpha : OpaqueAlpha,q);
2958 q+=(ptrdiff_t) GetPixelChannels(image);
2967 range=GetQuantumRange(quantum_info->depth);
2968 for (x=0; x < (ssize_t) number_pixels; x++)
2970 pixel=(
unsigned char) ((*p >> 4) & 0xf);
2971 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2972 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2973 GetPixelIndex(image,q),q);
2974 pixel=(
unsigned char) ((*p) & 0xf);
2975 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2977 q+=(ptrdiff_t) GetPixelChannels(image);
2986 for (x=0; x < (ssize_t) number_pixels; x++)
2988 p=PushCharPixel(p,&pixel);
2989 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2990 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2991 GetPixelIndex(image,q),q);
2992 p=PushCharPixel(p,&pixel);
2993 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2994 p+=(ptrdiff_t) quantum_info->pad;
2995 q+=(ptrdiff_t) GetPixelChannels(image);
3004 if (quantum_info->format == FloatingPointQuantumFormat)
3006 for (x=0; x < (ssize_t) number_pixels; x++)
3008 p=PushShortPixel(quantum_info->endian,p,&pixel);
3009 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3010 ClampToQuantum((
double) QuantumRange*(
double)
3011 HalfToSinglePrecision(pixel)),&range_exception),q);
3012 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3013 GetPixelIndex(image,q),q);
3014 p=PushShortPixel(quantum_info->endian,p,&pixel);
3015 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
3016 HalfToSinglePrecision(pixel)),q);
3017 p+=(ptrdiff_t) quantum_info->pad;
3018 q+=(ptrdiff_t) GetPixelChannels(image);
3022 for (x=0; x < (ssize_t) number_pixels; x++)
3024 p=PushShortPixel(quantum_info->endian,p,&pixel);
3025 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3026 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3027 GetPixelIndex(image,q),q);
3028 p=PushShortPixel(quantum_info->endian,p,&pixel);
3029 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
3030 p+=(ptrdiff_t) quantum_info->pad;
3031 q+=(ptrdiff_t) GetPixelChannels(image);
3037 if (quantum_info->format == FloatingPointQuantumFormat)
3042 for (x=0; x < (ssize_t) number_pixels; x++)
3044 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3045 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3046 ClampToQuantum(pixel),&range_exception),q);
3047 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3048 GetPixelIndex(image,q),q);
3049 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3050 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3051 p+=(ptrdiff_t) quantum_info->pad;
3052 q+=(ptrdiff_t) GetPixelChannels(image);
3061 for (x=0; x < (ssize_t) number_pixels; x++)
3063 p=PushLongPixel(quantum_info->endian,p,&pixel);
3064 SetPixelIndex(image,PushColormapIndex(image,pixel,
3065 &range_exception),q);
3066 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3067 GetPixelIndex(image,q),q);
3068 p=PushLongPixel(quantum_info->endian,p,&pixel);
3069 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
3070 p+=(ptrdiff_t) quantum_info->pad;
3071 q+=(ptrdiff_t) GetPixelChannels(image);
3078 if (quantum_info->format == FloatingPointQuantumFormat)
3083 for (x=0; x < (ssize_t) number_pixels; x++)
3085 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3086 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3087 ClampToQuantum(pixel),&range_exception),q);
3088 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3089 GetPixelIndex(image,q),q);
3090 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3091 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3092 p+=(ptrdiff_t) quantum_info->pad;
3093 q+=(ptrdiff_t) GetPixelChannels(image);
3101 if (quantum_info->format == FloatingPointQuantumFormat)
3106 for (x=0; x < (ssize_t) number_pixels; x++)
3108 p=PushDoublePixel(quantum_info,p,&pixel);
3109 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3110 ClampToQuantum(pixel),&range_exception),q);
3111 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3112 GetPixelIndex(image,q),q);
3113 p=PushDoublePixel(quantum_info,p,&pixel);
3114 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3115 p+=(ptrdiff_t) quantum_info->pad;
3116 q+=(ptrdiff_t) GetPixelChannels(image);
3127 range=GetQuantumRange(quantum_info->depth);
3128 for (x=0; x < (ssize_t) number_pixels; x++)
3130 p=PushQuantumPixel(quantum_info,p,&pixel);
3131 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3132 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3133 GetPixelIndex(image,q),q);
3134 p=PushQuantumPixel(quantum_info,p,&pixel);
3135 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3136 p+=(ptrdiff_t) quantum_info->pad;
3137 q+=(ptrdiff_t) GetPixelChannels(image);
3142 if (range_exception != MagickFalse)
3143 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
3144 "InvalidColormapIndex",
"`%s'",image->filename);
3147static void ImportMultispectralQuantum(
const Image *image,
3148 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
3149 const unsigned char *magick_restrict p,Quantum *magick_restrict q,
3150 ExceptionInfo *exception)
3159 if (image->number_meta_channels == 0)
3161 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3162 "MultispectralImageRequired",
"`%s'",image->filename);
3165 if (quantum_info->meta_channel != 0)
3167 ImportPixelChannel(image,quantum_info,number_pixels,p,q,
3168 (PixelChannel) (MetaPixelChannels+quantum_info->meta_channel-1));
3171 switch (quantum_info->depth)
3178 for (x=0; x < (ssize_t) number_pixels; x++)
3180 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3182 p=PushCharPixel(p,&pixel);
3183 q[i]=ScaleCharToQuantum(pixel);
3185 p+=(ptrdiff_t) quantum_info->pad;
3186 q+=(ptrdiff_t) GetPixelChannels(image);
3195 if (quantum_info->format == FloatingPointQuantumFormat)
3197 for (x=0; x < (ssize_t) number_pixels; x++)
3199 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3201 p=PushShortPixel(quantum_info->endian,p,&pixel);
3202 q[i]=ClampToQuantum((
double) QuantumRange*(
double)HalfToSinglePrecision(pixel));
3204 p+=(ptrdiff_t) quantum_info->pad;
3205 q+=(ptrdiff_t) GetPixelChannels(image);
3209 for (x=0; x < (ssize_t) number_pixels; x++)
3211 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3213 p=PushShortPixel(quantum_info->endian,p,&pixel);
3214 q[i]=ScaleShortToQuantum(pixel);
3216 p+=(ptrdiff_t) quantum_info->pad;
3217 q+=(ptrdiff_t) GetPixelChannels(image);
3223 if (quantum_info->format == FloatingPointQuantumFormat)
3228 for (x=0; x < (ssize_t) number_pixels; x++)
3230 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3232 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3233 q[i]=ClampToQuantum(pixel);
3235 p+=(ptrdiff_t) quantum_info->pad;
3236 q+=(ptrdiff_t) GetPixelChannels(image);
3245 for (x=0; x < (ssize_t) number_pixels; x++)
3247 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3249 p=PushLongPixel(quantum_info->endian,p,&pixel);
3250 q[i]=ScaleLongToQuantum(pixel);
3252 p+=(ptrdiff_t) quantum_info->pad;
3253 q+=(ptrdiff_t) GetPixelChannels(image);
3260 if (quantum_info->format == FloatingPointQuantumFormat)
3265 for (x=0; x < (ssize_t) number_pixels; x++)
3267 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3269 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3270 q[i]=ClampToQuantum(pixel);
3272 p+=(ptrdiff_t) quantum_info->pad;
3273 q+=(ptrdiff_t) GetPixelChannels(image);
3281 if (quantum_info->format == FloatingPointQuantumFormat)
3286 for (x=0; x < (ssize_t) number_pixels; x++)
3288 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3290 p=PushDoublePixel(quantum_info,p,&pixel);
3291 q[i]=ClampToQuantum(pixel);
3293 p+=(ptrdiff_t) quantum_info->pad;
3294 q+=(ptrdiff_t) GetPixelChannels(image);
3305 range=GetQuantumRange(quantum_info->depth);
3306 for (x=0; x < (ssize_t) number_pixels; x++)
3308 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3310 p=PushQuantumPixel(quantum_info,p,&pixel);
3311 q[i]=ScaleAnyToQuantum(pixel,range);
3313 q+=(ptrdiff_t) GetPixelChannels(image);
3320static void ImportOpacityQuantum(
const Image *image,QuantumInfo *quantum_info,
3321 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
3322 Quantum *magick_restrict q,ExceptionInfo* exception)
3330 if (image->alpha_trait == UndefinedPixelTrait)
3332 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3333 "ImageDoesNotHaveAnAlphaChannel",
"`%s'",image->filename);
3336 switch (quantum_info->depth)
3343 for (x=0; x < (ssize_t) number_pixels; x++)
3345 p=PushCharPixel(p,&pixel);
3346 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
3347 p+=(ptrdiff_t) quantum_info->pad;
3348 q+=(ptrdiff_t) GetPixelChannels(image);
3357 if (quantum_info->format == FloatingPointQuantumFormat)
3359 for (x=0; x < (ssize_t) number_pixels; x++)
3361 p=PushShortPixel(quantum_info->endian,p,&pixel);
3362 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
3363 HalfToSinglePrecision(pixel)),q);
3364 p+=(ptrdiff_t) quantum_info->pad;
3365 q+=(ptrdiff_t) GetPixelChannels(image);
3369 for (x=0; x < (ssize_t) number_pixels; x++)
3371 p=PushShortPixel(quantum_info->endian,p,&pixel);
3372 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
3373 p+=(ptrdiff_t) quantum_info->pad;
3374 q+=(ptrdiff_t) GetPixelChannels(image);
3380 if (quantum_info->format == FloatingPointQuantumFormat)
3385 for (x=0; x < (ssize_t) number_pixels; x++)
3387 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3388 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3389 p+=(ptrdiff_t) quantum_info->pad;
3390 q+=(ptrdiff_t) GetPixelChannels(image);
3399 for (x=0; x < (ssize_t) number_pixels; x++)
3401 p=PushLongPixel(quantum_info->endian,p,&pixel);
3402 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
3403 p+=(ptrdiff_t) quantum_info->pad;
3404 q+=(ptrdiff_t) GetPixelChannels(image);
3411 if (quantum_info->format == FloatingPointQuantumFormat)
3416 for (x=0; x < (ssize_t) number_pixels; x++)
3418 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3419 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3420 p+=(ptrdiff_t) quantum_info->pad;
3421 q+=(ptrdiff_t) GetPixelChannels(image);
3429 if (quantum_info->format == FloatingPointQuantumFormat)
3434 for (x=0; x < (ssize_t) number_pixels; x++)
3436 p=PushDoublePixel(quantum_info,p,&pixel);
3437 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3438 p+=(ptrdiff_t) quantum_info->pad;
3439 q+=(ptrdiff_t) GetPixelChannels(image);
3450 range=GetQuantumRange(quantum_info->depth);
3451 for (x=0; x < (ssize_t) number_pixels; x++)
3453 p=PushQuantumPixel(quantum_info,p,&pixel);
3454 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
3455 p+=(ptrdiff_t) quantum_info->pad;
3456 q+=(ptrdiff_t) GetPixelChannels(image);
3463static void ImportRGBQuantum(
const Image *image,QuantumInfo *quantum_info,
3464 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
3465 Quantum *magick_restrict q)
3476 assert(image != (Image *) NULL);
3477 assert(image->signature == MagickCoreSignature);
3478 switch (quantum_info->depth)
3485 for (x=0; x < (ssize_t) number_pixels; x++)
3487 p=PushCharPixel(p,&pixel);
3488 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3489 p=PushCharPixel(p,&pixel);
3490 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3491 p=PushCharPixel(p,&pixel);
3492 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
3493 SetPixelAlpha(image,OpaqueAlpha,q);
3494 p+=(ptrdiff_t) quantum_info->pad;
3495 q+=(ptrdiff_t) GetPixelChannels(image);
3504 range=GetQuantumRange(quantum_info->depth);
3505 if (quantum_info->pack == MagickFalse)
3507 for (x=0; x < (ssize_t) number_pixels; x++)
3509 p=PushLongPixel(quantum_info->endian,p,&pixel);
3510 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
3511 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
3513 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
3514 p+=(ptrdiff_t) quantum_info->pad;
3515 q+=(ptrdiff_t) GetPixelChannels(image);
3519 if (quantum_info->quantum == 32U)
3521 for (x=0; x < (ssize_t) number_pixels; x++)
3523 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3524 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3525 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3526 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3527 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3528 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3529 q+=(ptrdiff_t) GetPixelChannels(image);
3533 for (x=0; x < (ssize_t) number_pixels; x++)
3535 p=PushQuantumPixel(quantum_info,p,&pixel);
3536 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3537 p=PushQuantumPixel(quantum_info,p,&pixel);
3538 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3539 p=PushQuantumPixel(quantum_info,p,&pixel);
3540 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3541 q+=(ptrdiff_t) GetPixelChannels(image);
3547 range=GetQuantumRange(quantum_info->depth);
3548 if (quantum_info->pack == MagickFalse)
3553 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
3555 p=PushShortPixel(quantum_info->endian,p,&pixel);
3561 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3567 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3573 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3575 q+=(ptrdiff_t) GetPixelChannels(image);
3576 p+=(ptrdiff_t) quantum_info->pad;
3580 p=PushShortPixel(quantum_info->endian,p,&pixel);
3586 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3592 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3598 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3600 q+=(ptrdiff_t) GetPixelChannels(image);
3601 p+=(ptrdiff_t) quantum_info->pad;
3606 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3608 p=PushShortPixel(quantum_info->endian,p,&pixel);
3609 switch ((x+bit) % 3)
3614 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3620 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3626 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3628 q+=(ptrdiff_t) GetPixelChannels(image);
3629 p+=(ptrdiff_t) quantum_info->pad;
3643 if (quantum_info->quantum == 32U)
3645 for (x=0; x < (ssize_t) number_pixels; x++)
3647 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3648 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3649 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3650 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3651 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3652 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3653 q+=(ptrdiff_t) GetPixelChannels(image);
3657 for (x=0; x < (ssize_t) number_pixels; x++)
3659 p=PushQuantumPixel(quantum_info,p,&pixel);
3660 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3661 p=PushQuantumPixel(quantum_info,p,&pixel);
3662 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3663 p=PushQuantumPixel(quantum_info,p,&pixel);
3664 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3665 q+=(ptrdiff_t) GetPixelChannels(image);
3675 if (quantum_info->format == FloatingPointQuantumFormat)
3677 for (x=0; x < (ssize_t) number_pixels; x++)
3679 p=PushShortPixel(quantum_info->endian,p,&pixel);
3680 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
3681 HalfToSinglePrecision(pixel)),q);
3682 p=PushShortPixel(quantum_info->endian,p,&pixel);
3683 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
3684 HalfToSinglePrecision(pixel)),q);
3685 p=PushShortPixel(quantum_info->endian,p,&pixel);
3686 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
3687 HalfToSinglePrecision(pixel)),q);
3688 p+=(ptrdiff_t) quantum_info->pad;
3689 q+=(ptrdiff_t) GetPixelChannels(image);
3693 for (x=0; x < (ssize_t) number_pixels; x++)
3695 p=PushShortPixel(quantum_info->endian,p,&pixel);
3696 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3697 p=PushShortPixel(quantum_info->endian,p,&pixel);
3698 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
3699 p=PushShortPixel(quantum_info->endian,p,&pixel);
3700 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
3701 p+=(ptrdiff_t) quantum_info->pad;
3702 q+=(ptrdiff_t) GetPixelChannels(image);
3708 if (quantum_info->format == FloatingPointQuantumFormat)
3713 for (x=0; x < (ssize_t) number_pixels; x++)
3715 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3716 SetPixelRed(image,ClampToQuantum(pixel),q);
3717 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3718 SetPixelGreen(image,ClampToQuantum(pixel),q);
3719 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3720 SetPixelBlue(image,ClampToQuantum(pixel),q);
3721 p+=(ptrdiff_t) quantum_info->pad;
3722 q+=(ptrdiff_t) GetPixelChannels(image);
3731 for (x=0; x < (ssize_t) number_pixels; x++)
3733 p=PushLongPixel(quantum_info->endian,p,&pixel);
3734 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3735 p=PushLongPixel(quantum_info->endian,p,&pixel);
3736 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
3737 p=PushLongPixel(quantum_info->endian,p,&pixel);
3738 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
3739 p+=(ptrdiff_t) quantum_info->pad;
3740 q+=(ptrdiff_t) GetPixelChannels(image);
3747 if (quantum_info->format == FloatingPointQuantumFormat)
3752 for (x=0; x < (ssize_t) number_pixels; x++)
3754 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3755 SetPixelRed(image,ClampToQuantum(pixel),q);
3756 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3757 SetPixelGreen(image,ClampToQuantum(pixel),q);
3758 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3759 SetPixelBlue(image,ClampToQuantum(pixel),q);
3760 p+=(ptrdiff_t) quantum_info->pad;
3761 q+=(ptrdiff_t) GetPixelChannels(image);
3769 if (quantum_info->format == FloatingPointQuantumFormat)
3774 for (x=0; x < (ssize_t) number_pixels; x++)
3776 p=PushDoublePixel(quantum_info,p,&pixel);
3777 SetPixelRed(image,ClampToQuantum(pixel),q);
3778 p=PushDoublePixel(quantum_info,p,&pixel);
3779 SetPixelGreen(image,ClampToQuantum(pixel),q);
3780 p=PushDoublePixel(quantum_info,p,&pixel);
3781 SetPixelBlue(image,ClampToQuantum(pixel),q);
3782 p+=(ptrdiff_t) quantum_info->pad;
3783 q+=(ptrdiff_t) GetPixelChannels(image);
3794 range=GetQuantumRange(quantum_info->depth);
3795 for (x=0; x < (ssize_t) number_pixels; x++)
3797 p=PushQuantumPixel(quantum_info,p,&pixel);
3798 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3799 p=PushQuantumPixel(quantum_info,p,&pixel);
3800 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3801 p=PushQuantumPixel(quantum_info,p,&pixel);
3802 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3803 q+=(ptrdiff_t) GetPixelChannels(image);
3810static void ImportRGBAQuantum(
const Image *image,QuantumInfo *quantum_info,
3811 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
3812 Quantum *magick_restrict q)
3820 assert(image != (Image *) NULL);
3821 assert(image->signature == MagickCoreSignature);
3822 switch (quantum_info->depth)
3829 for (x=0; x < (ssize_t) number_pixels; x++)
3831 p=PushCharPixel(p,&pixel);
3832 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3833 p=PushCharPixel(p,&pixel);
3834 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3835 p=PushCharPixel(p,&pixel);
3836 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
3837 p=PushCharPixel(p,&pixel);
3838 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
3839 p+=(ptrdiff_t) quantum_info->pad;
3840 q+=(ptrdiff_t) GetPixelChannels(image);
3850 if (quantum_info->pack == MagickFalse)
3863 for (x=0; x < (ssize_t) number_pixels; x++)
3865 for (i=0; i < 4; i++)
3871 p=PushLongPixel(quantum_info->endian,p,&pixel);
3872 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
3873 (((pixel >> 22) & 0x3ff) << 6)));
3878 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
3879 (((pixel >> 12) & 0x3ff) << 6)));
3884 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
3885 (((pixel >> 2) & 0x3ff) << 6)));
3891 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
3892 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
3893 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
3894 case 3: SetPixelAlpha(image,(Quantum) quantum,q);
break;
3898 p+=(ptrdiff_t) quantum_info->pad;
3899 q+=(ptrdiff_t) GetPixelChannels(image);
3903 for (x=0; x < (ssize_t) number_pixels; x++)
3905 p=PushQuantumPixel(quantum_info,p,&pixel);
3906 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
3907 p=PushQuantumPixel(quantum_info,p,&pixel);
3908 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
3910 p=PushQuantumPixel(quantum_info,p,&pixel);
3911 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
3913 p=PushQuantumPixel(quantum_info,p,&pixel);
3914 SetPixelAlpha(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
3916 q+=(ptrdiff_t) GetPixelChannels(image);
3925 if (quantum_info->format == FloatingPointQuantumFormat)
3927 for (x=0; x < (ssize_t) number_pixels; x++)
3929 p=PushShortPixel(quantum_info->endian,p,&pixel);
3930 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
3931 HalfToSinglePrecision(pixel)),q);
3932 p=PushShortPixel(quantum_info->endian,p,&pixel);
3933 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
3934 HalfToSinglePrecision(pixel)),q);
3935 p=PushShortPixel(quantum_info->endian,p,&pixel);
3936 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
3937 HalfToSinglePrecision(pixel)),q);
3938 p=PushShortPixel(quantum_info->endian,p,&pixel);
3939 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
3940 HalfToSinglePrecision(pixel)),q);
3941 p+=(ptrdiff_t) quantum_info->pad;
3942 q+=(ptrdiff_t) GetPixelChannels(image);
3946 for (x=0; x < (ssize_t) number_pixels; x++)
3948 p=PushShortPixel(quantum_info->endian,p,&pixel);
3949 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3950 p=PushShortPixel(quantum_info->endian,p,&pixel);
3951 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
3952 p=PushShortPixel(quantum_info->endian,p,&pixel);
3953 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
3954 p=PushShortPixel(quantum_info->endian,p,&pixel);
3955 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
3956 p+=(ptrdiff_t) quantum_info->pad;
3957 q+=(ptrdiff_t) GetPixelChannels(image);
3963 if (quantum_info->format == FloatingPointQuantumFormat)
3968 for (x=0; x < (ssize_t) number_pixels; x++)
3970 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3971 SetPixelRed(image,ClampToQuantum(pixel),q);
3972 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3973 SetPixelGreen(image,ClampToQuantum(pixel),q);
3974 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3975 SetPixelBlue(image,ClampToQuantum(pixel),q);
3976 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3977 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3978 p+=(ptrdiff_t) quantum_info->pad;
3979 q+=(ptrdiff_t) GetPixelChannels(image);
3988 for (x=0; x < (ssize_t) number_pixels; x++)
3990 p=PushLongPixel(quantum_info->endian,p,&pixel);
3991 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3992 p=PushLongPixel(quantum_info->endian,p,&pixel);
3993 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
3994 p=PushLongPixel(quantum_info->endian,p,&pixel);
3995 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
3996 p=PushLongPixel(quantum_info->endian,p,&pixel);
3997 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
3998 p+=(ptrdiff_t) quantum_info->pad;
3999 q+=(ptrdiff_t) GetPixelChannels(image);
4006 if (quantum_info->format == FloatingPointQuantumFormat)
4011 for (x=0; x < (ssize_t) number_pixels; x++)
4013 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4014 SetPixelRed(image,ClampToQuantum(pixel),q);
4015 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4016 SetPixelGreen(image,ClampToQuantum(pixel),q);
4017 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4018 SetPixelBlue(image,ClampToQuantum(pixel),q);
4019 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4020 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4021 p+=(ptrdiff_t) quantum_info->pad;
4022 q+=(ptrdiff_t) GetPixelChannels(image);
4030 if (quantum_info->format == FloatingPointQuantumFormat)
4035 for (x=0; x < (ssize_t) number_pixels; x++)
4037 p=PushDoublePixel(quantum_info,p,&pixel);
4038 SetPixelRed(image,ClampToQuantum(pixel),q);
4039 p=PushDoublePixel(quantum_info,p,&pixel);
4040 SetPixelGreen(image,ClampToQuantum(pixel),q);
4041 p=PushDoublePixel(quantum_info,p,&pixel);
4042 SetPixelBlue(image,ClampToQuantum(pixel),q);
4043 p=PushDoublePixel(quantum_info,p,&pixel);
4044 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4045 p+=(ptrdiff_t) quantum_info->pad;
4046 q+=(ptrdiff_t) GetPixelChannels(image);
4057 range=GetQuantumRange(quantum_info->depth);
4058 for (x=0; x < (ssize_t) number_pixels; x++)
4060 p=PushQuantumPixel(quantum_info,p,&pixel);
4061 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4062 p=PushQuantumPixel(quantum_info,p,&pixel);
4063 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4064 p=PushQuantumPixel(quantum_info,p,&pixel);
4065 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4066 p=PushQuantumPixel(quantum_info,p,&pixel);
4067 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
4068 q+=(ptrdiff_t) GetPixelChannels(image);
4075static void ImportRGBOQuantum(
const Image *image,QuantumInfo *quantum_info,
4076 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
4077 Quantum *magick_restrict q)
4085 assert(image != (Image *) NULL);
4086 assert(image->signature == MagickCoreSignature);
4087 switch (quantum_info->depth)
4094 for (x=0; x < (ssize_t) number_pixels; x++)
4096 p=PushCharPixel(p,&pixel);
4097 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
4098 p=PushCharPixel(p,&pixel);
4099 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
4100 p=PushCharPixel(p,&pixel);
4101 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
4102 p=PushCharPixel(p,&pixel);
4103 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
4104 p+=(ptrdiff_t) quantum_info->pad;
4105 q+=(ptrdiff_t) GetPixelChannels(image);
4115 if (quantum_info->pack == MagickFalse)
4128 for (x=0; x < (ssize_t) number_pixels; x++)
4130 for (i=0; i < 4; i++)
4136 p=PushLongPixel(quantum_info->endian,p,&pixel);
4137 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4138 (((pixel >> 22) & 0x3ff) << 6)));
4143 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4144 (((pixel >> 12) & 0x3ff) << 6)));
4149 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4150 (((pixel >> 2) & 0x3ff) << 6)));
4156 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
4157 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
4158 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
4159 case 3: SetPixelOpacity(image,(Quantum) quantum,q);
break;
4163 p+=(ptrdiff_t) quantum_info->pad;
4164 q+=(ptrdiff_t) GetPixelChannels(image);
4168 for (x=0; x < (ssize_t) number_pixels; x++)
4170 p=PushQuantumPixel(quantum_info,p,&pixel);
4171 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
4172 p=PushQuantumPixel(quantum_info,p,&pixel);
4173 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4175 p=PushQuantumPixel(quantum_info,p,&pixel);
4176 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4178 p=PushQuantumPixel(quantum_info,p,&pixel);
4179 SetPixelOpacity(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4181 q+=(ptrdiff_t) GetPixelChannels(image);
4190 if (quantum_info->format == FloatingPointQuantumFormat)
4192 for (x=0; x < (ssize_t) number_pixels; x++)
4194 p=PushShortPixel(quantum_info->endian,p,&pixel);
4195 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
4196 HalfToSinglePrecision(pixel)),q);
4197 p=PushShortPixel(quantum_info->endian,p,&pixel);
4198 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
4199 HalfToSinglePrecision(pixel)),q);
4200 p=PushShortPixel(quantum_info->endian,p,&pixel);
4201 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
4202 HalfToSinglePrecision(pixel)),q);
4203 p=PushShortPixel(quantum_info->endian,p,&pixel);
4204 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
4205 HalfToSinglePrecision(pixel)),q);
4206 p+=(ptrdiff_t) quantum_info->pad;
4207 q+=(ptrdiff_t) GetPixelChannels(image);
4211 for (x=0; x < (ssize_t) number_pixels; x++)
4213 p=PushShortPixel(quantum_info->endian,p,&pixel);
4214 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
4215 p=PushShortPixel(quantum_info->endian,p,&pixel);
4216 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4217 p=PushShortPixel(quantum_info->endian,p,&pixel);
4218 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4219 p=PushShortPixel(quantum_info->endian,p,&pixel);
4220 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
4221 p+=(ptrdiff_t) quantum_info->pad;
4222 q+=(ptrdiff_t) GetPixelChannels(image);
4228 if (quantum_info->format == FloatingPointQuantumFormat)
4233 for (x=0; x < (ssize_t) number_pixels; x++)
4235 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4236 SetPixelRed(image,ClampToQuantum(pixel),q);
4237 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4238 SetPixelGreen(image,ClampToQuantum(pixel),q);
4239 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4240 SetPixelBlue(image,ClampToQuantum(pixel),q);
4241 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4242 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4243 p+=(ptrdiff_t) quantum_info->pad;
4244 q+=(ptrdiff_t) GetPixelChannels(image);
4253 for (x=0; x < (ssize_t) number_pixels; x++)
4255 p=PushLongPixel(quantum_info->endian,p,&pixel);
4256 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4257 p=PushLongPixel(quantum_info->endian,p,&pixel);
4258 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4259 p=PushLongPixel(quantum_info->endian,p,&pixel);
4260 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4261 p=PushLongPixel(quantum_info->endian,p,&pixel);
4262 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
4263 p+=(ptrdiff_t) quantum_info->pad;
4264 q+=(ptrdiff_t) GetPixelChannels(image);
4271 if (quantum_info->format == FloatingPointQuantumFormat)
4276 for (x=0; x < (ssize_t) number_pixels; x++)
4278 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4279 SetPixelRed(image,ClampToQuantum(pixel),q);
4280 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4281 SetPixelGreen(image,ClampToQuantum(pixel),q);
4282 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4283 SetPixelBlue(image,ClampToQuantum(pixel),q);
4284 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4285 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4286 p+=(ptrdiff_t) quantum_info->pad;
4287 q+=(ptrdiff_t) GetPixelChannels(image);
4295 if (quantum_info->format == FloatingPointQuantumFormat)
4300 for (x=0; x < (ssize_t) number_pixels; x++)
4302 p=PushDoublePixel(quantum_info,p,&pixel);
4303 SetPixelRed(image,ClampToQuantum(pixel),q);
4304 p=PushDoublePixel(quantum_info,p,&pixel);
4305 SetPixelGreen(image,ClampToQuantum(pixel),q);
4306 p=PushDoublePixel(quantum_info,p,&pixel);
4307 SetPixelBlue(image,ClampToQuantum(pixel),q);
4308 p=PushDoublePixel(quantum_info,p,&pixel);
4309 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4310 p+=(ptrdiff_t) quantum_info->pad;
4311 q+=(ptrdiff_t) GetPixelChannels(image);
4322 range=GetQuantumRange(quantum_info->depth);
4323 for (x=0; x < (ssize_t) number_pixels; x++)
4325 p=PushQuantumPixel(quantum_info,p,&pixel);
4326 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4327 p=PushQuantumPixel(quantum_info,p,&pixel);
4328 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4329 p=PushQuantumPixel(quantum_info,p,&pixel);
4330 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4331 p=PushQuantumPixel(quantum_info,p,&pixel);
4332 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
4333 q+=(ptrdiff_t) GetPixelChannels(image);
4340MagickExport
size_t ImportQuantumPixels(
const Image *image,
4341 CacheView *image_view,QuantumInfo *quantum_info,
4342 const QuantumType quantum_type,
const unsigned char *magick_restrict pixels,
4343 ExceptionInfo *exception)
4360 assert(image != (Image *) NULL);
4361 assert(image->signature == MagickCoreSignature);
4362 assert(quantum_info != (QuantumInfo *) NULL);
4363 assert(quantum_info->signature == MagickCoreSignature);
4364 assert(exception != (ExceptionInfo *) NULL);
4365 assert(exception->signature == MagickCoreSignature);
4366 if (IsEventLogging() != MagickFalse)
4367 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4368 if (pixels == (
const unsigned char *) NULL)
4369 pixels=(
const unsigned char *) GetQuantumPixels(quantum_info);
4372 if (image_view == (CacheView *) NULL)
4374 number_pixels=GetImageExtent(image);
4375 q=GetAuthenticPixelQueue(image);
4379 number_pixels=GetCacheViewExtent(image_view);
4380 q=GetCacheViewAuthenticPixelQueue(image_view);
4382 if (q == (Quantum *) NULL)
4384 ResetQuantumState(quantum_info);
4385 extent=GetQuantumExtent(image,quantum_info,quantum_type);
4386 switch (quantum_type)
4390 ImportAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
4395 ImportBGRQuantum(image,quantum_info,number_pixels,p,q);
4400 ImportBGRAQuantum(image,quantum_info,number_pixels,p,q);
4405 ImportBGROQuantum(image,quantum_info,number_pixels,p,q);
4410 ImportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
4416 ImportPixelChannel(image,quantum_info,number_pixels,p,q,BluePixelChannel);
4421 ImportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
4426 ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
4429 case MultispectralQuantum:
4431 ImportMultispectralQuantum(image,quantum_info,number_pixels,p,q,exception);
4436 ImportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
4441 ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
4446 ImportGrayQuantum(image,quantum_info,number_pixels,p,q);
4449 case GrayAlphaQuantum:
4451 ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
4455 case MagentaQuantum:
4457 ImportPixelChannel(image,quantum_info,number_pixels,p,q,GreenPixelChannel);
4462 ImportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
4465 case IndexAlphaQuantum:
4467 ImportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
4470 case OpacityQuantum:
4472 ImportOpacityQuantum(image,quantum_info,number_pixels,p,q,exception);
4478 ImportPixelChannel(image,quantum_info,number_pixels,p,q,RedPixelChannel);
4484 ImportRGBQuantum(image,quantum_info,number_pixels,p,q);
4490 ImportRGBAQuantum(image,quantum_info,number_pixels,p,q);
4495 ImportRGBOQuantum(image,quantum_info,number_pixels,p,q);
4501 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
4506 q=GetAuthenticPixelQueue(image);
4507 if (image_view != (CacheView *) NULL)
4508 q=GetCacheViewAuthenticPixelQueue(image_view);
4509 for (x=0; x < (ssize_t) number_pixels; x++)
4511 quantum=GetPixelRed(image,q);
4512 SetPixelRed(image,GetPixelGreen(image,q),q);
4513 SetPixelGreen(image,quantum,q);
4514 q+=(ptrdiff_t) GetPixelChannels(image);
4517 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
4526 q=GetAuthenticPixelQueue(image);
4527 if (image_view != (CacheView *) NULL)
4528 q=GetCacheViewAuthenticPixelQueue(image_view);
4529 for (x=0; x < (ssize_t) number_pixels; x++)
4534 Sa=QuantumScale*(double) GetPixelAlpha(image,q);
4535 gamma=MagickSafeReciprocal(Sa);
4536 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
4538 PixelChannel channel = GetPixelChannelChannel(image,i);
4539 PixelTrait traits = GetPixelChannelTraits(image,channel);
4540 if ((channel == AlphaPixelChannel) ||
4541 ((traits & UpdatePixelTrait) == 0))
4543 q[i]=ClampToQuantum(gamma*(
double) q[i]);
4545 q+=(ptrdiff_t) GetPixelChannels(image);