47#include "MagickCore/studio.h"
48#include "MagickCore/property.h"
49#include "MagickCore/blob.h"
50#include "MagickCore/blob-private.h"
51#include "MagickCore/color-private.h"
52#include "MagickCore/exception.h"
53#include "MagickCore/exception-private.h"
54#include "MagickCore/cache.h"
55#include "MagickCore/constitute.h"
56#include "MagickCore/delegate.h"
57#include "MagickCore/geometry.h"
58#include "MagickCore/list.h"
59#include "MagickCore/magick.h"
60#include "MagickCore/memory_.h"
61#include "MagickCore/monitor.h"
62#include "MagickCore/option.h"
63#include "MagickCore/pixel.h"
64#include "MagickCore/pixel-accessor.h"
65#include "MagickCore/quantum.h"
66#include "MagickCore/quantum-private.h"
67#include "MagickCore/resource_.h"
68#include "MagickCore/semaphore.h"
69#include "MagickCore/statistic.h"
70#include "MagickCore/stream.h"
71#include "MagickCore/string_.h"
72#include "MagickCore/utility.h"
113static inline Quantum PushColormapIndex(
const Image *image,
const size_t index,
114 MagickBooleanType *range_exception)
116 if (index < image->colors)
117 return((Quantum) index);
118 *range_exception=MagickTrue;
122static inline const unsigned char *PushDoublePixel(
QuantumInfo *quantum_info,
123 const unsigned char *magick_restrict pixels,
double *pixel)
131 if (quantum_info->endian == LSBEndian)
133 quantum[0]=(*pixels++);
134 quantum[1]=(*pixels++);
135 quantum[2]=(*pixels++);
136 quantum[3]=(*pixels++);
137 quantum[4]=(*pixels++);
138 quantum[5]=(*pixels++);
139 quantum[6]=(*pixels++);
140 quantum[7]=(*pixels++);
144 quantum[7]=(*pixels++);
145 quantum[6]=(*pixels++);
146 quantum[5]=(*pixels++);
147 quantum[4]=(*pixels++);
148 quantum[3]=(*pixels++);
149 quantum[2]=(*pixels++);
150 quantum[1]=(*pixels++);
151 quantum[0]=(*pixels++);
153 p=(
double *) quantum;
155 *pixel-=quantum_info->minimum;
156 *pixel*=quantum_info->scale;
160static inline float ScaleFloatPixel(
const QuantumInfo *quantum_info,
161 const unsigned char *quantum)
166 pixel=(double) (*((
float *) quantum));
167 pixel-=quantum_info->minimum;
168 pixel*=quantum_info->scale;
169 if (pixel < (
double) -FLT_MAX)
171 if (pixel > (
double) FLT_MAX)
176static inline const unsigned char *PushQuantumFloatPixel(
177 const QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,
183 if (quantum_info->endian == LSBEndian)
185 quantum[0]=(*pixels++);
186 quantum[1]=(*pixels++);
187 quantum[2]=(*pixels++);
188 quantum[3]=(*pixels++);
192 quantum[3]=(*pixels++);
193 quantum[2]=(*pixels++);
194 quantum[1]=(*pixels++);
195 quantum[0]=(*pixels++);
197 *pixel=ScaleFloatPixel(quantum_info,quantum);
201static inline const unsigned char *PushQuantumFloat24Pixel(
202 const QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,
208 if (quantum_info->endian == LSBEndian)
210 quantum[0]=(*pixels++);
211 quantum[1]=(*pixels++);
212 quantum[2]=(*pixels++);
216 quantum[2]=(*pixels++);
217 quantum[1]=(*pixels++);
218 quantum[0]=(*pixels++);
220 if ((quantum[0] | quantum[1] | quantum[2]) == 0U)
228 sign_bit=(quantum[2] & 0x80);
229 exponent=(quantum[2] & 0x7F);
231 exponent=exponent-63+127;
232 quantum[3]=sign_bit | (exponent >> 1);
233 quantum[2]=((exponent & 1) << 7) | ((quantum[1] & 0xFE) >> 1);
234 quantum[1]=((quantum[1] & 0x01) << 7) | ((quantum[0] & 0xFE) >> 1);
235 quantum[0]=(quantum[0] & 0x01) << 7;
237 *pixel=ScaleFloatPixel(quantum_info,quantum);
241static inline const unsigned char *PushQuantumPixel(
QuantumInfo *quantum_info,
242 const unsigned char *magick_restrict pixels,
unsigned int *quantum)
250 *quantum=(QuantumAny) 0;
251 for (i=(ssize_t) quantum_info->depth; i > 0L; )
253 if (quantum_info->state.bits == 0UL)
255 quantum_info->state.pixel=(*pixels++);
256 quantum_info->state.bits=8UL;
258 quantum_bits=(size_t) i;
259 if (quantum_bits > quantum_info->state.bits)
260 quantum_bits=quantum_info->state.bits;
261 i-=(ssize_t) quantum_bits;
262 quantum_info->state.bits-=quantum_bits;
263 if (quantum_bits < 64)
264 *quantum=(
unsigned int) (((MagickSizeType) *quantum << quantum_bits) |
265 ((quantum_info->state.pixel >> quantum_info->state.bits) &~
266 ((~0UL) << quantum_bits)));
271static inline const unsigned char *PushQuantumLongPixel(
272 QuantumInfo *quantum_info,
const unsigned char *magick_restrict pixels,
273 unsigned int *quantum)
282 for (i=(ssize_t) quantum_info->depth; i > 0; )
284 if (quantum_info->state.bits == 0)
286 pixels=PushLongPixel(quantum_info->endian,pixels,
287 &quantum_info->state.pixel);
288 quantum_info->state.bits=32U;
290 quantum_bits=(size_t) i;
291 if (quantum_bits > quantum_info->state.bits)
292 quantum_bits=quantum_info->state.bits;
293 *quantum|=(((quantum_info->state.pixel >> (32U-quantum_info->state.bits)) &
294 quantum_info->state.mask[quantum_bits]) << ((ssize_t)
295 quantum_info->depth-i));
296 i-=(ssize_t) quantum_bits;
297 quantum_info->state.bits-=quantum_bits;
303 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
304 Quantum *magick_restrict q)
312 assert(image != (
Image *) NULL);
313 assert(image->signature == MagickCoreSignature);
314 switch (quantum_info->depth)
321 for (x=0; x < (ssize_t) number_pixels; x++)
323 p=PushCharPixel(p,&pixel);
324 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
325 p+=quantum_info->pad;
326 q+=GetPixelChannels(image);
335 if (quantum_info->format == FloatingPointQuantumFormat)
337 for (x=0; x < (ssize_t) number_pixels; x++)
339 p=PushShortPixel(quantum_info->endian,p,&pixel);
340 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
341 HalfToSinglePrecision(pixel)),q);
342 p+=quantum_info->pad;
343 q+=GetPixelChannels(image);
347 for (x=0; x < (ssize_t) number_pixels; x++)
349 p=PushShortPixel(quantum_info->endian,p,&pixel);
350 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
351 p+=quantum_info->pad;
352 q+=GetPixelChannels(image);
358 if (quantum_info->format == FloatingPointQuantumFormat)
363 for (x=0; x < (ssize_t) number_pixels; x++)
365 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
366 SetPixelAlpha(image,ClampToQuantum(pixel),q);
367 p+=quantum_info->pad;
368 q+=GetPixelChannels(image);
377 for (x=0; x < (ssize_t) number_pixels; x++)
379 p=PushLongPixel(quantum_info->endian,p,&pixel);
380 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
381 p+=quantum_info->pad;
382 q+=GetPixelChannels(image);
389 if (quantum_info->format == FloatingPointQuantumFormat)
394 for (x=0; x < (ssize_t) number_pixels; x++)
396 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
397 SetPixelAlpha(image,ClampToQuantum(pixel),q);
398 p+=quantum_info->pad;
399 q+=GetPixelChannels(image);
407 if (quantum_info->format == FloatingPointQuantumFormat)
412 for (x=0; x < (ssize_t) number_pixels; x++)
414 p=PushDoublePixel(quantum_info,p,&pixel);
415 SetPixelAlpha(image,ClampToQuantum(pixel),q);
416 p+=quantum_info->pad;
417 q+=GetPixelChannels(image);
428 range=GetQuantumRange(quantum_info->depth);
429 for (x=0; x < (ssize_t) number_pixels; x++)
431 p=PushQuantumPixel(quantum_info,p,&pixel);
432 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
433 p+=quantum_info->pad;
434 q+=GetPixelChannels(image);
442 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
443 Quantum *magick_restrict q)
454 assert(image != (
Image *) NULL);
455 assert(image->signature == MagickCoreSignature);
456 switch (quantum_info->depth)
463 for (x=0; x < (ssize_t) number_pixels; x++)
465 p=PushCharPixel(p,&pixel);
466 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
467 p=PushCharPixel(p,&pixel);
468 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
469 p=PushCharPixel(p,&pixel);
470 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
471 SetPixelAlpha(image,OpaqueAlpha,q);
472 p+=quantum_info->pad;
473 q+=GetPixelChannels(image);
482 range=GetQuantumRange(quantum_info->depth);
483 if (quantum_info->pack == MagickFalse)
485 for (x=0; x < (ssize_t) number_pixels; x++)
487 p=PushLongPixel(quantum_info->endian,p,&pixel);
488 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
489 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
491 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
492 p+=quantum_info->pad;
493 q+=GetPixelChannels(image);
497 if (quantum_info->quantum == 32U)
499 for (x=0; x < (ssize_t) number_pixels; x++)
501 p=PushQuantumLongPixel(quantum_info,p,&pixel);
502 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
503 p=PushQuantumLongPixel(quantum_info,p,&pixel);
504 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
505 p=PushQuantumLongPixel(quantum_info,p,&pixel);
506 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
507 q+=GetPixelChannels(image);
511 for (x=0; x < (ssize_t) number_pixels; x++)
513 p=PushQuantumPixel(quantum_info,p,&pixel);
514 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
515 p=PushQuantumPixel(quantum_info,p,&pixel);
516 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
517 p=PushQuantumPixel(quantum_info,p,&pixel);
518 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
519 q+=GetPixelChannels(image);
525 range=GetQuantumRange(quantum_info->depth);
526 if (quantum_info->pack == MagickFalse)
531 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
533 p=PushShortPixel(quantum_info->endian,p,&pixel);
539 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
545 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
551 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
553 q+=GetPixelChannels(image);
557 p=PushShortPixel(quantum_info->endian,p,&pixel);
563 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
569 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
575 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
577 q+=GetPixelChannels(image);
581 p+=quantum_info->pad;
583 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
585 p=PushShortPixel(quantum_info->endian,p,&pixel);
591 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
597 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
603 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
605 q+=GetPixelChannels(image);
609 p+=quantum_info->pad;
620 if (quantum_info->quantum == 32U)
622 for (x=0; x < (ssize_t) number_pixels; x++)
624 p=PushQuantumLongPixel(quantum_info,p,&pixel);
625 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
626 p=PushQuantumLongPixel(quantum_info,p,&pixel);
627 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
628 p=PushQuantumLongPixel(quantum_info,p,&pixel);
629 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
630 q+=GetPixelChannels(image);
634 for (x=0; x < (ssize_t) number_pixels; x++)
636 p=PushQuantumPixel(quantum_info,p,&pixel);
637 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
638 p=PushQuantumPixel(quantum_info,p,&pixel);
639 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
640 p=PushQuantumPixel(quantum_info,p,&pixel);
641 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
642 q+=GetPixelChannels(image);
652 if (quantum_info->format == FloatingPointQuantumFormat)
654 for (x=0; x < (ssize_t) number_pixels; x++)
656 p=PushShortPixel(quantum_info->endian,p,&pixel);
657 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
658 HalfToSinglePrecision(pixel)),q);
659 p=PushShortPixel(quantum_info->endian,p,&pixel);
660 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
661 HalfToSinglePrecision(pixel)),q);
662 p=PushShortPixel(quantum_info->endian,p,&pixel);
663 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
664 HalfToSinglePrecision(pixel)),q);
665 p+=quantum_info->pad;
666 q+=GetPixelChannels(image);
670 for (x=0; x < (ssize_t) number_pixels; x++)
672 p=PushShortPixel(quantum_info->endian,p,&pixel);
673 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
674 p=PushShortPixel(quantum_info->endian,p,&pixel);
675 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
676 p=PushShortPixel(quantum_info->endian,p,&pixel);
677 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
678 p+=quantum_info->pad;
679 q+=GetPixelChannels(image);
685 if (quantum_info->format == FloatingPointQuantumFormat)
690 for (x=0; x < (ssize_t) number_pixels; x++)
692 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
693 SetPixelRed(image,ClampToQuantum(pixel),q);
694 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
695 SetPixelGreen(image,ClampToQuantum(pixel),q);
696 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
697 SetPixelBlue(image,ClampToQuantum(pixel),q);
698 p+=quantum_info->pad;
699 q+=GetPixelChannels(image);
708 for (x=0; x < (ssize_t) number_pixels; x++)
710 p=PushLongPixel(quantum_info->endian,p,&pixel);
711 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
712 p=PushLongPixel(quantum_info->endian,p,&pixel);
713 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
714 p=PushLongPixel(quantum_info->endian,p,&pixel);
715 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
716 p+=quantum_info->pad;
717 q+=GetPixelChannels(image);
724 if (quantum_info->format == FloatingPointQuantumFormat)
729 for (x=0; x < (ssize_t) number_pixels; x++)
731 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
732 SetPixelRed(image,ClampToQuantum(pixel),q);
733 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
734 SetPixelGreen(image,ClampToQuantum(pixel),q);
735 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
736 SetPixelBlue(image,ClampToQuantum(pixel),q);
737 p+=quantum_info->pad;
738 q+=GetPixelChannels(image);
746 if (quantum_info->format == FloatingPointQuantumFormat)
751 for (x=0; x < (ssize_t) number_pixels; x++)
753 p=PushDoublePixel(quantum_info,p,&pixel);
754 SetPixelRed(image,ClampToQuantum(pixel),q);
755 p=PushDoublePixel(quantum_info,p,&pixel);
756 SetPixelGreen(image,ClampToQuantum(pixel),q);
757 p=PushDoublePixel(quantum_info,p,&pixel);
758 SetPixelBlue(image,ClampToQuantum(pixel),q);
759 p+=quantum_info->pad;
760 q+=GetPixelChannels(image);
771 range=GetQuantumRange(quantum_info->depth);
772 for (x=0; x < (ssize_t) number_pixels; x++)
774 p=PushQuantumPixel(quantum_info,p,&pixel);
775 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
776 p=PushQuantumPixel(quantum_info,p,&pixel);
777 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
778 p=PushQuantumPixel(quantum_info,p,&pixel);
779 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
780 q+=GetPixelChannels(image);
788 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
789 Quantum *magick_restrict q)
797 assert(image != (
Image *) NULL);
798 assert(image->signature == MagickCoreSignature);
799 switch (quantum_info->depth)
806 for (x=0; x < (ssize_t) number_pixels; x++)
808 p=PushCharPixel(p,&pixel);
809 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
810 p=PushCharPixel(p,&pixel);
811 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
812 p=PushCharPixel(p,&pixel);
813 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
814 p=PushCharPixel(p,&pixel);
815 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
816 p+=quantum_info->pad;
817 q+=GetPixelChannels(image);
827 if (quantum_info->pack == MagickFalse)
840 for (x=0; x < (ssize_t) number_pixels; x++)
842 for (i=0; i < 4; i++)
848 p=PushLongPixel(quantum_info->endian,p,&pixel);
849 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
850 (((pixel >> 22) & 0x3ff) << 6)));
855 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
856 (((pixel >> 12) & 0x3ff) << 6)));
861 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
862 (((pixel >> 2) & 0x3ff) << 6)));
868 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
869 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
870 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
871 case 3: SetPixelAlpha(image,(Quantum) quantum,q);
break;
875 p+=quantum_info->pad;
876 q+=GetPixelChannels(image);
880 for (x=0; x < (ssize_t) number_pixels; x++)
882 p=PushQuantumPixel(quantum_info,p,&pixel);
883 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
884 p=PushQuantumPixel(quantum_info,p,&pixel);
885 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
887 p=PushQuantumPixel(quantum_info,p,&pixel);
888 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
890 p=PushQuantumPixel(quantum_info,p,&pixel);
891 SetPixelAlpha(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
893 q+=GetPixelChannels(image);
902 if (quantum_info->format == FloatingPointQuantumFormat)
904 for (x=0; x < (ssize_t) number_pixels; x++)
906 p=PushShortPixel(quantum_info->endian,p,&pixel);
907 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
908 HalfToSinglePrecision(pixel)),q);
909 p=PushShortPixel(quantum_info->endian,p,&pixel);
910 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
911 HalfToSinglePrecision(pixel)),q);
912 p=PushShortPixel(quantum_info->endian,p,&pixel);
913 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
914 HalfToSinglePrecision(pixel)),q);
915 p=PushShortPixel(quantum_info->endian,p,&pixel);
916 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
917 HalfToSinglePrecision(pixel)),q);
918 p+=quantum_info->pad;
919 q+=GetPixelChannels(image);
923 for (x=0; x < (ssize_t) number_pixels; x++)
925 p=PushShortPixel(quantum_info->endian,p,&pixel);
926 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
927 p=PushShortPixel(quantum_info->endian,p,&pixel);
928 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
929 p=PushShortPixel(quantum_info->endian,p,&pixel);
930 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
931 p=PushShortPixel(quantum_info->endian,p,&pixel);
932 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
933 p+=quantum_info->pad;
934 q+=GetPixelChannels(image);
940 if (quantum_info->format == FloatingPointQuantumFormat)
945 for (x=0; x < (ssize_t) number_pixels; x++)
947 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
948 SetPixelRed(image,ClampToQuantum(pixel),q);
949 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
950 SetPixelGreen(image,ClampToQuantum(pixel),q);
951 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
952 SetPixelBlue(image,ClampToQuantum(pixel),q);
953 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
954 SetPixelAlpha(image,ClampToQuantum(pixel),q);
955 p+=quantum_info->pad;
956 q+=GetPixelChannels(image);
965 for (x=0; x < (ssize_t) number_pixels; x++)
967 p=PushLongPixel(quantum_info->endian,p,&pixel);
968 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
969 p=PushLongPixel(quantum_info->endian,p,&pixel);
970 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
971 p=PushLongPixel(quantum_info->endian,p,&pixel);
972 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
973 p=PushLongPixel(quantum_info->endian,p,&pixel);
974 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
975 p+=quantum_info->pad;
976 q+=GetPixelChannels(image);
983 if (quantum_info->format == FloatingPointQuantumFormat)
988 for (x=0; x < (ssize_t) number_pixels; x++)
990 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
991 SetPixelRed(image,ClampToQuantum(pixel),q);
992 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
993 SetPixelGreen(image,ClampToQuantum(pixel),q);
994 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
995 SetPixelBlue(image,ClampToQuantum(pixel),q);
996 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
997 SetPixelAlpha(image,ClampToQuantum(pixel),q);
998 p+=quantum_info->pad;
999 q+=GetPixelChannels(image);
1007 if (quantum_info->format == FloatingPointQuantumFormat)
1012 for (x=0; x < (ssize_t) number_pixels; x++)
1014 p=PushDoublePixel(quantum_info,p,&pixel);
1015 SetPixelRed(image,ClampToQuantum(pixel),q);
1016 p=PushDoublePixel(quantum_info,p,&pixel);
1017 SetPixelGreen(image,ClampToQuantum(pixel),q);
1018 p=PushDoublePixel(quantum_info,p,&pixel);
1019 SetPixelBlue(image,ClampToQuantum(pixel),q);
1020 p=PushDoublePixel(quantum_info,p,&pixel);
1021 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1022 p+=quantum_info->pad;
1023 q+=GetPixelChannels(image);
1034 range=GetQuantumRange(quantum_info->depth);
1035 for (x=0; x < (ssize_t) number_pixels; x++)
1037 p=PushQuantumPixel(quantum_info,p,&pixel);
1038 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1039 p=PushQuantumPixel(quantum_info,p,&pixel);
1040 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1041 p=PushQuantumPixel(quantum_info,p,&pixel);
1042 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1043 p=PushQuantumPixel(quantum_info,p,&pixel);
1044 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1045 q+=GetPixelChannels(image);
1053 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1054 Quantum *magick_restrict q)
1062 assert(image != (
Image *) NULL);
1063 assert(image->signature == MagickCoreSignature);
1064 switch (quantum_info->depth)
1071 for (x=0; x < (ssize_t) number_pixels; x++)
1073 p=PushCharPixel(p,&pixel);
1074 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1075 p=PushCharPixel(p,&pixel);
1076 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1077 p=PushCharPixel(p,&pixel);
1078 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1079 p=PushCharPixel(p,&pixel);
1080 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
1081 p+=quantum_info->pad;
1082 q+=GetPixelChannels(image);
1092 if (quantum_info->pack == MagickFalse)
1105 for (x=0; x < (ssize_t) number_pixels; x++)
1107 for (i=0; i < 4; i++)
1113 p=PushLongPixel(quantum_info->endian,p,&pixel);
1114 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1115 (((pixel >> 22) & 0x3ff) << 6)));
1120 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1121 (((pixel >> 12) & 0x3ff) << 6)));
1126 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1127 (((pixel >> 2) & 0x3ff) << 6)));
1133 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
1134 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
1135 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
1136 case 3: SetPixelOpacity(image,(Quantum) quantum,q);
break;
1140 p+=quantum_info->pad;
1141 q+=GetPixelChannels(image);
1145 for (x=0; x < (ssize_t) number_pixels; x++)
1147 p=PushQuantumPixel(quantum_info,p,&pixel);
1148 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
1149 p=PushQuantumPixel(quantum_info,p,&pixel);
1150 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
1152 p=PushQuantumPixel(quantum_info,p,&pixel);
1153 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
1155 p=PushQuantumPixel(quantum_info,p,&pixel);
1156 SetPixelOpacity(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
1158 q+=GetPixelChannels(image);
1167 if (quantum_info->format == FloatingPointQuantumFormat)
1169 for (x=0; x < (ssize_t) number_pixels; x++)
1171 p=PushShortPixel(quantum_info->endian,p,&pixel);
1172 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
1173 HalfToSinglePrecision(pixel)),q);
1174 p=PushShortPixel(quantum_info->endian,p,&pixel);
1175 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
1176 HalfToSinglePrecision(pixel)),q);
1177 p=PushShortPixel(quantum_info->endian,p,&pixel);
1178 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1179 HalfToSinglePrecision(pixel)),q);
1180 p=PushShortPixel(quantum_info->endian,p,&pixel);
1181 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
1182 HalfToSinglePrecision(pixel)),q);
1183 p+=quantum_info->pad;
1184 q+=GetPixelChannels(image);
1188 for (x=0; x < (ssize_t) number_pixels; x++)
1190 p=PushShortPixel(quantum_info->endian,p,&pixel);
1191 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1192 p=PushShortPixel(quantum_info->endian,p,&pixel);
1193 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1194 p=PushShortPixel(quantum_info->endian,p,&pixel);
1195 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1196 p=PushShortPixel(quantum_info->endian,p,&pixel);
1197 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
1198 p+=quantum_info->pad;
1199 q+=GetPixelChannels(image);
1205 if (quantum_info->format == FloatingPointQuantumFormat)
1210 for (x=0; x < (ssize_t) number_pixels; x++)
1212 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1213 SetPixelRed(image,ClampToQuantum(pixel),q);
1214 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1215 SetPixelGreen(image,ClampToQuantum(pixel),q);
1216 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1217 SetPixelBlue(image,ClampToQuantum(pixel),q);
1218 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1219 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1220 p+=quantum_info->pad;
1221 q+=GetPixelChannels(image);
1230 for (x=0; x < (ssize_t) number_pixels; x++)
1232 p=PushLongPixel(quantum_info->endian,p,&pixel);
1233 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1234 p=PushLongPixel(quantum_info->endian,p,&pixel);
1235 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1236 p=PushLongPixel(quantum_info->endian,p,&pixel);
1237 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1238 p=PushLongPixel(quantum_info->endian,p,&pixel);
1239 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
1240 p+=quantum_info->pad;
1241 q+=GetPixelChannels(image);
1248 if (quantum_info->format == FloatingPointQuantumFormat)
1253 for (x=0; x < (ssize_t) number_pixels; x++)
1255 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1256 SetPixelRed(image,ClampToQuantum(pixel),q);
1257 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1258 SetPixelGreen(image,ClampToQuantum(pixel),q);
1259 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1260 SetPixelBlue(image,ClampToQuantum(pixel),q);
1261 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1262 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1263 p+=quantum_info->pad;
1264 q+=GetPixelChannels(image);
1272 if (quantum_info->format == FloatingPointQuantumFormat)
1277 for (x=0; x < (ssize_t) number_pixels; x++)
1279 p=PushDoublePixel(quantum_info,p,&pixel);
1280 SetPixelRed(image,ClampToQuantum(pixel),q);
1281 p=PushDoublePixel(quantum_info,p,&pixel);
1282 SetPixelGreen(image,ClampToQuantum(pixel),q);
1283 p=PushDoublePixel(quantum_info,p,&pixel);
1284 SetPixelBlue(image,ClampToQuantum(pixel),q);
1285 p=PushDoublePixel(quantum_info,p,&pixel);
1286 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1287 p+=quantum_info->pad;
1288 q+=GetPixelChannels(image);
1299 range=GetQuantumRange(quantum_info->depth);
1300 for (x=0; x < (ssize_t) number_pixels; x++)
1302 p=PushQuantumPixel(quantum_info,p,&pixel);
1303 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1304 p=PushQuantumPixel(quantum_info,p,&pixel);
1305 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1306 p=PushQuantumPixel(quantum_info,p,&pixel);
1307 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1308 p=PushQuantumPixel(quantum_info,p,&pixel);
1309 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
1310 q+=GetPixelChannels(image);
1317static void ImportBlackQuantum(
const Image *image,
QuantumInfo *quantum_info,
1318 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1327 if (image->colorspace != CMYKColorspace)
1329 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1330 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1333 switch (quantum_info->depth)
1340 for (x=0; x < (ssize_t) number_pixels; x++)
1342 p=PushCharPixel(p,&pixel);
1343 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1344 p+=quantum_info->pad;
1345 q+=GetPixelChannels(image);
1354 if (quantum_info->format == FloatingPointQuantumFormat)
1356 for (x=0; x < (ssize_t) number_pixels; x++)
1358 p=PushShortPixel(quantum_info->endian,p,&pixel);
1359 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*(
double)
1360 HalfToSinglePrecision(pixel)),q);
1361 p+=quantum_info->pad;
1362 q+=GetPixelChannels(image);
1366 for (x=0; x < (ssize_t) number_pixels; x++)
1368 p=PushShortPixel(quantum_info->endian,p,&pixel);
1369 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1370 p+=quantum_info->pad;
1371 q+=GetPixelChannels(image);
1377 if (quantum_info->format == FloatingPointQuantumFormat)
1382 for (x=0; x < (ssize_t) number_pixels; x++)
1384 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1385 SetPixelBlack(image,ClampToQuantum(pixel),q);
1386 p+=quantum_info->pad;
1387 q+=GetPixelChannels(image);
1396 for (x=0; x < (ssize_t) number_pixels; x++)
1398 p=PushLongPixel(quantum_info->endian,p,&pixel);
1399 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1400 p+=quantum_info->pad;
1401 q+=GetPixelChannels(image);
1408 if (quantum_info->format == FloatingPointQuantumFormat)
1413 for (x=0; x < (ssize_t) number_pixels; x++)
1415 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1416 SetPixelBlack(image,ClampToQuantum(pixel),q);
1417 p+=quantum_info->pad;
1418 q+=GetPixelChannels(image);
1426 if (quantum_info->format == FloatingPointQuantumFormat)
1431 for (x=0; x < (ssize_t) number_pixels; x++)
1433 p=PushDoublePixel(quantum_info,p,&pixel);
1434 SetPixelBlack(image,ClampToQuantum(pixel),q);
1435 p+=quantum_info->pad;
1436 q+=GetPixelChannels(image);
1447 range=GetQuantumRange(quantum_info->depth);
1448 for (x=0; x < (ssize_t) number_pixels; x++)
1450 p=PushQuantumPixel(quantum_info,p,&pixel);
1451 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1452 p+=quantum_info->pad;
1453 q+=GetPixelChannels(image);
1461 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1462 Quantum *magick_restrict q)
1470 assert(image != (
Image *) NULL);
1471 assert(image->signature == MagickCoreSignature);
1472 switch (quantum_info->depth)
1479 for (x=0; x < (ssize_t) number_pixels; x++)
1481 p=PushCharPixel(p,&pixel);
1482 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1483 p+=quantum_info->pad;
1484 q+=GetPixelChannels(image);
1493 if (quantum_info->format == FloatingPointQuantumFormat)
1495 for (x=0; x < (ssize_t) number_pixels; x++)
1497 p=PushShortPixel(quantum_info->endian,p,&pixel);
1498 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1499 HalfToSinglePrecision(pixel)),q);
1500 p+=quantum_info->pad;
1501 q+=GetPixelChannels(image);
1505 for (x=0; x < (ssize_t) number_pixels; x++)
1507 p=PushShortPixel(quantum_info->endian,p,&pixel);
1508 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1509 p+=quantum_info->pad;
1510 q+=GetPixelChannels(image);
1516 if (quantum_info->format == FloatingPointQuantumFormat)
1521 for (x=0; x < (ssize_t) number_pixels; x++)
1523 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1524 SetPixelBlue(image,ClampToQuantum(pixel),q);
1525 p+=quantum_info->pad;
1526 q+=GetPixelChannels(image);
1535 for (x=0; x < (ssize_t) number_pixels; x++)
1537 p=PushLongPixel(quantum_info->endian,p,&pixel);
1538 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1539 p+=quantum_info->pad;
1540 q+=GetPixelChannels(image);
1547 if (quantum_info->format == FloatingPointQuantumFormat)
1552 for (x=0; x < (ssize_t) number_pixels; x++)
1554 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1555 SetPixelBlue(image,ClampToQuantum(pixel),q);
1556 p+=quantum_info->pad;
1557 q+=GetPixelChannels(image);
1565 if (quantum_info->format == FloatingPointQuantumFormat)
1570 for (x=0; x < (ssize_t) number_pixels; x++)
1572 p=PushDoublePixel(quantum_info,p,&pixel);
1573 SetPixelBlue(image,ClampToQuantum(pixel),q);
1574 p+=quantum_info->pad;
1575 q+=GetPixelChannels(image);
1586 range=GetQuantumRange(quantum_info->depth);
1587 for (x=0; x < (ssize_t) number_pixels; x++)
1589 p=PushQuantumPixel(quantum_info,p,&pixel);
1590 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1591 p+=quantum_info->pad;
1592 q+=GetPixelChannels(image);
1599static void ImportCbYCrYQuantum(
const Image *image,
QuantumInfo *quantum_info,
1600 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1601 Quantum *magick_restrict q)
1612 assert(image != (
Image *) NULL);
1613 assert(image->signature == MagickCoreSignature);
1614 switch (quantum_info->depth)
1622 if (quantum_info->pack == MagickFalse)
1635 for (x=0; x < (ssize_t) (number_pixels-3); x+=4)
1637 for (i=0; i < 4; i++)
1643 p=PushLongPixel(quantum_info->endian,p,&pixel);
1644 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1645 (((pixel >> 22) & 0x3ff) << 6)));
1650 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1651 (((pixel >> 12) & 0x3ff) << 6)));
1656 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
1657 (((pixel >> 2) & 0x3ff) << 6)));
1661 cbcr[i]=(Quantum) (quantum);
1664 p+=quantum_info->pad;
1665 SetPixelRed(image,cbcr[1],q);
1666 SetPixelGreen(image,cbcr[0],q);
1667 SetPixelBlue(image,cbcr[2],q);
1668 q+=GetPixelChannels(image);
1669 SetPixelRed(image,cbcr[3],q);
1670 SetPixelGreen(image,cbcr[0],q);
1671 SetPixelBlue(image,cbcr[2],q);
1672 q+=GetPixelChannels(image);
1680 range=GetQuantumRange(quantum_info->depth);
1681 for (x=0; x < (ssize_t) number_pixels; x++)
1683 p=PushQuantumPixel(quantum_info,p,&pixel);
1684 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1685 p=PushQuantumPixel(quantum_info,p,&pixel);
1686 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1687 q+=GetPixelChannels(image);
1695 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1704 if (image->colorspace != CMYKColorspace)
1706 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1707 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1710 switch (quantum_info->depth)
1717 for (x=0; x < (ssize_t) number_pixels; x++)
1719 p=PushCharPixel(p,&pixel);
1720 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1721 p=PushCharPixel(p,&pixel);
1722 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1723 p=PushCharPixel(p,&pixel);
1724 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1725 p=PushCharPixel(p,&pixel);
1726 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1727 p+=quantum_info->pad;
1728 q+=GetPixelChannels(image);
1737 if (quantum_info->format == FloatingPointQuantumFormat)
1739 for (x=0; x < (ssize_t) number_pixels; x++)
1741 p=PushShortPixel(quantum_info->endian,p,&pixel);
1742 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
1743 HalfToSinglePrecision(pixel)),q);
1744 p=PushShortPixel(quantum_info->endian,p,&pixel);
1745 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
1746 HalfToSinglePrecision(pixel)),q);
1747 p=PushShortPixel(quantum_info->endian,p,&pixel);
1748 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1749 HalfToSinglePrecision(pixel)),q);
1750 p=PushShortPixel(quantum_info->endian,p,&pixel);
1751 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*(
double)
1752 HalfToSinglePrecision(pixel)),q);
1753 p+=quantum_info->pad;
1754 q+=GetPixelChannels(image);
1758 for (x=0; x < (ssize_t) number_pixels; x++)
1760 p=PushShortPixel(quantum_info->endian,p,&pixel);
1761 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1762 p=PushShortPixel(quantum_info->endian,p,&pixel);
1763 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1764 p=PushShortPixel(quantum_info->endian,p,&pixel);
1765 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1766 p=PushShortPixel(quantum_info->endian,p,&pixel);
1767 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1768 p+=quantum_info->pad;
1769 q+=GetPixelChannels(image);
1775 if (quantum_info->format == FloatingPointQuantumFormat)
1780 for (x=0; x < (ssize_t) number_pixels; x++)
1782 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1783 SetPixelRed(image,ClampToQuantum(pixel),q);
1784 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1785 SetPixelGreen(image,ClampToQuantum(pixel),q);
1786 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1787 SetPixelBlue(image,ClampToQuantum(pixel),q);
1788 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1789 SetPixelBlack(image,ClampToQuantum(pixel),q);
1790 p+=quantum_info->pad;
1791 q+=GetPixelChannels(image);
1800 for (x=0; x < (ssize_t) number_pixels; x++)
1802 p=PushLongPixel(quantum_info->endian,p,&pixel);
1803 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1804 p=PushLongPixel(quantum_info->endian,p,&pixel);
1805 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1806 p=PushLongPixel(quantum_info->endian,p,&pixel);
1807 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1808 p=PushLongPixel(quantum_info->endian,p,&pixel);
1809 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1810 p+=quantum_info->pad;
1811 q+=GetPixelChannels(image);
1818 if (quantum_info->format == FloatingPointQuantumFormat)
1823 for (x=0; x < (ssize_t) number_pixels; x++)
1825 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1826 SetPixelRed(image,ClampToQuantum(pixel),q);
1827 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1828 SetPixelGreen(image,ClampToQuantum(pixel),q);
1829 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1830 SetPixelBlue(image,ClampToQuantum(pixel),q);
1831 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
1832 SetPixelBlack(image,ClampToQuantum(pixel),q);
1833 p+=quantum_info->pad;
1834 q+=GetPixelChannels(image);
1842 if (quantum_info->format == FloatingPointQuantumFormat)
1847 for (x=0; x < (ssize_t) number_pixels; x++)
1849 p=PushDoublePixel(quantum_info,p,&pixel);
1850 SetPixelRed(image,ClampToQuantum(pixel),q);
1851 p=PushDoublePixel(quantum_info,p,&pixel);
1852 SetPixelGreen(image,ClampToQuantum(pixel),q);
1853 p=PushDoublePixel(quantum_info,p,&pixel);
1854 SetPixelBlue(image,ClampToQuantum(pixel),q);
1855 p=PushDoublePixel(quantum_info,p,&pixel);
1856 SetPixelBlack(image,ClampToQuantum(pixel),q);
1857 p+=quantum_info->pad;
1858 q+=GetPixelChannels(image);
1869 range=GetQuantumRange(quantum_info->depth);
1870 for (x=0; x < (ssize_t) number_pixels; x++)
1872 p=PushQuantumPixel(quantum_info,p,&pixel);
1873 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1874 p=PushQuantumPixel(quantum_info,p,&pixel);
1875 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1876 p=PushQuantumPixel(quantum_info,p,&pixel);
1877 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1878 p=PushQuantumPixel(quantum_info,p,&pixel);
1879 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1880 q+=GetPixelChannels(image);
1887static void ImportCMYKAQuantum(
const Image *image,
QuantumInfo *quantum_info,
1888 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
1897 if (image->colorspace != CMYKColorspace)
1899 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1900 "ColorSeparatedImageRequired",
"`%s'",image->filename);
1903 switch (quantum_info->depth)
1910 for (x=0; x < (ssize_t) number_pixels; x++)
1912 p=PushCharPixel(p,&pixel);
1913 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1914 p=PushCharPixel(p,&pixel);
1915 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1916 p=PushCharPixel(p,&pixel);
1917 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1918 p=PushCharPixel(p,&pixel);
1919 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1920 p=PushCharPixel(p,&pixel);
1921 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
1922 p+=quantum_info->pad;
1923 q+=GetPixelChannels(image);
1932 if (quantum_info->format == FloatingPointQuantumFormat)
1934 for (x=0; x < (ssize_t) number_pixels; x++)
1936 p=PushShortPixel(quantum_info->endian,p,&pixel);
1937 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
1938 HalfToSinglePrecision(pixel)),q);
1939 p=PushShortPixel(quantum_info->endian,p,&pixel);
1940 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
1941 HalfToSinglePrecision(pixel)),q);
1942 p=PushShortPixel(quantum_info->endian,p,&pixel);
1943 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
1944 HalfToSinglePrecision(pixel)),q);
1945 p=PushShortPixel(quantum_info->endian,p,&pixel);
1946 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*(
double)
1947 HalfToSinglePrecision(pixel)),q);
1948 p=PushShortPixel(quantum_info->endian,p,&pixel);
1949 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
1950 HalfToSinglePrecision(pixel)),q);
1951 p+=quantum_info->pad;
1952 q+=GetPixelChannels(image);
1956 for (x=0; x < (ssize_t) number_pixels; x++)
1958 p=PushShortPixel(quantum_info->endian,p,&pixel);
1959 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1960 p=PushShortPixel(quantum_info->endian,p,&pixel);
1961 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1962 p=PushShortPixel(quantum_info->endian,p,&pixel);
1963 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1964 p=PushShortPixel(quantum_info->endian,p,&pixel);
1965 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1966 p=PushShortPixel(quantum_info->endian,p,&pixel);
1967 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
1968 p+=quantum_info->pad;
1969 q+=GetPixelChannels(image);
1975 if (quantum_info->format == FloatingPointQuantumFormat)
1980 for (x=0; x < (ssize_t) number_pixels; x++)
1982 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1983 SetPixelRed(image,ClampToQuantum(pixel),q);
1984 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1985 SetPixelGreen(image,ClampToQuantum(pixel),q);
1986 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1987 SetPixelBlue(image,ClampToQuantum(pixel),q);
1988 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1989 SetPixelBlack(image,ClampToQuantum(pixel),q);
1990 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
1991 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1992 p+=quantum_info->pad;
1993 q+=GetPixelChannels(image);
2002 for (x=0; x < (ssize_t) number_pixels; x++)
2004 p=PushLongPixel(quantum_info->endian,p,&pixel);
2005 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
2006 p=PushLongPixel(quantum_info->endian,p,&pixel);
2007 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2008 p=PushLongPixel(quantum_info->endian,p,&pixel);
2009 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2010 p=PushLongPixel(quantum_info->endian,p,&pixel);
2011 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
2012 p=PushLongPixel(quantum_info->endian,p,&pixel);
2013 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2014 p+=quantum_info->pad;
2015 q+=GetPixelChannels(image);
2022 if (quantum_info->format == FloatingPointQuantumFormat)
2027 for (x=0; x < (ssize_t) number_pixels; x++)
2029 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2030 SetPixelRed(image,ClampToQuantum(pixel),q);
2031 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2032 SetPixelGreen(image,ClampToQuantum(pixel),q);
2033 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2034 SetPixelBlue(image,ClampToQuantum(pixel),q);
2035 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2036 SetPixelBlack(image,ClampToQuantum(pixel),q);
2037 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2038 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2039 p+=quantum_info->pad;
2040 q+=GetPixelChannels(image);
2048 if (quantum_info->format == FloatingPointQuantumFormat)
2053 for (x=0; x < (ssize_t) number_pixels; x++)
2055 p=PushDoublePixel(quantum_info,p,&pixel);
2056 SetPixelRed(image,ClampToQuantum(pixel),q);
2057 p=PushDoublePixel(quantum_info,p,&pixel);
2058 SetPixelGreen(image,ClampToQuantum(pixel),q);
2059 p=PushDoublePixel(quantum_info,p,&pixel);
2060 SetPixelBlue(image,ClampToQuantum(pixel),q);
2061 p=PushDoublePixel(quantum_info,p,&pixel);
2062 SetPixelBlack(image,ClampToQuantum(pixel),q);
2063 p=PushDoublePixel(quantum_info,p,&pixel);
2064 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2065 p+=quantum_info->pad;
2066 q+=GetPixelChannels(image);
2077 range=GetQuantumRange(quantum_info->depth);
2078 for (x=0; x < (ssize_t) number_pixels; x++)
2080 p=PushQuantumPixel(quantum_info,p,&pixel);
2081 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2082 p=PushQuantumPixel(quantum_info,p,&pixel);
2083 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2084 p=PushQuantumPixel(quantum_info,p,&pixel);
2085 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2086 p=PushQuantumPixel(quantum_info,p,&pixel);
2087 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
2088 p=PushQuantumPixel(quantum_info,p,&pixel);
2089 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2090 q+=GetPixelChannels(image);
2097static void ImportCMYKOQuantum(
const Image *image,
QuantumInfo *quantum_info,
2098 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
2107 if (image->colorspace != CMYKColorspace)
2109 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2110 "ColorSeparatedImageRequired",
"`%s'",image->filename);
2113 switch (quantum_info->depth)
2120 for (x=0; x < (ssize_t) number_pixels; x++)
2122 p=PushCharPixel(p,&pixel);
2123 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
2124 p=PushCharPixel(p,&pixel);
2125 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2126 p=PushCharPixel(p,&pixel);
2127 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
2128 p=PushCharPixel(p,&pixel);
2129 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
2130 p=PushCharPixel(p,&pixel);
2131 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
2132 p+=quantum_info->pad;
2133 q+=GetPixelChannels(image);
2142 if (quantum_info->format == FloatingPointQuantumFormat)
2144 for (x=0; x < (ssize_t) number_pixels; x++)
2146 p=PushShortPixel(quantum_info->endian,p,&pixel);
2147 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
2148 HalfToSinglePrecision(pixel)),q);
2149 p=PushShortPixel(quantum_info->endian,p,&pixel);
2150 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
2151 HalfToSinglePrecision(pixel)),q);
2152 p=PushShortPixel(quantum_info->endian,p,&pixel);
2153 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
2154 HalfToSinglePrecision(pixel)),q);
2155 p=PushShortPixel(quantum_info->endian,p,&pixel);
2156 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*(
double)
2157 HalfToSinglePrecision(pixel)),q);
2158 p=PushShortPixel(quantum_info->endian,p,&pixel);
2159 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
2160 HalfToSinglePrecision(pixel)),q);
2161 p+=quantum_info->pad;
2162 q+=GetPixelChannels(image);
2166 for (x=0; x < (ssize_t) number_pixels; x++)
2168 p=PushShortPixel(quantum_info->endian,p,&pixel);
2169 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
2170 p=PushShortPixel(quantum_info->endian,p,&pixel);
2171 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2172 p=PushShortPixel(quantum_info->endian,p,&pixel);
2173 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
2174 p=PushShortPixel(quantum_info->endian,p,&pixel);
2175 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
2176 p=PushShortPixel(quantum_info->endian,p,&pixel);
2177 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
2178 p+=quantum_info->pad;
2179 q+=GetPixelChannels(image);
2185 if (quantum_info->format == FloatingPointQuantumFormat)
2190 for (x=0; x < (ssize_t) number_pixels; x++)
2192 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2193 SetPixelRed(image,ClampToQuantum(pixel),q);
2194 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2195 SetPixelGreen(image,ClampToQuantum(pixel),q);
2196 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2197 SetPixelBlue(image,ClampToQuantum(pixel),q);
2198 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2199 SetPixelBlack(image,ClampToQuantum(pixel),q);
2200 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2201 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2202 p+=quantum_info->pad;
2203 q+=GetPixelChannels(image);
2212 for (x=0; x < (ssize_t) number_pixels; x++)
2214 p=PushLongPixel(quantum_info->endian,p,&pixel);
2215 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
2216 p=PushLongPixel(quantum_info->endian,p,&pixel);
2217 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2218 p=PushLongPixel(quantum_info->endian,p,&pixel);
2219 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2220 p=PushLongPixel(quantum_info->endian,p,&pixel);
2221 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
2222 p=PushLongPixel(quantum_info->endian,p,&pixel);
2223 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
2224 p+=quantum_info->pad;
2225 q+=GetPixelChannels(image);
2232 if (quantum_info->format == FloatingPointQuantumFormat)
2237 for (x=0; x < (ssize_t) number_pixels; x++)
2239 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2240 SetPixelRed(image,ClampToQuantum(pixel),q);
2241 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2242 SetPixelGreen(image,ClampToQuantum(pixel),q);
2243 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2244 SetPixelBlue(image,ClampToQuantum(pixel),q);
2245 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2246 SetPixelBlack(image,ClampToQuantum(pixel),q);
2247 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2248 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2249 p+=quantum_info->pad;
2250 q+=GetPixelChannels(image);
2258 if (quantum_info->format == FloatingPointQuantumFormat)
2263 for (x=0; x < (ssize_t) number_pixels; x++)
2265 p=PushDoublePixel(quantum_info,p,&pixel);
2266 SetPixelRed(image,ClampToQuantum(pixel),q);
2267 p=PushDoublePixel(quantum_info,p,&pixel);
2268 SetPixelGreen(image,ClampToQuantum(pixel),q);
2269 p=PushDoublePixel(quantum_info,p,&pixel);
2270 SetPixelBlue(image,ClampToQuantum(pixel),q);
2271 p=PushDoublePixel(quantum_info,p,&pixel);
2272 SetPixelBlack(image,ClampToQuantum(pixel),q);
2273 p=PushDoublePixel(quantum_info,p,&pixel);
2274 SetPixelOpacity(image,ClampToQuantum(pixel),q);
2275 p+=quantum_info->pad;
2276 q+=GetPixelChannels(image);
2287 range=GetQuantumRange(quantum_info->depth);
2288 for (x=0; x < (ssize_t) number_pixels; x++)
2290 p=PushQuantumPixel(quantum_info,p,&pixel);
2291 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2292 p=PushQuantumPixel(quantum_info,p,&pixel);
2293 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2294 p=PushQuantumPixel(quantum_info,p,&pixel);
2295 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2296 p=PushQuantumPixel(quantum_info,p,&pixel);
2297 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
2298 p=PushQuantumPixel(quantum_info,p,&pixel);
2299 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
2300 q+=GetPixelChannels(image);
2308 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
2309 Quantum *magick_restrict q)
2320 assert(image != (
Image *) NULL);
2321 assert(image->signature == MagickCoreSignature);
2322 switch (quantum_info->depth)
2332 if (quantum_info->min_is_white != MagickFalse)
2337 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
2339 for (bit=0; bit < 8; bit++)
2341 SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black : white,q);
2342 q+=GetPixelChannels(image);
2346 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
2348 SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black : white,q);
2349 q+=GetPixelChannels(image);
2360 range=GetQuantumRange(quantum_info->depth);
2361 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
2363 pixel=(
unsigned char) ((*p >> 4) & 0xf);
2364 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2365 q+=GetPixelChannels(image);
2366 pixel=(
unsigned char) ((*p) & 0xf);
2367 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2369 q+=GetPixelChannels(image);
2371 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2373 pixel=(
unsigned char) (*p++ >> 4);
2374 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2375 q+=GetPixelChannels(image);
2384 if (quantum_info->min_is_white != MagickFalse)
2386 for (x=0; x < (ssize_t) number_pixels; x++)
2388 p=PushCharPixel(p,&pixel);
2389 SetPixelGray(image,QuantumRange-ScaleCharToQuantum(pixel),q);
2390 SetPixelAlpha(image,OpaqueAlpha,q);
2391 p+=quantum_info->pad;
2392 q+=GetPixelChannels(image);
2396 for (x=0; x < (ssize_t) number_pixels; x++)
2398 p=PushCharPixel(p,&pixel);
2399 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2400 SetPixelAlpha(image,OpaqueAlpha,q);
2401 p+=quantum_info->pad;
2402 q+=GetPixelChannels(image);
2412 range=GetQuantumRange(quantum_info->depth);
2413 if (quantum_info->pack == MagickFalse)
2415 if (image->endian == LSBEndian)
2417 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2419 p=PushLongPixel(quantum_info->endian,p,&pixel);
2420 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2422 q+=GetPixelChannels(image);
2423 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2425 q+=GetPixelChannels(image);
2426 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2428 p+=quantum_info->pad;
2429 q+=GetPixelChannels(image);
2431 if (x++ < (ssize_t) (number_pixels-1))
2433 p=PushLongPixel(quantum_info->endian,p,&pixel);
2434 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2436 q+=GetPixelChannels(image);
2438 if (x++ < (ssize_t) number_pixels)
2440 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2442 q+=GetPixelChannels(image);
2446 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2448 p=PushLongPixel(quantum_info->endian,p,&pixel);
2449 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
2451 q+=GetPixelChannels(image);
2452 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
2454 q+=GetPixelChannels(image);
2455 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
2457 p+=quantum_info->pad;
2458 q+=GetPixelChannels(image);
2460 if (x++ < (ssize_t) (number_pixels-1))
2462 p=PushLongPixel(quantum_info->endian,p,&pixel);
2463 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2465 q+=GetPixelChannels(image);
2467 if (x++ < (ssize_t) number_pixels)
2469 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2471 q+=GetPixelChannels(image);
2475 for (x=0; x < (ssize_t) number_pixels; x++)
2477 p=PushQuantumPixel(quantum_info,p,&pixel);
2478 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2479 p+=quantum_info->pad;
2480 q+=GetPixelChannels(image);
2486 range=GetQuantumRange(quantum_info->depth);
2487 if (quantum_info->pack == MagickFalse)
2492 for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
2494 p=PushShortPixel(quantum_info->endian,p,&pixel);
2495 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2497 q+=GetPixelChannels(image);
2498 p=PushShortPixel(quantum_info->endian,p,&pixel);
2499 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2501 p+=quantum_info->pad;
2502 q+=GetPixelChannels(image);
2504 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2506 p=PushShortPixel(quantum_info->endian,p,&pixel);
2507 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2509 p+=quantum_info->pad;
2510 q+=GetPixelChannels(image);
2521 for (x=0; x < (ssize_t) number_pixels; x++)
2523 p=PushQuantumPixel(quantum_info,p,&pixel);
2524 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2525 p+=quantum_info->pad;
2526 q+=GetPixelChannels(image);
2536 if (quantum_info->min_is_white != MagickFalse)
2538 for (x=0; x < (ssize_t) number_pixels; x++)
2540 p=PushShortPixel(quantum_info->endian,p,&pixel);
2541 SetPixelGray(image,QuantumRange-ScaleShortToQuantum(pixel),q);
2542 p+=quantum_info->pad;
2543 q+=GetPixelChannels(image);
2547 if (quantum_info->format == FloatingPointQuantumFormat)
2549 for (x=0; x < (ssize_t) number_pixels; x++)
2551 p=PushShortPixel(quantum_info->endian,p,&pixel);
2552 SetPixelGray(image,ClampToQuantum((
double) QuantumRange*(
double)
2553 HalfToSinglePrecision(pixel)),q);
2554 p+=quantum_info->pad;
2555 q+=GetPixelChannels(image);
2559 if (quantum_info->format == SignedQuantumFormat)
2561 for (x=0; x < (ssize_t) number_pixels; x++)
2563 p=PushShortPixel(quantum_info->endian,p,&pixel);
2564 pixel=(
unsigned short) (((
unsigned int) pixel+32768) % 65536);
2565 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2566 p+=quantum_info->pad;
2567 q+=GetPixelChannels(image);
2571 for (x=0; x < (ssize_t) number_pixels; x++)
2573 p=PushShortPixel(quantum_info->endian,p,&pixel);
2574 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2575 p+=quantum_info->pad;
2576 q+=GetPixelChannels(image);
2582 if (quantum_info->format == FloatingPointQuantumFormat)
2587 for (x=0; x < (ssize_t) number_pixels; x++)
2589 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2590 SetPixelGray(image,ClampToQuantum(pixel),q);
2591 p+=quantum_info->pad;
2592 q+=GetPixelChannels(image);
2601 for (x=0; x < (ssize_t) number_pixels; x++)
2603 p=PushLongPixel(quantum_info->endian,p,&pixel);
2604 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2605 p+=quantum_info->pad;
2606 q+=GetPixelChannels(image);
2613 if (quantum_info->format == FloatingPointQuantumFormat)
2618 for (x=0; x < (ssize_t) number_pixels; x++)
2620 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2621 SetPixelGray(image,ClampToQuantum(pixel),q);
2622 p+=quantum_info->pad;
2623 q+=GetPixelChannels(image);
2631 if (quantum_info->format == FloatingPointQuantumFormat)
2636 for (x=0; x < (ssize_t) number_pixels; x++)
2638 p=PushDoublePixel(quantum_info,p,&pixel);
2639 SetPixelGray(image,ClampToQuantum(pixel),q);
2640 p+=quantum_info->pad;
2641 q+=GetPixelChannels(image);
2652 range=GetQuantumRange(quantum_info->depth);
2653 for (x=0; x < (ssize_t) number_pixels; x++)
2655 p=PushQuantumPixel(quantum_info,p,&pixel);
2656 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2657 p+=quantum_info->pad;
2658 q+=GetPixelChannels(image);
2665static void ImportGrayAlphaQuantum(
const Image *image,
QuantumInfo *quantum_info,
2666 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
2667 Quantum *magick_restrict q)
2678 assert(image != (
Image *) NULL);
2679 assert(image->signature == MagickCoreSignature);
2680 switch (quantum_info->depth)
2688 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2690 for (bit=0; bit < 8; bit+=2)
2692 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2693 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2694 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
2695 TransparentAlpha : OpaqueAlpha,q);
2696 q+=GetPixelChannels(image);
2700 if ((number_pixels % 4) != 0)
2701 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2703 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2704 SetPixelGray(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
2705 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
2706 TransparentAlpha : OpaqueAlpha,q);
2707 q+=GetPixelChannels(image);
2718 range=GetQuantumRange(quantum_info->depth);
2719 for (x=0; x < (ssize_t) number_pixels; x++)
2721 pixel=(
unsigned char) ((*p >> 4) & 0xf);
2722 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2723 pixel=(
unsigned char) ((*p) & 0xf);
2724 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2726 q+=GetPixelChannels(image);
2735 for (x=0; x < (ssize_t) number_pixels; x++)
2737 p=PushCharPixel(p,&pixel);
2738 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2739 p=PushCharPixel(p,&pixel);
2740 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2741 p+=quantum_info->pad;
2742 q+=GetPixelChannels(image);
2751 range=GetQuantumRange(quantum_info->depth);
2752 for (x=0; x < (ssize_t) number_pixels; x++)
2754 p=PushQuantumPixel(quantum_info,p,&pixel);
2755 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2756 p=PushQuantumPixel(quantum_info,p,&pixel);
2757 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2758 p+=quantum_info->pad;
2759 q+=GetPixelChannels(image);
2768 range=GetQuantumRange(quantum_info->depth);
2769 for (x=0; x < (ssize_t) number_pixels; x++)
2771 p=PushQuantumPixel(quantum_info,p,&pixel);
2772 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2773 p=PushQuantumPixel(quantum_info,p,&pixel);
2774 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2775 p+=quantum_info->pad;
2776 q+=GetPixelChannels(image);
2785 if (quantum_info->format == FloatingPointQuantumFormat)
2787 for (x=0; x < (ssize_t) number_pixels; x++)
2789 p=PushShortPixel(quantum_info->endian,p,&pixel);
2790 SetPixelGray(image,ClampToQuantum((
double) QuantumRange*(
double)
2791 HalfToSinglePrecision(pixel)),q);
2792 p=PushShortPixel(quantum_info->endian,p,&pixel);
2793 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
2794 HalfToSinglePrecision(pixel)),q);
2795 p+=quantum_info->pad;
2796 q+=GetPixelChannels(image);
2800 for (x=0; x < (ssize_t) number_pixels; x++)
2802 p=PushShortPixel(quantum_info->endian,p,&pixel);
2803 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2804 p=PushShortPixel(quantum_info->endian,p,&pixel);
2805 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
2806 p+=quantum_info->pad;
2807 q+=GetPixelChannels(image);
2813 if (quantum_info->format == FloatingPointQuantumFormat)
2818 for (x=0; x < (ssize_t) number_pixels; x++)
2820 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2821 SetPixelGray(image,ClampToQuantum(pixel),q);
2822 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2823 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2824 p+=quantum_info->pad;
2825 q+=GetPixelChannels(image);
2834 for (x=0; x < (ssize_t) number_pixels; x++)
2836 p=PushLongPixel(quantum_info->endian,p,&pixel);
2837 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2838 p=PushLongPixel(quantum_info->endian,p,&pixel);
2839 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2840 p+=quantum_info->pad;
2841 q+=GetPixelChannels(image);
2848 if (quantum_info->format == FloatingPointQuantumFormat)
2853 for (x=0; x < (ssize_t) number_pixels; x++)
2855 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2856 SetPixelGray(image,ClampToQuantum(pixel),q);
2857 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
2858 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2859 p+=quantum_info->pad;
2860 q+=GetPixelChannels(image);
2868 if (quantum_info->format == FloatingPointQuantumFormat)
2873 for (x=0; x < (ssize_t) number_pixels; x++)
2875 p=PushDoublePixel(quantum_info,p,&pixel);
2876 SetPixelGray(image,ClampToQuantum(pixel),q);
2877 p=PushDoublePixel(quantum_info,p,&pixel);
2878 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2879 p+=quantum_info->pad;
2880 q+=GetPixelChannels(image);
2891 range=GetQuantumRange(quantum_info->depth);
2892 for (x=0; x < (ssize_t) number_pixels; x++)
2894 p=PushQuantumPixel(quantum_info,p,&pixel);
2895 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2896 p=PushQuantumPixel(quantum_info,p,&pixel);
2897 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2898 p+=quantum_info->pad;
2899 q+=GetPixelChannels(image);
2906static void ImportGreenQuantum(
const Image *image,
QuantumInfo *quantum_info,
2907 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
2908 Quantum *magick_restrict q)
2916 assert(image != (
Image *) NULL);
2917 assert(image->signature == MagickCoreSignature);
2918 switch (quantum_info->depth)
2925 for (x=0; x < (ssize_t) number_pixels; x++)
2927 p=PushCharPixel(p,&pixel);
2928 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2929 p+=quantum_info->pad;
2930 q+=GetPixelChannels(image);
2939 if (quantum_info->format == FloatingPointQuantumFormat)
2941 for (x=0; x < (ssize_t) number_pixels; x++)
2943 p=PushShortPixel(quantum_info->endian,p,&pixel);
2944 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
2945 HalfToSinglePrecision(pixel)),q);
2946 p+=quantum_info->pad;
2947 q+=GetPixelChannels(image);
2951 for (x=0; x < (ssize_t) number_pixels; x++)
2953 p=PushShortPixel(quantum_info->endian,p,&pixel);
2954 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2955 p+=quantum_info->pad;
2956 q+=GetPixelChannels(image);
2962 if (quantum_info->format == FloatingPointQuantumFormat)
2967 for (x=0; x < (ssize_t) number_pixels; x++)
2969 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
2970 SetPixelGreen(image,ClampToQuantum(pixel),q);
2971 p+=quantum_info->pad;
2972 q+=GetPixelChannels(image);
2981 for (x=0; x < (ssize_t) number_pixels; x++)
2983 p=PushLongPixel(quantum_info->endian,p,&pixel);
2984 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2985 p+=quantum_info->pad;
2986 q+=GetPixelChannels(image);
2993 if (quantum_info->format == FloatingPointQuantumFormat)
2998 for (x=0; x < (ssize_t) number_pixels; x++)
3000 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3001 SetPixelGreen(image,ClampToQuantum(pixel),q);
3002 p+=quantum_info->pad;
3003 q+=GetPixelChannels(image);
3011 if (quantum_info->format == FloatingPointQuantumFormat)
3016 for (x=0; x < (ssize_t) number_pixels; x++)
3018 p=PushDoublePixel(quantum_info,p,&pixel);
3019 SetPixelGreen(image,ClampToQuantum(pixel),q);
3020 p+=quantum_info->pad;
3021 q+=GetPixelChannels(image);
3032 range=GetQuantumRange(quantum_info->depth);
3033 for (x=0; x < (ssize_t) number_pixels; x++)
3035 p=PushQuantumPixel(quantum_info,p,&pixel);
3036 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3037 p+=quantum_info->pad;
3038 q+=GetPixelChannels(image);
3045static void ImportIndexQuantum(
const Image *image,
QuantumInfo *quantum_info,
3046 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
3058 if (image->storage_class != PseudoClass)
3060 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3061 "ColormappedImageRequired",
"`%s'",image->filename);
3064 range_exception=MagickFalse;
3065 switch (quantum_info->depth)
3072 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
3074 for (bit=0; bit < 8; bit++)
3076 if (quantum_info->min_is_white == MagickFalse)
3077 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
3080 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
3082 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
3084 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3085 GetPixelIndex(image,q),q);
3086 q+=GetPixelChannels(image);
3090 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
3092 if (quantum_info->min_is_white == MagickFalse)
3093 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
3095 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
3096 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3097 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3098 GetPixelIndex(image,q),q);
3099 q+=GetPixelChannels(image);
3108 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
3110 pixel=(
unsigned char) ((*p >> 4) & 0xf);
3111 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3112 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3113 GetPixelIndex(image,q),q);
3114 q+=GetPixelChannels(image);
3115 pixel=(
unsigned char) ((*p) & 0xf);
3116 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3117 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3118 GetPixelIndex(image,q),q);
3120 q+=GetPixelChannels(image);
3122 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
3124 pixel=(
unsigned char) ((*p++ >> 4) & 0xf);
3125 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3126 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3127 GetPixelIndex(image,q),q);
3128 q+=GetPixelChannels(image);
3137 for (x=0; x < (ssize_t) number_pixels; x++)
3139 p=PushCharPixel(p,&pixel);
3140 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3141 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3142 GetPixelIndex(image,q),q);
3143 p+=quantum_info->pad;
3144 q+=GetPixelChannels(image);
3153 if (quantum_info->format == FloatingPointQuantumFormat)
3155 for (x=0; x < (ssize_t) number_pixels; x++)
3157 p=PushShortPixel(quantum_info->endian,p,&pixel);
3158 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3159 ClampToQuantum((
double) QuantumRange*(
double)
3160 HalfToSinglePrecision(pixel)),&range_exception),q);
3161 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3162 GetPixelIndex(image,q),q);
3163 p+=quantum_info->pad;
3164 q+=GetPixelChannels(image);
3168 for (x=0; x < (ssize_t) number_pixels; x++)
3170 p=PushShortPixel(quantum_info->endian,p,&pixel);
3171 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3172 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3173 GetPixelIndex(image,q),q);
3174 p+=quantum_info->pad;
3175 q+=GetPixelChannels(image);
3181 if (quantum_info->format == FloatingPointQuantumFormat)
3186 for (x=0; x < (ssize_t) number_pixels; x++)
3188 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3189 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3190 ClampToQuantum(pixel),&range_exception),q);
3191 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3192 GetPixelIndex(image,q),q);
3193 p+=quantum_info->pad;
3194 q+=GetPixelChannels(image);
3203 for (x=0; x < (ssize_t) number_pixels; x++)
3205 p=PushLongPixel(quantum_info->endian,p,&pixel);
3206 SetPixelIndex(image,PushColormapIndex(image,pixel,
3207 &range_exception),q);
3208 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3209 GetPixelIndex(image,q),q);
3210 p+=quantum_info->pad;
3211 q+=GetPixelChannels(image);
3218 if (quantum_info->format == FloatingPointQuantumFormat)
3223 for (x=0; x < (ssize_t) number_pixels; x++)
3225 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3226 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3227 ClampToQuantum(pixel),&range_exception),q);
3228 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3229 GetPixelIndex(image,q),q);
3230 p+=quantum_info->pad;
3231 q+=GetPixelChannels(image);
3239 if (quantum_info->format == FloatingPointQuantumFormat)
3244 for (x=0; x < (ssize_t) number_pixels; x++)
3246 p=PushDoublePixel(quantum_info,p,&pixel);
3247 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3248 ClampToQuantum(pixel),&range_exception),q);
3249 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3250 GetPixelIndex(image,q),q);
3251 p+=quantum_info->pad;
3252 q+=GetPixelChannels(image);
3263 for (x=0; x < (ssize_t) number_pixels; x++)
3265 p=PushQuantumPixel(quantum_info,p,&pixel);
3266 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3267 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3268 GetPixelIndex(image,q),q);
3269 p+=quantum_info->pad;
3270 q+=GetPixelChannels(image);
3275 if (range_exception != MagickFalse)
3276 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
3277 "InvalidColormapIndex",
"`%s'",image->filename);
3280static void ImportIndexAlphaQuantum(
const Image *image,
3281 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
3282 const unsigned char *magick_restrict p,Quantum *magick_restrict q,
3297 if (image->storage_class != PseudoClass)
3299 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3300 "ColormappedImageRequired",
"`%s'",image->filename);
3303 range_exception=MagickFalse;
3304 switch (quantum_info->depth)
3311 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
3313 for (bit=0; bit < 8; bit+=2)
3315 if (quantum_info->min_is_white == MagickFalse)
3316 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
3318 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
3319 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
3320 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
3321 TransparentAlpha : OpaqueAlpha,q);
3322 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
3323 q+=GetPixelChannels(image);
3326 if ((number_pixels % 4) != 0)
3327 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
3329 if (quantum_info->min_is_white == MagickFalse)
3330 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
3332 pixel=(
unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
3333 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
3334 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
3335 SetPixelAlpha(image,((*p) & (1UL << (
unsigned char) (6-bit))) == 0 ?
3336 TransparentAlpha : OpaqueAlpha,q);
3337 q+=GetPixelChannels(image);
3346 range=GetQuantumRange(quantum_info->depth);
3347 for (x=0; x < (ssize_t) number_pixels; x++)
3349 pixel=(
unsigned char) ((*p >> 4) & 0xf);
3350 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3351 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3352 GetPixelIndex(image,q),q);
3353 pixel=(
unsigned char) ((*p) & 0xf);
3354 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3356 q+=GetPixelChannels(image);
3365 for (x=0; x < (ssize_t) number_pixels; x++)
3367 p=PushCharPixel(p,&pixel);
3368 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3369 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3370 GetPixelIndex(image,q),q);
3371 p=PushCharPixel(p,&pixel);
3372 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
3373 p+=quantum_info->pad;
3374 q+=GetPixelChannels(image);
3383 if (quantum_info->format == FloatingPointQuantumFormat)
3385 for (x=0; x < (ssize_t) number_pixels; x++)
3387 p=PushShortPixel(quantum_info->endian,p,&pixel);
3388 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3389 ClampToQuantum((
double) QuantumRange*(
double)
3390 HalfToSinglePrecision(pixel)),&range_exception),q);
3391 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3392 GetPixelIndex(image,q),q);
3393 p=PushShortPixel(quantum_info->endian,p,&pixel);
3394 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
3395 HalfToSinglePrecision(pixel)),q);
3396 p+=quantum_info->pad;
3397 q+=GetPixelChannels(image);
3401 for (x=0; x < (ssize_t) number_pixels; x++)
3403 p=PushShortPixel(quantum_info->endian,p,&pixel);
3404 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3405 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3406 GetPixelIndex(image,q),q);
3407 p=PushShortPixel(quantum_info->endian,p,&pixel);
3408 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
3409 p+=quantum_info->pad;
3410 q+=GetPixelChannels(image);
3416 if (quantum_info->format == FloatingPointQuantumFormat)
3421 for (x=0; x < (ssize_t) number_pixels; x++)
3423 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3424 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3425 ClampToQuantum(pixel),&range_exception),q);
3426 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3427 GetPixelIndex(image,q),q);
3428 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3429 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3430 p+=quantum_info->pad;
3431 q+=GetPixelChannels(image);
3440 for (x=0; x < (ssize_t) number_pixels; x++)
3442 p=PushLongPixel(quantum_info->endian,p,&pixel);
3443 SetPixelIndex(image,PushColormapIndex(image,pixel,
3444 &range_exception),q);
3445 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3446 GetPixelIndex(image,q),q);
3447 p=PushLongPixel(quantum_info->endian,p,&pixel);
3448 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
3449 p+=quantum_info->pad;
3450 q+=GetPixelChannels(image);
3457 if (quantum_info->format == FloatingPointQuantumFormat)
3462 for (x=0; x < (ssize_t) number_pixels; x++)
3464 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3465 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3466 ClampToQuantum(pixel),&range_exception),q);
3467 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3468 GetPixelIndex(image,q),q);
3469 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3470 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3471 p+=quantum_info->pad;
3472 q+=GetPixelChannels(image);
3480 if (quantum_info->format == FloatingPointQuantumFormat)
3485 for (x=0; x < (ssize_t) number_pixels; x++)
3487 p=PushDoublePixel(quantum_info,p,&pixel);
3488 SetPixelIndex(image,PushColormapIndex(image,(
size_t)
3489 ClampToQuantum(pixel),&range_exception),q);
3490 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3491 GetPixelIndex(image,q),q);
3492 p=PushDoublePixel(quantum_info,p,&pixel);
3493 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3494 p+=quantum_info->pad;
3495 q+=GetPixelChannels(image);
3506 range=GetQuantumRange(quantum_info->depth);
3507 for (x=0; x < (ssize_t) number_pixels; x++)
3509 p=PushQuantumPixel(quantum_info,p,&pixel);
3510 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3511 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3512 GetPixelIndex(image,q),q);
3513 p=PushQuantumPixel(quantum_info,p,&pixel);
3514 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3515 p+=quantum_info->pad;
3516 q+=GetPixelChannels(image);
3521 if (range_exception != MagickFalse)
3522 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
3523 "InvalidColormapIndex",
"`%s'",image->filename);
3526static void ImportMultispectralQuantum(
const Image *image,
3527 QuantumInfo *quantum_info,
const MagickSizeType number_pixels,
3528 const unsigned char *magick_restrict p,Quantum *magick_restrict q,
3538 if (image->number_meta_channels == 0)
3540 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3541 "MultispectralImageRequired",
"`%s'",image->filename);
3544 switch (quantum_info->depth)
3551 for (x=0; x < (ssize_t) number_pixels; x++)
3553 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3555 p=PushCharPixel(p,&pixel);
3556 q[i]=ScaleCharToQuantum(pixel);
3558 p+=quantum_info->pad;
3559 q+=GetPixelChannels(image);
3568 if (quantum_info->format == FloatingPointQuantumFormat)
3570 for (x=0; x < (ssize_t) number_pixels; x++)
3572 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3574 p=PushShortPixel(quantum_info->endian,p,&pixel);
3575 q[i]=ClampToQuantum((
double) QuantumRange*(
double)HalfToSinglePrecision(pixel));
3577 p+=quantum_info->pad;
3578 q+=GetPixelChannels(image);
3582 for (x=0; x < (ssize_t) number_pixels; x++)
3584 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3586 p=PushShortPixel(quantum_info->endian,p,&pixel);
3587 q[i]=ScaleShortToQuantum(pixel);
3589 p+=quantum_info->pad;
3590 q+=GetPixelChannels(image);
3596 if (quantum_info->format == FloatingPointQuantumFormat)
3601 for (x=0; x < (ssize_t) number_pixels; x++)
3603 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3605 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3606 q[i]=ClampToQuantum(pixel);
3608 p+=quantum_info->pad;
3609 q+=GetPixelChannels(image);
3618 for (x=0; x < (ssize_t) number_pixels; x++)
3620 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3622 p=PushLongPixel(quantum_info->endian,p,&pixel);
3623 q[i]=ScaleLongToQuantum(pixel);
3625 p+=quantum_info->pad;
3626 q+=GetPixelChannels(image);
3633 if (quantum_info->format == FloatingPointQuantumFormat)
3638 for (x=0; x < (ssize_t) number_pixels; x++)
3640 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3642 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3643 q[i]=ClampToQuantum(pixel);
3645 p+=quantum_info->pad;
3646 q+=GetPixelChannels(image);
3654 if (quantum_info->format == FloatingPointQuantumFormat)
3659 for (x=0; x < (ssize_t) number_pixels; x++)
3661 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3663 p=PushDoublePixel(quantum_info,p,&pixel);
3664 q[i]=ClampToQuantum(pixel);
3666 p+=quantum_info->pad;
3667 q+=GetPixelChannels(image);
3678 range=GetQuantumRange(quantum_info->depth);
3679 for (x=0; x < (ssize_t) number_pixels; x++)
3681 for (i=0; i < (ssize_t) GetImageChannels(image); i++)
3683 p=PushQuantumPixel(quantum_info,p,&pixel);
3684 q[i]=ScaleAnyToQuantum(pixel,range);
3686 q+=GetPixelChannels(image);
3693static void ImportOpacityQuantum(
const Image *image,
QuantumInfo *quantum_info,
3694 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
3695 Quantum *magick_restrict q)
3703 assert(image != (
Image *) NULL);
3704 assert(image->signature == MagickCoreSignature);
3705 switch (quantum_info->depth)
3712 for (x=0; x < (ssize_t) number_pixels; x++)
3714 p=PushCharPixel(p,&pixel);
3715 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
3716 p+=quantum_info->pad;
3717 q+=GetPixelChannels(image);
3726 if (quantum_info->format == FloatingPointQuantumFormat)
3728 for (x=0; x < (ssize_t) number_pixels; x++)
3730 p=PushShortPixel(quantum_info->endian,p,&pixel);
3731 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
3732 HalfToSinglePrecision(pixel)),q);
3733 p+=quantum_info->pad;
3734 q+=GetPixelChannels(image);
3738 for (x=0; x < (ssize_t) number_pixels; x++)
3740 p=PushShortPixel(quantum_info->endian,p,&pixel);
3741 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
3742 p+=quantum_info->pad;
3743 q+=GetPixelChannels(image);
3749 if (quantum_info->format == FloatingPointQuantumFormat)
3754 for (x=0; x < (ssize_t) number_pixels; x++)
3756 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3757 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3758 p+=quantum_info->pad;
3759 q+=GetPixelChannels(image);
3768 for (x=0; x < (ssize_t) number_pixels; x++)
3770 p=PushLongPixel(quantum_info->endian,p,&pixel);
3771 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
3772 p+=quantum_info->pad;
3773 q+=GetPixelChannels(image);
3780 if (quantum_info->format == FloatingPointQuantumFormat)
3785 for (x=0; x < (ssize_t) number_pixels; x++)
3787 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3788 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3789 p+=quantum_info->pad;
3790 q+=GetPixelChannels(image);
3798 if (quantum_info->format == FloatingPointQuantumFormat)
3803 for (x=0; x < (ssize_t) number_pixels; x++)
3805 p=PushDoublePixel(quantum_info,p,&pixel);
3806 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3807 p+=quantum_info->pad;
3808 q+=GetPixelChannels(image);
3819 range=GetQuantumRange(quantum_info->depth);
3820 for (x=0; x < (ssize_t) number_pixels; x++)
3822 p=PushQuantumPixel(quantum_info,p,&pixel);
3823 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
3824 p+=quantum_info->pad;
3825 q+=GetPixelChannels(image);
3833 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
3834 Quantum *magick_restrict q)
3842 assert(image != (
Image *) NULL);
3843 assert(image->signature == MagickCoreSignature);
3844 switch (quantum_info->depth)
3851 for (x=0; x < (ssize_t) number_pixels; x++)
3853 p=PushCharPixel(p,&pixel);
3854 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3855 p+=quantum_info->pad;
3856 q+=GetPixelChannels(image);
3865 if (quantum_info->format == FloatingPointQuantumFormat)
3867 for (x=0; x < (ssize_t) number_pixels; x++)
3869 p=PushShortPixel(quantum_info->endian,p,&pixel);
3870 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
3871 HalfToSinglePrecision(pixel)),q);
3872 p+=quantum_info->pad;
3873 q+=GetPixelChannels(image);
3877 for (x=0; x < (ssize_t) number_pixels; x++)
3879 p=PushShortPixel(quantum_info->endian,p,&pixel);
3880 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3881 p+=quantum_info->pad;
3882 q+=GetPixelChannels(image);
3888 if (quantum_info->format == FloatingPointQuantumFormat)
3893 for (x=0; x < (ssize_t) number_pixels; x++)
3895 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
3896 SetPixelRed(image,ClampToQuantum(pixel),q);
3897 p+=quantum_info->pad;
3898 q+=GetPixelChannels(image);
3907 for (x=0; x < (ssize_t) number_pixels; x++)
3909 p=PushLongPixel(quantum_info->endian,p,&pixel);
3910 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3911 p+=quantum_info->pad;
3912 q+=GetPixelChannels(image);
3919 if (quantum_info->format == FloatingPointQuantumFormat)
3924 for (x=0; x < (ssize_t) number_pixels; x++)
3926 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
3927 SetPixelRed(image,ClampToQuantum(pixel),q);
3928 p+=quantum_info->pad;
3929 q+=GetPixelChannels(image);
3937 if (quantum_info->format == FloatingPointQuantumFormat)
3942 for (x=0; x < (ssize_t) number_pixels; x++)
3944 p=PushDoublePixel(quantum_info,p,&pixel);
3945 SetPixelRed(image,ClampToQuantum(pixel),q);
3946 p+=quantum_info->pad;
3947 q+=GetPixelChannels(image);
3958 range=GetQuantumRange(quantum_info->depth);
3959 for (x=0; x < (ssize_t) number_pixels; x++)
3961 p=PushQuantumPixel(quantum_info,p,&pixel);
3962 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3963 p+=quantum_info->pad;
3964 q+=GetPixelChannels(image);
3972 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
3973 Quantum *magick_restrict q)
3984 assert(image != (
Image *) NULL);
3985 assert(image->signature == MagickCoreSignature);
3986 switch (quantum_info->depth)
3993 for (x=0; x < (ssize_t) number_pixels; x++)
3995 p=PushCharPixel(p,&pixel);
3996 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3997 p=PushCharPixel(p,&pixel);
3998 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3999 p=PushCharPixel(p,&pixel);
4000 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
4001 SetPixelAlpha(image,OpaqueAlpha,q);
4002 p+=quantum_info->pad;
4003 q+=GetPixelChannels(image);
4012 range=GetQuantumRange(quantum_info->depth);
4013 if (quantum_info->pack == MagickFalse)
4015 for (x=0; x < (ssize_t) number_pixels; x++)
4017 p=PushLongPixel(quantum_info->endian,p,&pixel);
4018 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
4019 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
4021 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
4022 p+=quantum_info->pad;
4023 q+=GetPixelChannels(image);
4027 if (quantum_info->quantum == 32U)
4029 for (x=0; x < (ssize_t) number_pixels; x++)
4031 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4032 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4033 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4034 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4035 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4036 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4037 q+=GetPixelChannels(image);
4041 for (x=0; x < (ssize_t) number_pixels; x++)
4043 p=PushQuantumPixel(quantum_info,p,&pixel);
4044 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4045 p=PushQuantumPixel(quantum_info,p,&pixel);
4046 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4047 p=PushQuantumPixel(quantum_info,p,&pixel);
4048 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4049 q+=GetPixelChannels(image);
4055 range=GetQuantumRange(quantum_info->depth);
4056 if (quantum_info->pack == MagickFalse)
4061 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
4063 p=PushShortPixel(quantum_info->endian,p,&pixel);
4069 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4075 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4081 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4083 q+=GetPixelChannels(image);
4087 p=PushShortPixel(quantum_info->endian,p,&pixel);
4093 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4099 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4105 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4107 q+=GetPixelChannels(image);
4111 p+=quantum_info->pad;
4113 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
4115 p=PushShortPixel(quantum_info->endian,p,&pixel);
4116 switch ((x+bit) % 3)
4121 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4127 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4133 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
4135 q+=GetPixelChannels(image);
4139 p+=quantum_info->pad;
4150 if (quantum_info->quantum == 32U)
4152 for (x=0; x < (ssize_t) number_pixels; x++)
4154 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4155 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4156 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4157 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4158 p=PushQuantumLongPixel(quantum_info,p,&pixel);
4159 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4160 q+=GetPixelChannels(image);
4164 for (x=0; x < (ssize_t) number_pixels; x++)
4166 p=PushQuantumPixel(quantum_info,p,&pixel);
4167 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4168 p=PushQuantumPixel(quantum_info,p,&pixel);
4169 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4170 p=PushQuantumPixel(quantum_info,p,&pixel);
4171 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4172 q+=GetPixelChannels(image);
4182 if (quantum_info->format == FloatingPointQuantumFormat)
4184 for (x=0; x < (ssize_t) number_pixels; x++)
4186 p=PushShortPixel(quantum_info->endian,p,&pixel);
4187 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
4188 HalfToSinglePrecision(pixel)),q);
4189 p=PushShortPixel(quantum_info->endian,p,&pixel);
4190 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
4191 HalfToSinglePrecision(pixel)),q);
4192 p=PushShortPixel(quantum_info->endian,p,&pixel);
4193 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
4194 HalfToSinglePrecision(pixel)),q);
4195 p+=quantum_info->pad;
4196 q+=GetPixelChannels(image);
4200 for (x=0; x < (ssize_t) number_pixels; x++)
4202 p=PushShortPixel(quantum_info->endian,p,&pixel);
4203 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
4204 p=PushShortPixel(quantum_info->endian,p,&pixel);
4205 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4206 p=PushShortPixel(quantum_info->endian,p,&pixel);
4207 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4208 p+=quantum_info->pad;
4209 q+=GetPixelChannels(image);
4215 if (quantum_info->format == FloatingPointQuantumFormat)
4220 for (x=0; x < (ssize_t) number_pixels; x++)
4222 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4223 SetPixelRed(image,ClampToQuantum(pixel),q);
4224 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4225 SetPixelGreen(image,ClampToQuantum(pixel),q);
4226 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4227 SetPixelBlue(image,ClampToQuantum(pixel),q);
4228 p+=quantum_info->pad;
4229 q+=GetPixelChannels(image);
4238 for (x=0; x < (ssize_t) number_pixels; x++)
4240 p=PushLongPixel(quantum_info->endian,p,&pixel);
4241 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4242 p=PushLongPixel(quantum_info->endian,p,&pixel);
4243 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4244 p=PushLongPixel(quantum_info->endian,p,&pixel);
4245 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4246 p+=quantum_info->pad;
4247 q+=GetPixelChannels(image);
4254 if (quantum_info->format == FloatingPointQuantumFormat)
4259 for (x=0; x < (ssize_t) number_pixels; x++)
4261 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4262 SetPixelRed(image,ClampToQuantum(pixel),q);
4263 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4264 SetPixelGreen(image,ClampToQuantum(pixel),q);
4265 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4266 SetPixelBlue(image,ClampToQuantum(pixel),q);
4267 p+=quantum_info->pad;
4268 q+=GetPixelChannels(image);
4276 if (quantum_info->format == FloatingPointQuantumFormat)
4281 for (x=0; x < (ssize_t) number_pixels; x++)
4283 p=PushDoublePixel(quantum_info,p,&pixel);
4284 SetPixelRed(image,ClampToQuantum(pixel),q);
4285 p=PushDoublePixel(quantum_info,p,&pixel);
4286 SetPixelGreen(image,ClampToQuantum(pixel),q);
4287 p=PushDoublePixel(quantum_info,p,&pixel);
4288 SetPixelBlue(image,ClampToQuantum(pixel),q);
4289 p+=quantum_info->pad;
4290 q+=GetPixelChannels(image);
4301 range=GetQuantumRange(quantum_info->depth);
4302 for (x=0; x < (ssize_t) number_pixels; x++)
4304 p=PushQuantumPixel(quantum_info,p,&pixel);
4305 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4306 p=PushQuantumPixel(quantum_info,p,&pixel);
4307 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4308 p=PushQuantumPixel(quantum_info,p,&pixel);
4309 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4310 q+=GetPixelChannels(image);
4318 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
4319 Quantum *magick_restrict q)
4327 assert(image != (
Image *) NULL);
4328 assert(image->signature == MagickCoreSignature);
4329 switch (quantum_info->depth)
4336 for (x=0; x < (ssize_t) number_pixels; x++)
4338 p=PushCharPixel(p,&pixel);
4339 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
4340 p=PushCharPixel(p,&pixel);
4341 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
4342 p=PushCharPixel(p,&pixel);
4343 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
4344 p=PushCharPixel(p,&pixel);
4345 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
4346 p+=quantum_info->pad;
4347 q+=GetPixelChannels(image);
4357 if (quantum_info->pack == MagickFalse)
4370 for (x=0; x < (ssize_t) number_pixels; x++)
4372 for (i=0; i < 4; i++)
4378 p=PushLongPixel(quantum_info->endian,p,&pixel);
4379 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4380 (((pixel >> 22) & 0x3ff) << 6)));
4385 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4386 (((pixel >> 12) & 0x3ff) << 6)));
4391 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4392 (((pixel >> 2) & 0x3ff) << 6)));
4398 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
4399 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
4400 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
4401 case 3: SetPixelAlpha(image,(Quantum) quantum,q);
break;
4405 p+=quantum_info->pad;
4406 q+=GetPixelChannels(image);
4410 for (x=0; x < (ssize_t) number_pixels; x++)
4412 p=PushQuantumPixel(quantum_info,p,&pixel);
4413 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
4414 p=PushQuantumPixel(quantum_info,p,&pixel);
4415 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4417 p=PushQuantumPixel(quantum_info,p,&pixel);
4418 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4420 p=PushQuantumPixel(quantum_info,p,&pixel);
4421 SetPixelAlpha(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4423 q+=GetPixelChannels(image);
4432 if (quantum_info->format == FloatingPointQuantumFormat)
4434 for (x=0; x < (ssize_t) number_pixels; x++)
4436 p=PushShortPixel(quantum_info->endian,p,&pixel);
4437 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
4438 HalfToSinglePrecision(pixel)),q);
4439 p=PushShortPixel(quantum_info->endian,p,&pixel);
4440 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
4441 HalfToSinglePrecision(pixel)),q);
4442 p=PushShortPixel(quantum_info->endian,p,&pixel);
4443 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
4444 HalfToSinglePrecision(pixel)),q);
4445 p=PushShortPixel(quantum_info->endian,p,&pixel);
4446 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*(
double)
4447 HalfToSinglePrecision(pixel)),q);
4448 p+=quantum_info->pad;
4449 q+=GetPixelChannels(image);
4453 for (x=0; x < (ssize_t) number_pixels; x++)
4455 p=PushShortPixel(quantum_info->endian,p,&pixel);
4456 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
4457 p=PushShortPixel(quantum_info->endian,p,&pixel);
4458 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4459 p=PushShortPixel(quantum_info->endian,p,&pixel);
4460 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4461 p=PushShortPixel(quantum_info->endian,p,&pixel);
4462 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
4463 p+=quantum_info->pad;
4464 q+=GetPixelChannels(image);
4470 if (quantum_info->format == FloatingPointQuantumFormat)
4475 for (x=0; x < (ssize_t) number_pixels; x++)
4477 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4478 SetPixelRed(image,ClampToQuantum(pixel),q);
4479 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4480 SetPixelGreen(image,ClampToQuantum(pixel),q);
4481 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4482 SetPixelBlue(image,ClampToQuantum(pixel),q);
4483 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4484 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4485 p+=quantum_info->pad;
4486 q+=GetPixelChannels(image);
4495 for (x=0; x < (ssize_t) number_pixels; x++)
4497 p=PushLongPixel(quantum_info->endian,p,&pixel);
4498 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4499 p=PushLongPixel(quantum_info->endian,p,&pixel);
4500 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4501 p=PushLongPixel(quantum_info->endian,p,&pixel);
4502 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4503 p=PushLongPixel(quantum_info->endian,p,&pixel);
4504 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
4505 p+=quantum_info->pad;
4506 q+=GetPixelChannels(image);
4513 if (quantum_info->format == FloatingPointQuantumFormat)
4518 for (x=0; x < (ssize_t) number_pixels; x++)
4520 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4521 SetPixelRed(image,ClampToQuantum(pixel),q);
4522 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4523 SetPixelGreen(image,ClampToQuantum(pixel),q);
4524 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4525 SetPixelBlue(image,ClampToQuantum(pixel),q);
4526 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4527 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4528 p+=quantum_info->pad;
4529 q+=GetPixelChannels(image);
4537 if (quantum_info->format == FloatingPointQuantumFormat)
4542 for (x=0; x < (ssize_t) number_pixels; x++)
4544 p=PushDoublePixel(quantum_info,p,&pixel);
4545 SetPixelRed(image,ClampToQuantum(pixel),q);
4546 p=PushDoublePixel(quantum_info,p,&pixel);
4547 SetPixelGreen(image,ClampToQuantum(pixel),q);
4548 p=PushDoublePixel(quantum_info,p,&pixel);
4549 SetPixelBlue(image,ClampToQuantum(pixel),q);
4550 p=PushDoublePixel(quantum_info,p,&pixel);
4551 SetPixelAlpha(image,ClampToQuantum(pixel),q);
4552 p+=quantum_info->pad;
4553 q+=GetPixelChannels(image);
4564 range=GetQuantumRange(quantum_info->depth);
4565 for (x=0; x < (ssize_t) number_pixels; x++)
4567 p=PushQuantumPixel(quantum_info,p,&pixel);
4568 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4569 p=PushQuantumPixel(quantum_info,p,&pixel);
4570 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4571 p=PushQuantumPixel(quantum_info,p,&pixel);
4572 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4573 p=PushQuantumPixel(quantum_info,p,&pixel);
4574 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
4575 q+=GetPixelChannels(image);
4583 const MagickSizeType number_pixels,
const unsigned char *magick_restrict p,
4584 Quantum *magick_restrict q)
4592 assert(image != (
Image *) NULL);
4593 assert(image->signature == MagickCoreSignature);
4594 switch (quantum_info->depth)
4601 for (x=0; x < (ssize_t) number_pixels; x++)
4603 p=PushCharPixel(p,&pixel);
4604 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
4605 p=PushCharPixel(p,&pixel);
4606 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
4607 p=PushCharPixel(p,&pixel);
4608 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
4609 p=PushCharPixel(p,&pixel);
4610 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
4611 p+=quantum_info->pad;
4612 q+=GetPixelChannels(image);
4622 if (quantum_info->pack == MagickFalse)
4635 for (x=0; x < (ssize_t) number_pixels; x++)
4637 for (i=0; i < 4; i++)
4643 p=PushLongPixel(quantum_info->endian,p,&pixel);
4644 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4645 (((pixel >> 22) & 0x3ff) << 6)));
4650 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4651 (((pixel >> 12) & 0x3ff) << 6)));
4656 quantum=(size_t) (ScaleShortToQuantum((
unsigned short)
4657 (((pixel >> 2) & 0x3ff) << 6)));
4663 case 0: SetPixelRed(image,(Quantum) quantum,q);
break;
4664 case 1: SetPixelGreen(image,(Quantum) quantum,q);
break;
4665 case 2: SetPixelBlue(image,(Quantum) quantum,q);
break;
4666 case 3: SetPixelOpacity(image,(Quantum) quantum,q);
break;
4670 p+=quantum_info->pad;
4671 q+=GetPixelChannels(image);
4675 for (x=0; x < (ssize_t) number_pixels; x++)
4677 p=PushQuantumPixel(quantum_info,p,&pixel);
4678 SetPixelRed(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),q);
4679 p=PushQuantumPixel(quantum_info,p,&pixel);
4680 SetPixelGreen(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4682 p=PushQuantumPixel(quantum_info,p,&pixel);
4683 SetPixelBlue(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4685 p=PushQuantumPixel(quantum_info,p,&pixel);
4686 SetPixelOpacity(image,ScaleShortToQuantum((
unsigned short) (pixel << 6)),
4688 q+=GetPixelChannels(image);
4697 if (quantum_info->format == FloatingPointQuantumFormat)
4699 for (x=0; x < (ssize_t) number_pixels; x++)
4701 p=PushShortPixel(quantum_info->endian,p,&pixel);
4702 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*(
double)
4703 HalfToSinglePrecision(pixel)),q);
4704 p=PushShortPixel(quantum_info->endian,p,&pixel);
4705 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*(
double)
4706 HalfToSinglePrecision(pixel)),q);
4707 p=PushShortPixel(quantum_info->endian,p,&pixel);
4708 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*(
double)
4709 HalfToSinglePrecision(pixel)),q);
4710 p=PushShortPixel(quantum_info->endian,p,&pixel);
4711 SetPixelOpacity(image,ClampToQuantum((
double) QuantumRange*(
double)
4712 HalfToSinglePrecision(pixel)),q);
4713 p+=quantum_info->pad;
4714 q+=GetPixelChannels(image);
4718 for (x=0; x < (ssize_t) number_pixels; x++)
4720 p=PushShortPixel(quantum_info->endian,p,&pixel);
4721 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
4722 p=PushShortPixel(quantum_info->endian,p,&pixel);
4723 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4724 p=PushShortPixel(quantum_info->endian,p,&pixel);
4725 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4726 p=PushShortPixel(quantum_info->endian,p,&pixel);
4727 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
4728 p+=quantum_info->pad;
4729 q+=GetPixelChannels(image);
4735 if (quantum_info->format == FloatingPointQuantumFormat)
4740 for (x=0; x < (ssize_t) number_pixels; x++)
4742 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4743 SetPixelRed(image,ClampToQuantum(pixel),q);
4744 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4745 SetPixelGreen(image,ClampToQuantum(pixel),q);
4746 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4747 SetPixelBlue(image,ClampToQuantum(pixel),q);
4748 p=PushQuantumFloatPixel(quantum_info,p,&pixel);
4749 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4750 p+=quantum_info->pad;
4751 q+=GetPixelChannels(image);
4760 for (x=0; x < (ssize_t) number_pixels; x++)
4762 p=PushLongPixel(quantum_info->endian,p,&pixel);
4763 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4764 p=PushLongPixel(quantum_info->endian,p,&pixel);
4765 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4766 p=PushLongPixel(quantum_info->endian,p,&pixel);
4767 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4768 p=PushLongPixel(quantum_info->endian,p,&pixel);
4769 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
4770 p+=quantum_info->pad;
4771 q+=GetPixelChannels(image);
4778 if (quantum_info->format == FloatingPointQuantumFormat)
4783 for (x=0; x < (ssize_t) number_pixels; x++)
4785 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4786 SetPixelRed(image,ClampToQuantum(pixel),q);
4787 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4788 SetPixelGreen(image,ClampToQuantum(pixel),q);
4789 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4790 SetPixelBlue(image,ClampToQuantum(pixel),q);
4791 p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);
4792 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4793 p+=quantum_info->pad;
4794 q+=GetPixelChannels(image);
4802 if (quantum_info->format == FloatingPointQuantumFormat)
4807 for (x=0; x < (ssize_t) number_pixels; x++)
4809 p=PushDoublePixel(quantum_info,p,&pixel);
4810 SetPixelRed(image,ClampToQuantum(pixel),q);
4811 p=PushDoublePixel(quantum_info,p,&pixel);
4812 SetPixelGreen(image,ClampToQuantum(pixel),q);
4813 p=PushDoublePixel(quantum_info,p,&pixel);
4814 SetPixelBlue(image,ClampToQuantum(pixel),q);
4815 p=PushDoublePixel(quantum_info,p,&pixel);
4816 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4817 p+=quantum_info->pad;
4818 q+=GetPixelChannels(image);
4829 range=GetQuantumRange(quantum_info->depth);
4830 for (x=0; x < (ssize_t) number_pixels; x++)
4832 p=PushQuantumPixel(quantum_info,p,&pixel);
4833 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4834 p=PushQuantumPixel(quantum_info,p,&pixel);
4835 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4836 p=PushQuantumPixel(quantum_info,p,&pixel);
4837 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4838 p=PushQuantumPixel(quantum_info,p,&pixel);
4839 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
4840 q+=GetPixelChannels(image);
4847MagickExport
size_t ImportQuantumPixels(
const Image *image,
4849 const QuantumType quantum_type,
const unsigned char *magick_restrict pixels,
4867 assert(image != (
Image *) NULL);
4868 assert(image->signature == MagickCoreSignature);
4870 assert(quantum_info->signature == MagickCoreSignature);
4871 if (IsEventLogging() != MagickFalse)
4872 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4873 if (pixels == (
const unsigned char *) NULL)
4874 pixels=(
const unsigned char *) GetQuantumPixels(quantum_info);
4879 number_pixels=GetImageExtent(image);
4880 q=GetAuthenticPixelQueue(image);
4884 number_pixels=GetCacheViewExtent(image_view);
4885 q=GetCacheViewAuthenticPixelQueue(image_view);
4887 ResetQuantumState(quantum_info);
4888 extent=GetQuantumExtent(image,quantum_info,quantum_type);
4889 switch (quantum_type)
4893 ImportAlphaQuantum(image,quantum_info,number_pixels,p,q);
4898 ImportBGRQuantum(image,quantum_info,number_pixels,p,q);
4903 ImportBGRAQuantum(image,quantum_info,number_pixels,p,q);
4908 ImportBGROQuantum(image,quantum_info,number_pixels,p,q);
4913 ImportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
4919 ImportBlueQuantum(image,quantum_info,number_pixels,p,q);
4924 ImportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
4929 ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
4932 case MultispectralQuantum:
4934 ImportMultispectralQuantum(image,quantum_info,number_pixels,p,q,exception);
4939 ImportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
4944 ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
4949 ImportGrayQuantum(image,quantum_info,number_pixels,p,q);
4952 case GrayAlphaQuantum:
4954 ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
4958 case MagentaQuantum:
4960 ImportGreenQuantum(image,quantum_info,number_pixels,p,q);
4965 ImportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
4968 case IndexAlphaQuantum:
4970 ImportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
4973 case OpacityQuantum:
4975 ImportOpacityQuantum(image,quantum_info,number_pixels,p,q);
4981 ImportRedQuantum(image,quantum_info,number_pixels,p,q);
4987 ImportRGBQuantum(image,quantum_info,number_pixels,p,q);
4993 ImportRGBAQuantum(image,quantum_info,number_pixels,p,q);
4998 ImportRGBOQuantum(image,quantum_info,number_pixels,p,q);
5004 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
5009 q=GetAuthenticPixelQueue(image);
5011 q=GetCacheViewAuthenticPixelQueue(image_view);
5012 for (x=0; x < (ssize_t) number_pixels; x++)
5014 quantum=GetPixelRed(image,q);
5015 SetPixelRed(image,GetPixelGreen(image,q),q);
5016 SetPixelGreen(image,quantum,q);
5017 q+=GetPixelChannels(image);
5020 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
5029 q=GetAuthenticPixelQueue(image);
5031 q=GetCacheViewAuthenticPixelQueue(image_view);
5032 for (x=0; x < (ssize_t) number_pixels; x++)
5037 Sa=QuantumScale*(double) GetPixelAlpha(image,q);
5038 gamma=PerceptibleReciprocal(Sa);
5039 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
5041 PixelChannel channel = GetPixelChannelChannel(image,i);
5042 PixelTrait traits = GetPixelChannelTraits(image,channel);
5043 if ((channel == AlphaPixelChannel) ||
5044 ((traits & UpdatePixelTrait) == 0))
5046 q[i]=ClampToQuantum(gamma*(
double) q[i]);
5048 q+=GetPixelChannels(image);