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 % EEEEE X X PPPP OOO RRRR TTTTT %
13 % E X X P P O O R R T %
14 % EEE X PPPP O O RRRR T %
16 % EEEEE X X P OOO R R T %
18 % MagickCore Methods to Export Quantum Pixels %
25 % Copyright 1999-2008 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 % http://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 "magick/studio.h"
48 #include "magick/property.h"
49 #include "magick/blob.h"
50 #include "magick/blob-private.h"
51 #include "magick/color-private.h"
52 #include "magick/exception.h"
53 #include "magick/exception-private.h"
54 #include "magick/cache.h"
55 #include "magick/constitute.h"
56 #include "magick/delegate.h"
57 #include "magick/geometry.h"
58 #include "magick/list.h"
59 #include "magick/magick.h"
60 #include "magick/memory_.h"
61 #include "magick/monitor.h"
62 #include "magick/option.h"
63 #include "magick/pixel.h"
64 #include "magick/pixel-private.h"
65 #include "magick/quantum.h"
66 #include "magick/quantum-private.h"
67 #include "magick/resource_.h"
68 #include "magick/semaphore.h"
69 #include "magick/statistic.h"
70 #include "magick/stream.h"
71 #include "magick/string_.h"
72 #include "magick/utility.h"
75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
79 + E x p o r t Q u a n t u m P i x e l s %
83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
85 % ExportQuantumPixels() transfers one or more pixel components from the image
86 % pixel cache to a user supplied buffer. The pixels are returned in network
87 % byte order. MagickTrue is returned if the pixels are successfully
88 % transferred, otherwise MagickFalse.
90 % The format of the ExportQuantumPixels method is:
92 % size_t ExportQuantumPixels(const Image *image,const CacheView *image_view,
93 % const QuantumInfo *quantum_info,const QuantumType quantum_type,
94 % unsigned char *pixels,ExceptionInfo *exception)
96 % A description of each parameter follows:
100 % o image_view: the image cache view.
102 % o quantum_info: the quantum info.
104 % o quantum_type: Declare which pixel components to transfer (RGB, RGBA,
107 % o pixels: The components are transferred to this buffer.
109 % o exception: return any errors or warnings in this structure.
113 static inline unsigned char *PopDoublePixel(const QuantumState *quantum_state,
114 const double pixel,unsigned char *pixels)
122 p=(double *) quantum;
123 *p=(double) (pixel*quantum_state->inverse_scale+quantum_state->minimum);
124 if (quantum_state->endian != LSBEndian)
126 *pixels++=quantum[7];
127 *pixels++=quantum[6];
128 *pixels++=quantum[5];
129 *pixels++=quantum[4];
130 *pixels++=quantum[3];
131 *pixels++=quantum[2];
132 *pixels++=quantum[1];
133 *pixels++=quantum[0];
136 *pixels++=quantum[0];
137 *pixels++=quantum[1];
138 *pixels++=quantum[2];
139 *pixels++=quantum[3];
140 *pixels++=quantum[4];
141 *pixels++=quantum[5];
142 *pixels++=quantum[6];
143 *pixels++=quantum[7];
147 static inline unsigned char *PopFloatPixel(const QuantumState *quantum_state,
148 const float pixel,unsigned char *pixels)
157 *p=(float) ((double) pixel*quantum_state->inverse_scale+
158 quantum_state->minimum);
159 if (quantum_state->endian != LSBEndian)
161 *pixels++=quantum[3];
162 *pixels++=quantum[2];
163 *pixels++=quantum[1];
164 *pixels++=quantum[0];
167 *pixels++=quantum[0];
168 *pixels++=quantum[1];
169 *pixels++=quantum[2];
170 *pixels++=quantum[3];
174 static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
175 const unsigned long depth,const QuantumAny pixel,unsigned char *pixels)
180 register unsigned long
183 if (quantum_state->bits == 0UL)
184 quantum_state->bits=8UL;
185 for (i=(long) depth; i > 0L; )
187 quantum_bits=(unsigned long) i;
188 if (quantum_bits > quantum_state->bits)
189 quantum_bits=quantum_state->bits;
191 if (quantum_state->bits == 8)
193 quantum_state->bits-=quantum_bits;
194 *pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
195 quantum_state->bits);
196 if (quantum_state->bits == 0UL)
199 quantum_state->bits=8UL;
205 static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
206 const unsigned long depth,const unsigned long pixel,unsigned char *pixels)
214 if (quantum_state->bits == 0UL)
215 quantum_state->bits=32UL;
216 for (i=(long) depth; i > 0; )
218 quantum_bits=(unsigned long) i;
219 if (quantum_bits > quantum_state->bits)
220 quantum_bits=quantum_state->bits;
221 quantum_state->pixel|=(((pixel >> (depth-i)) &
222 quantum_state->mask[quantum_bits]) << (32UL-quantum_state->bits));
224 quantum_state->bits-=quantum_bits;
225 if (quantum_state->bits == 0U)
227 pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
228 quantum_state->pixel=0U;
229 quantum_state->bits=32UL;
235 MagickExport size_t ExportQuantumPixels(const Image *image,
236 const CacheView *image_view,const QuantumInfo *quantum_info,
237 const QuantumType quantum_type,unsigned char *pixels,ExceptionInfo *exception)
257 register const IndexPacket
260 register const PixelPacket
266 register unsigned char
272 assert(image != (Image *) NULL);
273 assert(image->signature == MagickSignature);
274 if (image->debug != MagickFalse)
275 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
276 assert(quantum_info != (QuantumInfo *) NULL);
277 assert(quantum_info->signature == MagickSignature);
278 if (pixels == (unsigned char *) NULL)
279 pixels=GetQuantumPixels(quantum_info);
280 number_pixels=GetImageExtent(image);
281 p=GetVirtualPixelQueue(image);
282 indexes=GetVirtualIndexQueue(image);
283 if (image_view != (CacheView *) NULL)
285 number_pixels=GetCacheViewExtent(image_view);
286 p=GetCacheViewVirtualPixelQueue(image_view);
287 indexes=GetCacheViewVirtualIndexQueue(image_view);
289 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
297 q=GetAuthenticPixelQueue(image);
298 if (image_view != (CacheView *) NULL)
299 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
300 for (x=0; x < (long) image->columns; x++)
302 alpha=QuantumScale*((double) QuantumRange-q->opacity);
303 q->red=ClampToQuantum(alpha*q->red);
304 q->green=ClampToQuantum(alpha*q->green);
305 q->blue=ClampToQuantum(alpha*q->blue);
309 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
314 q=GetAuthenticPixelQueue(image);
315 if (image_view != (CacheView *) NULL)
316 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
317 for (x=0; x < (long) number_pixels; x++)
319 q->opacity=(Quantum) GetAlphaPixelComponent(q);
323 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
331 q=GetAuthenticPixelQueue(image);
332 if (image_view != (CacheView *) NULL)
333 q=GetAuthenticPixelQueue(image);
334 for (x=0; x < (long) number_pixels; x++)
344 InitializeQuantumState(quantum_info,image->endian,&quantum_state);
345 extent=GetQuantumExtent(image,quantum_info,quantum_type);
346 endian=quantum_state.endian;
347 switch (quantum_type)
351 if (image->storage_class != PseudoClass)
353 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
354 "ColormappedImageRequired","`%s'",image->filename);
357 switch (quantum_info->depth)
361 register unsigned char
364 for (x=((long) number_pixels-7); x > 0; x-=8)
366 pixel=(unsigned char) *indexes++;
367 *q=((pixel & 0x01) << 7);
368 pixel=(unsigned char) *indexes++;
369 *q|=((pixel & 0x01) << 6);
370 pixel=(unsigned char) *indexes++;
371 *q|=((pixel & 0x01) << 5);
372 pixel=(unsigned char) *indexes++;
373 *q|=((pixel & 0x01) << 4);
374 pixel=(unsigned char) *indexes++;
375 *q|=((pixel & 0x01) << 3);
376 pixel=(unsigned char) *indexes++;
377 *q|=((pixel & 0x01) << 2);
378 pixel=(unsigned char) *indexes++;
379 *q|=((pixel & 0x01) << 1);
380 pixel=(unsigned char) *indexes++;
381 *q|=((pixel & 0x01) << 0);
384 if ((number_pixels % 8) != 0)
387 for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
389 pixel=(unsigned char) *indexes++;
390 *q|=((pixel & 0x01) << (unsigned char) bit);
398 register unsigned char
401 for (x=0; x < (long) (number_pixels-1) ; x+=2)
403 pixel=(unsigned char) *indexes++;
404 *q=((pixel & 0xf) << 4);
405 pixel=(unsigned char) *indexes++;
406 *q|=((pixel & 0xf) << 0);
409 if ((number_pixels % 2) != 0)
411 pixel=(unsigned char) *indexes++;
412 *q=((pixel & 0xf) << 4);
419 for (x=0; x < (long) number_pixels; x++)
421 q=PopCharPixel((unsigned char) indexes[x],q);
422 q+=quantum_info->pad;
428 if (quantum_info->format == FloatingPointQuantumFormat)
430 for (x=0; x < (long) number_pixels; x++)
432 q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
434 q+=quantum_info->pad;
438 for (x=0; x < (long) number_pixels; x++)
440 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
441 q+=quantum_info->pad;
447 if (quantum_info->format == FloatingPointQuantumFormat)
449 for (x=0; x < (long) number_pixels; x++)
451 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
453 q+=quantum_info->pad;
457 for (x=0; x < (long) number_pixels; x++)
459 q=PopLongPixel(endian,(unsigned long) indexes[x],q);
460 q+=quantum_info->pad;
466 if (quantum_info->format == FloatingPointQuantumFormat)
468 for (x=0; x < (long) number_pixels; x++)
470 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
472 q+=quantum_info->pad;
479 for (x=0; x < (long) number_pixels; x++)
481 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
483 q+=quantum_info->pad;
490 case IndexAlphaQuantum:
492 if (image->storage_class != PseudoClass)
494 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
495 "ColormappedImageRequired","`%s'",image->filename);
498 switch (quantum_info->depth)
502 register unsigned char
505 for (x=((long) number_pixels-3); x > 0; x-=4)
507 pixel=(unsigned char) *indexes++;
508 *q=((pixel & 0x01) << 7);
509 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
511 *q|=((pixel & 0x01) << 6);
513 pixel=(unsigned char) *indexes++;
514 *q|=((pixel & 0x01) << 5);
515 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
517 *q|=((pixel & 0x01) << 4);
519 pixel=(unsigned char) *indexes++;
520 *q|=((pixel & 0x01) << 3);
521 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
523 *q|=((pixel & 0x01) << 2);
525 pixel=(unsigned char) *indexes++;
526 *q|=((pixel & 0x01) << 1);
527 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
529 *q|=((pixel & 0x01) << 0);
533 if ((number_pixels % 4) != 0)
536 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
538 pixel=(unsigned char) *indexes++;
539 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
540 pixel=(unsigned char) (p->opacity == (Quantum)
541 TransparentOpacity ? 1 : 0);
542 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
551 register unsigned char
554 for (x=0; x < (long) number_pixels ; x++)
556 pixel=(unsigned char) *indexes++;
557 *q=((pixel & 0xf) << 4);
558 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
559 GetOpacityPixelComponent(p)))+0.5);
560 *q|=((pixel & 0xf) << 0);
568 register unsigned char
571 for (x=0; x < (long) number_pixels; x++)
573 q=PopCharPixel((unsigned char) indexes[x],q);
574 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
575 GetOpacityPixelComponent(p)));
576 q=PopCharPixel(pixel,q);
578 q+=quantum_info->pad;
584 register unsigned short
587 if (quantum_info->format == FloatingPointQuantumFormat)
589 for (x=0; x < (long) number_pixels; x++)
591 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
592 pixel=SinglePrecisionToHalf(QuantumScale*
593 GetAlphaPixelComponent(p));
594 q=PopShortPixel(endian,pixel,q);
596 q+=quantum_info->pad;
600 for (x=0; x < (long) number_pixels; x++)
602 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
603 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
604 GetOpacityPixelComponent(p)));
605 q=PopShortPixel(endian,pixel,q);
607 q+=quantum_info->pad;
613 register unsigned long
616 if (quantum_info->format == FloatingPointQuantumFormat)
618 for (x=0; x < (long) number_pixels; x++)
623 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
624 pixel=(float) (GetAlphaPixelComponent(p));
625 q=PopFloatPixel(&quantum_state,pixel,q);
627 q+=quantum_info->pad;
631 for (x=0; x < (long) number_pixels; x++)
633 q=PopLongPixel(endian,(unsigned long) indexes[x],q);
634 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
635 GetOpacityPixelComponent(p)));
636 q=PopLongPixel(endian,pixel,q);
638 q+=quantum_info->pad;
644 if (quantum_info->format == FloatingPointQuantumFormat)
646 for (x=0; x < (long) number_pixels; x++)
651 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
652 pixel=(double) (GetAlphaPixelComponent(p));
653 q=PopDoublePixel(&quantum_state,pixel,q);
655 q+=quantum_info->pad;
662 range=GetQuantumRange(image->depth);
663 for (x=0; x < (long) number_pixels; x++)
665 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
666 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
667 (Quantum) (GetAlphaPixelComponent(p)),range),q);
669 q+=quantum_info->pad;
678 switch (quantum_info->depth)
685 register unsigned char
691 if (quantum_info->min_is_white != MagickFalse)
696 threshold=(Quantum) (QuantumRange/2);
697 for (x=((long) number_pixels-7); x > 0; x-=8)
700 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
702 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
704 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
706 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
708 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
710 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
712 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
714 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
718 if ((number_pixels % 8) != 0)
721 for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
723 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
733 register unsigned char
736 for (x=0; x < (long) (number_pixels-1) ; x+=2)
738 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
739 *q=(((pixel >> 4) & 0xf) << 4);
741 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
746 if ((number_pixels % 2) != 0)
748 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
749 *q=(((pixel >> 4) & 0xf) << 4);
757 register unsigned char
760 for (x=0; x < (long) number_pixels; x++)
762 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
763 q=PopCharPixel(pixel,q);
765 q+=quantum_info->pad;
771 register unsigned short
774 range=GetQuantumRange(image->depth);
775 if (quantum_info->pack == MagickFalse)
777 for (x=0; x < (long) number_pixels; x++)
779 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
780 q=PopShortPixel(endian,(unsigned short) ScaleQuantumToAny(
781 (Quantum) pixel,range),q);
783 q+=quantum_info->pad;
787 for (x=0; x < (long) number_pixels; x++)
789 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
790 PixelIntensityToQuantum(p),range),q);
792 q+=quantum_info->pad;
798 register unsigned short
801 range=GetQuantumRange(image->depth);
802 if (quantum_info->pack == MagickFalse)
804 for (x=0; x < (long) number_pixels; x++)
806 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
807 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
809 q+=quantum_info->pad;
813 for (x=0; x < (long) number_pixels; x++)
815 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
816 PixelIntensityToQuantum(p),range),q);
818 q+=quantum_info->pad;
824 register unsigned short
827 if (quantum_info->format == FloatingPointQuantumFormat)
829 for (x=0; x < (long) number_pixels; x++)
831 pixel=SinglePrecisionToHalf(QuantumScale*
832 PixelIntensityToQuantum(p));
833 q=PopShortPixel(endian,pixel,q);
835 q+=quantum_info->pad;
839 for (x=0; x < (long) number_pixels; x++)
841 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
842 q=PopShortPixel(endian,pixel,q);
844 q+=quantum_info->pad;
850 register unsigned long
853 if (quantum_info->format == FloatingPointQuantumFormat)
855 for (x=0; x < (long) number_pixels; x++)
860 pixel=(float) PixelIntensityToQuantum(p);
861 q=PopFloatPixel(&quantum_state,pixel,q);
863 q+=quantum_info->pad;
867 for (x=0; x < (long) number_pixels; x++)
869 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
870 q=PopLongPixel(endian,pixel,q);
872 q+=quantum_info->pad;
878 if (quantum_info->format == FloatingPointQuantumFormat)
880 for (x=0; x < (long) number_pixels; x++)
885 pixel=(double) PixelIntensityToQuantum(p);
886 q=PopDoublePixel(&quantum_state,pixel,q);
888 q+=quantum_info->pad;
895 range=GetQuantumRange(image->depth);
896 for (x=0; x < (long) number_pixels; x++)
898 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
899 PixelIntensityToQuantum(p),range),q);
901 q+=quantum_info->pad;
908 case GrayAlphaQuantum:
910 switch (quantum_info->depth)
917 register unsigned char
924 if (quantum_info->min_is_white == MagickFalse)
929 threshold=(Quantum) (QuantumRange/2);
930 for (x=((long) number_pixels-3); x > 0; x-=4)
933 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
934 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
935 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
937 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
938 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
939 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
941 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
942 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
943 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
945 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
946 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
947 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
951 if ((number_pixels % 4) != 0)
954 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
956 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
958 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
960 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
970 register unsigned char
973 for (x=0; x < (long) number_pixels ; x++)
975 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
976 *q=(((pixel >> 4) & 0xf) << 4);
977 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
978 GetOpacityPixelComponent(p)))+0.5);
987 register unsigned char
990 for (x=0; x < (long) number_pixels; x++)
992 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
993 q=PopCharPixel(pixel,q);
994 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
995 GetOpacityPixelComponent(p)));
996 q=PopCharPixel(pixel,q);
998 q+=quantum_info->pad;
1004 register unsigned short
1007 if (quantum_info->format == FloatingPointQuantumFormat)
1009 for (x=0; x < (long) number_pixels; x++)
1011 pixel=SinglePrecisionToHalf(QuantumScale*
1012 PixelIntensityToQuantum(p));
1013 q=PopShortPixel(endian,pixel,q);
1014 pixel=SinglePrecisionToHalf(QuantumScale*
1015 GetAlphaPixelComponent(p));
1016 q=PopShortPixel(endian,pixel,q);
1018 q+=quantum_info->pad;
1022 for (x=0; x < (long) number_pixels; x++)
1024 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1025 q=PopShortPixel(endian,pixel,q);
1026 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1027 GetOpacityPixelComponent(p)));
1028 q=PopShortPixel(endian,pixel,q);
1030 q+=quantum_info->pad;
1036 register unsigned long
1039 if (quantum_info->format == FloatingPointQuantumFormat)
1041 for (x=0; x < (long) number_pixels; x++)
1046 pixel=(float) PixelIntensityToQuantum(p);
1047 q=PopFloatPixel(&quantum_state,pixel,q);
1048 pixel=(float) (GetAlphaPixelComponent(p));
1049 q=PopFloatPixel(&quantum_state,pixel,q);
1051 q+=quantum_info->pad;
1055 for (x=0; x < (long) number_pixels; x++)
1057 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1058 q=PopLongPixel(endian,pixel,q);
1059 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1060 GetOpacityPixelComponent(p)));
1061 q=PopLongPixel(endian,pixel,q);
1063 q+=quantum_info->pad;
1069 if (quantum_info->format == FloatingPointQuantumFormat)
1071 for (x=0; x < (long) number_pixels; x++)
1076 pixel=(double) PixelIntensityToQuantum(p);
1077 q=PopDoublePixel(&quantum_state,pixel,q);
1078 pixel=(double) (GetAlphaPixelComponent(p));
1079 q=PopDoublePixel(&quantum_state,pixel,q);
1081 q+=quantum_info->pad;
1088 range=GetQuantumRange(image->depth);
1089 for (x=0; x < (long) number_pixels; x++)
1091 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1092 PixelIntensityToQuantum(p),range),q);
1093 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1094 (Quantum) (GetAlphaPixelComponent(p)),range),q);
1096 q+=quantum_info->pad;
1106 switch (quantum_info->depth)
1110 register unsigned char
1113 for (x=0; x < (long) number_pixels; x++)
1115 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1116 q=PopCharPixel(pixel,q);
1118 q+=quantum_info->pad;
1124 register unsigned short
1127 if (quantum_info->format == FloatingPointQuantumFormat)
1129 for (x=0; x < (long) number_pixels; x++)
1131 pixel=SinglePrecisionToHalf(QuantumScale*
1132 GetRedPixelComponent(p));
1133 q=PopShortPixel(endian,pixel,q);
1135 q+=quantum_info->pad;
1139 for (x=0; x < (long) number_pixels; x++)
1141 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1142 q=PopShortPixel(endian,pixel,q);
1144 q+=quantum_info->pad;
1150 register unsigned long
1153 if (quantum_info->format == FloatingPointQuantumFormat)
1155 for (x=0; x < (long) number_pixels; x++)
1157 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1159 q+=quantum_info->pad;
1163 for (x=0; x < (long) number_pixels; x++)
1165 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1166 q=PopLongPixel(endian,pixel,q);
1168 q+=quantum_info->pad;
1174 if (quantum_info->format == FloatingPointQuantumFormat)
1176 for (x=0; x < (long) number_pixels; x++)
1178 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1180 q+=quantum_info->pad;
1187 range=GetQuantumRange(image->depth);
1188 for (x=0; x < (long) number_pixels; x++)
1190 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1193 q+=quantum_info->pad;
1201 case MagentaQuantum:
1203 switch (quantum_info->depth)
1207 register unsigned char
1210 for (x=0; x < (long) number_pixels; x++)
1212 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1213 q=PopCharPixel(pixel,q);
1215 q+=quantum_info->pad;
1221 register unsigned short
1224 if (quantum_info->format == FloatingPointQuantumFormat)
1226 for (x=0; x < (long) number_pixels; x++)
1228 pixel=SinglePrecisionToHalf(QuantumScale*
1229 GetGreenPixelComponent(p));
1230 q=PopShortPixel(endian,pixel,q);
1232 q+=quantum_info->pad;
1236 for (x=0; x < (long) number_pixels; x++)
1238 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1239 q=PopShortPixel(endian,pixel,q);
1241 q+=quantum_info->pad;
1247 register unsigned long
1250 if (quantum_info->format == FloatingPointQuantumFormat)
1252 for (x=0; x < (long) number_pixels; x++)
1254 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1256 q+=quantum_info->pad;
1260 for (x=0; x < (long) number_pixels; x++)
1262 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1263 q=PopLongPixel(endian,pixel,q);
1265 q+=quantum_info->pad;
1271 if (quantum_info->format == FloatingPointQuantumFormat)
1273 for (x=0; x < (long) number_pixels; x++)
1275 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1277 q+=quantum_info->pad;
1284 range=GetQuantumRange(image->depth);
1285 for (x=0; x < (long) number_pixels; x++)
1287 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1290 q+=quantum_info->pad;
1300 switch (quantum_info->depth)
1304 register unsigned char
1307 for (x=0; x < (long) number_pixels; x++)
1309 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1310 q=PopCharPixel(pixel,q);
1312 q+=quantum_info->pad;
1318 register unsigned short
1321 if (quantum_info->format == FloatingPointQuantumFormat)
1323 for (x=0; x < (long) number_pixels; x++)
1325 pixel=SinglePrecisionToHalf(QuantumScale*
1326 GetBluePixelComponent(p));
1327 q=PopShortPixel(endian,pixel,q);
1329 q+=quantum_info->pad;
1333 for (x=0; x < (long) number_pixels; x++)
1335 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1336 q=PopShortPixel(endian,pixel,q);
1338 q+=quantum_info->pad;
1344 register unsigned long
1347 if (quantum_info->format == FloatingPointQuantumFormat)
1349 for (x=0; x < (long) number_pixels; x++)
1351 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1353 q+=quantum_info->pad;
1357 for (x=0; x < (long) number_pixels; x++)
1359 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1360 q=PopLongPixel(endian,pixel,q);
1362 q+=quantum_info->pad;
1368 if (quantum_info->format == FloatingPointQuantumFormat)
1370 for (x=0; x < (long) number_pixels; x++)
1372 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1374 q+=quantum_info->pad;
1381 range=GetQuantumRange(image->depth);
1382 for (x=0; x < (long) number_pixels; x++)
1384 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1387 q+=quantum_info->pad;
1396 switch (quantum_info->depth)
1400 register unsigned char
1403 for (x=0; x < (long) number_pixels; x++)
1405 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1406 GetOpacityPixelComponent(p)));
1407 q=PopCharPixel(pixel,q);
1409 q+=quantum_info->pad;
1415 register unsigned short
1418 if (quantum_info->format == FloatingPointQuantumFormat)
1420 for (x=0; x < (long) number_pixels; x++)
1422 pixel=SinglePrecisionToHalf(QuantumScale*
1423 GetAlphaPixelComponent(p));
1424 q=PopShortPixel(endian,pixel,q);
1426 q+=quantum_info->pad;
1430 for (x=0; x < (long) number_pixels; x++)
1432 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1433 GetOpacityPixelComponent(p)));
1434 q=PopShortPixel(endian,pixel,q);
1436 q+=quantum_info->pad;
1442 register unsigned long
1445 if (quantum_info->format == FloatingPointQuantumFormat)
1447 for (x=0; x < (long) number_pixels; x++)
1452 pixel=(float) (GetAlphaPixelComponent(p));
1453 q=PopFloatPixel(&quantum_state,pixel,q);
1455 q+=quantum_info->pad;
1459 for (x=0; x < (long) number_pixels; x++)
1461 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1462 GetOpacityPixelComponent(p)));
1463 q=PopLongPixel(endian,pixel,q);
1465 q+=quantum_info->pad;
1471 if (quantum_info->format == FloatingPointQuantumFormat)
1473 for (x=0; x < (long) number_pixels; x++)
1478 pixel=(double) (GetAlphaPixelComponent(p));
1479 q=PopDoublePixel(&quantum_state,pixel,q);
1481 q+=quantum_info->pad;
1488 range=GetQuantumRange(image->depth);
1489 for (x=0; x < (long) number_pixels; x++)
1491 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1492 (Quantum) (GetAlphaPixelComponent(p)),range),q);
1494 q+=quantum_info->pad;
1501 case OpacityQuantum:
1503 switch (quantum_info->depth)
1507 register unsigned char
1510 for (x=0; x < (long) number_pixels; x++)
1512 pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
1513 q=PopCharPixel(pixel,q);
1515 q+=quantum_info->pad;
1521 register unsigned short
1524 if (quantum_info->format == FloatingPointQuantumFormat)
1526 for (x=0; x < (long) number_pixels; x++)
1528 pixel=SinglePrecisionToHalf(QuantumScale*
1529 GetOpacityPixelComponent(p));
1530 q=PopShortPixel(endian,pixel,q);
1532 q+=quantum_info->pad;
1536 for (x=0; x < (long) number_pixels; x++)
1538 pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1539 q=PopShortPixel(endian,pixel,q);
1541 q+=quantum_info->pad;
1547 register unsigned long
1550 if (quantum_info->format == FloatingPointQuantumFormat)
1552 for (x=0; x < (long) number_pixels; x++)
1554 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
1556 q+=quantum_info->pad;
1560 for (x=0; x < (long) number_pixels; x++)
1562 pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1563 q=PopLongPixel(endian,pixel,q);
1565 q+=quantum_info->pad;
1571 if (quantum_info->format == FloatingPointQuantumFormat)
1573 for (x=0; x < (long) number_pixels; x++)
1575 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
1577 q+=quantum_info->pad;
1584 range=GetQuantumRange(image->depth);
1585 for (x=0; x < (long) number_pixels; x++)
1587 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1588 p->opacity,range),q);
1590 q+=quantum_info->pad;
1599 if (image->colorspace != CMYKColorspace)
1601 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1602 "ColorSeparatedImageRequired","`%s'",image->filename);
1605 switch (quantum_info->depth)
1609 register unsigned char
1612 for (x=0; x < (long) number_pixels; x++)
1614 pixel=ScaleQuantumToChar(indexes[x]);
1615 q=PopCharPixel(pixel,q);
1617 q+=quantum_info->pad;
1623 register unsigned short
1626 if (quantum_info->format == FloatingPointQuantumFormat)
1628 for (x=0; x < (long) number_pixels; x++)
1630 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
1631 q=PopShortPixel(endian,pixel,q);
1633 q+=quantum_info->pad;
1637 for (x=0; x < (long) number_pixels; x++)
1639 pixel=ScaleQuantumToShort(indexes[x]);
1640 q=PopShortPixel(endian,pixel,q);
1642 q+=quantum_info->pad;
1648 register unsigned long
1651 if (quantum_info->format == FloatingPointQuantumFormat)
1653 for (x=0; x < (long) number_pixels; x++)
1655 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
1657 q+=quantum_info->pad;
1661 for (x=0; x < (long) number_pixels; x++)
1663 pixel=ScaleQuantumToLong(indexes[x]);
1664 q=PopLongPixel(endian,pixel,q);
1666 q+=quantum_info->pad;
1672 if (quantum_info->format == FloatingPointQuantumFormat)
1674 for (x=0; x < (long) number_pixels; x++)
1676 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
1678 q+=quantum_info->pad;
1685 range=GetQuantumRange(image->depth);
1686 for (x=0; x < (long) number_pixels; x++)
1688 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1689 (Quantum) indexes[x],range),q);
1691 q+=quantum_info->pad;
1701 switch (quantum_info->depth)
1705 for (x=0; x < (long) number_pixels; x++)
1707 q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
1708 q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
1709 q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
1711 q+=quantum_info->pad;
1717 register unsigned long
1720 range=GetQuantumRange(image->depth);
1721 if (quantum_info->pack == MagickFalse)
1723 for (x=0; x < (long) number_pixels; x++)
1725 pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
1726 ScaleQuantumToAny(p->green,range) << 12 |
1727 ScaleQuantumToAny(p->blue,range) << 2);
1728 q=PopLongPixel(endian,pixel,q);
1730 q+=quantum_info->pad;
1734 if (quantum_info->quantum == 32UL)
1736 for (x=0; x < (long) number_pixels; x++)
1738 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1739 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1740 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1741 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1742 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1743 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1745 q+=quantum_info->pad;
1749 for (x=0; x < (long) number_pixels; x++)
1751 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1752 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1753 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1754 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1755 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1756 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1758 q+=quantum_info->pad;
1764 register unsigned long
1767 range=GetQuantumRange(image->depth);
1768 if (quantum_info->pack == MagickFalse)
1770 for (x=0; x < (long) (3*number_pixels-1); x+=2)
1777 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1782 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1787 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1792 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1798 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1803 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1808 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1813 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1814 q+=quantum_info->pad;
1816 for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1818 switch ((x+bit) % 3)
1823 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1828 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1833 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1838 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1839 q+=quantum_info->pad;
1845 if (quantum_info->quantum == 32UL)
1847 for (x=0; x < (long) number_pixels; x++)
1849 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1850 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1851 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1852 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1853 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1854 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1856 q+=quantum_info->pad;
1860 for (x=0; x < (long) number_pixels; x++)
1862 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1863 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1864 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1865 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1866 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1867 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1869 q+=quantum_info->pad;
1875 register unsigned short
1878 if (quantum_info->format == FloatingPointQuantumFormat)
1880 for (x=0; x < (long) number_pixels; x++)
1882 pixel=SinglePrecisionToHalf(QuantumScale*
1883 GetRedPixelComponent(p));
1884 q=PopShortPixel(endian,pixel,q);
1885 pixel=SinglePrecisionToHalf(QuantumScale*
1886 GetGreenPixelComponent(p));
1887 q=PopShortPixel(endian,pixel,q);
1888 pixel=SinglePrecisionToHalf(QuantumScale*
1889 GetBluePixelComponent(p));
1890 q=PopShortPixel(endian,pixel,q);
1892 q+=quantum_info->pad;
1896 for (x=0; x < (long) number_pixels; x++)
1898 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1899 q=PopShortPixel(endian,pixel,q);
1900 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1901 q=PopShortPixel(endian,pixel,q);
1902 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1903 q=PopShortPixel(endian,pixel,q);
1905 q+=quantum_info->pad;
1911 register unsigned long
1914 if (quantum_info->format == FloatingPointQuantumFormat)
1916 for (x=0; x < (long) number_pixels; x++)
1918 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1919 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1920 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1922 q+=quantum_info->pad;
1926 for (x=0; x < (long) number_pixels; x++)
1928 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1929 q=PopLongPixel(endian,pixel,q);
1930 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1931 q=PopLongPixel(endian,pixel,q);
1932 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1933 q=PopLongPixel(endian,pixel,q);
1935 q+=quantum_info->pad;
1941 if (quantum_info->format == FloatingPointQuantumFormat)
1943 for (x=0; x < (long) number_pixels; x++)
1945 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1946 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1947 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1949 q+=quantum_info->pad;
1956 range=GetQuantumRange(image->depth);
1957 for (x=0; x < (long) number_pixels; x++)
1959 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1961 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1963 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1966 q+=quantum_info->pad;
1977 switch (quantum_info->depth)
1981 register unsigned char
1984 for (x=0; x < (long) number_pixels; x++)
1986 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1987 q=PopCharPixel(pixel,q);
1988 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1989 q=PopCharPixel(pixel,q);
1990 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1991 q=PopCharPixel(pixel,q);
1992 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1993 GetOpacityPixelComponent(p)));
1994 q=PopCharPixel(pixel,q);
1996 q+=quantum_info->pad;
2002 register unsigned short
2005 if (quantum_info->format == FloatingPointQuantumFormat)
2007 for (x=0; x < (long) number_pixels; x++)
2009 pixel=SinglePrecisionToHalf(QuantumScale*
2010 GetRedPixelComponent(p));
2011 q=PopShortPixel(endian,pixel,q);
2012 pixel=SinglePrecisionToHalf(QuantumScale*
2013 GetGreenPixelComponent(p));
2014 q=PopShortPixel(endian,pixel,q);
2015 pixel=SinglePrecisionToHalf(QuantumScale*
2016 GetBluePixelComponent(p));
2017 q=PopShortPixel(endian,pixel,q);
2018 pixel=SinglePrecisionToHalf(QuantumScale*
2019 GetAlphaPixelComponent(p));
2020 q=PopShortPixel(endian,pixel,q);
2022 q+=quantum_info->pad;
2026 for (x=0; x < (long) number_pixels; x++)
2028 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2029 q=PopShortPixel(endian,pixel,q);
2030 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2031 q=PopShortPixel(endian,pixel,q);
2032 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2033 q=PopShortPixel(endian,pixel,q);
2034 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2035 GetOpacityPixelComponent(p)));
2036 q=PopShortPixel(endian,pixel,q);
2038 q+=quantum_info->pad;
2044 register unsigned long
2047 if (quantum_info->format == FloatingPointQuantumFormat)
2049 for (x=0; x < (long) number_pixels; x++)
2054 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2055 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2056 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2057 pixel=(float) (GetAlphaPixelComponent(p));
2058 q=PopFloatPixel(&quantum_state,pixel,q);
2060 q+=quantum_info->pad;
2064 for (x=0; x < (long) number_pixels; x++)
2066 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2067 q=PopLongPixel(endian,pixel,q);
2068 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2069 q=PopLongPixel(endian,pixel,q);
2070 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2071 q=PopLongPixel(endian,pixel,q);
2072 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2073 GetOpacityPixelComponent(p)));
2074 q=PopLongPixel(endian,pixel,q);
2076 q+=quantum_info->pad;
2082 if (quantum_info->format == FloatingPointQuantumFormat)
2087 for (x=0; x < (long) number_pixels; x++)
2089 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2090 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2091 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2092 pixel=(double) (GetAlphaPixelComponent(p));
2093 q=PopDoublePixel(&quantum_state,pixel,q);
2095 q+=quantum_info->pad;
2102 range=GetQuantumRange(image->depth);
2103 for (x=0; x < (long) number_pixels; x++)
2105 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2107 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2109 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2111 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2112 (Quantum) (GetAlphaPixelComponent(p)),range),q);
2114 q+=quantum_info->pad;
2123 if (image->colorspace != CMYKColorspace)
2125 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2126 "ColorSeparatedImageRequired","`%s'",image->filename);
2129 switch (quantum_info->depth)
2133 register unsigned char
2136 for (x=0; x < (long) number_pixels; x++)
2138 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2139 q=PopCharPixel(pixel,q);
2140 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2141 q=PopCharPixel(pixel,q);
2142 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2143 q=PopCharPixel(pixel,q);
2144 pixel=ScaleQuantumToChar(indexes[x]);
2145 q=PopCharPixel(pixel,q);
2147 q+=quantum_info->pad;
2153 register unsigned short
2156 if (quantum_info->format == FloatingPointQuantumFormat)
2158 for (x=0; x < (long) number_pixels; x++)
2160 pixel=SinglePrecisionToHalf(QuantumScale*
2161 GetRedPixelComponent(p));
2162 q=PopShortPixel(endian,pixel,q);
2163 pixel=SinglePrecisionToHalf(QuantumScale*
2164 GetGreenPixelComponent(p));
2165 q=PopShortPixel(endian,pixel,q);
2166 pixel=SinglePrecisionToHalf(QuantumScale*
2167 GetBluePixelComponent(p));
2168 q=PopShortPixel(endian,pixel,q);
2169 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2170 q=PopShortPixel(endian,pixel,q);
2172 q+=quantum_info->pad;
2176 for (x=0; x < (long) number_pixels; x++)
2178 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2179 q=PopShortPixel(endian,pixel,q);
2180 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2181 q=PopShortPixel(endian,pixel,q);
2182 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2183 q=PopShortPixel(endian,pixel,q);
2184 pixel=ScaleQuantumToShort(indexes[x]);
2185 q=PopShortPixel(endian,pixel,q);
2187 q+=quantum_info->pad;
2193 register unsigned long
2196 if (quantum_info->format == FloatingPointQuantumFormat)
2198 for (x=0; x < (long) number_pixels; x++)
2200 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2201 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2202 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2203 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2205 q+=quantum_info->pad;
2209 for (x=0; x < (long) number_pixels; x++)
2211 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2212 q=PopLongPixel(endian,pixel,q);
2213 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2214 q=PopLongPixel(endian,pixel,q);
2215 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2216 q=PopLongPixel(endian,pixel,q);
2217 pixel=ScaleQuantumToLong(indexes[x]);
2218 q=PopLongPixel(endian,pixel,q);
2220 q+=quantum_info->pad;
2226 if (quantum_info->format == FloatingPointQuantumFormat)
2228 for (x=0; x < (long) number_pixels; x++)
2230 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2231 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2232 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2233 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2235 q+=quantum_info->pad;
2242 range=GetQuantumRange(image->depth);
2243 for (x=0; x < (long) number_pixels; x++)
2245 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2247 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2249 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2251 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2252 indexes[x],range),q);
2254 q+=quantum_info->pad;
2264 if (image->colorspace != CMYKColorspace)
2266 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2267 "ColorSeparatedImageRequired","`%s'",image->filename);
2270 switch (quantum_info->depth)
2274 register unsigned char
2277 for (x=0; x < (long) number_pixels; x++)
2279 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2280 q=PopCharPixel(pixel,q);
2281 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2282 q=PopCharPixel(pixel,q);
2283 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2284 q=PopCharPixel(pixel,q);
2285 pixel=ScaleQuantumToChar(indexes[x]);
2286 q=PopCharPixel(pixel,q);
2287 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2288 GetOpacityPixelComponent(p)));
2289 q=PopCharPixel(pixel,q);
2291 q+=quantum_info->pad;
2297 register unsigned short
2300 if (quantum_info->format == FloatingPointQuantumFormat)
2302 for (x=0; x < (long) number_pixels; x++)
2304 pixel=SinglePrecisionToHalf(QuantumScale*
2305 GetRedPixelComponent(p));
2306 q=PopShortPixel(endian,pixel,q);
2307 pixel=SinglePrecisionToHalf(QuantumScale*
2308 GetGreenPixelComponent(p));
2309 q=PopShortPixel(endian,pixel,q);
2310 pixel=SinglePrecisionToHalf(QuantumScale*
2311 GetBluePixelComponent(p));
2312 q=PopShortPixel(endian,pixel,q);
2313 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2314 q=PopShortPixel(endian,pixel,q);
2315 pixel=SinglePrecisionToHalf(QuantumScale*
2316 GetAlphaPixelComponent(p));
2317 q=PopShortPixel(endian,pixel,q);
2319 q+=quantum_info->pad;
2323 for (x=0; x < (long) number_pixels; x++)
2325 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2326 q=PopShortPixel(endian,pixel,q);
2327 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2328 q=PopShortPixel(endian,pixel,q);
2329 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2330 q=PopShortPixel(endian,pixel,q);
2331 pixel=ScaleQuantumToShort(indexes[x]);
2332 q=PopShortPixel(endian,pixel,q);
2333 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2334 GetOpacityPixelComponent(p)));
2335 q=PopShortPixel(endian,pixel,q);
2337 q+=quantum_info->pad;
2343 register unsigned long
2346 if (quantum_info->format == FloatingPointQuantumFormat)
2348 for (x=0; x < (long) number_pixels; x++)
2353 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2354 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2355 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2356 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2357 pixel=(float) (GetAlphaPixelComponent(p));
2358 q=PopFloatPixel(&quantum_state,pixel,q);
2360 q+=quantum_info->pad;
2364 for (x=0; x < (long) number_pixels; x++)
2366 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2367 q=PopLongPixel(endian,pixel,q);
2368 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2369 q=PopLongPixel(endian,pixel,q);
2370 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2371 q=PopLongPixel(endian,pixel,q);
2372 pixel=ScaleQuantumToLong(indexes[x]);
2373 q=PopLongPixel(endian,pixel,q);
2374 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2375 GetOpacityPixelComponent(p)));
2376 q=PopLongPixel(endian,pixel,q);
2378 q+=quantum_info->pad;
2384 if (quantum_info->format == FloatingPointQuantumFormat)
2389 for (x=0; x < (long) number_pixels; x++)
2391 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2392 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2393 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2394 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2395 pixel=(double) (GetAlphaPixelComponent(p));
2396 q=PopDoublePixel(&quantum_state,pixel,q);
2398 q+=quantum_info->pad;
2405 range=GetQuantumRange(image->depth);
2406 for (x=0; x < (long) number_pixels; x++)
2408 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2410 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2412 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2414 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2415 indexes[x],range),q);
2416 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2417 p->opacity,range),q);
2419 q+=quantum_info->pad;
2437 register unsigned long
2445 range=GetQuantumRange(image->depth);
2446 switch (quantum_info->depth)
2450 if (quantum_info->pack == MagickFalse)
2452 for (x=0; x < (long) number_pixels; x+=2)
2454 for (i=0; i < 4; i++)
2460 quantum=GetRedPixelComponent(p);
2465 quantum=GetGreenPixelComponent(p);
2470 quantum=GetBluePixelComponent(p);
2474 cbcr[i]=(Quantum) quantum;
2477 pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
2478 (unsigned long) (cbcr[0]) << 12 |
2479 (unsigned long) (cbcr[2]) << 2);
2480 q=PopLongPixel(endian,pixel,q);
2482 pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
2483 (unsigned long) (cbcr[0]) << 12 |
2484 (unsigned long) (cbcr[2]) << 2);
2485 q=PopLongPixel(endian,pixel,q);
2487 q+=quantum_info->pad;
2495 for (x=0; x < (long) number_pixels; x+=2)
2497 for (i=0; i < 4; i++)
2503 quantum=GetRedPixelComponent(p);
2508 quantum=GetGreenPixelComponent(p);
2513 quantum=GetBluePixelComponent(p);
2517 cbcr[i]=(Quantum) quantum;
2520 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2522 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2524 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2527 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2529 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2531 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2534 q+=quantum_info->pad;
2544 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2549 register PixelPacket
2552 q=GetAuthenticPixelQueue(image);
2553 if (image_view != (CacheView *) NULL)
2554 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2555 for (x=0; x < (long) number_pixels; x++)
2563 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2565 register PixelPacket
2568 q=GetAuthenticPixelQueue(image);
2569 if (image_view != (CacheView *) NULL)
2570 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2571 for (x=0; x < (long) number_pixels; x++)
2573 q->opacity=(Quantum) GetAlphaPixelComponent(q);