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,
93 % const CacheView *image_view,const QuantumInfo *quantum_info,
94 % const QuantumType quantum_type,unsigned char *pixels,
95 % ExceptionInfo *exception)
97 % A description of each parameter follows:
101 % o image_view: the image cache view.
103 % o quantum_info: the quantum info.
105 % o quantum_type: Declare which pixel components to transfer (RGB, RGBA,
108 % o pixels: The components are transferred to this buffer.
110 % o exception: return any errors or warnings in this structure.
114 static inline unsigned char *PopDoublePixel(const QuantumState *quantum_state,
115 const double pixel,unsigned char *pixels)
123 p=(double *) quantum;
124 *p=(double) (pixel*quantum_state->inverse_scale+quantum_state->minimum);
125 if (quantum_state->endian != LSBEndian)
127 *pixels++=quantum[7];
128 *pixels++=quantum[6];
129 *pixels++=quantum[5];
130 *pixels++=quantum[4];
131 *pixels++=quantum[3];
132 *pixels++=quantum[2];
133 *pixels++=quantum[1];
134 *pixels++=quantum[0];
137 *pixels++=quantum[0];
138 *pixels++=quantum[1];
139 *pixels++=quantum[2];
140 *pixels++=quantum[3];
141 *pixels++=quantum[4];
142 *pixels++=quantum[5];
143 *pixels++=quantum[6];
144 *pixels++=quantum[7];
148 static inline unsigned char *PopFloatPixel(const QuantumState *quantum_state,
149 const float pixel,unsigned char *pixels)
158 *p=(float) ((double) pixel*quantum_state->inverse_scale+
159 quantum_state->minimum);
160 if (quantum_state->endian != LSBEndian)
162 *pixels++=quantum[3];
163 *pixels++=quantum[2];
164 *pixels++=quantum[1];
165 *pixels++=quantum[0];
168 *pixels++=quantum[0];
169 *pixels++=quantum[1];
170 *pixels++=quantum[2];
171 *pixels++=quantum[3];
175 static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
176 const size_t depth,const QuantumAny pixel,unsigned char *pixels)
184 if (quantum_state->bits == 0UL)
185 quantum_state->bits=8U;
186 for (i=(ssize_t) depth; i > 0L; )
188 quantum_bits=(size_t) i;
189 if (quantum_bits > quantum_state->bits)
190 quantum_bits=quantum_state->bits;
191 i-=(ssize_t) quantum_bits;
192 if (quantum_state->bits == 8UL)
194 quantum_state->bits-=quantum_bits;
195 *pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
196 quantum_state->bits);
197 if (quantum_state->bits == 0UL)
200 quantum_state->bits=8UL;
206 static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
207 const size_t depth,const size_t pixel,unsigned char *pixels)
215 if (quantum_state->bits == 0U)
216 quantum_state->bits=32UL;
217 for (i=(ssize_t) depth; i > 0; )
219 quantum_bits=(size_t) i;
220 if (quantum_bits > quantum_state->bits)
221 quantum_bits=quantum_state->bits;
222 quantum_state->pixel|=(((pixel >> (depth-i)) &
223 quantum_state->mask[quantum_bits]) << (32U-quantum_state->bits));
224 i-=(ssize_t) quantum_bits;
225 quantum_state->bits-=quantum_bits;
226 if (quantum_state->bits == 0U)
228 pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
229 quantum_state->pixel=0U;
230 quantum_state->bits=32U;
236 MagickExport size_t ExportQuantumPixels(const Image *image,
237 const CacheView *image_view,const QuantumInfo *quantum_info,
238 const QuantumType quantum_type,unsigned char *pixels,ExceptionInfo *exception)
258 register const IndexPacket
261 register const PixelPacket
267 register unsigned char
273 assert(image != (Image *) NULL);
274 assert(image->signature == MagickSignature);
275 if (image->debug != MagickFalse)
276 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
277 assert(quantum_info != (QuantumInfo *) NULL);
278 assert(quantum_info->signature == MagickSignature);
279 if (pixels == (unsigned char *) NULL)
280 pixels=GetQuantumPixels(quantum_info);
281 if (image_view == (CacheView *) NULL)
283 number_pixels=GetImageExtent(image);
284 p=GetVirtualPixelQueue(image);
285 indexes=GetVirtualIndexQueue(image);
289 number_pixels=GetCacheViewExtent(image_view);
290 p=GetCacheViewVirtualPixelQueue(image_view);
291 indexes=GetCacheViewVirtualIndexQueue(image_view);
293 if (quantum_info->alpha_type == AssociatedQuantumAlpha)
301 q=GetAuthenticPixelQueue(image);
302 if (image_view != (CacheView *) NULL)
303 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
304 for (x=0; x < (ssize_t) image->columns; x++)
306 alpha=QuantumScale*((double) QuantumRange-q->opacity);
307 q->red=ClampToQuantum(alpha*q->red);
308 q->green=ClampToQuantum(alpha*q->green);
309 q->blue=ClampToQuantum(alpha*q->blue);
313 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
314 (quantum_type == BGROQuantum))
319 q=GetAuthenticPixelQueue(image);
320 if (image_view != (CacheView *) NULL)
321 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
322 for (x=0; x < (ssize_t) number_pixels; x++)
324 q->opacity=(Quantum) GetAlphaPixelComponent(q);
328 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
336 q=GetAuthenticPixelQueue(image);
337 if (image_view != (CacheView *) NULL)
338 q=GetAuthenticPixelQueue(image);
339 for (x=0; x < (ssize_t) number_pixels; x++)
349 InitializeQuantumState(quantum_info,image->endian,&quantum_state);
350 extent=GetQuantumExtent(image,quantum_info,quantum_type);
351 endian=quantum_state.endian;
352 switch (quantum_type)
356 if (image->storage_class != PseudoClass)
358 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
359 "ColormappedImageRequired","`%s'",image->filename);
362 switch (quantum_info->depth)
366 register unsigned char
369 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
371 pixel=(unsigned char) *indexes++;
372 *q=((pixel & 0x01) << 7);
373 pixel=(unsigned char) *indexes++;
374 *q|=((pixel & 0x01) << 6);
375 pixel=(unsigned char) *indexes++;
376 *q|=((pixel & 0x01) << 5);
377 pixel=(unsigned char) *indexes++;
378 *q|=((pixel & 0x01) << 4);
379 pixel=(unsigned char) *indexes++;
380 *q|=((pixel & 0x01) << 3);
381 pixel=(unsigned char) *indexes++;
382 *q|=((pixel & 0x01) << 2);
383 pixel=(unsigned char) *indexes++;
384 *q|=((pixel & 0x01) << 1);
385 pixel=(unsigned char) *indexes++;
386 *q|=((pixel & 0x01) << 0);
389 if ((number_pixels % 8) != 0)
392 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
394 pixel=(unsigned char) *indexes++;
395 *q|=((pixel & 0x01) << (unsigned char) bit);
403 register unsigned char
406 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
408 pixel=(unsigned char) *indexes++;
409 *q=((pixel & 0xf) << 4);
410 pixel=(unsigned char) *indexes++;
411 *q|=((pixel & 0xf) << 0);
414 if ((number_pixels % 2) != 0)
416 pixel=(unsigned char) *indexes++;
417 *q=((pixel & 0xf) << 4);
424 for (x=0; x < (ssize_t) number_pixels; x++)
426 q=PopCharPixel((unsigned char) indexes[x],q);
427 q+=quantum_info->pad;
433 if (quantum_info->format == FloatingPointQuantumFormat)
435 for (x=0; x < (ssize_t) number_pixels; x++)
437 q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
439 q+=quantum_info->pad;
443 for (x=0; x < (ssize_t) number_pixels; x++)
445 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
446 q+=quantum_info->pad;
452 if (quantum_info->format == FloatingPointQuantumFormat)
454 for (x=0; x < (ssize_t) number_pixels; x++)
456 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
458 q+=quantum_info->pad;
462 for (x=0; x < (ssize_t) number_pixels; x++)
464 q=PopLongPixel(endian,(unsigned int) indexes[x],q);
465 q+=quantum_info->pad;
471 if (quantum_info->format == FloatingPointQuantumFormat)
473 for (x=0; x < (ssize_t) number_pixels; x++)
475 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
477 q+=quantum_info->pad;
484 for (x=0; x < (ssize_t) number_pixels; x++)
486 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
488 q+=quantum_info->pad;
495 case IndexAlphaQuantum:
497 if (image->storage_class != PseudoClass)
499 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
500 "ColormappedImageRequired","`%s'",image->filename);
503 switch (quantum_info->depth)
507 register unsigned char
510 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
512 pixel=(unsigned char) *indexes++;
513 *q=((pixel & 0x01) << 7);
514 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
516 *q|=((pixel & 0x01) << 6);
518 pixel=(unsigned char) *indexes++;
519 *q|=((pixel & 0x01) << 5);
520 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
522 *q|=((pixel & 0x01) << 4);
524 pixel=(unsigned char) *indexes++;
525 *q|=((pixel & 0x01) << 3);
526 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
528 *q|=((pixel & 0x01) << 2);
530 pixel=(unsigned char) *indexes++;
531 *q|=((pixel & 0x01) << 1);
532 pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
534 *q|=((pixel & 0x01) << 0);
538 if ((number_pixels % 4) != 0)
541 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
543 pixel=(unsigned char) *indexes++;
544 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
545 pixel=(unsigned char) (p->opacity == (Quantum)
546 TransparentOpacity ? 1 : 0);
547 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
556 register unsigned char
559 for (x=0; x < (ssize_t) number_pixels ; x++)
561 pixel=(unsigned char) *indexes++;
562 *q=((pixel & 0xf) << 4);
563 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
564 GetOpacityPixelComponent(p)))+0.5);
565 *q|=((pixel & 0xf) << 0);
573 register unsigned char
576 for (x=0; x < (ssize_t) number_pixels; x++)
578 q=PopCharPixel((unsigned char) indexes[x],q);
579 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
580 GetOpacityPixelComponent(p)));
581 q=PopCharPixel(pixel,q);
583 q+=quantum_info->pad;
589 register unsigned short
592 if (quantum_info->format == FloatingPointQuantumFormat)
594 for (x=0; x < (ssize_t) number_pixels; x++)
596 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
597 pixel=SinglePrecisionToHalf(QuantumScale*
598 GetAlphaPixelComponent(p));
599 q=PopShortPixel(endian,pixel,q);
601 q+=quantum_info->pad;
605 for (x=0; x < (ssize_t) number_pixels; x++)
607 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
608 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
609 GetOpacityPixelComponent(p)));
610 q=PopShortPixel(endian,pixel,q);
612 q+=quantum_info->pad;
618 register unsigned int
621 if (quantum_info->format == FloatingPointQuantumFormat)
623 for (x=0; x < (ssize_t) number_pixels; x++)
628 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
629 pixel=(float) (GetAlphaPixelComponent(p));
630 q=PopFloatPixel(&quantum_state,pixel,q);
632 q+=quantum_info->pad;
636 for (x=0; x < (ssize_t) number_pixels; x++)
638 q=PopLongPixel(endian,(unsigned int) indexes[x],q);
639 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
640 GetOpacityPixelComponent(p)));
641 q=PopLongPixel(endian,pixel,q);
643 q+=quantum_info->pad;
649 if (quantum_info->format == FloatingPointQuantumFormat)
651 for (x=0; x < (ssize_t) number_pixels; x++)
656 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
657 pixel=(double) (GetAlphaPixelComponent(p));
658 q=PopDoublePixel(&quantum_state,pixel,q);
660 q+=quantum_info->pad;
667 range=GetQuantumRange(image->depth);
668 for (x=0; x < (ssize_t) number_pixels; x++)
670 q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
671 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
672 (Quantum) (GetAlphaPixelComponent(p)),range),q);
674 q+=quantum_info->pad;
683 switch (quantum_info->depth)
687 for (x=0; x < (ssize_t) number_pixels; x++)
689 q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
690 q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
691 q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
693 q+=quantum_info->pad;
699 register unsigned int
702 range=GetQuantumRange(image->depth);
703 if (quantum_info->pack == MagickFalse)
705 for (x=0; x < (ssize_t) number_pixels; x++)
707 pixel=(unsigned int) (ScaleQuantumToAny(p->red,range) << 22 |
708 ScaleQuantumToAny(p->green,range) << 12 |
709 ScaleQuantumToAny(p->blue,range) << 2);
710 q=PopLongPixel(endian,pixel,q);
712 q+=quantum_info->pad;
716 if (quantum_info->quantum == 32UL)
718 for (x=0; x < (ssize_t) number_pixels; x++)
720 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
721 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
722 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
723 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
724 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
725 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
727 q+=quantum_info->pad;
731 for (x=0; x < (ssize_t) number_pixels; x++)
733 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
734 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
735 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
736 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
737 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
738 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
740 q+=quantum_info->pad;
746 register unsigned int
749 range=GetQuantumRange(image->depth);
750 if (quantum_info->pack == MagickFalse)
752 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
759 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
764 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
769 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
774 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
780 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
785 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
790 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
795 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
796 q+=quantum_info->pad;
798 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
805 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
810 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
815 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
820 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
821 q+=quantum_info->pad;
827 if (quantum_info->quantum == 32UL)
829 for (x=0; x < (ssize_t) number_pixels; x++)
831 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
832 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
833 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
834 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
835 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
836 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
838 q+=quantum_info->pad;
842 for (x=0; x < (ssize_t) number_pixels; x++)
844 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
845 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
846 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
847 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
848 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
849 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
851 q+=quantum_info->pad;
857 register unsigned short
860 if (quantum_info->format == FloatingPointQuantumFormat)
862 for (x=0; x < (ssize_t) number_pixels; x++)
864 pixel=SinglePrecisionToHalf(QuantumScale*
865 GetBluePixelComponent(p));
866 q=PopShortPixel(endian,pixel,q);
867 pixel=SinglePrecisionToHalf(QuantumScale*
868 GetGreenPixelComponent(p));
869 q=PopShortPixel(endian,pixel,q);
870 pixel=SinglePrecisionToHalf(QuantumScale*
871 GetRedPixelComponent(p));
872 q=PopShortPixel(endian,pixel,q);
874 q+=quantum_info->pad;
878 for (x=0; x < (ssize_t) number_pixels; x++)
880 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
881 q=PopShortPixel(endian,pixel,q);
882 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
883 q=PopShortPixel(endian,pixel,q);
884 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
885 q=PopShortPixel(endian,pixel,q);
887 q+=quantum_info->pad;
893 register unsigned int
896 if (quantum_info->format == FloatingPointQuantumFormat)
898 for (x=0; x < (ssize_t) number_pixels; x++)
900 q=PopFloatPixel(&quantum_state,(float) p->red,q);
901 q=PopFloatPixel(&quantum_state,(float) p->green,q);
902 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
904 q+=quantum_info->pad;
908 for (x=0; x < (ssize_t) number_pixels; x++)
910 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
911 q=PopLongPixel(endian,pixel,q);
912 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
913 q=PopLongPixel(endian,pixel,q);
914 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
915 q=PopLongPixel(endian,pixel,q);
917 q+=quantum_info->pad;
923 if (quantum_info->format == FloatingPointQuantumFormat)
925 for (x=0; x < (ssize_t) number_pixels; x++)
927 q=PopDoublePixel(&quantum_state,(double) p->red,q);
928 q=PopDoublePixel(&quantum_state,(double) p->green,q);
929 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
931 q+=quantum_info->pad;
938 range=GetQuantumRange(image->depth);
939 for (x=0; x < (ssize_t) number_pixels; x++)
941 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
943 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
945 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
948 q+=quantum_info->pad;
958 switch (quantum_info->depth)
962 register unsigned char
965 for (x=0; x < (ssize_t) number_pixels; x++)
967 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
968 q=PopCharPixel(pixel,q);
969 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
970 q=PopCharPixel(pixel,q);
971 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
972 q=PopCharPixel(pixel,q);
973 pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
974 q=PopCharPixel(pixel,q);
976 q+=quantum_info->pad;
982 register unsigned int
985 range=GetQuantumRange(image->depth);
986 if (quantum_info->pack == MagickFalse)
1000 for (x=0; x < (ssize_t) number_pixels; x++)
1002 for (i=0; i < 4; i++)
1006 case 0: quantum=p->red; break;
1007 case 1: quantum=p->green; break;
1008 case 2: quantum=p->blue; break;
1009 case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
1015 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1021 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1027 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1029 q=PopLongPixel(endian,pixel,q);
1037 q+=quantum_info->pad;
1041 if (quantum_info->quantum == 32UL)
1043 for (x=0; x < (ssize_t) number_pixels; x++)
1045 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
1046 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1047 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
1048 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1049 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
1050 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1051 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
1053 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1055 q+=quantum_info->pad;
1059 for (x=0; x < (ssize_t) number_pixels; x++)
1061 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
1062 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1063 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
1064 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1065 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
1066 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1067 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
1069 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1071 q+=quantum_info->pad;
1077 register unsigned short
1080 if (quantum_info->format == FloatingPointQuantumFormat)
1082 for (x=0; x < (ssize_t) number_pixels; x++)
1084 pixel=SinglePrecisionToHalf(QuantumScale*
1085 GetBluePixelComponent(p));
1086 q=PopShortPixel(endian,pixel,q);
1087 pixel=SinglePrecisionToHalf(QuantumScale*
1088 GetGreenPixelComponent(p));
1089 q=PopShortPixel(endian,pixel,q);
1090 pixel=SinglePrecisionToHalf(QuantumScale*
1091 GetRedPixelComponent(p));
1092 q=PopShortPixel(endian,pixel,q);
1093 pixel=SinglePrecisionToHalf(QuantumScale*
1094 GetAlphaPixelComponent(p));
1095 q=PopShortPixel(endian,pixel,q);
1097 q+=quantum_info->pad;
1101 for (x=0; x < (ssize_t) number_pixels; x++)
1103 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1104 q=PopShortPixel(endian,pixel,q);
1105 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1106 q=PopShortPixel(endian,pixel,q);
1107 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1108 q=PopShortPixel(endian,pixel,q);
1109 pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
1110 q=PopShortPixel(endian,pixel,q);
1112 q+=quantum_info->pad;
1118 register unsigned int
1121 if (quantum_info->format == FloatingPointQuantumFormat)
1123 for (x=0; x < (ssize_t) number_pixels; x++)
1128 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1129 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1130 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1131 pixel=(float) GetAlphaPixelComponent(p);
1132 q=PopFloatPixel(&quantum_state,pixel,q);
1134 q+=quantum_info->pad;
1138 for (x=0; x < (ssize_t) number_pixels; x++)
1140 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1141 q=PopLongPixel(endian,pixel,q);
1142 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1143 q=PopLongPixel(endian,pixel,q);
1144 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1145 q=PopLongPixel(endian,pixel,q);
1146 pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
1147 q=PopLongPixel(endian,pixel,q);
1149 q+=quantum_info->pad;
1155 if (quantum_info->format == FloatingPointQuantumFormat)
1160 for (x=0; x < (ssize_t) number_pixels; x++)
1162 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1163 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1164 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1165 pixel=(double) GetAlphaPixelComponent(p);
1166 q=PopDoublePixel(&quantum_state,pixel,q);
1168 q+=quantum_info->pad;
1175 range=GetQuantumRange(image->depth);
1176 for (x=0; x < (ssize_t) number_pixels; x++)
1178 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1179 GetBluePixelComponent(p),range),q);
1180 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1181 GetGreenPixelComponent(p),range),q);
1182 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1183 GetRedPixelComponent(p),range),q);
1184 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1185 (Quantum) GetAlphaPixelComponent(p),range),q);
1187 q+=quantum_info->pad;
1196 switch (quantum_info->depth)
1203 register unsigned char
1209 if (quantum_info->min_is_white != MagickFalse)
1214 threshold=(Quantum) (QuantumRange/2);
1215 for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1218 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
1220 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
1222 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
1224 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
1226 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
1228 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
1230 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
1232 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
1236 if ((number_pixels % 8) != 0)
1239 for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1241 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
1251 register unsigned char
1254 for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
1256 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1257 *q=(((pixel >> 4) & 0xf) << 4);
1259 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1264 if ((number_pixels % 2) != 0)
1266 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1267 *q=(((pixel >> 4) & 0xf) << 4);
1275 register unsigned char
1278 for (x=0; x < (ssize_t) number_pixels; x++)
1280 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1281 q=PopCharPixel(pixel,q);
1283 q+=quantum_info->pad;
1289 range=GetQuantumRange(image->depth);
1290 if (quantum_info->pack == MagickFalse)
1292 register unsigned int
1295 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
1297 pixel=(unsigned int) (
1298 ScaleQuantumToAny(PixelIntensityToQuantum(p+2),range) << 22 |
1299 ScaleQuantumToAny(PixelIntensityToQuantum(p+1),range) << 12 |
1300 ScaleQuantumToAny(PixelIntensityToQuantum(p+0),range) << 2);
1301 q=PopLongPixel(endian,pixel,q);
1303 q+=quantum_info->pad;
1306 if (x++ < (ssize_t) (number_pixels-1))
1307 pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+1),
1309 if (x++ < (ssize_t) number_pixels)
1310 pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+0),
1312 q=PopLongPixel(endian,pixel,q);
1315 for (x=0; x < (ssize_t) number_pixels; x++)
1317 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1318 PixelIntensityToQuantum(p),range),q);
1320 q+=quantum_info->pad;
1326 register unsigned short
1329 range=GetQuantumRange(image->depth);
1330 if (quantum_info->pack == MagickFalse)
1332 for (x=0; x < (ssize_t) number_pixels; x++)
1334 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1335 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
1337 q+=quantum_info->pad;
1341 for (x=0; x < (ssize_t) number_pixels; x++)
1343 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1344 PixelIntensityToQuantum(p),range),q);
1346 q+=quantum_info->pad;
1352 register unsigned short
1355 if (quantum_info->format == FloatingPointQuantumFormat)
1357 for (x=0; x < (ssize_t) number_pixels; x++)
1359 pixel=SinglePrecisionToHalf(QuantumScale*
1360 PixelIntensityToQuantum(p));
1361 q=PopShortPixel(endian,pixel,q);
1363 q+=quantum_info->pad;
1367 for (x=0; x < (ssize_t) number_pixels; x++)
1369 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1370 q=PopShortPixel(endian,pixel,q);
1372 q+=quantum_info->pad;
1378 register unsigned int
1381 if (quantum_info->format == FloatingPointQuantumFormat)
1383 for (x=0; x < (ssize_t) number_pixels; x++)
1388 pixel=(float) PixelIntensityToQuantum(p);
1389 q=PopFloatPixel(&quantum_state,pixel,q);
1391 q+=quantum_info->pad;
1395 for (x=0; x < (ssize_t) number_pixels; x++)
1397 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1398 q=PopLongPixel(endian,pixel,q);
1400 q+=quantum_info->pad;
1406 if (quantum_info->format == FloatingPointQuantumFormat)
1408 for (x=0; x < (ssize_t) number_pixels; x++)
1413 pixel=(double) PixelIntensityToQuantum(p);
1414 q=PopDoublePixel(&quantum_state,pixel,q);
1416 q+=quantum_info->pad;
1423 range=GetQuantumRange(image->depth);
1424 for (x=0; x < (ssize_t) number_pixels; x++)
1426 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1427 PixelIntensityToQuantum(p),range),q);
1429 q+=quantum_info->pad;
1436 case GrayAlphaQuantum:
1438 switch (quantum_info->depth)
1445 register unsigned char
1452 if (quantum_info->min_is_white == MagickFalse)
1457 threshold=(Quantum) (QuantumRange/2);
1458 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
1461 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 7;
1462 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1463 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
1465 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 5;
1466 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1467 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
1469 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 3;
1470 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1471 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
1473 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 1;
1474 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1475 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
1479 if ((number_pixels % 4) != 0)
1482 for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
1484 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) <<
1486 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
1488 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
1498 register unsigned char
1501 for (x=0; x < (ssize_t) number_pixels ; x++)
1503 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1504 *q=(((pixel >> 4) & 0xf) << 4);
1505 pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
1506 GetOpacityPixelComponent(p)))+0.5);
1515 register unsigned char
1518 for (x=0; x < (ssize_t) number_pixels; x++)
1520 pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1521 q=PopCharPixel(pixel,q);
1522 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1523 GetOpacityPixelComponent(p)));
1524 q=PopCharPixel(pixel,q);
1526 q+=quantum_info->pad;
1532 register unsigned short
1535 if (quantum_info->format == FloatingPointQuantumFormat)
1537 for (x=0; x < (ssize_t) number_pixels; x++)
1539 pixel=SinglePrecisionToHalf(QuantumScale*
1540 PixelIntensityToQuantum(p));
1541 q=PopShortPixel(endian,pixel,q);
1542 pixel=SinglePrecisionToHalf(QuantumScale*
1543 GetAlphaPixelComponent(p));
1544 q=PopShortPixel(endian,pixel,q);
1546 q+=quantum_info->pad;
1550 for (x=0; x < (ssize_t) number_pixels; x++)
1552 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1553 q=PopShortPixel(endian,pixel,q);
1554 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1555 GetOpacityPixelComponent(p)));
1556 q=PopShortPixel(endian,pixel,q);
1558 q+=quantum_info->pad;
1564 register unsigned int
1567 if (quantum_info->format == FloatingPointQuantumFormat)
1569 for (x=0; x < (ssize_t) number_pixels; x++)
1574 pixel=(float) PixelIntensityToQuantum(p);
1575 q=PopFloatPixel(&quantum_state,pixel,q);
1576 pixel=(float) (GetAlphaPixelComponent(p));
1577 q=PopFloatPixel(&quantum_state,pixel,q);
1579 q+=quantum_info->pad;
1583 for (x=0; x < (ssize_t) number_pixels; x++)
1585 pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1586 q=PopLongPixel(endian,pixel,q);
1587 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1588 GetOpacityPixelComponent(p)));
1589 q=PopLongPixel(endian,pixel,q);
1591 q+=quantum_info->pad;
1597 if (quantum_info->format == FloatingPointQuantumFormat)
1599 for (x=0; x < (ssize_t) number_pixels; x++)
1604 pixel=(double) PixelIntensityToQuantum(p);
1605 q=PopDoublePixel(&quantum_state,pixel,q);
1606 pixel=(double) (GetAlphaPixelComponent(p));
1607 q=PopDoublePixel(&quantum_state,pixel,q);
1609 q+=quantum_info->pad;
1616 range=GetQuantumRange(image->depth);
1617 for (x=0; x < (ssize_t) number_pixels; x++)
1619 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1620 PixelIntensityToQuantum(p),range),q);
1621 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1622 (Quantum) (GetAlphaPixelComponent(p)),range),q);
1624 q+=quantum_info->pad;
1634 switch (quantum_info->depth)
1638 register unsigned char
1641 for (x=0; x < (ssize_t) number_pixels; x++)
1643 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1644 q=PopCharPixel(pixel,q);
1646 q+=quantum_info->pad;
1652 register unsigned short
1655 if (quantum_info->format == FloatingPointQuantumFormat)
1657 for (x=0; x < (ssize_t) number_pixels; x++)
1659 pixel=SinglePrecisionToHalf(QuantumScale*
1660 GetRedPixelComponent(p));
1661 q=PopShortPixel(endian,pixel,q);
1663 q+=quantum_info->pad;
1667 for (x=0; x < (ssize_t) number_pixels; x++)
1669 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1670 q=PopShortPixel(endian,pixel,q);
1672 q+=quantum_info->pad;
1678 register unsigned int
1681 if (quantum_info->format == FloatingPointQuantumFormat)
1683 for (x=0; x < (ssize_t) number_pixels; x++)
1685 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1687 q+=quantum_info->pad;
1691 for (x=0; x < (ssize_t) number_pixels; x++)
1693 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1694 q=PopLongPixel(endian,pixel,q);
1696 q+=quantum_info->pad;
1702 if (quantum_info->format == FloatingPointQuantumFormat)
1704 for (x=0; x < (ssize_t) number_pixels; x++)
1706 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1708 q+=quantum_info->pad;
1715 range=GetQuantumRange(image->depth);
1716 for (x=0; x < (ssize_t) number_pixels; x++)
1718 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1721 q+=quantum_info->pad;
1729 case MagentaQuantum:
1731 switch (quantum_info->depth)
1735 register unsigned char
1738 for (x=0; x < (ssize_t) number_pixels; x++)
1740 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1741 q=PopCharPixel(pixel,q);
1743 q+=quantum_info->pad;
1749 register unsigned short
1752 if (quantum_info->format == FloatingPointQuantumFormat)
1754 for (x=0; x < (ssize_t) number_pixels; x++)
1756 pixel=SinglePrecisionToHalf(QuantumScale*
1757 GetGreenPixelComponent(p));
1758 q=PopShortPixel(endian,pixel,q);
1760 q+=quantum_info->pad;
1764 for (x=0; x < (ssize_t) number_pixels; x++)
1766 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1767 q=PopShortPixel(endian,pixel,q);
1769 q+=quantum_info->pad;
1775 register unsigned int
1778 if (quantum_info->format == FloatingPointQuantumFormat)
1780 for (x=0; x < (ssize_t) number_pixels; x++)
1782 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1784 q+=quantum_info->pad;
1788 for (x=0; x < (ssize_t) number_pixels; x++)
1790 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1791 q=PopLongPixel(endian,pixel,q);
1793 q+=quantum_info->pad;
1799 if (quantum_info->format == FloatingPointQuantumFormat)
1801 for (x=0; x < (ssize_t) number_pixels; x++)
1803 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1805 q+=quantum_info->pad;
1812 range=GetQuantumRange(image->depth);
1813 for (x=0; x < (ssize_t) number_pixels; x++)
1815 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1818 q+=quantum_info->pad;
1828 switch (quantum_info->depth)
1832 register unsigned char
1835 for (x=0; x < (ssize_t) number_pixels; x++)
1837 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1838 q=PopCharPixel(pixel,q);
1840 q+=quantum_info->pad;
1846 register unsigned short
1849 if (quantum_info->format == FloatingPointQuantumFormat)
1851 for (x=0; x < (ssize_t) number_pixels; x++)
1853 pixel=SinglePrecisionToHalf(QuantumScale*
1854 GetBluePixelComponent(p));
1855 q=PopShortPixel(endian,pixel,q);
1857 q+=quantum_info->pad;
1861 for (x=0; x < (ssize_t) number_pixels; x++)
1863 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1864 q=PopShortPixel(endian,pixel,q);
1866 q+=quantum_info->pad;
1872 register unsigned int
1875 if (quantum_info->format == FloatingPointQuantumFormat)
1877 for (x=0; x < (ssize_t) number_pixels; x++)
1879 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1881 q+=quantum_info->pad;
1885 for (x=0; x < (ssize_t) number_pixels; x++)
1887 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1888 q=PopLongPixel(endian,pixel,q);
1890 q+=quantum_info->pad;
1896 if (quantum_info->format == FloatingPointQuantumFormat)
1898 for (x=0; x < (ssize_t) number_pixels; x++)
1900 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1902 q+=quantum_info->pad;
1909 range=GetQuantumRange(image->depth);
1910 for (x=0; x < (ssize_t) number_pixels; x++)
1912 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1915 q+=quantum_info->pad;
1924 switch (quantum_info->depth)
1928 register unsigned char
1931 for (x=0; x < (ssize_t) number_pixels; x++)
1933 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1934 GetOpacityPixelComponent(p)));
1935 q=PopCharPixel(pixel,q);
1937 q+=quantum_info->pad;
1943 register unsigned short
1946 if (quantum_info->format == FloatingPointQuantumFormat)
1948 for (x=0; x < (ssize_t) number_pixels; x++)
1950 pixel=SinglePrecisionToHalf(QuantumScale*
1951 GetAlphaPixelComponent(p));
1952 q=PopShortPixel(endian,pixel,q);
1954 q+=quantum_info->pad;
1958 for (x=0; x < (ssize_t) number_pixels; x++)
1960 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1961 GetOpacityPixelComponent(p)));
1962 q=PopShortPixel(endian,pixel,q);
1964 q+=quantum_info->pad;
1970 register unsigned int
1973 if (quantum_info->format == FloatingPointQuantumFormat)
1975 for (x=0; x < (ssize_t) number_pixels; x++)
1980 pixel=(float) (GetAlphaPixelComponent(p));
1981 q=PopFloatPixel(&quantum_state,pixel,q);
1983 q+=quantum_info->pad;
1987 for (x=0; x < (ssize_t) number_pixels; x++)
1989 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1990 GetOpacityPixelComponent(p)));
1991 q=PopLongPixel(endian,pixel,q);
1993 q+=quantum_info->pad;
1999 if (quantum_info->format == FloatingPointQuantumFormat)
2001 for (x=0; x < (ssize_t) number_pixels; x++)
2006 pixel=(double) (GetAlphaPixelComponent(p));
2007 q=PopDoublePixel(&quantum_state,pixel,q);
2009 q+=quantum_info->pad;
2016 range=GetQuantumRange(image->depth);
2017 for (x=0; x < (ssize_t) number_pixels; x++)
2019 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2020 (Quantum) (GetAlphaPixelComponent(p)),range),q);
2022 q+=quantum_info->pad;
2029 case OpacityQuantum:
2031 switch (quantum_info->depth)
2035 register unsigned char
2038 for (x=0; x < (ssize_t) number_pixels; x++)
2040 pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
2041 q=PopCharPixel(pixel,q);
2043 q+=quantum_info->pad;
2049 register unsigned short
2052 if (quantum_info->format == FloatingPointQuantumFormat)
2054 for (x=0; x < (ssize_t) number_pixels; x++)
2056 pixel=SinglePrecisionToHalf(QuantumScale*
2057 GetOpacityPixelComponent(p));
2058 q=PopShortPixel(endian,pixel,q);
2060 q+=quantum_info->pad;
2064 for (x=0; x < (ssize_t) number_pixels; x++)
2066 pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
2067 q=PopShortPixel(endian,pixel,q);
2069 q+=quantum_info->pad;
2075 register unsigned int
2078 if (quantum_info->format == FloatingPointQuantumFormat)
2080 for (x=0; x < (ssize_t) number_pixels; x++)
2082 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
2084 q+=quantum_info->pad;
2088 for (x=0; x < (ssize_t) number_pixels; x++)
2090 pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
2091 q=PopLongPixel(endian,pixel,q);
2093 q+=quantum_info->pad;
2099 if (quantum_info->format == FloatingPointQuantumFormat)
2101 for (x=0; x < (ssize_t) number_pixels; x++)
2103 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
2105 q+=quantum_info->pad;
2112 range=GetQuantumRange(image->depth);
2113 for (x=0; x < (ssize_t) number_pixels; x++)
2115 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2116 p->opacity,range),q);
2118 q+=quantum_info->pad;
2127 if (image->colorspace != CMYKColorspace)
2129 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2130 "ColorSeparatedImageRequired","`%s'",image->filename);
2133 switch (quantum_info->depth)
2137 register unsigned char
2140 for (x=0; x < (ssize_t) number_pixels; x++)
2142 pixel=ScaleQuantumToChar(indexes[x]);
2143 q=PopCharPixel(pixel,q);
2145 q+=quantum_info->pad;
2151 register unsigned short
2154 if (quantum_info->format == FloatingPointQuantumFormat)
2156 for (x=0; x < (ssize_t) number_pixels; x++)
2158 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2159 q=PopShortPixel(endian,pixel,q);
2161 q+=quantum_info->pad;
2165 for (x=0; x < (ssize_t) number_pixels; x++)
2167 pixel=ScaleQuantumToShort(indexes[x]);
2168 q=PopShortPixel(endian,pixel,q);
2170 q+=quantum_info->pad;
2176 register unsigned int
2179 if (quantum_info->format == FloatingPointQuantumFormat)
2181 for (x=0; x < (ssize_t) number_pixels; x++)
2183 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2185 q+=quantum_info->pad;
2189 for (x=0; x < (ssize_t) number_pixels; x++)
2191 pixel=ScaleQuantumToLong(indexes[x]);
2192 q=PopLongPixel(endian,pixel,q);
2194 q+=quantum_info->pad;
2200 if (quantum_info->format == FloatingPointQuantumFormat)
2202 for (x=0; x < (ssize_t) number_pixels; x++)
2204 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2206 q+=quantum_info->pad;
2213 range=GetQuantumRange(image->depth);
2214 for (x=0; x < (ssize_t) number_pixels; x++)
2216 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2217 (Quantum) indexes[x],range),q);
2219 q+=quantum_info->pad;
2229 switch (quantum_info->depth)
2233 for (x=0; x < (ssize_t) number_pixels; x++)
2235 q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
2236 q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
2237 q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
2239 q+=quantum_info->pad;
2245 register unsigned int
2248 range=GetQuantumRange(image->depth);
2249 if (quantum_info->pack == MagickFalse)
2251 for (x=0; x < (ssize_t) number_pixels; x++)
2253 pixel=(unsigned int) (ScaleQuantumToAny(p->red,range) << 22 |
2254 ScaleQuantumToAny(p->green,range) << 12 |
2255 ScaleQuantumToAny(p->blue,range) << 2);
2256 q=PopLongPixel(endian,pixel,q);
2258 q+=quantum_info->pad;
2262 if (quantum_info->quantum == 32UL)
2264 for (x=0; x < (ssize_t) number_pixels; x++)
2266 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2267 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2268 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2269 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2270 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2271 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2273 q+=quantum_info->pad;
2277 for (x=0; x < (ssize_t) number_pixels; x++)
2279 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2280 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2281 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2282 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2283 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2284 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2286 q+=quantum_info->pad;
2292 register unsigned int
2295 range=GetQuantumRange(image->depth);
2296 if (quantum_info->pack == MagickFalse)
2298 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
2305 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2310 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2315 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2320 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2326 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2331 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2336 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2341 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2342 q+=quantum_info->pad;
2344 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
2346 switch ((x+bit) % 3)
2351 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2356 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2361 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2366 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2367 q+=quantum_info->pad;
2373 if (quantum_info->quantum == 32UL)
2375 for (x=0; x < (ssize_t) number_pixels; x++)
2377 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2378 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2379 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2380 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2381 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2382 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2384 q+=quantum_info->pad;
2388 for (x=0; x < (ssize_t) number_pixels; x++)
2390 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2391 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2392 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2393 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2394 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2395 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2397 q+=quantum_info->pad;
2403 register unsigned short
2406 if (quantum_info->format == FloatingPointQuantumFormat)
2408 for (x=0; x < (ssize_t) number_pixels; x++)
2410 pixel=SinglePrecisionToHalf(QuantumScale*
2411 GetRedPixelComponent(p));
2412 q=PopShortPixel(endian,pixel,q);
2413 pixel=SinglePrecisionToHalf(QuantumScale*
2414 GetGreenPixelComponent(p));
2415 q=PopShortPixel(endian,pixel,q);
2416 pixel=SinglePrecisionToHalf(QuantumScale*
2417 GetBluePixelComponent(p));
2418 q=PopShortPixel(endian,pixel,q);
2420 q+=quantum_info->pad;
2424 for (x=0; x < (ssize_t) number_pixels; x++)
2426 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2427 q=PopShortPixel(endian,pixel,q);
2428 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2429 q=PopShortPixel(endian,pixel,q);
2430 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2431 q=PopShortPixel(endian,pixel,q);
2433 q+=quantum_info->pad;
2439 register unsigned int
2442 if (quantum_info->format == FloatingPointQuantumFormat)
2444 for (x=0; x < (ssize_t) number_pixels; x++)
2446 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2447 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2448 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2450 q+=quantum_info->pad;
2454 for (x=0; x < (ssize_t) number_pixels; x++)
2456 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2457 q=PopLongPixel(endian,pixel,q);
2458 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2459 q=PopLongPixel(endian,pixel,q);
2460 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2461 q=PopLongPixel(endian,pixel,q);
2463 q+=quantum_info->pad;
2469 if (quantum_info->format == FloatingPointQuantumFormat)
2471 for (x=0; x < (ssize_t) number_pixels; x++)
2473 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2474 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2475 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2477 q+=quantum_info->pad;
2484 range=GetQuantumRange(image->depth);
2485 for (x=0; x < (ssize_t) number_pixels; x++)
2487 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2489 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2491 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2494 q+=quantum_info->pad;
2505 switch (quantum_info->depth)
2509 register unsigned char
2512 for (x=0; x < (ssize_t) number_pixels; x++)
2514 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2515 q=PopCharPixel(pixel,q);
2516 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2517 q=PopCharPixel(pixel,q);
2518 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2519 q=PopCharPixel(pixel,q);
2520 pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
2521 q=PopCharPixel(pixel,q);
2523 q+=quantum_info->pad;
2529 register unsigned int
2532 range=GetQuantumRange(image->depth);
2533 if (quantum_info->pack == MagickFalse)
2547 for (x=0; x < (ssize_t) number_pixels; x++)
2549 for (i=0; i < 4; i++)
2553 case 0: quantum=p->red; break;
2554 case 1: quantum=p->green; break;
2555 case 2: quantum=p->blue; break;
2556 case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
2562 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2568 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2574 pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2576 q=PopLongPixel(endian,pixel,q);
2584 q+=quantum_info->pad;
2588 if (quantum_info->quantum == 32UL)
2590 for (x=0; x < (ssize_t) number_pixels; x++)
2592 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2593 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2594 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2595 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2596 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2597 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2598 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
2600 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2602 q+=quantum_info->pad;
2606 for (x=0; x < (ssize_t) number_pixels; x++)
2608 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2609 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2610 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2611 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2612 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2613 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2614 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
2616 q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2618 q+=quantum_info->pad;
2624 register unsigned short
2627 if (quantum_info->format == FloatingPointQuantumFormat)
2629 for (x=0; x < (ssize_t) number_pixels; x++)
2631 pixel=SinglePrecisionToHalf(QuantumScale*
2632 GetRedPixelComponent(p));
2633 q=PopShortPixel(endian,pixel,q);
2634 pixel=SinglePrecisionToHalf(QuantumScale*
2635 GetGreenPixelComponent(p));
2636 q=PopShortPixel(endian,pixel,q);
2637 pixel=SinglePrecisionToHalf(QuantumScale*
2638 GetBluePixelComponent(p));
2639 q=PopShortPixel(endian,pixel,q);
2640 pixel=SinglePrecisionToHalf(QuantumScale*
2641 GetAlphaPixelComponent(p));
2642 q=PopShortPixel(endian,pixel,q);
2644 q+=quantum_info->pad;
2648 for (x=0; x < (ssize_t) number_pixels; x++)
2650 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2651 q=PopShortPixel(endian,pixel,q);
2652 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2653 q=PopShortPixel(endian,pixel,q);
2654 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2655 q=PopShortPixel(endian,pixel,q);
2656 pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
2657 q=PopShortPixel(endian,pixel,q);
2659 q+=quantum_info->pad;
2665 register unsigned int
2668 if (quantum_info->format == FloatingPointQuantumFormat)
2670 for (x=0; x < (ssize_t) number_pixels; x++)
2675 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2676 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2677 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2678 pixel=(float) GetAlphaPixelComponent(p);
2679 q=PopFloatPixel(&quantum_state,pixel,q);
2681 q+=quantum_info->pad;
2685 for (x=0; x < (ssize_t) number_pixels; x++)
2687 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2688 q=PopLongPixel(endian,pixel,q);
2689 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2690 q=PopLongPixel(endian,pixel,q);
2691 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2692 q=PopLongPixel(endian,pixel,q);
2693 pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
2694 q=PopLongPixel(endian,pixel,q);
2696 q+=quantum_info->pad;
2702 if (quantum_info->format == FloatingPointQuantumFormat)
2707 for (x=0; x < (ssize_t) number_pixels; x++)
2709 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2710 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2711 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2712 pixel=(double) GetAlphaPixelComponent(p);
2713 q=PopDoublePixel(&quantum_state,pixel,q);
2715 q+=quantum_info->pad;
2722 range=GetQuantumRange(image->depth);
2723 for (x=0; x < (ssize_t) number_pixels; x++)
2725 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2726 GetRedPixelComponent(p),range),q);
2727 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2728 GetGreenPixelComponent(p),range),q);
2729 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2730 GetBluePixelComponent(p),range),q);
2731 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2732 (Quantum) GetAlphaPixelComponent(p),range),q);
2734 q+=quantum_info->pad;
2743 if (image->colorspace != CMYKColorspace)
2745 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2746 "ColorSeparatedImageRequired","`%s'",image->filename);
2749 switch (quantum_info->depth)
2753 register unsigned char
2756 for (x=0; x < (ssize_t) number_pixels; x++)
2758 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2759 q=PopCharPixel(pixel,q);
2760 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2761 q=PopCharPixel(pixel,q);
2762 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2763 q=PopCharPixel(pixel,q);
2764 pixel=ScaleQuantumToChar(indexes[x]);
2765 q=PopCharPixel(pixel,q);
2767 q+=quantum_info->pad;
2773 register unsigned short
2776 if (quantum_info->format == FloatingPointQuantumFormat)
2778 for (x=0; x < (ssize_t) number_pixels; x++)
2780 pixel=SinglePrecisionToHalf(QuantumScale*
2781 GetRedPixelComponent(p));
2782 q=PopShortPixel(endian,pixel,q);
2783 pixel=SinglePrecisionToHalf(QuantumScale*
2784 GetGreenPixelComponent(p));
2785 q=PopShortPixel(endian,pixel,q);
2786 pixel=SinglePrecisionToHalf(QuantumScale*
2787 GetBluePixelComponent(p));
2788 q=PopShortPixel(endian,pixel,q);
2789 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2790 q=PopShortPixel(endian,pixel,q);
2792 q+=quantum_info->pad;
2796 for (x=0; x < (ssize_t) number_pixels; x++)
2798 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2799 q=PopShortPixel(endian,pixel,q);
2800 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2801 q=PopShortPixel(endian,pixel,q);
2802 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2803 q=PopShortPixel(endian,pixel,q);
2804 pixel=ScaleQuantumToShort(indexes[x]);
2805 q=PopShortPixel(endian,pixel,q);
2807 q+=quantum_info->pad;
2813 register unsigned int
2816 if (quantum_info->format == FloatingPointQuantumFormat)
2818 for (x=0; x < (ssize_t) number_pixels; x++)
2820 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2821 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2822 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2823 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2825 q+=quantum_info->pad;
2829 for (x=0; x < (ssize_t) number_pixels; x++)
2831 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2832 q=PopLongPixel(endian,pixel,q);
2833 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2834 q=PopLongPixel(endian,pixel,q);
2835 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2836 q=PopLongPixel(endian,pixel,q);
2837 pixel=ScaleQuantumToLong(indexes[x]);
2838 q=PopLongPixel(endian,pixel,q);
2840 q+=quantum_info->pad;
2846 if (quantum_info->format == FloatingPointQuantumFormat)
2848 for (x=0; x < (ssize_t) number_pixels; x++)
2850 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2851 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2852 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2853 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2855 q+=quantum_info->pad;
2862 range=GetQuantumRange(image->depth);
2863 for (x=0; x < (ssize_t) number_pixels; x++)
2865 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2867 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2869 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2871 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2872 indexes[x],range),q);
2874 q+=quantum_info->pad;
2884 if (image->colorspace != CMYKColorspace)
2886 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2887 "ColorSeparatedImageRequired","`%s'",image->filename);
2890 switch (quantum_info->depth)
2894 register unsigned char
2897 for (x=0; x < (ssize_t) number_pixels; x++)
2899 pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2900 q=PopCharPixel(pixel,q);
2901 pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2902 q=PopCharPixel(pixel,q);
2903 pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2904 q=PopCharPixel(pixel,q);
2905 pixel=ScaleQuantumToChar(indexes[x]);
2906 q=PopCharPixel(pixel,q);
2907 pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2908 GetOpacityPixelComponent(p)));
2909 q=PopCharPixel(pixel,q);
2911 q+=quantum_info->pad;
2917 register unsigned short
2920 if (quantum_info->format == FloatingPointQuantumFormat)
2922 for (x=0; x < (ssize_t) number_pixels; x++)
2924 pixel=SinglePrecisionToHalf(QuantumScale*
2925 GetRedPixelComponent(p));
2926 q=PopShortPixel(endian,pixel,q);
2927 pixel=SinglePrecisionToHalf(QuantumScale*
2928 GetGreenPixelComponent(p));
2929 q=PopShortPixel(endian,pixel,q);
2930 pixel=SinglePrecisionToHalf(QuantumScale*
2931 GetBluePixelComponent(p));
2932 q=PopShortPixel(endian,pixel,q);
2933 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2934 q=PopShortPixel(endian,pixel,q);
2935 pixel=SinglePrecisionToHalf(QuantumScale*
2936 GetAlphaPixelComponent(p));
2937 q=PopShortPixel(endian,pixel,q);
2939 q+=quantum_info->pad;
2943 for (x=0; x < (ssize_t) number_pixels; x++)
2945 pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2946 q=PopShortPixel(endian,pixel,q);
2947 pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2948 q=PopShortPixel(endian,pixel,q);
2949 pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2950 q=PopShortPixel(endian,pixel,q);
2951 pixel=ScaleQuantumToShort(indexes[x]);
2952 q=PopShortPixel(endian,pixel,q);
2953 pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2954 GetOpacityPixelComponent(p)));
2955 q=PopShortPixel(endian,pixel,q);
2957 q+=quantum_info->pad;
2963 register unsigned int
2966 if (quantum_info->format == FloatingPointQuantumFormat)
2968 for (x=0; x < (ssize_t) number_pixels; x++)
2973 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2974 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2975 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2976 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2977 pixel=(float) (GetAlphaPixelComponent(p));
2978 q=PopFloatPixel(&quantum_state,pixel,q);
2980 q+=quantum_info->pad;
2984 for (x=0; x < (ssize_t) number_pixels; x++)
2986 pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2987 q=PopLongPixel(endian,pixel,q);
2988 pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2989 q=PopLongPixel(endian,pixel,q);
2990 pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2991 q=PopLongPixel(endian,pixel,q);
2992 pixel=ScaleQuantumToLong(indexes[x]);
2993 q=PopLongPixel(endian,pixel,q);
2994 pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2995 GetOpacityPixelComponent(p)));
2996 q=PopLongPixel(endian,pixel,q);
2998 q+=quantum_info->pad;
3004 if (quantum_info->format == FloatingPointQuantumFormat)
3009 for (x=0; x < (ssize_t) number_pixels; x++)
3011 q=PopDoublePixel(&quantum_state,(double) p->red,q);
3012 q=PopDoublePixel(&quantum_state,(double) p->green,q);
3013 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
3014 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
3015 pixel=(double) (GetAlphaPixelComponent(p));
3016 q=PopDoublePixel(&quantum_state,pixel,q);
3018 q+=quantum_info->pad;
3025 range=GetQuantumRange(image->depth);
3026 for (x=0; x < (ssize_t) number_pixels; x++)
3028 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3030 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3032 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3034 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3035 indexes[x],range),q);
3036 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3037 p->opacity,range),q);
3039 q+=quantum_info->pad;
3057 register unsigned int
3065 range=GetQuantumRange(image->depth);
3066 switch (quantum_info->depth)
3070 if (quantum_info->pack == MagickFalse)
3072 for (x=0; x < (ssize_t) number_pixels; x+=2)
3074 for (i=0; i < 4; i++)
3080 quantum=GetRedPixelComponent(p);
3085 quantum=GetGreenPixelComponent(p);
3090 quantum=GetBluePixelComponent(p);
3094 cbcr[i]=(Quantum) quantum;
3097 pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 |
3098 (size_t) (cbcr[0]) << 12 |
3099 (size_t) (cbcr[2]) << 2);
3100 q=PopLongPixel(endian,pixel,q);
3102 pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 |
3103 (size_t) (cbcr[0]) << 12 |
3104 (size_t) (cbcr[2]) << 2);
3105 q=PopLongPixel(endian,pixel,q);
3107 q+=quantum_info->pad;
3115 for (x=0; x < (ssize_t) number_pixels; x+=2)
3117 for (i=0; i < 4; i++)
3123 quantum=GetRedPixelComponent(p);
3128 quantum=GetGreenPixelComponent(p);
3133 quantum=GetBluePixelComponent(p);
3137 cbcr[i]=(Quantum) quantum;
3140 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3142 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3144 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3147 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3149 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3151 q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3154 q+=quantum_info->pad;
3164 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3169 register PixelPacket
3172 q=GetAuthenticPixelQueue(image);
3173 if (image_view != (CacheView *) NULL)
3174 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3175 for (x=0; x < (ssize_t) number_pixels; x++)
3183 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
3184 (quantum_type == BGROQuantum))
3186 register PixelPacket
3189 q=GetAuthenticPixelQueue(image);
3190 if (image_view != (CacheView *) NULL)
3191 q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3192 for (x=0; x < (ssize_t) number_pixels; x++)
3194 q->opacity=(Quantum) GetAlphaPixelComponent(q);