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 register unsigned long
780 for (x=0; x < (long) number_pixels; x+=3)
782 pixel=(unsigned long) (
783 ScaleQuantumToAny(PixelIntensityToQuantum(p+2),range) << 22 |
784 ScaleQuantumToAny(PixelIntensityToQuantum(p+1),range) << 12 |
785 ScaleQuantumToAny(PixelIntensityToQuantum(p+0),range) << 2);
786 q=PopLongPixel(endian,pixel,q);
788 q+=quantum_info->pad;
790 if (x++ < (long) (number_pixels-1))
791 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
792 PixelIntensityToQuantum(p+1),range),q);
793 if (x++ < (long) number_pixels)
794 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
795 PixelIntensityToQuantum(p+0),range),q);
798 for (x=0; x < (long) number_pixels; x++)
800 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
801 PixelIntensityToQuantum(p),range),q);
803 q+=quantum_info->pad;
805 printf("%d\n",q-pixels);
810 register unsigned short
813 range=GetQuantumRange(image->depth);
814 if (quantum_info->pack == MagickFalse)
816 for (x=0; x < (long) number_pixels; x++)
818 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
819 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
821 q+=quantum_info->pad;
825 for (x=0; x < (long) number_pixels; x++)
827 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
828 PixelIntensityToQuantum(p),range),q);
830 q+=quantum_info->pad;
836 register unsigned short
839 if (quantum_info->format == FloatingPointQuantumFormat)
841 for (x=0; x < (long) number_pixels; x++)
843 pixel=SinglePrecisionToHalf(QuantumScale*
844 PixelIntensityToQuantum(p));
845 q=PopShortPixel(endian,pixel,q);
847 q+=quantum_info->pad;
851 for (x=0; x < (long) number_pixels; x++)
853 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
854 q=PopShortPixel(endian,pixel,q);
856 q+=quantum_info->pad;
862 register unsigned long
865 if (quantum_info->format == FloatingPointQuantumFormat)
867 for (x=0; x < (long) number_pixels; x++)
872 pixel=(float) PixelIntensityToQuantum(p);
873 q=PopFloatPixel(&quantum_state,pixel,q);
875 q+=quantum_info->pad;
879 for (x=0; x < (long) number_pixels; x++)
881 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
882 q=PopLongPixel(endian,pixel,q);
884 q+=quantum_info->pad;
890 if (quantum_info->format == FloatingPointQuantumFormat)
892 for (x=0; x < (long) number_pixels; x++)
897 pixel=(double) PixelIntensityToQuantum(p);
898 q=PopDoublePixel(&quantum_state,pixel,q);
900 q+=quantum_info->pad;
907 range=GetQuantumRange(image->depth);
908 for (x=0; x < (long) number_pixels; x++)
910 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
911 PixelIntensityToQuantum(p),range),q);
913 q+=quantum_info->pad;
920 case GrayAlphaQuantum:
922 switch (quantum_info->depth)
929 register unsigned char
936 if (quantum_info->min_is_white == MagickFalse)
941 threshold=(Quantum) (QuantumRange/2);
942 for (x=((long) number_pixels-3); x > 0; x-=4)
945 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
946 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
947 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
949 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
950 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
951 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
953 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
954 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
955 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
957 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
958 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
959 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
963 if ((number_pixels % 4) != 0)
966 for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
968 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
970 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
972 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
982 register unsigned char
985 for (x=0; x < (long) number_pixels ; x++)
987 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
988 *q=(((pixel >> 4) & 0xf) << 4);
989 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
990 GetOpacityPixelComponent(p)))+0.5);
999 register unsigned char
1002 for (x=0; x < (long) number_pixels; x++)
1004 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1005 q=PopCharPixel(pixel,q);
1006 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1007 GetOpacityPixelComponent(p)));
1008 q=PopCharPixel(pixel,q);
1010 q+=quantum_info->pad;
1016 register unsigned short
1019 if (quantum_info->format == FloatingPointQuantumFormat)
1021 for (x=0; x < (long) number_pixels; x++)
1023 pixel=SinglePrecisionToHalf(QuantumScale*
1024 PixelIntensityToQuantum(p));
1025 q=PopShortPixel(endian,pixel,q);
1026 pixel=SinglePrecisionToHalf(QuantumScale*
1027 GetAlphaPixelComponent(p));
1028 q=PopShortPixel(endian,pixel,q);
1030 q+=quantum_info->pad;
1034 for (x=0; x < (long) number_pixels; x++)
1036 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1037 q=PopShortPixel(endian,pixel,q);
1038 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1039 GetOpacityPixelComponent(p)));
1040 q=PopShortPixel(endian,pixel,q);
1042 q+=quantum_info->pad;
1048 register unsigned long
1051 if (quantum_info->format == FloatingPointQuantumFormat)
1053 for (x=0; x < (long) number_pixels; x++)
1058 pixel=(float) PixelIntensityToQuantum(p);
1059 q=PopFloatPixel(&quantum_state,pixel,q);
1060 pixel=(float) (GetAlphaPixelComponent(p));
1061 q=PopFloatPixel(&quantum_state,pixel,q);
1063 q+=quantum_info->pad;
1067 for (x=0; x < (long) number_pixels; x++)
1069 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1070 q=PopLongPixel(endian,pixel,q);
1071 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1072 GetOpacityPixelComponent(p)));
1073 q=PopLongPixel(endian,pixel,q);
1075 q+=quantum_info->pad;
1081 if (quantum_info->format == FloatingPointQuantumFormat)
1083 for (x=0; x < (long) number_pixels; x++)
1088 pixel=(double) PixelIntensityToQuantum(p);
1089 q=PopDoublePixel(&quantum_state,pixel,q);
1090 pixel=(double) (GetAlphaPixelComponent(p));
1091 q=PopDoublePixel(&quantum_state,pixel,q);
1093 q+=quantum_info->pad;
1100 range=GetQuantumRange(image->depth);
1101 for (x=0; x < (long) number_pixels; x++)
1103 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1104 PixelIntensityToQuantum(p),range),q);
1105 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1106 (Quantum) (GetAlphaPixelComponent(p)),range),q);
1108 q+=quantum_info->pad;
1118 switch (quantum_info->depth)
1122 register unsigned char
1125 for (x=0; x < (long) number_pixels; x++)
1127 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1128 q=PopCharPixel(pixel,q);
1130 q+=quantum_info->pad;
1136 register unsigned short
1139 if (quantum_info->format == FloatingPointQuantumFormat)
1141 for (x=0; x < (long) number_pixels; x++)
1143 pixel=SinglePrecisionToHalf(QuantumScale*
1144 GetRedPixelComponent(p));
1145 q=PopShortPixel(endian,pixel,q);
1147 q+=quantum_info->pad;
1151 for (x=0; x < (long) number_pixels; x++)
1153 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1154 q=PopShortPixel(endian,pixel,q);
1156 q+=quantum_info->pad;
1162 register unsigned long
1165 if (quantum_info->format == FloatingPointQuantumFormat)
1167 for (x=0; x < (long) number_pixels; x++)
1169 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1171 q+=quantum_info->pad;
1175 for (x=0; x < (long) number_pixels; x++)
1177 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1178 q=PopLongPixel(endian,pixel,q);
1180 q+=quantum_info->pad;
1186 if (quantum_info->format == FloatingPointQuantumFormat)
1188 for (x=0; x < (long) number_pixels; x++)
1190 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1192 q+=quantum_info->pad;
1199 range=GetQuantumRange(image->depth);
1200 for (x=0; x < (long) number_pixels; x++)
1202 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1205 q+=quantum_info->pad;
1213 case MagentaQuantum:
1215 switch (quantum_info->depth)
1219 register unsigned char
1222 for (x=0; x < (long) number_pixels; x++)
1224 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1225 q=PopCharPixel(pixel,q);
1227 q+=quantum_info->pad;
1233 register unsigned short
1236 if (quantum_info->format == FloatingPointQuantumFormat)
1238 for (x=0; x < (long) number_pixels; x++)
1240 pixel=SinglePrecisionToHalf(QuantumScale*
1241 GetGreenPixelComponent(p));
1242 q=PopShortPixel(endian,pixel,q);
1244 q+=quantum_info->pad;
1248 for (x=0; x < (long) number_pixels; x++)
1250 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1251 q=PopShortPixel(endian,pixel,q);
1253 q+=quantum_info->pad;
1259 register unsigned long
1262 if (quantum_info->format == FloatingPointQuantumFormat)
1264 for (x=0; x < (long) number_pixels; x++)
1266 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1268 q+=quantum_info->pad;
1272 for (x=0; x < (long) number_pixels; x++)
1274 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1275 q=PopLongPixel(endian,pixel,q);
1277 q+=quantum_info->pad;
1283 if (quantum_info->format == FloatingPointQuantumFormat)
1285 for (x=0; x < (long) number_pixels; x++)
1287 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1289 q+=quantum_info->pad;
1296 range=GetQuantumRange(image->depth);
1297 for (x=0; x < (long) number_pixels; x++)
1299 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1302 q+=quantum_info->pad;
1312 switch (quantum_info->depth)
1316 register unsigned char
1319 for (x=0; x < (long) number_pixels; x++)
1321 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1322 q=PopCharPixel(pixel,q);
1324 q+=quantum_info->pad;
1330 register unsigned short
1333 if (quantum_info->format == FloatingPointQuantumFormat)
1335 for (x=0; x < (long) number_pixels; x++)
1337 pixel=SinglePrecisionToHalf(QuantumScale*
1338 GetBluePixelComponent(p));
1339 q=PopShortPixel(endian,pixel,q);
1341 q+=quantum_info->pad;
1345 for (x=0; x < (long) number_pixels; x++)
1347 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1348 q=PopShortPixel(endian,pixel,q);
1350 q+=quantum_info->pad;
1356 register unsigned long
1359 if (quantum_info->format == FloatingPointQuantumFormat)
1361 for (x=0; x < (long) number_pixels; x++)
1363 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1365 q+=quantum_info->pad;
1369 for (x=0; x < (long) number_pixels; x++)
1371 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1372 q=PopLongPixel(endian,pixel,q);
1374 q+=quantum_info->pad;
1380 if (quantum_info->format == FloatingPointQuantumFormat)
1382 for (x=0; x < (long) number_pixels; x++)
1384 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1386 q+=quantum_info->pad;
1393 range=GetQuantumRange(image->depth);
1394 for (x=0; x < (long) number_pixels; x++)
1396 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1399 q+=quantum_info->pad;
1408 switch (quantum_info->depth)
1412 register unsigned char
1415 for (x=0; x < (long) number_pixels; x++)
1417 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1418 GetOpacityPixelComponent(p)));
1419 q=PopCharPixel(pixel,q);
1421 q+=quantum_info->pad;
1427 register unsigned short
1430 if (quantum_info->format == FloatingPointQuantumFormat)
1432 for (x=0; x < (long) number_pixels; x++)
1434 pixel=SinglePrecisionToHalf(QuantumScale*
1435 GetAlphaPixelComponent(p));
1436 q=PopShortPixel(endian,pixel,q);
1438 q+=quantum_info->pad;
1442 for (x=0; x < (long) number_pixels; x++)
1444 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1445 GetOpacityPixelComponent(p)));
1446 q=PopShortPixel(endian,pixel,q);
1448 q+=quantum_info->pad;
1454 register unsigned long
1457 if (quantum_info->format == FloatingPointQuantumFormat)
1459 for (x=0; x < (long) number_pixels; x++)
1464 pixel=(float) (GetAlphaPixelComponent(p));
1465 q=PopFloatPixel(&quantum_state,pixel,q);
1467 q+=quantum_info->pad;
1471 for (x=0; x < (long) number_pixels; x++)
1473 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1474 GetOpacityPixelComponent(p)));
1475 q=PopLongPixel(endian,pixel,q);
1477 q+=quantum_info->pad;
1483 if (quantum_info->format == FloatingPointQuantumFormat)
1485 for (x=0; x < (long) number_pixels; x++)
1490 pixel=(double) (GetAlphaPixelComponent(p));
1491 q=PopDoublePixel(&quantum_state,pixel,q);
1493 q+=quantum_info->pad;
1500 range=GetQuantumRange(image->depth);
1501 for (x=0; x < (long) number_pixels; x++)
1503 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1504 (Quantum) (GetAlphaPixelComponent(p)),range),q);
1506 q+=quantum_info->pad;
1513 case OpacityQuantum:
1515 switch (quantum_info->depth)
1519 register unsigned char
1522 for (x=0; x < (long) number_pixels; x++)
1524 pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
1525 q=PopCharPixel(pixel,q);
1527 q+=quantum_info->pad;
1533 register unsigned short
1536 if (quantum_info->format == FloatingPointQuantumFormat)
1538 for (x=0; x < (long) number_pixels; x++)
1540 pixel=SinglePrecisionToHalf(QuantumScale*
1541 GetOpacityPixelComponent(p));
1542 q=PopShortPixel(endian,pixel,q);
1544 q+=quantum_info->pad;
1548 for (x=0; x < (long) number_pixels; x++)
1550 pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1551 q=PopShortPixel(endian,pixel,q);
1553 q+=quantum_info->pad;
1559 register unsigned long
1562 if (quantum_info->format == FloatingPointQuantumFormat)
1564 for (x=0; x < (long) number_pixels; x++)
1566 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
1568 q+=quantum_info->pad;
1572 for (x=0; x < (long) number_pixels; x++)
1574 pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1575 q=PopLongPixel(endian,pixel,q);
1577 q+=quantum_info->pad;
1583 if (quantum_info->format == FloatingPointQuantumFormat)
1585 for (x=0; x < (long) number_pixels; x++)
1587 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
1589 q+=quantum_info->pad;
1596 range=GetQuantumRange(image->depth);
1597 for (x=0; x < (long) number_pixels; x++)
1599 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1600 p->opacity,range),q);
1602 q+=quantum_info->pad;
1611 if (image->colorspace != CMYKColorspace)
1613 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1614 "ColorSeparatedImageRequired","`%s'",image->filename);
1617 switch (quantum_info->depth)
1621 register unsigned char
1624 for (x=0; x < (long) number_pixels; x++)
1626 pixel=ScaleQuantumToChar(indexes[x]);
1627 q=PopCharPixel(pixel,q);
1629 q+=quantum_info->pad;
1635 register unsigned short
1638 if (quantum_info->format == FloatingPointQuantumFormat)
1640 for (x=0; x < (long) number_pixels; x++)
1642 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
1643 q=PopShortPixel(endian,pixel,q);
1645 q+=quantum_info->pad;
1649 for (x=0; x < (long) number_pixels; x++)
1651 pixel=ScaleQuantumToShort(indexes[x]);
1652 q=PopShortPixel(endian,pixel,q);
1654 q+=quantum_info->pad;
1660 register unsigned long
1663 if (quantum_info->format == FloatingPointQuantumFormat)
1665 for (x=0; x < (long) number_pixels; x++)
1667 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
1669 q+=quantum_info->pad;
1673 for (x=0; x < (long) number_pixels; x++)
1675 pixel=ScaleQuantumToLong(indexes[x]);
1676 q=PopLongPixel(endian,pixel,q);
1678 q+=quantum_info->pad;
1684 if (quantum_info->format == FloatingPointQuantumFormat)
1686 for (x=0; x < (long) number_pixels; x++)
1688 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
1690 q+=quantum_info->pad;
1697 range=GetQuantumRange(image->depth);
1698 for (x=0; x < (long) number_pixels; x++)
1700 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1701 (Quantum) indexes[x],range),q);
1703 q+=quantum_info->pad;
1713 switch (quantum_info->depth)
1717 for (x=0; x < (long) number_pixels; x++)
1719 q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
1720 q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
1721 q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
1723 q+=quantum_info->pad;
1729 register unsigned long
1732 range=GetQuantumRange(image->depth);
1733 if (quantum_info->pack == MagickFalse)
1735 for (x=0; x < (long) number_pixels; x++)
1737 pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
1738 ScaleQuantumToAny(p->green,range) << 12 |
1739 ScaleQuantumToAny(p->blue,range) << 2);
1740 q=PopLongPixel(endian,pixel,q);
1742 q+=quantum_info->pad;
1746 if (quantum_info->quantum == 32UL)
1748 for (x=0; x < (long) number_pixels; x++)
1750 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1751 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1752 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1753 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1754 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1755 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1757 q+=quantum_info->pad;
1761 for (x=0; x < (long) number_pixels; x++)
1763 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1764 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1765 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1766 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1767 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1768 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1770 q+=quantum_info->pad;
1776 register unsigned long
1779 range=GetQuantumRange(image->depth);
1780 if (quantum_info->pack == MagickFalse)
1782 for (x=0; x < (long) (3*number_pixels-1); x+=2)
1789 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1794 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1799 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1804 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1810 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1815 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1820 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1825 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1826 q+=quantum_info->pad;
1828 for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1830 switch ((x+bit) % 3)
1835 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1840 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1845 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1850 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1851 q+=quantum_info->pad;
1857 if (quantum_info->quantum == 32UL)
1859 for (x=0; x < (long) number_pixels; x++)
1861 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1862 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1863 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1864 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1865 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1866 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1868 q+=quantum_info->pad;
1872 for (x=0; x < (long) number_pixels; x++)
1874 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1875 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1876 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1877 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1878 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1879 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1881 q+=quantum_info->pad;
1887 register unsigned short
1890 if (quantum_info->format == FloatingPointQuantumFormat)
1892 for (x=0; x < (long) number_pixels; x++)
1894 pixel=SinglePrecisionToHalf(QuantumScale*
1895 GetRedPixelComponent(p));
1896 q=PopShortPixel(endian,pixel,q);
1897 pixel=SinglePrecisionToHalf(QuantumScale*
1898 GetGreenPixelComponent(p));
1899 q=PopShortPixel(endian,pixel,q);
1900 pixel=SinglePrecisionToHalf(QuantumScale*
1901 GetBluePixelComponent(p));
1902 q=PopShortPixel(endian,pixel,q);
1904 q+=quantum_info->pad;
1908 for (x=0; x < (long) number_pixels; x++)
1910 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1911 q=PopShortPixel(endian,pixel,q);
1912 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1913 q=PopShortPixel(endian,pixel,q);
1914 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1915 q=PopShortPixel(endian,pixel,q);
1917 q+=quantum_info->pad;
1923 register unsigned long
1926 if (quantum_info->format == FloatingPointQuantumFormat)
1928 for (x=0; x < (long) number_pixels; x++)
1930 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1931 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1932 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1934 q+=quantum_info->pad;
1938 for (x=0; x < (long) number_pixels; x++)
1940 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1941 q=PopLongPixel(endian,pixel,q);
1942 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1943 q=PopLongPixel(endian,pixel,q);
1944 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1945 q=PopLongPixel(endian,pixel,q);
1947 q+=quantum_info->pad;
1953 if (quantum_info->format == FloatingPointQuantumFormat)
1955 for (x=0; x < (long) number_pixels; x++)
1957 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1958 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1959 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1961 q+=quantum_info->pad;
1968 range=GetQuantumRange(image->depth);
1969 for (x=0; x < (long) number_pixels; x++)
1971 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1973 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1975 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1978 q+=quantum_info->pad;
1989 switch (quantum_info->depth)
1993 register unsigned char
1996 for (x=0; x < (long) number_pixels; x++)
1998 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1999 q=PopCharPixel(pixel,q);
2000 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2001 q=PopCharPixel(pixel,q);
2002 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2003 q=PopCharPixel(pixel,q);
2004 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2005 GetOpacityPixelComponent(p)));
2006 q=PopCharPixel(pixel,q);
2008 q+=quantum_info->pad;
2014 register unsigned short
2017 if (quantum_info->format == FloatingPointQuantumFormat)
2019 for (x=0; x < (long) number_pixels; x++)
2021 pixel=SinglePrecisionToHalf(QuantumScale*
2022 GetRedPixelComponent(p));
2023 q=PopShortPixel(endian,pixel,q);
2024 pixel=SinglePrecisionToHalf(QuantumScale*
2025 GetGreenPixelComponent(p));
2026 q=PopShortPixel(endian,pixel,q);
2027 pixel=SinglePrecisionToHalf(QuantumScale*
2028 GetBluePixelComponent(p));
2029 q=PopShortPixel(endian,pixel,q);
2030 pixel=SinglePrecisionToHalf(QuantumScale*
2031 GetAlphaPixelComponent(p));
2032 q=PopShortPixel(endian,pixel,q);
2034 q+=quantum_info->pad;
2038 for (x=0; x < (long) number_pixels; x++)
2040 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2041 q=PopShortPixel(endian,pixel,q);
2042 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2043 q=PopShortPixel(endian,pixel,q);
2044 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2045 q=PopShortPixel(endian,pixel,q);
2046 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2047 GetOpacityPixelComponent(p)));
2048 q=PopShortPixel(endian,pixel,q);
2050 q+=quantum_info->pad;
2056 register unsigned long
2059 if (quantum_info->format == FloatingPointQuantumFormat)
2061 for (x=0; x < (long) number_pixels; x++)
2066 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2067 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2068 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2069 pixel=(float) (GetAlphaPixelComponent(p));
2070 q=PopFloatPixel(&quantum_state,pixel,q);
2072 q+=quantum_info->pad;
2076 for (x=0; x < (long) number_pixels; x++)
2078 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2079 q=PopLongPixel(endian,pixel,q);
2080 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2081 q=PopLongPixel(endian,pixel,q);
2082 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2083 q=PopLongPixel(endian,pixel,q);
2084 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2085 GetOpacityPixelComponent(p)));
2086 q=PopLongPixel(endian,pixel,q);
2088 q+=quantum_info->pad;
2094 if (quantum_info->format == FloatingPointQuantumFormat)
2099 for (x=0; x < (long) number_pixels; x++)
2101 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2102 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2103 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2104 pixel=(double) (GetAlphaPixelComponent(p));
2105 q=PopDoublePixel(&quantum_state,pixel,q);
2107 q+=quantum_info->pad;
2114 range=GetQuantumRange(image->depth);
2115 for (x=0; x < (long) number_pixels; x++)
2117 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2119 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2121 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2123 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2124 (Quantum) (GetAlphaPixelComponent(p)),range),q);
2126 q+=quantum_info->pad;
2135 if (image->colorspace != CMYKColorspace)
2137 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2138 "ColorSeparatedImageRequired","`%s'",image->filename);
2141 switch (quantum_info->depth)
2145 register unsigned char
2148 for (x=0; x < (long) number_pixels; x++)
2150 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2151 q=PopCharPixel(pixel,q);
2152 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2153 q=PopCharPixel(pixel,q);
2154 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2155 q=PopCharPixel(pixel,q);
2156 pixel=ScaleQuantumToChar(indexes[x]);
2157 q=PopCharPixel(pixel,q);
2159 q+=quantum_info->pad;
2165 register unsigned short
2168 if (quantum_info->format == FloatingPointQuantumFormat)
2170 for (x=0; x < (long) number_pixels; x++)
2172 pixel=SinglePrecisionToHalf(QuantumScale*
2173 GetRedPixelComponent(p));
2174 q=PopShortPixel(endian,pixel,q);
2175 pixel=SinglePrecisionToHalf(QuantumScale*
2176 GetGreenPixelComponent(p));
2177 q=PopShortPixel(endian,pixel,q);
2178 pixel=SinglePrecisionToHalf(QuantumScale*
2179 GetBluePixelComponent(p));
2180 q=PopShortPixel(endian,pixel,q);
2181 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2182 q=PopShortPixel(endian,pixel,q);
2184 q+=quantum_info->pad;
2188 for (x=0; x < (long) number_pixels; x++)
2190 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2191 q=PopShortPixel(endian,pixel,q);
2192 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2193 q=PopShortPixel(endian,pixel,q);
2194 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2195 q=PopShortPixel(endian,pixel,q);
2196 pixel=ScaleQuantumToShort(indexes[x]);
2197 q=PopShortPixel(endian,pixel,q);
2199 q+=quantum_info->pad;
2205 register unsigned long
2208 if (quantum_info->format == FloatingPointQuantumFormat)
2210 for (x=0; x < (long) number_pixels; x++)
2212 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2213 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2214 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2215 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2217 q+=quantum_info->pad;
2221 for (x=0; x < (long) number_pixels; x++)
2223 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2224 q=PopLongPixel(endian,pixel,q);
2225 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2226 q=PopLongPixel(endian,pixel,q);
2227 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2228 q=PopLongPixel(endian,pixel,q);
2229 pixel=ScaleQuantumToLong(indexes[x]);
2230 q=PopLongPixel(endian,pixel,q);
2232 q+=quantum_info->pad;
2238 if (quantum_info->format == FloatingPointQuantumFormat)
2240 for (x=0; x < (long) number_pixels; x++)
2242 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2243 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2244 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2245 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2247 q+=quantum_info->pad;
2254 range=GetQuantumRange(image->depth);
2255 for (x=0; x < (long) number_pixels; x++)
2257 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2259 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2261 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2263 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2264 indexes[x],range),q);
2266 q+=quantum_info->pad;
2276 if (image->colorspace != CMYKColorspace)
2278 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2279 "ColorSeparatedImageRequired","`%s'",image->filename);
2282 switch (quantum_info->depth)
2286 register unsigned char
2289 for (x=0; x < (long) number_pixels; x++)
2291 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2292 q=PopCharPixel(pixel,q);
2293 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2294 q=PopCharPixel(pixel,q);
2295 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2296 q=PopCharPixel(pixel,q);
2297 pixel=ScaleQuantumToChar(indexes[x]);
2298 q=PopCharPixel(pixel,q);
2299 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2300 GetOpacityPixelComponent(p)));
2301 q=PopCharPixel(pixel,q);
2303 q+=quantum_info->pad;
2309 register unsigned short
2312 if (quantum_info->format == FloatingPointQuantumFormat)
2314 for (x=0; x < (long) number_pixels; x++)
2316 pixel=SinglePrecisionToHalf(QuantumScale*
2317 GetRedPixelComponent(p));
2318 q=PopShortPixel(endian,pixel,q);
2319 pixel=SinglePrecisionToHalf(QuantumScale*
2320 GetGreenPixelComponent(p));
2321 q=PopShortPixel(endian,pixel,q);
2322 pixel=SinglePrecisionToHalf(QuantumScale*
2323 GetBluePixelComponent(p));
2324 q=PopShortPixel(endian,pixel,q);
2325 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2326 q=PopShortPixel(endian,pixel,q);
2327 pixel=SinglePrecisionToHalf(QuantumScale*
2328 GetAlphaPixelComponent(p));
2329 q=PopShortPixel(endian,pixel,q);
2331 q+=quantum_info->pad;
2335 for (x=0; x < (long) number_pixels; x++)
2337 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2338 q=PopShortPixel(endian,pixel,q);
2339 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2340 q=PopShortPixel(endian,pixel,q);
2341 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2342 q=PopShortPixel(endian,pixel,q);
2343 pixel=ScaleQuantumToShort(indexes[x]);
2344 q=PopShortPixel(endian,pixel,q);
2345 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2346 GetOpacityPixelComponent(p)));
2347 q=PopShortPixel(endian,pixel,q);
2349 q+=quantum_info->pad;
2355 register unsigned long
2358 if (quantum_info->format == FloatingPointQuantumFormat)
2360 for (x=0; x < (long) number_pixels; x++)
2365 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2366 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2367 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2368 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2369 pixel=(float) (GetAlphaPixelComponent(p));
2370 q=PopFloatPixel(&quantum_state,pixel,q);
2372 q+=quantum_info->pad;
2376 for (x=0; x < (long) number_pixels; x++)
2378 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2379 q=PopLongPixel(endian,pixel,q);
2380 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2381 q=PopLongPixel(endian,pixel,q);
2382 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2383 q=PopLongPixel(endian,pixel,q);
2384 pixel=ScaleQuantumToLong(indexes[x]);
2385 q=PopLongPixel(endian,pixel,q);
2386 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2387 GetOpacityPixelComponent(p)));
2388 q=PopLongPixel(endian,pixel,q);
2390 q+=quantum_info->pad;
2396 if (quantum_info->format == FloatingPointQuantumFormat)
2401 for (x=0; x < (long) number_pixels; x++)
2403 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2404 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2405 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2406 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2407 pixel=(double) (GetAlphaPixelComponent(p));
2408 q=PopDoublePixel(&quantum_state,pixel,q);
2410 q+=quantum_info->pad;
2417 range=GetQuantumRange(image->depth);
2418 for (x=0; x < (long) number_pixels; x++)
2420 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2422 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2424 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2426 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2427 indexes[x],range),q);
2428 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2429 p->opacity,range),q);
2431 q+=quantum_info->pad;
2449 register unsigned long
2457 range=GetQuantumRange(image->depth);
2458 switch (quantum_info->depth)
2462 if (quantum_info->pack == MagickFalse)
2464 for (x=0; x < (long) number_pixels; x+=2)
2466 for (i=0; i < 4; i++)
2472 quantum=GetRedPixelComponent(p);
2477 quantum=GetGreenPixelComponent(p);
2482 quantum=GetBluePixelComponent(p);
2486 cbcr[i]=(Quantum) quantum;
2489 pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
2490 (unsigned long) (cbcr[0]) << 12 |
2491 (unsigned long) (cbcr[2]) << 2);
2492 q=PopLongPixel(endian,pixel,q);
2494 pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
2495 (unsigned long) (cbcr[0]) << 12 |
2496 (unsigned long) (cbcr[2]) << 2);
2497 q=PopLongPixel(endian,pixel,q);
2499 q+=quantum_info->pad;
2507 for (x=0; x < (long) number_pixels; x+=2)
2509 for (i=0; i < 4; i++)
2515 quantum=GetRedPixelComponent(p);
2520 quantum=GetGreenPixelComponent(p);
2525 quantum=GetBluePixelComponent(p);
2529 cbcr[i]=(Quantum) quantum;
2532 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2534 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2536 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2539 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2541 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2543 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2546 q+=quantum_info->pad;
2556 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2561 register PixelPacket
2564 q=GetAuthenticPixelQueue(image);
2565 if (image_view != (CacheView *) NULL)
2566 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2567 for (x=0; x < (long) number_pixels; x++)
2575 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2577 register PixelPacket
2580 q=GetAuthenticPixelQueue(image);
2581 if (image_view != (CacheView *) NULL)
2582 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2583 for (x=0; x < (long) number_pixels; x++)
2585 q->opacity=(Quantum) GetAlphaPixelComponent(q);