2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % QQQ U U AAA N N TTTTT U U M M %
7 % Q Q U U A A NN N T U U MM MM %
8 % Q Q U U AAAAA N N N T U U M M M %
9 % Q QQ U U A A N NN T U U M M %
10 % QQQQ UUU A A N N T UUU M M %
12 % IIIII M M PPPP OOO RRRR TTTTT %
13 % I MM MM P P O O R R T %
14 % I M M M PPPP O O RRRR T %
16 % IIIII M M P OOO R R T %
18 % MagickCore Methods to Import Quantum Pixels %
25 % Copyright 1999-2017 ImageMagick Studio LLC, a non-profit organization %
26 % dedicated to making software imaging solutions freely available. %
28 % You may not use this file except in compliance with the License. You may %
29 % obtain a copy of the License at %
31 % https://www.imagemagick.org/script/license.php %
33 % Unless required by applicable law or agreed to in writing, software %
34 % distributed under the License is distributed on an "AS IS" BASIS, %
35 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
36 % See the License for the specific language governing permissions and %
37 % limitations under the License. %
39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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/pixel-private.h"
66 #include "MagickCore/quantum.h"
67 #include "MagickCore/quantum-private.h"
68 #include "MagickCore/resource_.h"
69 #include "MagickCore/semaphore.h"
70 #include "MagickCore/statistic.h"
71 #include "MagickCore/stream.h"
72 #include "MagickCore/string_.h"
73 #include "MagickCore/utility.h"
76 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
80 % I m p o r t Q u a n t u m P i x e l s %
84 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
86 % ImportQuantumPixels() transfers one or more pixel components from a user
87 % supplied buffer into the image pixel cache of an image. The pixels are
88 % expected in network byte order. It returns MagickTrue if the pixels are
89 % successfully transferred, otherwise MagickFalse.
91 % The format of the ImportQuantumPixels method is:
93 % size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
94 % QuantumInfo *quantum_info,const QuantumType quantum_type,
95 % const unsigned char *magick_restrict pixels,ExceptionInfo *exception)
97 % A description of each parameter follows:
101 % o image_view: the image cache view.
103 % o quantum_info: the quantum info.
105 % o quantum_type: Declare which pixel components to transfer (red, green,
106 % blue, opacity, RGB, or RGBA).
108 % o pixels: The pixel components are transferred from this buffer.
110 % o exception: return any errors or warnings in this structure.
114 static inline Quantum PushColormapIndex(const Image *image,const size_t index,
115 MagickBooleanType *range_exception)
117 if (index < image->colors)
118 return((Quantum) index);
119 *range_exception=MagickTrue;
123 static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
124 const unsigned char *magick_restrict pixels,double *pixel)
132 if (quantum_info->endian == LSBEndian)
134 quantum[0]=(*pixels++);
135 quantum[1]=(*pixels++);
136 quantum[2]=(*pixels++);
137 quantum[3]=(*pixels++);
138 quantum[4]=(*pixels++);
139 quantum[5]=(*pixels++);
140 quantum[6]=(*pixels++);
141 quantum[7]=(*pixels++);
142 p=(double *) quantum;
144 *pixel-=quantum_info->minimum;
145 *pixel*=quantum_info->scale;
148 quantum[7]=(*pixels++);
149 quantum[6]=(*pixels++);
150 quantum[5]=(*pixels++);
151 quantum[4]=(*pixels++);
152 quantum[3]=(*pixels++);
153 quantum[2]=(*pixels++);
154 quantum[1]=(*pixels++);
155 quantum[0]=(*pixels++);
156 p=(double *) quantum;
158 *pixel-=quantum_info->minimum;
159 *pixel*=quantum_info->scale;
163 static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
164 const unsigned char *magick_restrict pixels,float *pixel)
172 if (quantum_info->endian == LSBEndian)
174 quantum[0]=(*pixels++);
175 quantum[1]=(*pixels++);
176 quantum[2]=(*pixels++);
177 quantum[3]=(*pixels++);
180 *pixel-=quantum_info->minimum;
181 *pixel*=quantum_info->scale;
184 quantum[3]=(*pixels++);
185 quantum[2]=(*pixels++);
186 quantum[1]=(*pixels++);
187 quantum[0]=(*pixels++);
190 *pixel-=quantum_info->minimum;
191 *pixel*=quantum_info->scale;
195 static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
196 const unsigned char *magick_restrict pixels,unsigned int *quantum)
204 *quantum=(QuantumAny) 0;
205 for (i=(ssize_t) quantum_info->depth; i > 0L; )
207 if (quantum_info->state.bits == 0UL)
209 quantum_info->state.pixel=(*pixels++);
210 quantum_info->state.bits=8UL;
212 quantum_bits=(size_t) i;
213 if (quantum_bits > quantum_info->state.bits)
214 quantum_bits=quantum_info->state.bits;
215 i-=(ssize_t) quantum_bits;
216 quantum_info->state.bits-=quantum_bits;
217 *quantum=(unsigned int) ((*quantum << quantum_bits) |
218 ((quantum_info->state.pixel >> quantum_info->state.bits) &~ ((~0UL) <<
224 static inline const unsigned char *PushQuantumLongPixel(
225 QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
226 unsigned int *quantum)
235 for (i=(ssize_t) quantum_info->depth; i > 0; )
237 if (quantum_info->state.bits == 0)
239 pixels=PushLongPixel(quantum_info->endian,pixels,
240 &quantum_info->state.pixel);
241 quantum_info->state.bits=32U;
243 quantum_bits=(size_t) i;
244 if (quantum_bits > quantum_info->state.bits)
245 quantum_bits=quantum_info->state.bits;
246 *quantum|=(((quantum_info->state.pixel >> (32U-quantum_info->state.bits)) &
247 quantum_info->state.mask[quantum_bits]) << (quantum_info->depth-i));
248 i-=(ssize_t) quantum_bits;
249 quantum_info->state.bits-=quantum_bits;
254 static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
255 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
256 Quantum *magick_restrict q)
267 assert(image != (Image *) NULL);
268 assert(image->signature == MagickCoreSignature);
269 switch (quantum_info->depth)
276 for (x=0; x < (ssize_t) number_pixels; x++)
278 p=PushCharPixel(p,&pixel);
279 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
280 p+=quantum_info->pad;
281 q+=GetPixelChannels(image);
290 if (quantum_info->format == FloatingPointQuantumFormat)
292 for (x=0; x < (ssize_t) number_pixels; x++)
294 p=PushShortPixel(quantum_info->endian,p,&pixel);
295 SetPixelAlpha(image,ClampToQuantum(QuantumRange*
296 HalfToSinglePrecision(pixel)),q);
297 p+=quantum_info->pad;
298 q+=GetPixelChannels(image);
302 for (x=0; x < (ssize_t) number_pixels; x++)
304 p=PushShortPixel(quantum_info->endian,p,&pixel);
305 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
306 p+=quantum_info->pad;
307 q+=GetPixelChannels(image);
316 if (quantum_info->format == FloatingPointQuantumFormat)
321 for (x=0; x < (ssize_t) number_pixels; x++)
323 p=PushFloatPixel(quantum_info,p,&pixel);
324 SetPixelAlpha(image,ClampToQuantum(pixel),q);
325 p+=quantum_info->pad;
326 q+=GetPixelChannels(image);
330 for (x=0; x < (ssize_t) number_pixels; x++)
332 p=PushLongPixel(quantum_info->endian,p,&pixel);
333 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
334 p+=quantum_info->pad;
335 q+=GetPixelChannels(image);
341 if (quantum_info->format == FloatingPointQuantumFormat)
346 for (x=0; x < (ssize_t) number_pixels; x++)
348 p=PushDoublePixel(quantum_info,p,&pixel);
349 SetPixelAlpha(image,ClampToQuantum(pixel),q);
350 p+=quantum_info->pad;
351 q+=GetPixelChannels(image);
358 range=GetQuantumRange(quantum_info->depth);
359 for (x=0; x < (ssize_t) number_pixels; x++)
361 p=PushQuantumPixel(quantum_info,p,&pixel);
362 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
363 p+=quantum_info->pad;
364 q+=GetPixelChannels(image);
371 static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
372 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
373 Quantum *magick_restrict q)
387 assert(image != (Image *) NULL);
388 assert(image->signature == MagickCoreSignature);
389 switch (quantum_info->depth)
396 for (x=0; x < (ssize_t) number_pixels; x++)
398 p=PushCharPixel(p,&pixel);
399 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
400 p=PushCharPixel(p,&pixel);
401 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
402 p=PushCharPixel(p,&pixel);
403 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
404 SetPixelAlpha(image,OpaqueAlpha,q);
405 p+=quantum_info->pad;
406 q+=GetPixelChannels(image);
412 range=GetQuantumRange(quantum_info->depth);
413 if (quantum_info->pack == MagickFalse)
415 for (x=0; x < (ssize_t) number_pixels; x++)
417 p=PushLongPixel(quantum_info->endian,p,&pixel);
418 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
419 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
421 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
422 p+=quantum_info->pad;
423 q+=GetPixelChannels(image);
427 if (quantum_info->quantum == 32U)
429 for (x=0; x < (ssize_t) number_pixels; x++)
431 p=PushQuantumLongPixel(quantum_info,p,&pixel);
432 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
433 p=PushQuantumLongPixel(quantum_info,p,&pixel);
434 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
435 p=PushQuantumLongPixel(quantum_info,p,&pixel);
436 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
437 q+=GetPixelChannels(image);
441 for (x=0; x < (ssize_t) number_pixels; x++)
443 p=PushQuantumPixel(quantum_info,p,&pixel);
444 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
445 p=PushQuantumPixel(quantum_info,p,&pixel);
446 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
447 p=PushQuantumPixel(quantum_info,p,&pixel);
448 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
449 q+=GetPixelChannels(image);
455 range=GetQuantumRange(quantum_info->depth);
456 if (quantum_info->pack == MagickFalse)
461 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
463 p=PushShortPixel(quantum_info->endian,p,&pixel);
469 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
475 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
481 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
483 q+=GetPixelChannels(image);
487 p=PushShortPixel(quantum_info->endian,p,&pixel);
493 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
499 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
505 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
507 q+=GetPixelChannels(image);
511 p+=quantum_info->pad;
513 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
515 p=PushShortPixel(quantum_info->endian,p,&pixel);
521 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
527 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
533 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
535 q+=GetPixelChannels(image);
539 p+=quantum_info->pad;
545 if (quantum_info->quantum == 32U)
547 for (x=0; x < (ssize_t) number_pixels; x++)
549 p=PushQuantumLongPixel(quantum_info,p,&pixel);
550 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
551 p=PushQuantumLongPixel(quantum_info,p,&pixel);
552 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
553 p=PushQuantumLongPixel(quantum_info,p,&pixel);
554 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
555 q+=GetPixelChannels(image);
559 for (x=0; x < (ssize_t) number_pixels; x++)
561 p=PushQuantumPixel(quantum_info,p,&pixel);
562 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
563 p=PushQuantumPixel(quantum_info,p,&pixel);
564 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
565 p=PushQuantumPixel(quantum_info,p,&pixel);
566 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
567 q+=GetPixelChannels(image);
576 if (quantum_info->format == FloatingPointQuantumFormat)
578 for (x=0; x < (ssize_t) number_pixels; x++)
580 p=PushShortPixel(quantum_info->endian,p,&pixel);
581 SetPixelRed(image,ClampToQuantum(QuantumRange*
582 HalfToSinglePrecision(pixel)),q);
583 p=PushShortPixel(quantum_info->endian,p,&pixel);
584 SetPixelGreen(image,ClampToQuantum(QuantumRange*
585 HalfToSinglePrecision(pixel)),q);
586 p=PushShortPixel(quantum_info->endian,p,&pixel);
587 SetPixelBlue(image,ClampToQuantum(QuantumRange*
588 HalfToSinglePrecision(pixel)),q);
589 p+=quantum_info->pad;
590 q+=GetPixelChannels(image);
594 for (x=0; x < (ssize_t) number_pixels; x++)
596 p=PushShortPixel(quantum_info->endian,p,&pixel);
597 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
598 p=PushShortPixel(quantum_info->endian,p,&pixel);
599 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
600 p=PushShortPixel(quantum_info->endian,p,&pixel);
601 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
602 p+=quantum_info->pad;
603 q+=GetPixelChannels(image);
612 if (quantum_info->format == FloatingPointQuantumFormat)
617 for (x=0; x < (ssize_t) number_pixels; x++)
619 p=PushFloatPixel(quantum_info,p,&pixel);
620 SetPixelRed(image,ClampToQuantum(pixel),q);
621 p=PushFloatPixel(quantum_info,p,&pixel);
622 SetPixelGreen(image,ClampToQuantum(pixel),q);
623 p=PushFloatPixel(quantum_info,p,&pixel);
624 SetPixelBlue(image,ClampToQuantum(pixel),q);
625 p+=quantum_info->pad;
626 q+=GetPixelChannels(image);
630 for (x=0; x < (ssize_t) number_pixels; x++)
632 p=PushLongPixel(quantum_info->endian,p,&pixel);
633 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
634 p=PushLongPixel(quantum_info->endian,p,&pixel);
635 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
636 p=PushLongPixel(quantum_info->endian,p,&pixel);
637 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
638 p+=quantum_info->pad;
639 q+=GetPixelChannels(image);
645 if (quantum_info->format == FloatingPointQuantumFormat)
650 for (x=0; x < (ssize_t) number_pixels; x++)
652 p=PushDoublePixel(quantum_info,p,&pixel);
653 SetPixelRed(image,ClampToQuantum(pixel),q);
654 p=PushDoublePixel(quantum_info,p,&pixel);
655 SetPixelGreen(image,ClampToQuantum(pixel),q);
656 p=PushDoublePixel(quantum_info,p,&pixel);
657 SetPixelBlue(image,ClampToQuantum(pixel),q);
658 p+=quantum_info->pad;
659 q+=GetPixelChannels(image);
666 range=GetQuantumRange(quantum_info->depth);
667 for (x=0; x < (ssize_t) number_pixels; x++)
669 p=PushQuantumPixel(quantum_info,p,&pixel);
670 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
671 p=PushQuantumPixel(quantum_info,p,&pixel);
672 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
673 p=PushQuantumPixel(quantum_info,p,&pixel);
674 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
675 q+=GetPixelChannels(image);
682 static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
683 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
684 Quantum *magick_restrict q)
695 assert(image != (Image *) NULL);
696 assert(image->signature == MagickCoreSignature);
697 switch (quantum_info->depth)
704 for (x=0; x < (ssize_t) number_pixels; x++)
706 p=PushCharPixel(p,&pixel);
707 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
708 p=PushCharPixel(p,&pixel);
709 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
710 p=PushCharPixel(p,&pixel);
711 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
712 p=PushCharPixel(p,&pixel);
713 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
714 p+=quantum_info->pad;
715 q+=GetPixelChannels(image);
722 if (quantum_info->pack == MagickFalse)
735 for (x=0; x < (ssize_t) number_pixels; x++)
737 for (i=0; i < 4; i++)
743 p=PushLongPixel(quantum_info->endian,p,&pixel);
744 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
745 (((pixel >> 22) & 0x3ff) << 6)));
750 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
751 (((pixel >> 12) & 0x3ff) << 6)));
756 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
757 (((pixel >> 2) & 0x3ff) << 6)));
763 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
764 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
765 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
766 case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
770 p+=quantum_info->pad;
771 q+=GetPixelChannels(image);
775 for (x=0; x < (ssize_t) number_pixels; x++)
777 p=PushQuantumPixel(quantum_info,p,&pixel);
778 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
779 p=PushQuantumPixel(quantum_info,p,&pixel);
780 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
782 p=PushQuantumPixel(quantum_info,p,&pixel);
783 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
785 p=PushQuantumPixel(quantum_info,p,&pixel);
786 SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
788 q+=GetPixelChannels(image);
797 if (quantum_info->format == FloatingPointQuantumFormat)
799 for (x=0; x < (ssize_t) number_pixels; x++)
801 p=PushShortPixel(quantum_info->endian,p,&pixel);
802 SetPixelRed(image,ClampToQuantum(QuantumRange*
803 HalfToSinglePrecision(pixel)),q);
804 p=PushShortPixel(quantum_info->endian,p,&pixel);
805 SetPixelGreen(image,ClampToQuantum(QuantumRange*
806 HalfToSinglePrecision(pixel)),q);
807 p=PushShortPixel(quantum_info->endian,p,&pixel);
808 SetPixelBlue(image,ClampToQuantum(QuantumRange*
809 HalfToSinglePrecision(pixel)),q);
810 p=PushShortPixel(quantum_info->endian,p,&pixel);
811 SetPixelAlpha(image,ClampToQuantum(QuantumRange*
812 HalfToSinglePrecision(pixel)),q);
813 p+=quantum_info->pad;
814 q+=GetPixelChannels(image);
818 for (x=0; x < (ssize_t) number_pixels; x++)
820 p=PushShortPixel(quantum_info->endian,p,&pixel);
821 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
822 p=PushShortPixel(quantum_info->endian,p,&pixel);
823 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
824 p=PushShortPixel(quantum_info->endian,p,&pixel);
825 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
826 p=PushShortPixel(quantum_info->endian,p,&pixel);
827 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
828 p+=quantum_info->pad;
829 q+=GetPixelChannels(image);
838 if (quantum_info->format == FloatingPointQuantumFormat)
843 for (x=0; x < (ssize_t) number_pixels; x++)
845 p=PushFloatPixel(quantum_info,p,&pixel);
846 SetPixelRed(image,ClampToQuantum(pixel),q);
847 p=PushFloatPixel(quantum_info,p,&pixel);
848 SetPixelGreen(image,ClampToQuantum(pixel),q);
849 p=PushFloatPixel(quantum_info,p,&pixel);
850 SetPixelBlue(image,ClampToQuantum(pixel),q);
851 p=PushFloatPixel(quantum_info,p,&pixel);
852 SetPixelAlpha(image,ClampToQuantum(pixel),q);
853 p+=quantum_info->pad;
854 q+=GetPixelChannels(image);
858 for (x=0; x < (ssize_t) number_pixels; x++)
860 p=PushLongPixel(quantum_info->endian,p,&pixel);
861 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
862 p=PushLongPixel(quantum_info->endian,p,&pixel);
863 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
864 p=PushLongPixel(quantum_info->endian,p,&pixel);
865 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
866 p=PushLongPixel(quantum_info->endian,p,&pixel);
867 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
868 p+=quantum_info->pad;
869 q+=GetPixelChannels(image);
875 if (quantum_info->format == FloatingPointQuantumFormat)
880 for (x=0; x < (ssize_t) number_pixels; x++)
882 p=PushDoublePixel(quantum_info,p,&pixel);
883 SetPixelRed(image,ClampToQuantum(pixel),q);
884 p=PushDoublePixel(quantum_info,p,&pixel);
885 SetPixelGreen(image,ClampToQuantum(pixel),q);
886 p=PushDoublePixel(quantum_info,p,&pixel);
887 SetPixelBlue(image,ClampToQuantum(pixel),q);
888 p=PushDoublePixel(quantum_info,p,&pixel);
889 SetPixelAlpha(image,ClampToQuantum(pixel),q);
890 p+=quantum_info->pad;
891 q+=GetPixelChannels(image);
898 range=GetQuantumRange(quantum_info->depth);
899 for (x=0; x < (ssize_t) number_pixels; x++)
901 p=PushQuantumPixel(quantum_info,p,&pixel);
902 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
903 p=PushQuantumPixel(quantum_info,p,&pixel);
904 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
905 p=PushQuantumPixel(quantum_info,p,&pixel);
906 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
907 p=PushQuantumPixel(quantum_info,p,&pixel);
908 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
909 q+=GetPixelChannels(image);
916 static void ImportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
917 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
918 Quantum *magick_restrict q)
929 assert(image != (Image *) NULL);
930 assert(image->signature == MagickCoreSignature);
931 switch (quantum_info->depth)
938 for (x=0; x < (ssize_t) number_pixels; x++)
940 p=PushCharPixel(p,&pixel);
941 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
942 p=PushCharPixel(p,&pixel);
943 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
944 p=PushCharPixel(p,&pixel);
945 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
946 p=PushCharPixel(p,&pixel);
947 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
948 p+=quantum_info->pad;
949 q+=GetPixelChannels(image);
956 if (quantum_info->pack == MagickFalse)
969 for (x=0; x < (ssize_t) number_pixels; x++)
971 for (i=0; i < 4; i++)
977 p=PushLongPixel(quantum_info->endian,p,&pixel);
978 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
979 (((pixel >> 22) & 0x3ff) << 6)));
984 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
985 (((pixel >> 12) & 0x3ff) << 6)));
990 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
991 (((pixel >> 2) & 0x3ff) << 6)));
997 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
998 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
999 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
1000 case 3: SetPixelOpacity(image,(Quantum) quantum,q); break;
1004 p+=quantum_info->pad;
1005 q+=GetPixelChannels(image);
1009 for (x=0; x < (ssize_t) number_pixels; x++)
1011 p=PushQuantumPixel(quantum_info,p,&pixel);
1012 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
1013 p=PushQuantumPixel(quantum_info,p,&pixel);
1014 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
1016 p=PushQuantumPixel(quantum_info,p,&pixel);
1017 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
1019 p=PushQuantumPixel(quantum_info,p,&pixel);
1020 SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
1022 q+=GetPixelChannels(image);
1031 if (quantum_info->format == FloatingPointQuantumFormat)
1033 for (x=0; x < (ssize_t) number_pixels; x++)
1035 p=PushShortPixel(quantum_info->endian,p,&pixel);
1036 SetPixelRed(image,ClampToQuantum(QuantumRange*
1037 HalfToSinglePrecision(pixel)),q);
1038 p=PushShortPixel(quantum_info->endian,p,&pixel);
1039 SetPixelGreen(image,ClampToQuantum(QuantumRange*
1040 HalfToSinglePrecision(pixel)),q);
1041 p=PushShortPixel(quantum_info->endian,p,&pixel);
1042 SetPixelBlue(image,ClampToQuantum(QuantumRange*
1043 HalfToSinglePrecision(pixel)),q);
1044 p=PushShortPixel(quantum_info->endian,p,&pixel);
1045 SetPixelOpacity(image,ClampToQuantum(QuantumRange*
1046 HalfToSinglePrecision(pixel)),q);
1047 p+=quantum_info->pad;
1048 q+=GetPixelChannels(image);
1052 for (x=0; x < (ssize_t) number_pixels; x++)
1054 p=PushShortPixel(quantum_info->endian,p,&pixel);
1055 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1056 p=PushShortPixel(quantum_info->endian,p,&pixel);
1057 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1058 p=PushShortPixel(quantum_info->endian,p,&pixel);
1059 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1060 p=PushShortPixel(quantum_info->endian,p,&pixel);
1061 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
1062 p+=quantum_info->pad;
1063 q+=GetPixelChannels(image);
1072 if (quantum_info->format == FloatingPointQuantumFormat)
1077 for (x=0; x < (ssize_t) number_pixels; x++)
1079 p=PushFloatPixel(quantum_info,p,&pixel);
1080 SetPixelRed(image,ClampToQuantum(pixel),q);
1081 p=PushFloatPixel(quantum_info,p,&pixel);
1082 SetPixelGreen(image,ClampToQuantum(pixel),q);
1083 p=PushFloatPixel(quantum_info,p,&pixel);
1084 SetPixelBlue(image,ClampToQuantum(pixel),q);
1085 p=PushFloatPixel(quantum_info,p,&pixel);
1086 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1087 p+=quantum_info->pad;
1088 q+=GetPixelChannels(image);
1092 for (x=0; x < (ssize_t) number_pixels; x++)
1094 p=PushLongPixel(quantum_info->endian,p,&pixel);
1095 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1096 p=PushLongPixel(quantum_info->endian,p,&pixel);
1097 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1098 p=PushLongPixel(quantum_info->endian,p,&pixel);
1099 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1100 p=PushLongPixel(quantum_info->endian,p,&pixel);
1101 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
1102 p+=quantum_info->pad;
1103 q+=GetPixelChannels(image);
1109 if (quantum_info->format == FloatingPointQuantumFormat)
1114 for (x=0; x < (ssize_t) number_pixels; x++)
1116 p=PushDoublePixel(quantum_info,p,&pixel);
1117 SetPixelRed(image,ClampToQuantum(pixel),q);
1118 p=PushDoublePixel(quantum_info,p,&pixel);
1119 SetPixelGreen(image,ClampToQuantum(pixel),q);
1120 p=PushDoublePixel(quantum_info,p,&pixel);
1121 SetPixelBlue(image,ClampToQuantum(pixel),q);
1122 p=PushDoublePixel(quantum_info,p,&pixel);
1123 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1124 p+=quantum_info->pad;
1125 q+=GetPixelChannels(image);
1132 range=GetQuantumRange(quantum_info->depth);
1133 for (x=0; x < (ssize_t) number_pixels; x++)
1135 p=PushQuantumPixel(quantum_info,p,&pixel);
1136 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1137 p=PushQuantumPixel(quantum_info,p,&pixel);
1138 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1139 p=PushQuantumPixel(quantum_info,p,&pixel);
1140 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1141 p=PushQuantumPixel(quantum_info,p,&pixel);
1142 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
1143 q+=GetPixelChannels(image);
1150 static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
1151 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1152 Quantum *magick_restrict q,ExceptionInfo *exception)
1163 if (image->colorspace != CMYKColorspace)
1165 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1166 "ColorSeparatedImageRequired","`%s'",image->filename);
1169 switch (quantum_info->depth)
1176 for (x=0; x < (ssize_t) number_pixels; x++)
1178 p=PushCharPixel(p,&pixel);
1179 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1180 p+=quantum_info->pad;
1181 q+=GetPixelChannels(image);
1190 if (quantum_info->format == FloatingPointQuantumFormat)
1192 for (x=0; x < (ssize_t) number_pixels; x++)
1194 p=PushShortPixel(quantum_info->endian,p,&pixel);
1195 SetPixelBlack(image,ClampToQuantum(QuantumRange*
1196 HalfToSinglePrecision(pixel)),q);
1197 p+=quantum_info->pad;
1198 q+=GetPixelChannels(image);
1202 for (x=0; x < (ssize_t) number_pixels; x++)
1204 p=PushShortPixel(quantum_info->endian,p,&pixel);
1205 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1206 p+=quantum_info->pad;
1207 q+=GetPixelChannels(image);
1216 if (quantum_info->format == FloatingPointQuantumFormat)
1221 for (x=0; x < (ssize_t) number_pixels; x++)
1223 p=PushFloatPixel(quantum_info,p,&pixel);
1224 SetPixelBlack(image,ClampToQuantum(pixel),q);
1225 p+=quantum_info->pad;
1226 q+=GetPixelChannels(image);
1230 for (x=0; x < (ssize_t) number_pixels; x++)
1232 p=PushLongPixel(quantum_info->endian,p,&pixel);
1233 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1234 p+=quantum_info->pad;
1235 q+=GetPixelChannels(image);
1241 if (quantum_info->format == FloatingPointQuantumFormat)
1246 for (x=0; x < (ssize_t) number_pixels; x++)
1248 p=PushDoublePixel(quantum_info,p,&pixel);
1249 SetPixelBlack(image,ClampToQuantum(pixel),q);
1250 p+=quantum_info->pad;
1251 q+=GetPixelChannels(image);
1258 range=GetQuantumRange(quantum_info->depth);
1259 for (x=0; x < (ssize_t) number_pixels; x++)
1261 p=PushQuantumPixel(quantum_info,p,&pixel);
1262 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1263 p+=quantum_info->pad;
1264 q+=GetPixelChannels(image);
1271 static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
1272 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1273 Quantum *magick_restrict q)
1284 assert(image != (Image *) NULL);
1285 assert(image->signature == MagickCoreSignature);
1286 switch (quantum_info->depth)
1293 for (x=0; x < (ssize_t) number_pixels; x++)
1295 p=PushCharPixel(p,&pixel);
1296 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1297 p+=quantum_info->pad;
1298 q+=GetPixelChannels(image);
1307 if (quantum_info->format == FloatingPointQuantumFormat)
1309 for (x=0; x < (ssize_t) number_pixels; x++)
1311 p=PushShortPixel(quantum_info->endian,p,&pixel);
1312 SetPixelBlue(image,ClampToQuantum(QuantumRange*
1313 HalfToSinglePrecision(pixel)),q);
1314 p+=quantum_info->pad;
1315 q+=GetPixelChannels(image);
1319 for (x=0; x < (ssize_t) number_pixels; x++)
1321 p=PushShortPixel(quantum_info->endian,p,&pixel);
1322 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1323 p+=quantum_info->pad;
1324 q+=GetPixelChannels(image);
1333 if (quantum_info->format == FloatingPointQuantumFormat)
1338 for (x=0; x < (ssize_t) number_pixels; x++)
1340 p=PushFloatPixel(quantum_info,p,&pixel);
1341 SetPixelBlue(image,ClampToQuantum(pixel),q);
1342 p+=quantum_info->pad;
1343 q+=GetPixelChannels(image);
1347 for (x=0; x < (ssize_t) number_pixels; x++)
1349 p=PushLongPixel(quantum_info->endian,p,&pixel);
1350 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1351 p+=quantum_info->pad;
1352 q+=GetPixelChannels(image);
1358 if (quantum_info->format == FloatingPointQuantumFormat)
1363 for (x=0; x < (ssize_t) number_pixels; x++)
1365 p=PushDoublePixel(quantum_info,p,&pixel);
1366 SetPixelBlue(image,ClampToQuantum(pixel),q);
1367 p+=quantum_info->pad;
1368 q+=GetPixelChannels(image);
1375 range=GetQuantumRange(quantum_info->depth);
1376 for (x=0; x < (ssize_t) number_pixels; x++)
1378 p=PushQuantumPixel(quantum_info,p,&pixel);
1379 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1380 p+=quantum_info->pad;
1381 q+=GetPixelChannels(image);
1388 static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
1389 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1390 Quantum *magick_restrict q)
1401 assert(image != (Image *) NULL);
1402 assert(image->signature == MagickCoreSignature);
1403 switch (quantum_info->depth)
1411 if (quantum_info->pack == MagickFalse)
1424 for (x=0; x < (ssize_t) number_pixels; x+=4)
1426 for (i=0; i < 4; i++)
1432 p=PushLongPixel(quantum_info->endian,p,&pixel);
1433 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1434 (((pixel >> 22) & 0x3ff) << 6)));
1439 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1440 (((pixel >> 12) & 0x3ff) << 6)));
1445 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1446 (((pixel >> 2) & 0x3ff) << 6)));
1450 cbcr[i]=(Quantum) (quantum);
1453 p+=quantum_info->pad;
1454 SetPixelRed(image,cbcr[1],q);
1455 SetPixelGreen(image,cbcr[0],q);
1456 SetPixelBlue(image,cbcr[2],q);
1457 q+=GetPixelChannels(image);
1458 SetPixelRed(image,cbcr[3],q);
1459 SetPixelGreen(image,cbcr[0],q);
1460 SetPixelBlue(image,cbcr[2],q);
1461 q+=GetPixelChannels(image);
1468 range=GetQuantumRange(quantum_info->depth);
1469 for (x=0; x < (ssize_t) number_pixels; x++)
1471 p=PushQuantumPixel(quantum_info,p,&pixel);
1472 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1473 p=PushQuantumPixel(quantum_info,p,&pixel);
1474 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1475 q+=GetPixelChannels(image);
1482 static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
1483 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1484 Quantum *magick_restrict q,ExceptionInfo *exception)
1495 if (image->colorspace != CMYKColorspace)
1497 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1498 "ColorSeparatedImageRequired","`%s'",image->filename);
1501 switch (quantum_info->depth)
1508 for (x=0; x < (ssize_t) number_pixels; x++)
1510 p=PushCharPixel(p,&pixel);
1511 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1512 p=PushCharPixel(p,&pixel);
1513 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1514 p=PushCharPixel(p,&pixel);
1515 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1516 p=PushCharPixel(p,&pixel);
1517 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1518 p+=quantum_info->pad;
1519 q+=GetPixelChannels(image);
1528 if (quantum_info->format == FloatingPointQuantumFormat)
1530 for (x=0; x < (ssize_t) number_pixels; x++)
1532 p=PushShortPixel(quantum_info->endian,p,&pixel);
1533 SetPixelRed(image,ClampToQuantum(QuantumRange*
1534 HalfToSinglePrecision(pixel)),q);
1535 p=PushShortPixel(quantum_info->endian,p,&pixel);
1536 SetPixelGreen(image,ClampToQuantum(QuantumRange*
1537 HalfToSinglePrecision(pixel)),q);
1538 p=PushShortPixel(quantum_info->endian,p,&pixel);
1539 SetPixelBlue(image,ClampToQuantum(QuantumRange*
1540 HalfToSinglePrecision(pixel)),q);
1541 p=PushShortPixel(quantum_info->endian,p,&pixel);
1542 SetPixelBlack(image,ClampToQuantum(QuantumRange*
1543 HalfToSinglePrecision(pixel)),q);
1544 p+=quantum_info->pad;
1545 q+=GetPixelChannels(image);
1549 for (x=0; x < (ssize_t) number_pixels; x++)
1551 p=PushShortPixel(quantum_info->endian,p,&pixel);
1552 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1553 p=PushShortPixel(quantum_info->endian,p,&pixel);
1554 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1555 p=PushShortPixel(quantum_info->endian,p,&pixel);
1556 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1557 p=PushShortPixel(quantum_info->endian,p,&pixel);
1558 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1559 p+=quantum_info->pad;
1560 q+=GetPixelChannels(image);
1569 if (quantum_info->format == FloatingPointQuantumFormat)
1574 for (x=0; x < (ssize_t) number_pixels; x++)
1576 p=PushFloatPixel(quantum_info,p,&pixel);
1577 SetPixelRed(image,ClampToQuantum(pixel),q);
1578 p=PushFloatPixel(quantum_info,p,&pixel);
1579 SetPixelGreen(image,ClampToQuantum(pixel),q);
1580 p=PushFloatPixel(quantum_info,p,&pixel);
1581 SetPixelBlue(image,ClampToQuantum(pixel),q);
1582 p=PushFloatPixel(quantum_info,p,&pixel);
1583 SetPixelBlack(image,ClampToQuantum(pixel),q);
1584 p+=quantum_info->pad;
1585 q+=GetPixelChannels(image);
1589 for (x=0; x < (ssize_t) number_pixels; x++)
1591 p=PushLongPixel(quantum_info->endian,p,&pixel);
1592 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1593 p=PushLongPixel(quantum_info->endian,p,&pixel);
1594 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1595 p=PushLongPixel(quantum_info->endian,p,&pixel);
1596 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1597 p=PushLongPixel(quantum_info->endian,p,&pixel);
1598 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1599 p+=quantum_info->pad;
1600 q+=GetPixelChannels(image);
1606 if (quantum_info->format == FloatingPointQuantumFormat)
1611 for (x=0; x < (ssize_t) number_pixels; x++)
1613 p=PushDoublePixel(quantum_info,p,&pixel);
1614 SetPixelRed(image,ClampToQuantum(pixel),q);
1615 p=PushDoublePixel(quantum_info,p,&pixel);
1616 SetPixelGreen(image,ClampToQuantum(pixel),q);
1617 p=PushDoublePixel(quantum_info,p,&pixel);
1618 SetPixelBlue(image,ClampToQuantum(pixel),q);
1619 p=PushDoublePixel(quantum_info,p,&pixel);
1620 SetPixelBlack(image,ClampToQuantum(pixel),q);
1621 p+=quantum_info->pad;
1622 q+=GetPixelChannels(image);
1629 range=GetQuantumRange(quantum_info->depth);
1630 for (x=0; x < (ssize_t) number_pixels; x++)
1632 p=PushQuantumPixel(quantum_info,p,&pixel);
1633 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1634 p=PushQuantumPixel(quantum_info,p,&pixel);
1635 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1636 p=PushQuantumPixel(quantum_info,p,&pixel);
1637 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1638 p=PushQuantumPixel(quantum_info,p,&pixel);
1639 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1640 q+=GetPixelChannels(image);
1647 static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
1648 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1649 Quantum *magick_restrict q,ExceptionInfo *exception)
1660 if (image->colorspace != CMYKColorspace)
1662 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1663 "ColorSeparatedImageRequired","`%s'",image->filename);
1666 switch (quantum_info->depth)
1673 for (x=0; x < (ssize_t) number_pixels; x++)
1675 p=PushCharPixel(p,&pixel);
1676 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1677 p=PushCharPixel(p,&pixel);
1678 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1679 p=PushCharPixel(p,&pixel);
1680 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1681 p=PushCharPixel(p,&pixel);
1682 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1683 p=PushCharPixel(p,&pixel);
1684 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
1685 p+=quantum_info->pad;
1686 q+=GetPixelChannels(image);
1695 if (quantum_info->format == FloatingPointQuantumFormat)
1697 for (x=0; x < (ssize_t) number_pixels; x++)
1699 p=PushShortPixel(quantum_info->endian,p,&pixel);
1700 SetPixelRed(image,ClampToQuantum(QuantumRange*
1701 HalfToSinglePrecision(pixel)),q);
1702 p=PushShortPixel(quantum_info->endian,p,&pixel);
1703 SetPixelGreen(image,ClampToQuantum(QuantumRange*
1704 HalfToSinglePrecision(pixel)),q);
1705 p=PushShortPixel(quantum_info->endian,p,&pixel);
1706 SetPixelBlue(image,ClampToQuantum(QuantumRange*
1707 HalfToSinglePrecision(pixel)),q);
1708 p=PushShortPixel(quantum_info->endian,p,&pixel);
1709 SetPixelBlack(image,ClampToQuantum(QuantumRange*
1710 HalfToSinglePrecision(pixel)),q);
1711 p=PushShortPixel(quantum_info->endian,p,&pixel);
1712 SetPixelAlpha(image,ClampToQuantum(QuantumRange*
1713 HalfToSinglePrecision(pixel)),q);
1714 p+=quantum_info->pad;
1715 q+=GetPixelChannels(image);
1719 for (x=0; x < (ssize_t) number_pixels; x++)
1721 p=PushShortPixel(quantum_info->endian,p,&pixel);
1722 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1723 p=PushShortPixel(quantum_info->endian,p,&pixel);
1724 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1725 p=PushShortPixel(quantum_info->endian,p,&pixel);
1726 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1727 p=PushShortPixel(quantum_info->endian,p,&pixel);
1728 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1729 p=PushShortPixel(quantum_info->endian,p,&pixel);
1730 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
1731 p+=quantum_info->pad;
1732 q+=GetPixelChannels(image);
1741 if (quantum_info->format == FloatingPointQuantumFormat)
1746 for (x=0; x < (ssize_t) number_pixels; x++)
1748 p=PushFloatPixel(quantum_info,p,&pixel);
1749 SetPixelRed(image,ClampToQuantum(pixel),q);
1750 p=PushFloatPixel(quantum_info,p,&pixel);
1751 SetPixelGreen(image,ClampToQuantum(pixel),q);
1752 p=PushFloatPixel(quantum_info,p,&pixel);
1753 SetPixelBlue(image,ClampToQuantum(pixel),q);
1754 p=PushFloatPixel(quantum_info,p,&pixel);
1755 SetPixelBlack(image,ClampToQuantum(pixel),q);
1756 p=PushFloatPixel(quantum_info,p,&pixel);
1757 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1758 p+=quantum_info->pad;
1759 q+=GetPixelChannels(image);
1763 for (x=0; x < (ssize_t) number_pixels; x++)
1765 p=PushLongPixel(quantum_info->endian,p,&pixel);
1766 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1767 p=PushLongPixel(quantum_info->endian,p,&pixel);
1768 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1769 p=PushLongPixel(quantum_info->endian,p,&pixel);
1770 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1771 p=PushLongPixel(quantum_info->endian,p,&pixel);
1772 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1773 p=PushLongPixel(quantum_info->endian,p,&pixel);
1774 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
1775 p+=quantum_info->pad;
1776 q+=GetPixelChannels(image);
1782 if (quantum_info->format == FloatingPointQuantumFormat)
1787 for (x=0; x < (ssize_t) number_pixels; x++)
1789 p=PushDoublePixel(quantum_info,p,&pixel);
1790 SetPixelRed(image,ClampToQuantum(pixel),q);
1791 p=PushDoublePixel(quantum_info,p,&pixel);
1792 SetPixelGreen(image,ClampToQuantum(pixel),q);
1793 p=PushDoublePixel(quantum_info,p,&pixel);
1794 SetPixelBlue(image,ClampToQuantum(pixel),q);
1795 p=PushDoublePixel(quantum_info,p,&pixel);
1796 SetPixelBlack(image,ClampToQuantum(pixel),q);
1797 p=PushDoublePixel(quantum_info,p,&pixel);
1798 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1799 p=PushDoublePixel(quantum_info,p,&pixel);
1800 p+=quantum_info->pad;
1801 q+=GetPixelChannels(image);
1808 range=GetQuantumRange(quantum_info->depth);
1809 for (x=0; x < (ssize_t) number_pixels; x++)
1811 p=PushQuantumPixel(quantum_info,p,&pixel);
1812 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1813 p=PushQuantumPixel(quantum_info,p,&pixel);
1814 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1815 p=PushQuantumPixel(quantum_info,p,&pixel);
1816 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1817 p=PushQuantumPixel(quantum_info,p,&pixel);
1818 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
1819 p=PushQuantumPixel(quantum_info,p,&pixel);
1820 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1821 q+=GetPixelChannels(image);
1828 static void ImportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
1829 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
1830 Quantum *magick_restrict q,ExceptionInfo *exception)
1841 if (image->colorspace != CMYKColorspace)
1843 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1844 "ColorSeparatedImageRequired","`%s'",image->filename);
1847 switch (quantum_info->depth)
1854 for (x=0; x < (ssize_t) number_pixels; x++)
1856 p=PushCharPixel(p,&pixel);
1857 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1858 p=PushCharPixel(p,&pixel);
1859 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1860 p=PushCharPixel(p,&pixel);
1861 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1862 p=PushCharPixel(p,&pixel);
1863 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
1864 p=PushCharPixel(p,&pixel);
1865 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
1866 p+=quantum_info->pad;
1867 q+=GetPixelChannels(image);
1876 if (quantum_info->format == FloatingPointQuantumFormat)
1878 for (x=0; x < (ssize_t) number_pixels; x++)
1880 p=PushShortPixel(quantum_info->endian,p,&pixel);
1881 SetPixelRed(image,ClampToQuantum(QuantumRange*
1882 HalfToSinglePrecision(pixel)),q);
1883 p=PushShortPixel(quantum_info->endian,p,&pixel);
1884 SetPixelGreen(image,ClampToQuantum(QuantumRange*
1885 HalfToSinglePrecision(pixel)),q);
1886 p=PushShortPixel(quantum_info->endian,p,&pixel);
1887 SetPixelBlue(image,ClampToQuantum(QuantumRange*
1888 HalfToSinglePrecision(pixel)),q);
1889 p=PushShortPixel(quantum_info->endian,p,&pixel);
1890 SetPixelBlack(image,ClampToQuantum(QuantumRange*
1891 HalfToSinglePrecision(pixel)),q);
1892 p=PushShortPixel(quantum_info->endian,p,&pixel);
1893 SetPixelOpacity(image,ClampToQuantum(QuantumRange*
1894 HalfToSinglePrecision(pixel)),q);
1895 p+=quantum_info->pad;
1896 q+=GetPixelChannels(image);
1900 for (x=0; x < (ssize_t) number_pixels; x++)
1902 p=PushShortPixel(quantum_info->endian,p,&pixel);
1903 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1904 p=PushShortPixel(quantum_info->endian,p,&pixel);
1905 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1906 p=PushShortPixel(quantum_info->endian,p,&pixel);
1907 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1908 p=PushShortPixel(quantum_info->endian,p,&pixel);
1909 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
1910 p=PushShortPixel(quantum_info->endian,p,&pixel);
1911 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
1912 p+=quantum_info->pad;
1913 q+=GetPixelChannels(image);
1922 if (quantum_info->format == FloatingPointQuantumFormat)
1927 for (x=0; x < (ssize_t) number_pixels; x++)
1929 p=PushFloatPixel(quantum_info,p,&pixel);
1930 SetPixelRed(image,ClampToQuantum(pixel),q);
1931 p=PushFloatPixel(quantum_info,p,&pixel);
1932 SetPixelGreen(image,ClampToQuantum(pixel),q);
1933 p=PushFloatPixel(quantum_info,p,&pixel);
1934 SetPixelBlue(image,ClampToQuantum(pixel),q);
1935 p=PushFloatPixel(quantum_info,p,&pixel);
1936 SetPixelBlack(image,ClampToQuantum(pixel),q);
1937 p=PushFloatPixel(quantum_info,p,&pixel);
1938 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1939 p+=quantum_info->pad;
1940 q+=GetPixelChannels(image);
1944 for (x=0; x < (ssize_t) number_pixels; x++)
1946 p=PushLongPixel(quantum_info->endian,p,&pixel);
1947 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1948 p=PushLongPixel(quantum_info->endian,p,&pixel);
1949 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1950 p=PushLongPixel(quantum_info->endian,p,&pixel);
1951 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1952 p=PushLongPixel(quantum_info->endian,p,&pixel);
1953 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
1954 p=PushLongPixel(quantum_info->endian,p,&pixel);
1955 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
1956 p+=quantum_info->pad;
1957 q+=GetPixelChannels(image);
1963 if (quantum_info->format == FloatingPointQuantumFormat)
1968 for (x=0; x < (ssize_t) number_pixels; x++)
1970 p=PushDoublePixel(quantum_info,p,&pixel);
1971 SetPixelRed(image,ClampToQuantum(pixel),q);
1972 p=PushDoublePixel(quantum_info,p,&pixel);
1973 SetPixelGreen(image,ClampToQuantum(pixel),q);
1974 p=PushDoublePixel(quantum_info,p,&pixel);
1975 SetPixelBlue(image,ClampToQuantum(pixel),q);
1976 p=PushDoublePixel(quantum_info,p,&pixel);
1977 SetPixelBlack(image,ClampToQuantum(pixel),q);
1978 p=PushDoublePixel(quantum_info,p,&pixel);
1979 SetPixelOpacity(image,ClampToQuantum(pixel),q);
1980 p=PushDoublePixel(quantum_info,p,&pixel);
1981 p+=quantum_info->pad;
1982 q+=GetPixelChannels(image);
1989 range=GetQuantumRange(quantum_info->depth);
1990 for (x=0; x < (ssize_t) number_pixels; x++)
1992 p=PushQuantumPixel(quantum_info,p,&pixel);
1993 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1994 p=PushQuantumPixel(quantum_info,p,&pixel);
1995 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1996 p=PushQuantumPixel(quantum_info,p,&pixel);
1997 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1998 p=PushQuantumPixel(quantum_info,p,&pixel);
1999 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
2000 p=PushQuantumPixel(quantum_info,p,&pixel);
2001 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
2002 q+=GetPixelChannels(image);
2009 static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
2010 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2011 Quantum *magick_restrict q)
2025 assert(image != (Image *) NULL);
2026 assert(image->signature == MagickCoreSignature);
2028 switch (quantum_info->depth)
2038 if (quantum_info->min_is_white != MagickFalse)
2043 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
2045 for (bit=0; bit < 8; bit++)
2047 SetPixelGray(image,((*p) & (1 << (7-bit))) == 0 ? black : white,q);
2048 q+=GetPixelChannels(image);
2052 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
2054 SetPixelGray(image,((*p) & (0x01 << (7-bit))) == 0 ? black : white,q);
2055 q+=GetPixelChannels(image);
2063 register unsigned char
2066 range=GetQuantumRange(quantum_info->depth);
2067 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
2069 pixel=(unsigned char) ((*p >> 4) & 0xf);
2070 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2071 q+=GetPixelChannels(image);
2072 pixel=(unsigned char) ((*p) & 0xf);
2073 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2075 q+=GetPixelChannels(image);
2077 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2079 pixel=(unsigned char) (*p++ >> 4);
2080 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2081 q+=GetPixelChannels(image);
2090 if (quantum_info->min_is_white != MagickFalse)
2092 for (x=0; x < (ssize_t) number_pixels; x++)
2094 p=PushCharPixel(p,&pixel);
2095 SetPixelGray(image,QuantumRange-ScaleCharToQuantum(pixel),q);
2096 SetPixelAlpha(image,OpaqueAlpha,q);
2097 p+=quantum_info->pad;
2098 q+=GetPixelChannels(image);
2102 for (x=0; x < (ssize_t) number_pixels; x++)
2104 p=PushCharPixel(p,&pixel);
2105 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2106 SetPixelAlpha(image,OpaqueAlpha,q);
2107 p+=quantum_info->pad;
2108 q+=GetPixelChannels(image);
2114 range=GetQuantumRange(quantum_info->depth);
2115 if (quantum_info->pack == MagickFalse)
2117 if (image->endian == LSBEndian)
2119 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2121 p=PushLongPixel(quantum_info->endian,p,&pixel);
2122 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2124 q+=GetPixelChannels(image);
2125 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2127 q+=GetPixelChannels(image);
2128 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2130 p+=quantum_info->pad;
2131 q+=GetPixelChannels(image);
2133 p=PushLongPixel(quantum_info->endian,p,&pixel);
2134 if (x++ < (ssize_t) (number_pixels-1))
2136 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2138 q+=GetPixelChannels(image);
2140 if (x++ < (ssize_t) number_pixels)
2142 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2144 q+=GetPixelChannels(image);
2148 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
2150 p=PushLongPixel(quantum_info->endian,p,&pixel);
2151 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
2153 q+=GetPixelChannels(image);
2154 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
2156 q+=GetPixelChannels(image);
2157 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
2159 p+=quantum_info->pad;
2160 q+=GetPixelChannels(image);
2162 p=PushLongPixel(quantum_info->endian,p,&pixel);
2163 if (x++ < (ssize_t) (number_pixels-1))
2165 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2167 q+=GetPixelChannels(image);
2169 if (x++ < (ssize_t) number_pixels)
2171 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2173 q+=GetPixelChannels(image);
2177 for (x=0; x < (ssize_t) number_pixels; x++)
2179 p=PushQuantumPixel(quantum_info,p,&pixel);
2180 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2181 p+=quantum_info->pad;
2182 q+=GetPixelChannels(image);
2188 range=GetQuantumRange(quantum_info->depth);
2189 if (quantum_info->pack == MagickFalse)
2194 for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
2196 p=PushShortPixel(quantum_info->endian,p,&pixel);
2197 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2199 q+=GetPixelChannels(image);
2200 p=PushShortPixel(quantum_info->endian,p,&pixel);
2201 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2203 p+=quantum_info->pad;
2204 q+=GetPixelChannels(image);
2206 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2208 p=PushShortPixel(quantum_info->endian,p,&pixel);
2209 SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
2211 p+=quantum_info->pad;
2212 q+=GetPixelChannels(image);
2218 for (x=0; x < (ssize_t) number_pixels; x++)
2220 p=PushQuantumPixel(quantum_info,p,&pixel);
2221 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2222 p+=quantum_info->pad;
2223 q+=GetPixelChannels(image);
2232 if (quantum_info->min_is_white != MagickFalse)
2234 for (x=0; x < (ssize_t) number_pixels; x++)
2236 p=PushShortPixel(quantum_info->endian,p,&pixel);
2237 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2238 p+=quantum_info->pad;
2239 q+=GetPixelChannels(image);
2243 if (quantum_info->format == FloatingPointQuantumFormat)
2245 for (x=0; x < (ssize_t) number_pixels; x++)
2247 p=PushShortPixel(quantum_info->endian,p,&pixel);
2248 SetPixelGray(image,ClampToQuantum(QuantumRange*
2249 HalfToSinglePrecision(pixel)),q);
2250 p+=quantum_info->pad;
2251 q+=GetPixelChannels(image);
2255 for (x=0; x < (ssize_t) number_pixels; x++)
2257 p=PushShortPixel(quantum_info->endian,p,&pixel);
2258 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2259 p+=quantum_info->pad;
2260 q+=GetPixelChannels(image);
2269 if (quantum_info->format == FloatingPointQuantumFormat)
2274 for (x=0; x < (ssize_t) number_pixels; x++)
2276 p=PushFloatPixel(quantum_info,p,&pixel);
2277 SetPixelGray(image,ClampToQuantum(pixel),q);
2278 p+=quantum_info->pad;
2279 q+=GetPixelChannels(image);
2283 for (x=0; x < (ssize_t) number_pixels; x++)
2285 p=PushLongPixel(quantum_info->endian,p,&pixel);
2286 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2287 p+=quantum_info->pad;
2288 q+=GetPixelChannels(image);
2294 if (quantum_info->format == FloatingPointQuantumFormat)
2299 for (x=0; x < (ssize_t) number_pixels; x++)
2301 p=PushDoublePixel(quantum_info,p,&pixel);
2302 SetPixelGray(image,ClampToQuantum(pixel),q);
2303 p+=quantum_info->pad;
2304 q+=GetPixelChannels(image);
2311 range=GetQuantumRange(quantum_info->depth);
2312 for (x=0; x < (ssize_t) number_pixels; x++)
2314 p=PushQuantumPixel(quantum_info,p,&pixel);
2315 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2316 p+=quantum_info->pad;
2317 q+=GetPixelChannels(image);
2324 static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
2325 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2326 Quantum *magick_restrict q)
2340 assert(image != (Image *) NULL);
2341 assert(image->signature == MagickCoreSignature);
2342 switch (quantum_info->depth)
2346 register unsigned char
2350 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2352 for (bit=0; bit < 8; bit+=2)
2354 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2355 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2356 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
2357 TransparentAlpha : OpaqueAlpha,q);
2358 q+=GetPixelChannels(image);
2362 if ((number_pixels % 4) != 0)
2363 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2365 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2366 SetPixelGray(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
2367 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
2368 TransparentAlpha : OpaqueAlpha,q);
2369 q+=GetPixelChannels(image);
2377 register unsigned char
2380 range=GetQuantumRange(quantum_info->depth);
2381 for (x=0; x < (ssize_t) number_pixels; x++)
2383 pixel=(unsigned char) ((*p >> 4) & 0xf);
2384 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2385 pixel=(unsigned char) ((*p) & 0xf);
2386 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2388 q+=GetPixelChannels(image);
2397 for (x=0; x < (ssize_t) number_pixels; x++)
2399 p=PushCharPixel(p,&pixel);
2400 SetPixelGray(image,ScaleCharToQuantum(pixel),q);
2401 p=PushCharPixel(p,&pixel);
2402 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2403 p+=quantum_info->pad;
2404 q+=GetPixelChannels(image);
2410 range=GetQuantumRange(quantum_info->depth);
2411 for (x=0; x < (ssize_t) number_pixels; x++)
2413 p=PushQuantumPixel(quantum_info,p,&pixel);
2414 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2415 p=PushQuantumPixel(quantum_info,p,&pixel);
2416 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2417 p+=quantum_info->pad;
2418 q+=GetPixelChannels(image);
2424 range=GetQuantumRange(quantum_info->depth);
2425 for (x=0; x < (ssize_t) number_pixels; x++)
2427 p=PushQuantumPixel(quantum_info,p,&pixel);
2428 SetPixelGray(image,ScaleAnyToQuantum(pixel,range),q);
2429 p=PushQuantumPixel(quantum_info,p,&pixel);
2430 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2431 p+=quantum_info->pad;
2432 q+=GetPixelChannels(image);
2441 if (quantum_info->format == FloatingPointQuantumFormat)
2443 for (x=0; x < (ssize_t) number_pixels; x++)
2445 p=PushShortPixel(quantum_info->endian,p,&pixel);
2446 SetPixelGray(image,ClampToQuantum(QuantumRange*
2447 HalfToSinglePrecision(pixel)),q);
2448 p=PushShortPixel(quantum_info->endian,p,&pixel);
2449 SetPixelAlpha(image,ClampToQuantum(QuantumRange*
2450 HalfToSinglePrecision(pixel)),q);
2451 p+=quantum_info->pad;
2452 q+=GetPixelChannels(image);
2456 for (x=0; x < (ssize_t) number_pixels; x++)
2458 p=PushShortPixel(quantum_info->endian,p,&pixel);
2459 SetPixelGray(image,ScaleShortToQuantum(pixel),q);
2460 p=PushShortPixel(quantum_info->endian,p,&pixel);
2461 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
2462 p+=quantum_info->pad;
2463 q+=GetPixelChannels(image);
2472 if (quantum_info->format == FloatingPointQuantumFormat)
2477 for (x=0; x < (ssize_t) number_pixels; x++)
2479 p=PushFloatPixel(quantum_info,p,&pixel);
2480 SetPixelGray(image,ClampToQuantum(pixel),q);
2481 p=PushFloatPixel(quantum_info,p,&pixel);
2482 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2483 p+=quantum_info->pad;
2484 q+=GetPixelChannels(image);
2488 for (x=0; x < (ssize_t) number_pixels; x++)
2490 p=PushLongPixel(quantum_info->endian,p,&pixel);
2491 SetPixelGray(image,ScaleLongToQuantum(pixel),q);
2492 p=PushLongPixel(quantum_info->endian,p,&pixel);
2493 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2494 p+=quantum_info->pad;
2495 q+=GetPixelChannels(image);
2501 if (quantum_info->format == FloatingPointQuantumFormat)
2506 for (x=0; x < (ssize_t) number_pixels; x++)
2508 p=PushDoublePixel(quantum_info,p,&pixel);
2509 SetPixelGray(image,ClampToQuantum(pixel),q);
2510 p=PushDoublePixel(quantum_info,p,&pixel);
2511 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2512 p+=quantum_info->pad;
2513 q+=GetPixelChannels(image);
2520 range=GetQuantumRange(quantum_info->depth);
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=PushQuantumPixel(quantum_info,p,&pixel);
2526 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2527 p+=quantum_info->pad;
2528 q+=GetPixelChannels(image);
2535 static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
2536 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2537 Quantum *magick_restrict q)
2548 assert(image != (Image *) NULL);
2549 assert(image->signature == MagickCoreSignature);
2550 switch (quantum_info->depth)
2557 for (x=0; x < (ssize_t) number_pixels; x++)
2559 p=PushCharPixel(p,&pixel);
2560 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2561 p+=quantum_info->pad;
2562 q+=GetPixelChannels(image);
2571 if (quantum_info->format == FloatingPointQuantumFormat)
2573 for (x=0; x < (ssize_t) number_pixels; x++)
2575 p=PushShortPixel(quantum_info->endian,p,&pixel);
2576 SetPixelGreen(image,ClampToQuantum(QuantumRange*
2577 HalfToSinglePrecision(pixel)),q);
2578 p+=quantum_info->pad;
2579 q+=GetPixelChannels(image);
2583 for (x=0; x < (ssize_t) number_pixels; x++)
2585 p=PushShortPixel(quantum_info->endian,p,&pixel);
2586 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2587 p+=quantum_info->pad;
2588 q+=GetPixelChannels(image);
2597 if (quantum_info->format == FloatingPointQuantumFormat)
2602 for (x=0; x < (ssize_t) number_pixels; x++)
2604 p=PushFloatPixel(quantum_info,p,&pixel);
2605 SetPixelGreen(image,ClampToQuantum(pixel),q);
2606 p+=quantum_info->pad;
2607 q+=GetPixelChannels(image);
2611 for (x=0; x < (ssize_t) number_pixels; x++)
2613 p=PushLongPixel(quantum_info->endian,p,&pixel);
2614 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2615 p+=quantum_info->pad;
2616 q+=GetPixelChannels(image);
2622 if (quantum_info->format == FloatingPointQuantumFormat)
2627 for (x=0; x < (ssize_t) number_pixels; x++)
2629 p=PushDoublePixel(quantum_info,p,&pixel);
2630 SetPixelGreen(image,ClampToQuantum(pixel),q);
2631 p+=quantum_info->pad;
2632 q+=GetPixelChannels(image);
2639 range=GetQuantumRange(quantum_info->depth);
2640 for (x=0; x < (ssize_t) number_pixels; x++)
2642 p=PushQuantumPixel(quantum_info,p,&pixel);
2643 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2644 p+=quantum_info->pad;
2645 q+=GetPixelChannels(image);
2652 static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
2653 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
2654 Quantum *magick_restrict q,ExceptionInfo *exception)
2668 if (image->storage_class != PseudoClass)
2670 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2671 "ColormappedImageRequired","`%s'",image->filename);
2674 range_exception=MagickFalse;
2675 switch (quantum_info->depth)
2679 register unsigned char
2682 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
2684 for (bit=0; bit < 8; bit++)
2686 if (quantum_info->min_is_white == MagickFalse)
2687 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
2690 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
2692 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
2694 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2695 GetPixelIndex(image,q),q);
2696 q+=GetPixelChannels(image);
2700 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
2702 if (quantum_info->min_is_white == MagickFalse)
2703 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
2705 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2706 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2707 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2708 GetPixelIndex(image,q),q);
2709 q+=GetPixelChannels(image);
2715 register unsigned char
2718 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
2720 pixel=(unsigned char) ((*p >> 4) & 0xf);
2721 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2722 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2723 GetPixelIndex(image,q),q);
2724 q+=GetPixelChannels(image);
2725 pixel=(unsigned char) ((*p) & 0xf);
2726 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2727 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2728 GetPixelIndex(image,q),q);
2730 q+=GetPixelChannels(image);
2732 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
2734 pixel=(unsigned char) ((*p++ >> 4) & 0xf);
2735 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2736 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2737 GetPixelIndex(image,q),q);
2738 q+=GetPixelChannels(image);
2747 for (x=0; x < (ssize_t) number_pixels; x++)
2749 p=PushCharPixel(p,&pixel);
2750 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2751 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2752 GetPixelIndex(image,q),q);
2753 p+=quantum_info->pad;
2754 q+=GetPixelChannels(image);
2763 if (quantum_info->format == FloatingPointQuantumFormat)
2765 for (x=0; x < (ssize_t) number_pixels; x++)
2767 p=PushShortPixel(quantum_info->endian,p,&pixel);
2768 SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
2769 (double) QuantumRange*HalfToSinglePrecision(pixel)),
2770 &range_exception),q);
2771 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2772 GetPixelIndex(image,q),q);
2773 p+=quantum_info->pad;
2774 q+=GetPixelChannels(image);
2778 for (x=0; x < (ssize_t) number_pixels; x++)
2780 p=PushShortPixel(quantum_info->endian,p,&pixel);
2781 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2782 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2783 GetPixelIndex(image,q),q);
2784 p+=quantum_info->pad;
2785 q+=GetPixelChannels(image);
2794 if (quantum_info->format == FloatingPointQuantumFormat)
2799 for (x=0; x < (ssize_t) number_pixels; x++)
2801 p=PushFloatPixel(quantum_info,p,&pixel);
2802 SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
2803 &range_exception),q);
2804 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2805 GetPixelIndex(image,q),q);
2806 p+=quantum_info->pad;
2807 q+=GetPixelChannels(image);
2811 for (x=0; x < (ssize_t) number_pixels; x++)
2813 p=PushLongPixel(quantum_info->endian,p,&pixel);
2814 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2815 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2816 GetPixelIndex(image,q),q);
2817 p+=quantum_info->pad;
2818 q+=GetPixelChannels(image);
2824 if (quantum_info->format == FloatingPointQuantumFormat)
2829 for (x=0; x < (ssize_t) number_pixels; x++)
2831 p=PushDoublePixel(quantum_info,p,&pixel);
2832 SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
2833 &range_exception),q);
2834 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2835 GetPixelIndex(image,q),q);
2836 p+=quantum_info->pad;
2837 q+=GetPixelChannels(image);
2844 for (x=0; x < (ssize_t) number_pixels; x++)
2846 p=PushQuantumPixel(quantum_info,p,&pixel);
2847 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2848 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2849 GetPixelIndex(image,q),q);
2850 p+=quantum_info->pad;
2851 q+=GetPixelChannels(image);
2856 if (range_exception != MagickFalse)
2857 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
2858 "InvalidColormapIndex","`%s'",image->filename);
2861 static void ImportIndexAlphaQuantum(const Image *image,
2862 QuantumInfo *quantum_info,const MagickSizeType number_pixels,
2863 const unsigned char *magick_restrict p,Quantum *magick_restrict q,
2864 ExceptionInfo *exception)
2881 if (image->storage_class != PseudoClass)
2883 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2884 "ColormappedImageRequired","`%s'",image->filename);
2887 range_exception=MagickFalse;
2888 switch (quantum_info->depth)
2892 register unsigned char
2895 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
2897 for (bit=0; bit < 8; bit+=2)
2899 if (quantum_info->min_is_white == MagickFalse)
2900 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
2902 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2903 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2904 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
2905 TransparentAlpha : OpaqueAlpha,q);
2906 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
2907 q+=GetPixelChannels(image);
2910 if ((number_pixels % 4) != 0)
2911 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
2913 if (quantum_info->min_is_white == MagickFalse)
2914 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ? 0x00 : 0x01);
2916 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
2917 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
2918 SetPixelGray(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
2919 SetPixelAlpha(image,((*p) & (1UL << (unsigned char) (6-bit))) == 0 ?
2920 TransparentAlpha : OpaqueAlpha,q);
2921 q+=GetPixelChannels(image);
2927 register unsigned char
2930 range=GetQuantumRange(quantum_info->depth);
2931 for (x=0; x < (ssize_t) number_pixels; x++)
2933 pixel=(unsigned char) ((*p >> 4) & 0xf);
2934 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2935 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2936 GetPixelIndex(image,q),q);
2937 pixel=(unsigned char) ((*p) & 0xf);
2938 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2940 q+=GetPixelChannels(image);
2949 for (x=0; x < (ssize_t) number_pixels; x++)
2951 p=PushCharPixel(p,&pixel);
2952 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2953 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2954 GetPixelIndex(image,q),q);
2955 p=PushCharPixel(p,&pixel);
2956 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2957 p+=quantum_info->pad;
2958 q+=GetPixelChannels(image);
2967 if (quantum_info->format == FloatingPointQuantumFormat)
2969 for (x=0; x < (ssize_t) number_pixels; x++)
2971 p=PushShortPixel(quantum_info->endian,p,&pixel);
2972 SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
2973 (double) QuantumRange*HalfToSinglePrecision(pixel)),
2974 &range_exception),q);
2975 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2976 GetPixelIndex(image,q),q);
2977 p=PushShortPixel(quantum_info->endian,p,&pixel);
2978 SetPixelAlpha(image,ClampToQuantum(QuantumRange*
2979 HalfToSinglePrecision(pixel)),q);
2980 p+=quantum_info->pad;
2981 q+=GetPixelChannels(image);
2985 for (x=0; x < (ssize_t) number_pixels; x++)
2987 p=PushShortPixel(quantum_info->endian,p,&pixel);
2988 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
2989 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
2990 GetPixelIndex(image,q),q);
2991 p=PushShortPixel(quantum_info->endian,p,&pixel);
2992 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
2993 p+=quantum_info->pad;
2994 q+=GetPixelChannels(image);
3003 if (quantum_info->format == FloatingPointQuantumFormat)
3008 for (x=0; x < (ssize_t) number_pixels; x++)
3010 p=PushFloatPixel(quantum_info,p,&pixel);
3011 SetPixelIndex(image,PushColormapIndex(image,
3012 ClampToQuantum(pixel),&range_exception),q);
3013 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3014 GetPixelIndex(image,q),q);
3015 p=PushFloatPixel(quantum_info,p,&pixel);
3016 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3017 p+=quantum_info->pad;
3018 q+=GetPixelChannels(image);
3022 for (x=0; x < (ssize_t) number_pixels; x++)
3024 p=PushLongPixel(quantum_info->endian,p,&pixel);
3025 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3026 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3027 GetPixelIndex(image,q),q);
3028 p=PushLongPixel(quantum_info->endian,p,&pixel);
3029 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
3030 p+=quantum_info->pad;
3031 q+=GetPixelChannels(image);
3037 if (quantum_info->format == FloatingPointQuantumFormat)
3042 for (x=0; x < (ssize_t) number_pixels; x++)
3044 p=PushDoublePixel(quantum_info,p,&pixel);
3045 SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
3046 &range_exception),q);
3047 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3048 GetPixelIndex(image,q),q);
3049 p=PushDoublePixel(quantum_info,p,&pixel);
3050 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3051 p+=quantum_info->pad;
3052 q+=GetPixelChannels(image);
3059 range=GetQuantumRange(quantum_info->depth);
3060 for (x=0; x < (ssize_t) number_pixels; x++)
3062 p=PushQuantumPixel(quantum_info,p,&pixel);
3063 SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
3064 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
3065 GetPixelIndex(image,q),q);
3066 p=PushQuantumPixel(quantum_info,p,&pixel);
3067 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3068 p+=quantum_info->pad;
3069 q+=GetPixelChannels(image);
3074 if (range_exception != MagickFalse)
3075 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
3076 "InvalidColormapIndex","`%s'",image->filename);
3079 static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
3080 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3081 Quantum *magick_restrict q)
3092 assert(image != (Image *) NULL);
3093 assert(image->signature == MagickCoreSignature);
3094 switch (quantum_info->depth)
3101 for (x=0; x < (ssize_t) number_pixels; x++)
3103 p=PushCharPixel(p,&pixel);
3104 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
3105 p+=quantum_info->pad;
3106 q+=GetPixelChannels(image);
3115 if (quantum_info->format == FloatingPointQuantumFormat)
3117 for (x=0; x < (ssize_t) number_pixels; x++)
3119 p=PushShortPixel(quantum_info->endian,p,&pixel);
3120 SetPixelOpacity(image,ClampToQuantum(QuantumRange*
3121 HalfToSinglePrecision(pixel)),q);
3122 p+=quantum_info->pad;
3123 q+=GetPixelChannels(image);
3127 for (x=0; x < (ssize_t) number_pixels; x++)
3129 p=PushShortPixel(quantum_info->endian,p,&pixel);
3130 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
3131 p+=quantum_info->pad;
3132 q+=GetPixelChannels(image);
3141 if (quantum_info->format == FloatingPointQuantumFormat)
3146 for (x=0; x < (ssize_t) number_pixels; x++)
3148 p=PushFloatPixel(quantum_info,p,&pixel);
3149 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3150 p+=quantum_info->pad;
3151 q+=GetPixelChannels(image);
3155 for (x=0; x < (ssize_t) number_pixels; x++)
3157 p=PushLongPixel(quantum_info->endian,p,&pixel);
3158 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
3159 p+=quantum_info->pad;
3160 q+=GetPixelChannels(image);
3166 if (quantum_info->format == FloatingPointQuantumFormat)
3171 for (x=0; x < (ssize_t) number_pixels; x++)
3173 p=PushDoublePixel(quantum_info,p,&pixel);
3174 SetPixelOpacity(image,ClampToQuantum(pixel),q);
3175 p+=quantum_info->pad;
3176 q+=GetPixelChannels(image);
3183 range=GetQuantumRange(quantum_info->depth);
3184 for (x=0; x < (ssize_t) number_pixels; x++)
3186 p=PushQuantumPixel(quantum_info,p,&pixel);
3187 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
3188 p+=quantum_info->pad;
3189 q+=GetPixelChannels(image);
3196 static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
3197 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3198 Quantum *magick_restrict q)
3209 assert(image != (Image *) NULL);
3210 assert(image->signature == MagickCoreSignature);
3211 switch (quantum_info->depth)
3218 for (x=0; x < (ssize_t) number_pixels; x++)
3220 p=PushCharPixel(p,&pixel);
3221 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3222 p+=quantum_info->pad;
3223 q+=GetPixelChannels(image);
3232 if (quantum_info->format == FloatingPointQuantumFormat)
3234 for (x=0; x < (ssize_t) number_pixels; x++)
3236 p=PushShortPixel(quantum_info->endian,p,&pixel);
3237 SetPixelRed(image,ClampToQuantum(QuantumRange*
3238 HalfToSinglePrecision(pixel)),q);
3239 p+=quantum_info->pad;
3240 q+=GetPixelChannels(image);
3244 for (x=0; x < (ssize_t) number_pixels; x++)
3246 p=PushShortPixel(quantum_info->endian,p,&pixel);
3247 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3248 p+=quantum_info->pad;
3249 q+=GetPixelChannels(image);
3258 if (quantum_info->format == FloatingPointQuantumFormat)
3263 for (x=0; x < (ssize_t) number_pixels; x++)
3265 p=PushFloatPixel(quantum_info,p,&pixel);
3266 SetPixelRed(image,ClampToQuantum(pixel),q);
3267 p+=quantum_info->pad;
3268 q+=GetPixelChannels(image);
3272 for (x=0; x < (ssize_t) number_pixels; x++)
3274 p=PushLongPixel(quantum_info->endian,p,&pixel);
3275 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3276 p+=quantum_info->pad;
3277 q+=GetPixelChannels(image);
3283 if (quantum_info->format == FloatingPointQuantumFormat)
3288 for (x=0; x < (ssize_t) number_pixels; x++)
3290 p=PushDoublePixel(quantum_info,p,&pixel);
3291 SetPixelRed(image,ClampToQuantum(pixel),q);
3292 p+=quantum_info->pad;
3293 q+=GetPixelChannels(image);
3300 range=GetQuantumRange(quantum_info->depth);
3301 for (x=0; x < (ssize_t) number_pixels; x++)
3303 p=PushQuantumPixel(quantum_info,p,&pixel);
3304 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3305 p+=quantum_info->pad;
3306 q+=GetPixelChannels(image);
3313 static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
3314 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3315 Quantum *magick_restrict q)
3329 assert(image != (Image *) NULL);
3330 assert(image->signature == MagickCoreSignature);
3331 switch (quantum_info->depth)
3338 for (x=0; x < (ssize_t) number_pixels; x++)
3340 p=PushCharPixel(p,&pixel);
3341 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3342 p=PushCharPixel(p,&pixel);
3343 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3344 p=PushCharPixel(p,&pixel);
3345 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
3346 SetPixelAlpha(image,OpaqueAlpha,q);
3347 p+=quantum_info->pad;
3348 q+=GetPixelChannels(image);
3354 range=GetQuantumRange(quantum_info->depth);
3355 if (quantum_info->pack == MagickFalse)
3357 for (x=0; x < (ssize_t) number_pixels; x++)
3359 p=PushLongPixel(quantum_info->endian,p,&pixel);
3360 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);
3361 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
3363 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);
3364 p+=quantum_info->pad;
3365 q+=GetPixelChannels(image);
3369 if (quantum_info->quantum == 32U)
3371 for (x=0; x < (ssize_t) number_pixels; x++)
3373 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3374 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3375 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3376 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3377 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3378 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3379 q+=GetPixelChannels(image);
3383 for (x=0; x < (ssize_t) number_pixels; x++)
3385 p=PushQuantumPixel(quantum_info,p,&pixel);
3386 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3387 p=PushQuantumPixel(quantum_info,p,&pixel);
3388 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3389 p=PushQuantumPixel(quantum_info,p,&pixel);
3390 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3391 q+=GetPixelChannels(image);
3397 range=GetQuantumRange(quantum_info->depth);
3398 if (quantum_info->pack == MagickFalse)
3403 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
3405 p=PushShortPixel(quantum_info->endian,p,&pixel);
3411 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3417 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3423 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3425 q+=GetPixelChannels(image);
3429 p=PushShortPixel(quantum_info->endian,p,&pixel);
3435 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3441 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3447 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3449 q+=GetPixelChannels(image);
3453 p+=quantum_info->pad;
3455 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
3457 p=PushShortPixel(quantum_info->endian,p,&pixel);
3458 switch ((x+bit) % 3)
3463 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3469 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3475 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),
3477 q+=GetPixelChannels(image);
3481 p+=quantum_info->pad;
3487 if (quantum_info->quantum == 32U)
3489 for (x=0; x < (ssize_t) number_pixels; x++)
3491 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3492 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3493 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3494 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3495 p=PushQuantumLongPixel(quantum_info,p,&pixel);
3496 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3497 q+=GetPixelChannels(image);
3501 for (x=0; x < (ssize_t) number_pixels; x++)
3503 p=PushQuantumPixel(quantum_info,p,&pixel);
3504 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3505 p=PushQuantumPixel(quantum_info,p,&pixel);
3506 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3507 p=PushQuantumPixel(quantum_info,p,&pixel);
3508 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3509 q+=GetPixelChannels(image);
3518 if (quantum_info->format == FloatingPointQuantumFormat)
3520 for (x=0; x < (ssize_t) number_pixels; x++)
3522 p=PushShortPixel(quantum_info->endian,p,&pixel);
3523 SetPixelRed(image,ClampToQuantum(QuantumRange*
3524 HalfToSinglePrecision(pixel)),q);
3525 p=PushShortPixel(quantum_info->endian,p,&pixel);
3526 SetPixelGreen(image,ClampToQuantum(QuantumRange*
3527 HalfToSinglePrecision(pixel)),q);
3528 p=PushShortPixel(quantum_info->endian,p,&pixel);
3529 SetPixelBlue(image,ClampToQuantum(QuantumRange*
3530 HalfToSinglePrecision(pixel)),q);
3531 p+=quantum_info->pad;
3532 q+=GetPixelChannels(image);
3536 for (x=0; x < (ssize_t) number_pixels; x++)
3538 p=PushShortPixel(quantum_info->endian,p,&pixel);
3539 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3540 p=PushShortPixel(quantum_info->endian,p,&pixel);
3541 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
3542 p=PushShortPixel(quantum_info->endian,p,&pixel);
3543 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
3544 p+=quantum_info->pad;
3545 q+=GetPixelChannels(image);
3554 if (quantum_info->format == FloatingPointQuantumFormat)
3559 for (x=0; x < (ssize_t) number_pixels; x++)
3561 p=PushFloatPixel(quantum_info,p,&pixel);
3562 SetPixelRed(image,ClampToQuantum(pixel),q);
3563 p=PushFloatPixel(quantum_info,p,&pixel);
3564 SetPixelGreen(image,ClampToQuantum(pixel),q);
3565 p=PushFloatPixel(quantum_info,p,&pixel);
3566 SetPixelBlue(image,ClampToQuantum(pixel),q);
3567 p+=quantum_info->pad;
3568 q+=GetPixelChannels(image);
3572 for (x=0; x < (ssize_t) number_pixels; x++)
3574 p=PushLongPixel(quantum_info->endian,p,&pixel);
3575 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3576 p=PushLongPixel(quantum_info->endian,p,&pixel);
3577 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
3578 p=PushLongPixel(quantum_info->endian,p,&pixel);
3579 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
3580 p+=quantum_info->pad;
3581 q+=GetPixelChannels(image);
3587 if (quantum_info->format == FloatingPointQuantumFormat)
3592 for (x=0; x < (ssize_t) number_pixels; x++)
3594 p=PushDoublePixel(quantum_info,p,&pixel);
3595 SetPixelRed(image,ClampToQuantum(pixel),q);
3596 p=PushDoublePixel(quantum_info,p,&pixel);
3597 SetPixelGreen(image,ClampToQuantum(pixel),q);
3598 p=PushDoublePixel(quantum_info,p,&pixel);
3599 SetPixelBlue(image,ClampToQuantum(pixel),q);
3600 p+=quantum_info->pad;
3601 q+=GetPixelChannels(image);
3608 range=GetQuantumRange(quantum_info->depth);
3609 for (x=0; x < (ssize_t) number_pixels; x++)
3611 p=PushQuantumPixel(quantum_info,p,&pixel);
3612 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3613 p=PushQuantumPixel(quantum_info,p,&pixel);
3614 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3615 p=PushQuantumPixel(quantum_info,p,&pixel);
3616 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3617 q+=GetPixelChannels(image);
3624 static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
3625 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3626 Quantum *magick_restrict q)
3637 assert(image != (Image *) NULL);
3638 assert(image->signature == MagickCoreSignature);
3639 switch (quantum_info->depth)
3646 for (x=0; x < (ssize_t) number_pixels; x++)
3648 p=PushCharPixel(p,&pixel);
3649 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3650 p=PushCharPixel(p,&pixel);
3651 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3652 p=PushCharPixel(p,&pixel);
3653 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
3654 p=PushCharPixel(p,&pixel);
3655 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
3656 p+=quantum_info->pad;
3657 q+=GetPixelChannels(image);
3664 if (quantum_info->pack == MagickFalse)
3677 for (x=0; x < (ssize_t) number_pixels; x++)
3679 for (i=0; i < 4; i++)
3685 p=PushLongPixel(quantum_info->endian,p,&pixel);
3686 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3687 (((pixel >> 22) & 0x3ff) << 6)));
3692 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3693 (((pixel >> 12) & 0x3ff) << 6)));
3698 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3699 (((pixel >> 2) & 0x3ff) << 6)));
3705 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
3706 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
3707 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
3708 case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
3712 p+=quantum_info->pad;
3713 q+=GetPixelChannels(image);
3717 for (x=0; x < (ssize_t) number_pixels; x++)
3719 p=PushQuantumPixel(quantum_info,p,&pixel);
3720 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
3721 p=PushQuantumPixel(quantum_info,p,&pixel);
3722 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
3724 p=PushQuantumPixel(quantum_info,p,&pixel);
3725 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
3727 p=PushQuantumPixel(quantum_info,p,&pixel);
3728 SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
3730 q+=GetPixelChannels(image);
3739 if (quantum_info->format == FloatingPointQuantumFormat)
3741 for (x=0; x < (ssize_t) number_pixels; x++)
3743 p=PushShortPixel(quantum_info->endian,p,&pixel);
3744 SetPixelRed(image,ClampToQuantum(QuantumRange*
3745 HalfToSinglePrecision(pixel)),q);
3746 p=PushShortPixel(quantum_info->endian,p,&pixel);
3747 SetPixelGreen(image,ClampToQuantum(QuantumRange*
3748 HalfToSinglePrecision(pixel)),q);
3749 p=PushShortPixel(quantum_info->endian,p,&pixel);
3750 SetPixelBlue(image,ClampToQuantum(QuantumRange*
3751 HalfToSinglePrecision(pixel)),q);
3752 p=PushShortPixel(quantum_info->endian,p,&pixel);
3753 SetPixelAlpha(image,ClampToQuantum(QuantumRange*
3754 HalfToSinglePrecision(pixel)),q);
3755 p+=quantum_info->pad;
3756 q+=GetPixelChannels(image);
3760 for (x=0; x < (ssize_t) number_pixels; x++)
3762 p=PushShortPixel(quantum_info->endian,p,&pixel);
3763 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3764 p=PushShortPixel(quantum_info->endian,p,&pixel);
3765 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
3766 p=PushShortPixel(quantum_info->endian,p,&pixel);
3767 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
3768 p=PushShortPixel(quantum_info->endian,p,&pixel);
3769 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
3770 p+=quantum_info->pad;
3771 q+=GetPixelChannels(image);
3780 if (quantum_info->format == FloatingPointQuantumFormat)
3785 for (x=0; x < (ssize_t) number_pixels; x++)
3787 p=PushFloatPixel(quantum_info,p,&pixel);
3788 SetPixelRed(image,ClampToQuantum(pixel),q);
3789 p=PushFloatPixel(quantum_info,p,&pixel);
3790 SetPixelGreen(image,ClampToQuantum(pixel),q);
3791 p=PushFloatPixel(quantum_info,p,&pixel);
3792 SetPixelBlue(image,ClampToQuantum(pixel),q);
3793 p=PushFloatPixel(quantum_info,p,&pixel);
3794 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3795 p+=quantum_info->pad;
3796 q+=GetPixelChannels(image);
3800 for (x=0; x < (ssize_t) number_pixels; x++)
3802 p=PushLongPixel(quantum_info->endian,p,&pixel);
3803 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3804 p=PushLongPixel(quantum_info->endian,p,&pixel);
3805 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
3806 p=PushLongPixel(quantum_info->endian,p,&pixel);
3807 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
3808 p=PushLongPixel(quantum_info->endian,p,&pixel);
3809 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
3810 p+=quantum_info->pad;
3811 q+=GetPixelChannels(image);
3817 if (quantum_info->format == FloatingPointQuantumFormat)
3822 for (x=0; x < (ssize_t) number_pixels; x++)
3824 p=PushDoublePixel(quantum_info,p,&pixel);
3825 SetPixelRed(image,ClampToQuantum(pixel),q);
3826 p=PushDoublePixel(quantum_info,p,&pixel);
3827 SetPixelGreen(image,ClampToQuantum(pixel),q);
3828 p=PushDoublePixel(quantum_info,p,&pixel);
3829 SetPixelBlue(image,ClampToQuantum(pixel),q);
3830 p=PushDoublePixel(quantum_info,p,&pixel);
3831 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3832 p+=quantum_info->pad;
3833 q+=GetPixelChannels(image);
3840 range=GetQuantumRange(quantum_info->depth);
3841 for (x=0; x < (ssize_t) number_pixels; x++)
3843 p=PushQuantumPixel(quantum_info,p,&pixel);
3844 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3845 p=PushQuantumPixel(quantum_info,p,&pixel);
3846 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3847 p=PushQuantumPixel(quantum_info,p,&pixel);
3848 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3849 p=PushQuantumPixel(quantum_info,p,&pixel);
3850 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3851 q+=GetPixelChannels(image);
3858 static void ImportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
3859 const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
3860 Quantum *magick_restrict q)
3871 assert(image != (Image *) NULL);
3872 assert(image->signature == MagickCoreSignature);
3873 switch (quantum_info->depth)
3880 for (x=0; x < (ssize_t) number_pixels; x++)
3882 p=PushCharPixel(p,&pixel);
3883 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3884 p=PushCharPixel(p,&pixel);
3885 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3886 p=PushCharPixel(p,&pixel);
3887 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
3888 p=PushCharPixel(p,&pixel);
3889 SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
3890 p+=quantum_info->pad;
3891 q+=GetPixelChannels(image);
3898 if (quantum_info->pack == MagickFalse)
3911 for (x=0; x < (ssize_t) number_pixels; x++)
3913 for (i=0; i < 4; i++)
3919 p=PushLongPixel(quantum_info->endian,p,&pixel);
3920 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3921 (((pixel >> 22) & 0x3ff) << 6)));
3926 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3927 (((pixel >> 12) & 0x3ff) << 6)));
3932 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3933 (((pixel >> 2) & 0x3ff) << 6)));
3939 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
3940 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
3941 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
3942 case 3: SetPixelOpacity(image,(Quantum) quantum,q); break;
3946 p+=quantum_info->pad;
3947 q+=GetPixelChannels(image);
3951 for (x=0; x < (ssize_t) number_pixels; x++)
3953 p=PushQuantumPixel(quantum_info,p,&pixel);
3954 SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);
3955 p=PushQuantumPixel(quantum_info,p,&pixel);
3956 SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
3958 p=PushQuantumPixel(quantum_info,p,&pixel);
3959 SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
3961 p=PushQuantumPixel(quantum_info,p,&pixel);
3962 SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
3964 q+=GetPixelChannels(image);
3973 if (quantum_info->format == FloatingPointQuantumFormat)
3975 for (x=0; x < (ssize_t) number_pixels; x++)
3977 p=PushShortPixel(quantum_info->endian,p,&pixel);
3978 SetPixelRed(image,ClampToQuantum(QuantumRange*
3979 HalfToSinglePrecision(pixel)),q);
3980 p=PushShortPixel(quantum_info->endian,p,&pixel);
3981 SetPixelGreen(image,ClampToQuantum(QuantumRange*
3982 HalfToSinglePrecision(pixel)),q);
3983 p=PushShortPixel(quantum_info->endian,p,&pixel);
3984 SetPixelBlue(image,ClampToQuantum(QuantumRange*
3985 HalfToSinglePrecision(pixel)),q);
3986 p=PushShortPixel(quantum_info->endian,p,&pixel);
3987 SetPixelOpacity(image,ClampToQuantum(QuantumRange*
3988 HalfToSinglePrecision(pixel)),q);
3989 p+=quantum_info->pad;
3990 q+=GetPixelChannels(image);
3994 for (x=0; x < (ssize_t) number_pixels; x++)
3996 p=PushShortPixel(quantum_info->endian,p,&pixel);
3997 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3998 p=PushShortPixel(quantum_info->endian,p,&pixel);
3999 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
4000 p=PushShortPixel(quantum_info->endian,p,&pixel);
4001 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
4002 p=PushShortPixel(quantum_info->endian,p,&pixel);
4003 SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
4004 p+=quantum_info->pad;
4005 q+=GetPixelChannels(image);
4014 if (quantum_info->format == FloatingPointQuantumFormat)
4019 for (x=0; x < (ssize_t) number_pixels; x++)
4021 p=PushFloatPixel(quantum_info,p,&pixel);
4022 SetPixelRed(image,ClampToQuantum(pixel),q);
4023 p=PushFloatPixel(quantum_info,p,&pixel);
4024 SetPixelGreen(image,ClampToQuantum(pixel),q);
4025 p=PushFloatPixel(quantum_info,p,&pixel);
4026 SetPixelBlue(image,ClampToQuantum(pixel),q);
4027 p=PushFloatPixel(quantum_info,p,&pixel);
4028 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4029 p+=quantum_info->pad;
4030 q+=GetPixelChannels(image);
4034 for (x=0; x < (ssize_t) number_pixels; x++)
4036 p=PushLongPixel(quantum_info->endian,p,&pixel);
4037 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
4038 p=PushLongPixel(quantum_info->endian,p,&pixel);
4039 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
4040 p=PushLongPixel(quantum_info->endian,p,&pixel);
4041 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
4042 p=PushLongPixel(quantum_info->endian,p,&pixel);
4043 SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
4044 p+=quantum_info->pad;
4045 q+=GetPixelChannels(image);
4051 if (quantum_info->format == FloatingPointQuantumFormat)
4056 for (x=0; x < (ssize_t) number_pixels; x++)
4058 p=PushDoublePixel(quantum_info,p,&pixel);
4059 SetPixelRed(image,ClampToQuantum(pixel),q);
4060 p=PushDoublePixel(quantum_info,p,&pixel);
4061 SetPixelGreen(image,ClampToQuantum(pixel),q);
4062 p=PushDoublePixel(quantum_info,p,&pixel);
4063 SetPixelBlue(image,ClampToQuantum(pixel),q);
4064 p=PushDoublePixel(quantum_info,p,&pixel);
4065 SetPixelOpacity(image,ClampToQuantum(pixel),q);
4066 p+=quantum_info->pad;
4067 q+=GetPixelChannels(image);
4074 range=GetQuantumRange(quantum_info->depth);
4075 for (x=0; x < (ssize_t) number_pixels; x++)
4077 p=PushQuantumPixel(quantum_info,p,&pixel);
4078 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
4079 p=PushQuantumPixel(quantum_info,p,&pixel);
4080 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
4081 p=PushQuantumPixel(quantum_info,p,&pixel);
4082 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
4083 p=PushQuantumPixel(quantum_info,p,&pixel);
4084 SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
4085 q+=GetPixelChannels(image);
4092 MagickExport size_t ImportQuantumPixels(const Image *image,
4093 CacheView *image_view,QuantumInfo *quantum_info,
4094 const QuantumType quantum_type,const unsigned char *magick_restrict pixels,
4095 ExceptionInfo *exception)
4100 register const unsigned char
4112 assert(image != (Image *) NULL);
4113 assert(image->signature == MagickCoreSignature);
4114 if (image->debug != MagickFalse)
4115 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4116 assert(quantum_info != (QuantumInfo *) NULL);
4117 assert(quantum_info->signature == MagickCoreSignature);
4118 if (pixels == (const unsigned char *) NULL)
4119 pixels=(const unsigned char *) GetQuantumPixels(quantum_info);
4122 if (image_view == (CacheView *) NULL)
4124 number_pixels=GetImageExtent(image);
4125 q=GetAuthenticPixelQueue(image);
4129 number_pixels=GetCacheViewExtent(image_view);
4130 q=GetCacheViewAuthenticPixelQueue(image_view);
4132 ResetQuantumState(quantum_info);
4133 extent=GetQuantumExtent(image,quantum_info,quantum_type);
4134 switch (quantum_type)
4138 ImportAlphaQuantum(image,quantum_info,number_pixels,p,q);
4143 ImportBGRQuantum(image,quantum_info,number_pixels,p,q);
4148 ImportBGRAQuantum(image,quantum_info,number_pixels,p,q);
4153 ImportBGROQuantum(image,quantum_info,number_pixels,p,q);
4158 ImportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
4164 ImportBlueQuantum(image,quantum_info,number_pixels,p,q);
4169 ImportCMYKQuantum(image,quantum_info,number_pixels,p,q,exception);
4174 ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
4179 ImportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
4184 ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q);
4189 ImportGrayQuantum(image,quantum_info,number_pixels,p,q);
4192 case GrayAlphaQuantum:
4194 ImportGrayAlphaQuantum(image,quantum_info,number_pixels,p,q);
4198 case MagentaQuantum:
4200 ImportGreenQuantum(image,quantum_info,number_pixels,p,q);
4205 ImportIndexQuantum(image,quantum_info,number_pixels,p,q,exception);
4208 case IndexAlphaQuantum:
4210 ImportIndexAlphaQuantum(image,quantum_info,number_pixels,p,q,exception);
4213 case OpacityQuantum:
4215 ImportOpacityQuantum(image,quantum_info,number_pixels,p,q);
4221 ImportRedQuantum(image,quantum_info,number_pixels,p,q);
4227 ImportRGBQuantum(image,quantum_info,number_pixels,p,q);
4233 ImportRGBAQuantum(image,quantum_info,number_pixels,p,q);
4238 ImportRGBOQuantum(image,quantum_info,number_pixels,p,q);
4244 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
4252 q=GetAuthenticPixelQueue(image);
4253 if (image_view != (CacheView *) NULL)
4254 q=GetCacheViewAuthenticPixelQueue(image_view);
4255 for (x=0; x < (ssize_t) number_pixels; x++)
4257 quantum=GetPixelRed(image,q);
4258 SetPixelRed(image,GetPixelGreen(image,q),q);
4259 SetPixelGreen(image,quantum,q);
4260 q+=GetPixelChannels(image);
4263 if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
4275 q=GetAuthenticPixelQueue(image);
4276 if (image_view != (CacheView *) NULL)
4277 q=GetCacheViewAuthenticPixelQueue(image_view);
4278 for (x=0; x < (ssize_t) number_pixels; x++)
4283 if (GetPixelWriteMask(image,q) == 0)
4285 q+=GetPixelChannels(image);
4288 Sa=QuantumScale*GetPixelAlpha(image,q);
4289 gamma=PerceptibleReciprocal(Sa);
4290 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
4292 PixelChannel channel=GetPixelChannelChannel(image,i);
4293 PixelTrait traits=GetPixelChannelTraits(image,channel);
4294 if ((channel == AlphaPixelChannel) ||
4295 ((traits & UpdatePixelTrait) == 0))
4297 q[i]=ClampToQuantum(gamma*q[i]);
4299 q+=GetPixelChannels(image);