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=RoundToQuantum(alpha*q->red);
304 q->green=RoundToQuantum(alpha*q->green);
305 q->blue=RoundToQuantum(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) (QuantumRange-q->opacity);
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,ScaleFloatToHalf(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-
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-p->opacity));
575 q=PopCharPixel(pixel,q);
577 q+=quantum_info->pad;
583 register unsigned short
586 if (quantum_info->format == FloatingPointQuantumFormat)
588 for (x=0; x < (long) number_pixels; x++)
590 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
591 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
592 q=PopShortPixel(endian,pixel,q);
594 q+=quantum_info->pad;
598 for (x=0; x < (long) number_pixels; x++)
600 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
601 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
602 q=PopShortPixel(endian,pixel,q);
604 q+=quantum_info->pad;
610 register unsigned long
613 if (quantum_info->format == FloatingPointQuantumFormat)
615 for (x=0; x < (long) number_pixels; x++)
620 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
621 pixel=(float) (QuantumRange-p->opacity);
622 q=PopFloatPixel(&quantum_state,pixel,q);
624 q+=quantum_info->pad;
628 for (x=0; x < (long) number_pixels; x++)
630 q=PopLongPixel(endian,(unsigned long) indexes[x],q);
631 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
632 q=PopLongPixel(endian,pixel,q);
634 q+=quantum_info->pad;
640 if (quantum_info->format == FloatingPointQuantumFormat)
642 for (x=0; x < (long) number_pixels; x++)
647 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
648 pixel=(double) (QuantumRange-p->opacity);
649 q=PopDoublePixel(&quantum_state,pixel,q);
651 q+=quantum_info->pad;
658 range=GetQuantumRange(image->depth);
659 for (x=0; x < (long) number_pixels; x++)
661 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
662 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
663 (Quantum) (QuantumRange-p->opacity),range),q);
665 q+=quantum_info->pad;
674 switch (quantum_info->depth)
681 register unsigned char
687 if (quantum_info->min_is_white != MagickFalse)
692 threshold=(Quantum) (QuantumRange/2);
693 for (x=((long) number_pixels-7); x > 0; x-=8)
696 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
698 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
700 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
702 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
704 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
706 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
708 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
710 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
714 if ((number_pixels % 8) != 0)
717 for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
719 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
729 register unsigned char
732 for (x=0; x < (long) (number_pixels-1) ; x+=2)
734 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
735 *q=(((pixel >> 4) & 0xf) << 4);
737 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
742 if ((number_pixels % 2) != 0)
744 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
745 *q=(((pixel >> 4) & 0xf) << 4);
753 register unsigned char
756 for (x=0; x < (long) number_pixels; x++)
758 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
759 q=PopCharPixel(pixel,q);
761 q+=quantum_info->pad;
767 register unsigned short
770 range=GetQuantumRange(image->depth);
771 if (quantum_info->pack == MagickFalse)
773 for (x=0; x < (long) number_pixels; x++)
775 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
776 q=PopShortPixel(endian,(unsigned short) ScaleQuantumToAny(
777 (Quantum) pixel,range),q);
779 q+=quantum_info->pad;
783 for (x=0; x < (long) number_pixels; x++)
785 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
786 PixelIntensityToQuantum(p),range),q);
788 q+=quantum_info->pad;
794 register unsigned short
797 range=GetQuantumRange(image->depth);
798 if (quantum_info->pack == MagickFalse)
800 for (x=0; x < (long) number_pixels; x++)
802 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
803 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
805 q+=quantum_info->pad;
809 for (x=0; x < (long) number_pixels; x++)
811 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
812 PixelIntensityToQuantum(p),range),q);
814 q+=quantum_info->pad;
820 register unsigned short
823 if (quantum_info->format == FloatingPointQuantumFormat)
825 for (x=0; x < (long) number_pixels; x++)
827 pixel=ScaleFloatToHalf(QuantumScale*PixelIntensityToQuantum(p));
828 q=PopShortPixel(endian,pixel,q);
830 q+=quantum_info->pad;
834 for (x=0; x < (long) number_pixels; x++)
836 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
837 q=PopShortPixel(endian,pixel,q);
839 q+=quantum_info->pad;
845 register unsigned long
848 if (quantum_info->format == FloatingPointQuantumFormat)
850 for (x=0; x < (long) number_pixels; x++)
855 pixel=(float) PixelIntensityToQuantum(p);
856 q=PopFloatPixel(&quantum_state,pixel,q);
858 q+=quantum_info->pad;
862 for (x=0; x < (long) number_pixels; x++)
864 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
865 q=PopLongPixel(endian,pixel,q);
867 q+=quantum_info->pad;
873 if (quantum_info->format == FloatingPointQuantumFormat)
875 for (x=0; x < (long) number_pixels; x++)
880 pixel=(double) PixelIntensityToQuantum(p);
881 q=PopDoublePixel(&quantum_state,pixel,q);
883 q+=quantum_info->pad;
890 range=GetQuantumRange(image->depth);
891 for (x=0; x < (long) number_pixels; x++)
893 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
894 PixelIntensityToQuantum(p),range),q);
896 q+=quantum_info->pad;
903 case GrayAlphaQuantum:
905 switch (quantum_info->depth)
912 register unsigned char
919 if (quantum_info->min_is_white == MagickFalse)
924 threshold=(Quantum) (QuantumRange/2);
925 for (x=((long) number_pixels-3); x > 0; x-=4)
928 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
929 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
930 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
932 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
933 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
934 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
936 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
937 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
938 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
940 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
941 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
942 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
946 if ((number_pixels % 4) != 0)
949 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
951 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
953 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
955 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
965 register unsigned char
968 for (x=0; x < (long) number_pixels ; x++)
970 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
971 *q=(((pixel >> 4) & 0xf) << 4);
972 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
982 register unsigned char
985 for (x=0; x < (long) number_pixels; x++)
987 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
988 q=PopCharPixel(pixel,q);
989 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
990 q=PopCharPixel(pixel,q);
992 q+=quantum_info->pad;
998 register unsigned short
1001 if (quantum_info->format == FloatingPointQuantumFormat)
1003 for (x=0; x < (long) number_pixels; x++)
1005 pixel=ScaleFloatToHalf(QuantumScale*PixelIntensityToQuantum(p));
1006 q=PopShortPixel(endian,pixel,q);
1007 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
1008 q=PopShortPixel(endian,pixel,q);
1010 q+=quantum_info->pad;
1014 for (x=0; x < (long) number_pixels; x++)
1016 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1017 q=PopShortPixel(endian,pixel,q);
1018 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
1019 q=PopShortPixel(endian,pixel,q);
1021 q+=quantum_info->pad;
1027 register unsigned long
1030 if (quantum_info->format == FloatingPointQuantumFormat)
1032 for (x=0; x < (long) number_pixels; x++)
1037 pixel=(float) PixelIntensityToQuantum(p);
1038 q=PopFloatPixel(&quantum_state,pixel,q);
1039 pixel=(float) (QuantumRange-p->opacity);
1040 q=PopFloatPixel(&quantum_state,pixel,q);
1042 q+=quantum_info->pad;
1046 for (x=0; x < (long) number_pixels; x++)
1048 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1049 q=PopLongPixel(endian,pixel,q);
1050 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
1051 q=PopLongPixel(endian,pixel,q);
1053 q+=quantum_info->pad;
1059 if (quantum_info->format == FloatingPointQuantumFormat)
1061 for (x=0; x < (long) number_pixels; x++)
1066 pixel=(double) PixelIntensityToQuantum(p);
1067 q=PopDoublePixel(&quantum_state,pixel,q);
1068 pixel=(double) (QuantumRange-p->opacity);
1069 q=PopDoublePixel(&quantum_state,pixel,q);
1071 q+=quantum_info->pad;
1078 range=GetQuantumRange(image->depth);
1079 for (x=0; x < (long) number_pixels; x++)
1081 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1082 PixelIntensityToQuantum(p),range),q);
1083 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1084 (Quantum) (QuantumRange-p->opacity),range),q);
1086 q+=quantum_info->pad;
1096 switch (quantum_info->depth)
1100 register unsigned char
1103 for (x=0; x < (long) number_pixels; x++)
1105 pixel=ScaleQuantumToChar(p->red);
1106 q=PopCharPixel(pixel,q);
1108 q+=quantum_info->pad;
1114 register unsigned short
1117 if (quantum_info->format == FloatingPointQuantumFormat)
1119 for (x=0; x < (long) number_pixels; x++)
1121 pixel=ScaleFloatToHalf(QuantumScale*p->red);
1122 q=PopShortPixel(endian,pixel,q);
1124 q+=quantum_info->pad;
1128 for (x=0; x < (long) number_pixels; x++)
1130 pixel=ScaleQuantumToShort(p->red);
1131 q=PopShortPixel(endian,pixel,q);
1133 q+=quantum_info->pad;
1139 register unsigned long
1142 if (quantum_info->format == FloatingPointQuantumFormat)
1144 for (x=0; x < (long) number_pixels; x++)
1146 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1148 q+=quantum_info->pad;
1152 for (x=0; x < (long) number_pixels; x++)
1154 pixel=ScaleQuantumToLong(p->red);
1155 q=PopLongPixel(endian,pixel,q);
1157 q+=quantum_info->pad;
1163 if (quantum_info->format == FloatingPointQuantumFormat)
1165 for (x=0; x < (long) number_pixels; x++)
1167 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1169 q+=quantum_info->pad;
1176 range=GetQuantumRange(image->depth);
1177 for (x=0; x < (long) number_pixels; x++)
1179 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1182 q+=quantum_info->pad;
1190 case MagentaQuantum:
1192 switch (quantum_info->depth)
1196 register unsigned char
1199 for (x=0; x < (long) number_pixels; x++)
1201 pixel=ScaleQuantumToChar(p->green);
1202 q=PopCharPixel(pixel,q);
1204 q+=quantum_info->pad;
1210 register unsigned short
1213 if (quantum_info->format == FloatingPointQuantumFormat)
1215 for (x=0; x < (long) number_pixels; x++)
1217 pixel=ScaleFloatToHalf(QuantumScale*p->green);
1218 q=PopShortPixel(endian,pixel,q);
1220 q+=quantum_info->pad;
1224 for (x=0; x < (long) number_pixels; x++)
1226 pixel=ScaleQuantumToShort(p->green);
1227 q=PopShortPixel(endian,pixel,q);
1229 q+=quantum_info->pad;
1235 register unsigned long
1238 if (quantum_info->format == FloatingPointQuantumFormat)
1240 for (x=0; x < (long) number_pixels; x++)
1242 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1244 q+=quantum_info->pad;
1248 for (x=0; x < (long) number_pixels; x++)
1250 pixel=ScaleQuantumToLong(p->green);
1251 q=PopLongPixel(endian,pixel,q);
1253 q+=quantum_info->pad;
1259 if (quantum_info->format == FloatingPointQuantumFormat)
1261 for (x=0; x < (long) number_pixels; x++)
1263 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1265 q+=quantum_info->pad;
1272 range=GetQuantumRange(image->depth);
1273 for (x=0; x < (long) number_pixels; x++)
1275 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1278 q+=quantum_info->pad;
1288 switch (quantum_info->depth)
1292 register unsigned char
1295 for (x=0; x < (long) number_pixels; x++)
1297 pixel=ScaleQuantumToChar(p->blue);
1298 q=PopCharPixel(pixel,q);
1300 q+=quantum_info->pad;
1306 register unsigned short
1309 if (quantum_info->format == FloatingPointQuantumFormat)
1311 for (x=0; x < (long) number_pixels; x++)
1313 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
1314 q=PopShortPixel(endian,pixel,q);
1316 q+=quantum_info->pad;
1320 for (x=0; x < (long) number_pixels; x++)
1322 pixel=ScaleQuantumToShort(p->blue);
1323 q=PopShortPixel(endian,pixel,q);
1325 q+=quantum_info->pad;
1331 register unsigned long
1334 if (quantum_info->format == FloatingPointQuantumFormat)
1336 for (x=0; x < (long) number_pixels; x++)
1338 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1340 q+=quantum_info->pad;
1344 for (x=0; x < (long) number_pixels; x++)
1346 pixel=ScaleQuantumToLong(p->blue);
1347 q=PopLongPixel(endian,pixel,q);
1349 q+=quantum_info->pad;
1355 if (quantum_info->format == FloatingPointQuantumFormat)
1357 for (x=0; x < (long) number_pixels; x++)
1359 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1361 q+=quantum_info->pad;
1368 range=GetQuantumRange(image->depth);
1369 for (x=0; x < (long) number_pixels; x++)
1371 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1374 q+=quantum_info->pad;
1383 switch (quantum_info->depth)
1387 register unsigned char
1390 for (x=0; x < (long) number_pixels; x++)
1392 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
1393 q=PopCharPixel(pixel,q);
1395 q+=quantum_info->pad;
1401 register unsigned short
1404 if (quantum_info->format == FloatingPointQuantumFormat)
1406 for (x=0; x < (long) number_pixels; x++)
1408 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
1409 q=PopShortPixel(endian,pixel,q);
1411 q+=quantum_info->pad;
1415 for (x=0; x < (long) number_pixels; x++)
1417 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
1418 q=PopShortPixel(endian,pixel,q);
1420 q+=quantum_info->pad;
1426 register unsigned long
1429 if (quantum_info->format == FloatingPointQuantumFormat)
1431 for (x=0; x < (long) number_pixels; x++)
1436 pixel=(float) (QuantumRange-p->opacity);
1437 q=PopFloatPixel(&quantum_state,pixel,q);
1439 q+=quantum_info->pad;
1443 for (x=0; x < (long) number_pixels; x++)
1445 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
1446 q=PopLongPixel(endian,pixel,q);
1448 q+=quantum_info->pad;
1454 if (quantum_info->format == FloatingPointQuantumFormat)
1456 for (x=0; x < (long) number_pixels; x++)
1461 pixel=(double) (QuantumRange-p->opacity);
1462 q=PopDoublePixel(&quantum_state,pixel,q);
1464 q+=quantum_info->pad;
1471 range=GetQuantumRange(image->depth);
1472 for (x=0; x < (long) number_pixels; x++)
1474 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1475 (Quantum) (QuantumRange-p->opacity),range),q);
1477 q+=quantum_info->pad;
1484 case OpacityQuantum:
1486 switch (quantum_info->depth)
1490 register unsigned char
1493 for (x=0; x < (long) number_pixels; x++)
1495 pixel=ScaleQuantumToChar(p->opacity);
1496 q=PopCharPixel(pixel,q);
1498 q+=quantum_info->pad;
1504 register unsigned short
1507 if (quantum_info->format == FloatingPointQuantumFormat)
1509 for (x=0; x < (long) number_pixels; x++)
1511 pixel=ScaleFloatToHalf(QuantumScale*p->opacity);
1512 q=PopShortPixel(endian,pixel,q);
1514 q+=quantum_info->pad;
1518 for (x=0; x < (long) number_pixels; x++)
1520 pixel=ScaleQuantumToShort(p->opacity);
1521 q=PopShortPixel(endian,pixel,q);
1523 q+=quantum_info->pad;
1529 register unsigned long
1532 if (quantum_info->format == FloatingPointQuantumFormat)
1534 for (x=0; x < (long) number_pixels; x++)
1536 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
1538 q+=quantum_info->pad;
1542 for (x=0; x < (long) number_pixels; x++)
1544 pixel=ScaleQuantumToLong(p->opacity);
1545 q=PopLongPixel(endian,pixel,q);
1547 q+=quantum_info->pad;
1553 if (quantum_info->format == FloatingPointQuantumFormat)
1555 for (x=0; x < (long) number_pixels; x++)
1557 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
1559 q+=quantum_info->pad;
1566 range=GetQuantumRange(image->depth);
1567 for (x=0; x < (long) number_pixels; x++)
1569 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1570 p->opacity,range),q);
1572 q+=quantum_info->pad;
1581 if (image->colorspace != CMYKColorspace)
1583 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1584 "ColorSeparatedImageRequired","`%s'",image->filename);
1587 switch (quantum_info->depth)
1591 register unsigned char
1594 for (x=0; x < (long) number_pixels; x++)
1596 pixel=ScaleQuantumToChar(indexes[x]);
1597 q=PopCharPixel(pixel,q);
1599 q+=quantum_info->pad;
1605 register unsigned short
1608 if (quantum_info->format == FloatingPointQuantumFormat)
1610 for (x=0; x < (long) number_pixels; x++)
1612 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
1613 q=PopShortPixel(endian,pixel,q);
1615 q+=quantum_info->pad;
1619 for (x=0; x < (long) number_pixels; x++)
1621 pixel=ScaleQuantumToShort(indexes[x]);
1622 q=PopShortPixel(endian,pixel,q);
1624 q+=quantum_info->pad;
1630 register unsigned long
1633 if (quantum_info->format == FloatingPointQuantumFormat)
1635 for (x=0; x < (long) number_pixels; x++)
1637 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
1639 q+=quantum_info->pad;
1643 for (x=0; x < (long) number_pixels; x++)
1645 pixel=ScaleQuantumToLong(indexes[x]);
1646 q=PopLongPixel(endian,pixel,q);
1648 q+=quantum_info->pad;
1654 if (quantum_info->format == FloatingPointQuantumFormat)
1656 for (x=0; x < (long) number_pixels; x++)
1658 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
1660 q+=quantum_info->pad;
1667 range=GetQuantumRange(image->depth);
1668 for (x=0; x < (long) number_pixels; x++)
1670 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1671 (Quantum) indexes[x],range),q);
1673 q+=quantum_info->pad;
1683 switch (quantum_info->depth)
1687 for (x=0; x < (long) number_pixels; x++)
1689 q=PopCharPixel(ScaleQuantumToChar(p->red),q);
1690 q=PopCharPixel(ScaleQuantumToChar(p->green),q);
1691 q=PopCharPixel(ScaleQuantumToChar(p->blue),q);
1693 q+=quantum_info->pad;
1699 register unsigned long
1702 range=GetQuantumRange(image->depth);
1703 if (quantum_info->pack == MagickFalse)
1705 for (x=0; x < (long) number_pixels; x++)
1707 pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
1708 ScaleQuantumToAny(p->green,range) << 12 |
1709 ScaleQuantumToAny(p->blue,range) << 2);
1710 q=PopLongPixel(endian,pixel,q);
1712 q+=quantum_info->pad;
1716 if (quantum_info->quantum == 32UL)
1718 for (x=0; x < (long) number_pixels; x++)
1720 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1721 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1722 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1723 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1724 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1725 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1727 q+=quantum_info->pad;
1731 for (x=0; x < (long) number_pixels; x++)
1733 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1734 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1735 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1736 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1737 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1738 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1740 q+=quantum_info->pad;
1746 register unsigned long
1749 range=GetQuantumRange(image->depth);
1750 if (quantum_info->pack == MagickFalse)
1752 for (x=0; x < (long) (3*number_pixels-1); x+=2)
1759 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1764 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1769 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1774 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1780 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1785 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1790 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1795 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1796 q+=quantum_info->pad;
1798 for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1800 switch ((x+bit) % 3)
1805 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1810 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1815 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1820 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1821 q+=quantum_info->pad;
1827 if (quantum_info->quantum == 32UL)
1829 for (x=0; x < (long) number_pixels; x++)
1831 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1832 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1833 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1834 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1835 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1836 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1838 q+=quantum_info->pad;
1842 for (x=0; x < (long) number_pixels; x++)
1844 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1845 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1846 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1847 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1848 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1849 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1851 q+=quantum_info->pad;
1857 register unsigned short
1860 if (quantum_info->format == FloatingPointQuantumFormat)
1862 for (x=0; x < (long) number_pixels; x++)
1864 pixel=ScaleFloatToHalf(QuantumScale*p->red);
1865 q=PopShortPixel(endian,pixel,q);
1866 pixel=ScaleFloatToHalf(QuantumScale*p->green);
1867 q=PopShortPixel(endian,pixel,q);
1868 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
1869 q=PopShortPixel(endian,pixel,q);
1871 q+=quantum_info->pad;
1875 for (x=0; x < (long) number_pixels; x++)
1877 pixel=ScaleQuantumToShort(p->red);
1878 q=PopShortPixel(endian,pixel,q);
1879 pixel=ScaleQuantumToShort(p->green);
1880 q=PopShortPixel(endian,pixel,q);
1881 pixel=ScaleQuantumToShort(p->blue);
1882 q=PopShortPixel(endian,pixel,q);
1884 q+=quantum_info->pad;
1890 register unsigned long
1893 if (quantum_info->format == FloatingPointQuantumFormat)
1895 for (x=0; x < (long) number_pixels; x++)
1897 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1898 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1899 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1901 q+=quantum_info->pad;
1905 for (x=0; x < (long) number_pixels; x++)
1907 pixel=ScaleQuantumToLong(p->red);
1908 q=PopLongPixel(endian,pixel,q);
1909 pixel=ScaleQuantumToLong(p->green);
1910 q=PopLongPixel(endian,pixel,q);
1911 pixel=ScaleQuantumToLong(p->blue);
1912 q=PopLongPixel(endian,pixel,q);
1914 q+=quantum_info->pad;
1920 if (quantum_info->format == FloatingPointQuantumFormat)
1922 for (x=0; x < (long) number_pixels; x++)
1924 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1925 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1926 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1928 q+=quantum_info->pad;
1935 range=GetQuantumRange(image->depth);
1936 for (x=0; x < (long) number_pixels; x++)
1938 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1940 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1942 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1945 q+=quantum_info->pad;
1956 switch (quantum_info->depth)
1960 register unsigned char
1963 for (x=0; x < (long) number_pixels; x++)
1965 pixel=ScaleQuantumToChar(p->red);
1966 q=PopCharPixel(pixel,q);
1967 pixel=ScaleQuantumToChar(p->green);
1968 q=PopCharPixel(pixel,q);
1969 pixel=ScaleQuantumToChar(p->blue);
1970 q=PopCharPixel(pixel,q);
1971 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
1972 q=PopCharPixel(pixel,q);
1974 q+=quantum_info->pad;
1980 register unsigned short
1983 if (quantum_info->format == FloatingPointQuantumFormat)
1985 for (x=0; x < (long) number_pixels; x++)
1987 pixel=ScaleFloatToHalf(QuantumScale*p->red);
1988 q=PopShortPixel(endian,pixel,q);
1989 pixel=ScaleFloatToHalf(QuantumScale*p->green);
1990 q=PopShortPixel(endian,pixel,q);
1991 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
1992 q=PopShortPixel(endian,pixel,q);
1993 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
1994 q=PopShortPixel(endian,pixel,q);
1996 q+=quantum_info->pad;
2000 for (x=0; x < (long) number_pixels; x++)
2002 pixel=ScaleQuantumToShort(p->red);
2003 q=PopShortPixel(endian,pixel,q);
2004 pixel=ScaleQuantumToShort(p->green);
2005 q=PopShortPixel(endian,pixel,q);
2006 pixel=ScaleQuantumToShort(p->blue);
2007 q=PopShortPixel(endian,pixel,q);
2008 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
2009 q=PopShortPixel(endian,pixel,q);
2011 q+=quantum_info->pad;
2017 register unsigned long
2020 if (quantum_info->format == FloatingPointQuantumFormat)
2022 for (x=0; x < (long) number_pixels; x++)
2027 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2028 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2029 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2030 pixel=(float) (QuantumRange-p->opacity);
2031 q=PopFloatPixel(&quantum_state,pixel,q);
2033 q+=quantum_info->pad;
2037 for (x=0; x < (long) number_pixels; x++)
2039 pixel=ScaleQuantumToLong(p->red);
2040 q=PopLongPixel(endian,pixel,q);
2041 pixel=ScaleQuantumToLong(p->green);
2042 q=PopLongPixel(endian,pixel,q);
2043 pixel=ScaleQuantumToLong(p->blue);
2044 q=PopLongPixel(endian,pixel,q);
2045 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
2046 q=PopLongPixel(endian,pixel,q);
2048 q+=quantum_info->pad;
2054 if (quantum_info->format == FloatingPointQuantumFormat)
2059 for (x=0; x < (long) number_pixels; x++)
2061 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2062 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2063 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2064 pixel=(double) (QuantumRange-p->opacity);
2065 q=PopDoublePixel(&quantum_state,pixel,q);
2067 q+=quantum_info->pad;
2074 range=GetQuantumRange(image->depth);
2075 for (x=0; x < (long) number_pixels; x++)
2077 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2079 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2081 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2083 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2084 (Quantum) (QuantumRange-p->opacity),range),q);
2086 q+=quantum_info->pad;
2095 if (image->colorspace != CMYKColorspace)
2097 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2098 "ColorSeparatedImageRequired","`%s'",image->filename);
2101 switch (quantum_info->depth)
2105 register unsigned char
2108 for (x=0; x < (long) number_pixels; x++)
2110 pixel=ScaleQuantumToChar(p->red);
2111 q=PopCharPixel(pixel,q);
2112 pixel=ScaleQuantumToChar(p->green);
2113 q=PopCharPixel(pixel,q);
2114 pixel=ScaleQuantumToChar(p->blue);
2115 q=PopCharPixel(pixel,q);
2116 pixel=ScaleQuantumToChar(indexes[x]);
2117 q=PopCharPixel(pixel,q);
2119 q+=quantum_info->pad;
2125 register unsigned short
2128 if (quantum_info->format == FloatingPointQuantumFormat)
2130 for (x=0; x < (long) number_pixels; x++)
2132 pixel=ScaleFloatToHalf(QuantumScale*p->red);
2133 q=PopShortPixel(endian,pixel,q);
2134 pixel=ScaleFloatToHalf(QuantumScale*p->green);
2135 q=PopShortPixel(endian,pixel,q);
2136 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
2137 q=PopShortPixel(endian,pixel,q);
2138 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
2139 q=PopShortPixel(endian,pixel,q);
2141 q+=quantum_info->pad;
2145 for (x=0; x < (long) number_pixels; x++)
2147 pixel=ScaleQuantumToShort(p->red);
2148 q=PopShortPixel(endian,pixel,q);
2149 pixel=ScaleQuantumToShort(p->green);
2150 q=PopShortPixel(endian,pixel,q);
2151 pixel=ScaleQuantumToShort(p->blue);
2152 q=PopShortPixel(endian,pixel,q);
2153 pixel=ScaleQuantumToShort(indexes[x]);
2154 q=PopShortPixel(endian,pixel,q);
2156 q+=quantum_info->pad;
2162 register unsigned long
2165 if (quantum_info->format == FloatingPointQuantumFormat)
2167 for (x=0; x < (long) number_pixels; x++)
2169 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2170 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2171 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2172 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2174 q+=quantum_info->pad;
2178 for (x=0; x < (long) number_pixels; x++)
2180 pixel=ScaleQuantumToLong(p->red);
2181 q=PopLongPixel(endian,pixel,q);
2182 pixel=ScaleQuantumToLong(p->green);
2183 q=PopLongPixel(endian,pixel,q);
2184 pixel=ScaleQuantumToLong(p->blue);
2185 q=PopLongPixel(endian,pixel,q);
2186 pixel=ScaleQuantumToLong(indexes[x]);
2187 q=PopLongPixel(endian,pixel,q);
2189 q+=quantum_info->pad;
2195 if (quantum_info->format == FloatingPointQuantumFormat)
2197 for (x=0; x < (long) number_pixels; x++)
2199 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2200 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2201 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2202 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2204 q+=quantum_info->pad;
2211 range=GetQuantumRange(image->depth);
2212 for (x=0; x < (long) number_pixels; x++)
2214 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2216 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2218 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2220 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2221 indexes[x],range),q);
2223 q+=quantum_info->pad;
2233 if (image->colorspace != CMYKColorspace)
2235 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2236 "ColorSeparatedImageRequired","`%s'",image->filename);
2239 switch (quantum_info->depth)
2243 register unsigned char
2246 for (x=0; x < (long) number_pixels; x++)
2248 pixel=ScaleQuantumToChar(p->red);
2249 q=PopCharPixel(pixel,q);
2250 pixel=ScaleQuantumToChar(p->green);
2251 q=PopCharPixel(pixel,q);
2252 pixel=ScaleQuantumToChar(p->blue);
2253 q=PopCharPixel(pixel,q);
2254 pixel=ScaleQuantumToChar(indexes[x]);
2255 q=PopCharPixel(pixel,q);
2256 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-p->opacity));
2257 q=PopCharPixel(pixel,q);
2259 q+=quantum_info->pad;
2265 register unsigned short
2268 if (quantum_info->format == FloatingPointQuantumFormat)
2270 for (x=0; x < (long) number_pixels; x++)
2272 pixel=ScaleFloatToHalf(QuantumScale*p->red);
2273 q=PopShortPixel(endian,pixel,q);
2274 pixel=ScaleFloatToHalf(QuantumScale*p->green);
2275 q=PopShortPixel(endian,pixel,q);
2276 pixel=ScaleFloatToHalf(QuantumScale*p->blue);
2277 q=PopShortPixel(endian,pixel,q);
2278 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
2279 q=PopShortPixel(endian,pixel,q);
2280 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-p->opacity));
2281 q=PopShortPixel(endian,pixel,q);
2283 q+=quantum_info->pad;
2287 for (x=0; x < (long) number_pixels; x++)
2289 pixel=ScaleQuantumToShort(p->red);
2290 q=PopShortPixel(endian,pixel,q);
2291 pixel=ScaleQuantumToShort(p->green);
2292 q=PopShortPixel(endian,pixel,q);
2293 pixel=ScaleQuantumToShort(p->blue);
2294 q=PopShortPixel(endian,pixel,q);
2295 pixel=ScaleQuantumToShort(indexes[x]);
2296 q=PopShortPixel(endian,pixel,q);
2297 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-p->opacity));
2298 q=PopShortPixel(endian,pixel,q);
2300 q+=quantum_info->pad;
2306 register unsigned long
2309 if (quantum_info->format == FloatingPointQuantumFormat)
2311 for (x=0; x < (long) number_pixels; x++)
2316 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2317 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2318 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2319 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2320 pixel=(float) (QuantumRange-p->opacity);
2321 q=PopFloatPixel(&quantum_state,pixel,q);
2323 q+=quantum_info->pad;
2327 for (x=0; x < (long) number_pixels; x++)
2329 pixel=ScaleQuantumToLong(p->red);
2330 q=PopLongPixel(endian,pixel,q);
2331 pixel=ScaleQuantumToLong(p->green);
2332 q=PopLongPixel(endian,pixel,q);
2333 pixel=ScaleQuantumToLong(p->blue);
2334 q=PopLongPixel(endian,pixel,q);
2335 pixel=ScaleQuantumToLong(indexes[x]);
2336 q=PopLongPixel(endian,pixel,q);
2337 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-p->opacity));
2338 q=PopLongPixel(endian,pixel,q);
2340 q+=quantum_info->pad;
2346 if (quantum_info->format == FloatingPointQuantumFormat)
2351 for (x=0; x < (long) number_pixels; x++)
2353 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2354 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2355 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2356 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2357 pixel=(double) (QuantumRange-p->opacity);
2358 q=PopDoublePixel(&quantum_state,pixel,q);
2360 q+=quantum_info->pad;
2367 range=GetQuantumRange(image->depth);
2368 for (x=0; x < (long) number_pixels; x++)
2370 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2372 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2374 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2376 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2377 indexes[x],range),q);
2378 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2379 p->opacity,range),q);
2381 q+=quantum_info->pad;
2399 register unsigned long
2407 range=GetQuantumRange(image->depth);
2408 switch (quantum_info->depth)
2412 if (quantum_info->pack == MagickFalse)
2414 for (x=0; x < (long) number_pixels; x+=2)
2416 for (i=0; i < 4; i++)
2436 cbcr[i]=(Quantum) quantum;
2439 pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
2440 (unsigned long) (cbcr[0]) << 12 |
2441 (unsigned long) (cbcr[2]) << 2);
2442 q=PopLongPixel(endian,pixel,q);
2444 pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
2445 (unsigned long) (cbcr[0]) << 12 |
2446 (unsigned long) (cbcr[2]) << 2);
2447 q=PopLongPixel(endian,pixel,q);
2449 q+=quantum_info->pad;
2457 for (x=0; x < (long) number_pixels; x+=2)
2459 for (i=0; i < 4; i++)
2479 cbcr[i]=(Quantum) quantum;
2482 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2484 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2486 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2489 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2491 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2493 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2496 q+=quantum_info->pad;
2506 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2511 register PixelPacket
2514 q=GetAuthenticPixelQueue(image);
2515 if (image_view != (CacheView *) NULL)
2516 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2517 for (x=0; x < (long) number_pixels; x++)
2525 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2527 register PixelPacket
2530 q=GetAuthenticPixelQueue(image);
2531 if (image_view != (CacheView *) NULL)
2532 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2533 for (x=0; x < (long) number_pixels; x++)
2535 q->opacity=(Quantum) (QuantumRange-q->opacity);