2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % QQQ U U AAA N N TTTTT U U M M %
7 % Q Q U U A A NN N T U U MM MM %
8 % Q Q U U AAAAA N N N T U U M M M %
9 % Q QQ U U A A N NN T U U M M %
10 % QQQQ UUU A A N N T UUU M M %
12 % IIIII M M PPPP OOO RRRR TTTTT %
13 % I MM MM P P O O R R T %
14 % I M M M PPPP O O RRRR T %
16 % IIIII M M P OOO R R T %
18 % MagickCore Methods to Import Quantum Pixels %
25 % Copyright 1999-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 "MagickCore/studio.h"
48 #include "MagickCore/property.h"
49 #include "MagickCore/blob.h"
50 #include "MagickCore/blob-private.h"
51 #include "MagickCore/color-private.h"
52 #include "MagickCore/exception.h"
53 #include "MagickCore/exception-private.h"
54 #include "MagickCore/cache.h"
55 #include "MagickCore/constitute.h"
56 #include "MagickCore/delegate.h"
57 #include "MagickCore/geometry.h"
58 #include "MagickCore/list.h"
59 #include "MagickCore/magick.h"
60 #include "MagickCore/memory_.h"
61 #include "MagickCore/monitor.h"
62 #include "MagickCore/option.h"
63 #include "MagickCore/pixel.h"
64 #include "MagickCore/pixel-accessor.h"
65 #include "MagickCore/quantum.h"
66 #include "MagickCore/quantum-private.h"
67 #include "MagickCore/resource_.h"
68 #include "MagickCore/semaphore.h"
69 #include "MagickCore/statistic.h"
70 #include "MagickCore/stream.h"
71 #include "MagickCore/string_.h"
72 #include "MagickCore/utility.h"
75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
79 % I m p o r t Q u a n t u m P i x e l s %
83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
85 % ImportQuantumPixels() transfers one or more pixel components from a user
86 % supplied buffer into the image pixel cache of an image. The pixels are
87 % expected in network byte order. It returns MagickTrue if the pixels are
88 % successfully transferred, otherwise MagickFalse.
90 % The format of the ImportQuantumPixels method is:
92 % size_t ImportQuantumPixels(Image *image,CacheView *image_view,
93 % const QuantumInfo *quantum_info,const QuantumType quantum_type,
94 % const 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 (red, green,
105 % blue, opacity, RGB, or RGBA).
107 % o pixels: The pixel components are transferred from this buffer.
109 % o exception: return any errors or warnings in this structure.
113 static inline Quantum PushColormapIndex(Image *image,
114 const size_t index,MagickBooleanType *range_exception)
116 if (index < image->colors)
117 return((Quantum) index);
118 *range_exception=MagickTrue;
122 static inline const unsigned char *PushDoublePixel(
123 const QuantumState *quantum_state,const unsigned char *pixels,double *pixel)
131 if (quantum_state->endian != LSBEndian)
133 quantum[7]=(*pixels++);
134 quantum[6]=(*pixels++);
135 quantum[5]=(*pixels++);
136 quantum[5]=(*pixels++);
137 quantum[3]=(*pixels++);
138 quantum[2]=(*pixels++);
139 quantum[1]=(*pixels++);
140 quantum[0]=(*pixels++);
141 p=(double *) quantum;
143 *pixel-=quantum_state->minimum;
144 *pixel*=quantum_state->scale;
147 quantum[0]=(*pixels++);
148 quantum[1]=(*pixels++);
149 quantum[2]=(*pixels++);
150 quantum[3]=(*pixels++);
151 quantum[4]=(*pixels++);
152 quantum[5]=(*pixels++);
153 quantum[6]=(*pixels++);
154 quantum[7]=(*pixels++);
155 p=(double *) quantum;
157 *pixel-=quantum_state->minimum;
158 *pixel*=quantum_state->scale;
162 static inline const unsigned char *PushFloatPixel(
163 const QuantumState *quantum_state,const unsigned char *pixels,float *pixel)
171 if (quantum_state->endian != LSBEndian)
173 quantum[3]=(*pixels++);
174 quantum[2]=(*pixels++);
175 quantum[1]=(*pixels++);
176 quantum[0]=(*pixels++);
179 *pixel-=quantum_state->minimum;
180 *pixel*=quantum_state->scale;
183 quantum[0]=(*pixels++);
184 quantum[1]=(*pixels++);
185 quantum[2]=(*pixels++);
186 quantum[3]=(*pixels++);
189 *pixel-=quantum_state->minimum;
190 *pixel*=quantum_state->scale;
194 static inline const unsigned char *PushQuantumPixel(
195 QuantumState *quantum_state,const size_t depth,
196 const unsigned char *pixels,unsigned int *quantum)
204 *quantum=(QuantumAny) 0;
205 for (i=(ssize_t) depth; i > 0L; )
207 if (quantum_state->bits == 0UL)
209 quantum_state->pixel=(*pixels++);
210 quantum_state->bits=8UL;
212 quantum_bits=(size_t) i;
213 if (quantum_bits > quantum_state->bits)
214 quantum_bits=quantum_state->bits;
215 i-=(ssize_t) quantum_bits;
216 quantum_state->bits-=quantum_bits;
217 *quantum=(unsigned int) ((*quantum << quantum_bits) |
218 ((quantum_state->pixel >> quantum_state->bits) &~ ((~0UL) <<
224 static inline const unsigned char *PushQuantumLongPixel(
225 QuantumState *quantum_state,const size_t depth,
226 const unsigned char *pixels,unsigned int *quantum)
235 for (i=(ssize_t) depth; i > 0; )
237 if (quantum_state->bits == 0)
239 pixels=PushLongPixel(quantum_state->endian,pixels,
240 &quantum_state->pixel);
241 quantum_state->bits=32U;
243 quantum_bits=(size_t) i;
244 if (quantum_bits > quantum_state->bits)
245 quantum_bits=quantum_state->bits;
246 *quantum|=(((quantum_state->pixel >> (32U-quantum_state->bits)) &
247 quantum_state->mask[quantum_bits]) << (depth-i));
248 i-=(ssize_t) quantum_bits;
249 quantum_state->bits-=quantum_bits;
254 MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
255 const QuantumInfo *quantum_info,const QuantumType quantum_type,
256 const unsigned char *pixels,ExceptionInfo *exception)
270 register const unsigned char
289 assert(image != (Image *) NULL);
290 assert(image->signature == MagickSignature);
291 if (image->debug != MagickFalse)
292 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
293 assert(quantum_info != (QuantumInfo *) NULL);
294 assert(quantum_info->signature == MagickSignature);
295 if (pixels == (const unsigned char *) NULL)
296 pixels=GetQuantumPixels(quantum_info);
299 if (image_view == (CacheView *) NULL)
301 number_pixels=GetImageExtent(image);
302 q=GetAuthenticPixelQueue(image);
303 channels=GetPixelChannels(image);
307 number_pixels=GetCacheViewExtent(image_view);
308 q=GetCacheViewAuthenticPixelQueue(image_view);
309 channels=GetPixelChannels(image);
311 InitializeQuantumState(quantum_info,image->endian,&quantum_state);
312 extent=GetQuantumExtent(image,quantum_info,quantum_type);
313 endian=quantum_state.endian;
314 switch (quantum_type)
321 if (image->storage_class != PseudoClass)
323 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
324 "ColormappedImageRequired","`%s'",image->filename);
327 range_exception=MagickFalse;
328 switch (quantum_info->depth)
332 register unsigned char
335 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
337 for (bit=0; bit < 8; bit++)
339 if (quantum_info->min_is_white == MagickFalse)
340 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
343 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
345 SetPixelIndex(image,PushColormapIndex(image,pixel,
346 &range_exception),q);
347 SetPixelPacket(image,image->colormap+(ssize_t)
348 GetPixelIndex(image,q),q);
353 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
355 if (quantum_info->min_is_white == MagickFalse)
356 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
359 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
361 SetPixelIndex(image,PushColormapIndex(image,pixel,
362 &range_exception),q);
363 SetPixelPacket(image,image->colormap+(ssize_t)
364 GetPixelIndex(image,q),q);
371 register unsigned char
374 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
376 pixel=(unsigned char) ((*p >> 4) & 0xf);
377 SetPixelIndex(image,PushColormapIndex(image,pixel,
378 &range_exception),q);
379 SetPixelPacket(image,image->colormap+(ssize_t)
380 GetPixelIndex(image,q),q);
382 pixel=(unsigned char) ((*p) & 0xf);
383 SetPixelIndex(image,PushColormapIndex(image,pixel,
384 &range_exception),q);
385 SetPixelPacket(image,image->colormap+(ssize_t)
386 GetPixelIndex(image,q),q);
390 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
392 pixel=(unsigned char) ((*p++ >> 4) & 0xf);
393 SetPixelIndex(image,PushColormapIndex(image,pixel,
394 &range_exception),q);
395 SetPixelPacket(image,image->colormap+(ssize_t)
396 GetPixelIndex(image,q),q);
406 for (x=0; x < (ssize_t) number_pixels; x++)
408 p=PushCharPixel(p,&pixel);
409 SetPixelIndex(image,PushColormapIndex(image,pixel,
410 &range_exception),q);
411 SetPixelPacket(image,image->colormap+(ssize_t)
412 GetPixelIndex(image,q),q);
413 p+=quantum_info->pad;
423 if (quantum_info->format == FloatingPointQuantumFormat)
425 for (x=0; x < (ssize_t) number_pixels; x++)
427 p=PushShortPixel(endian,p,&pixel);
428 SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
429 (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
430 &range_exception),q);
431 SetPixelPacket(image,image->colormap+(ssize_t)
432 GetPixelIndex(image,q),q);
433 p+=quantum_info->pad;
438 for (x=0; x < (ssize_t) number_pixels; x++)
440 p=PushShortPixel(endian,p,&pixel);
441 SetPixelIndex(image,PushColormapIndex(image,pixel,
442 &range_exception),q);
443 SetPixelPacket(image,image->colormap+(ssize_t)
444 GetPixelIndex(image,q),q);
445 p+=quantum_info->pad;
455 if (quantum_info->format == FloatingPointQuantumFormat)
460 for (x=0; x < (ssize_t) number_pixels; x++)
462 p=PushFloatPixel(&quantum_state,p,&pixel);
463 SetPixelIndex(image,PushColormapIndex(image,
464 ClampToQuantum(pixel),&range_exception),q);
465 SetPixelPacket(image,image->colormap+(ssize_t)
466 GetPixelIndex(image,q),q);
467 p+=quantum_info->pad;
472 for (x=0; x < (ssize_t) number_pixels; x++)
474 p=PushLongPixel(endian,p,&pixel);
475 SetPixelIndex(image,PushColormapIndex(image,pixel,
476 &range_exception),q);
477 SetPixelPacket(image,image->colormap+(ssize_t)
478 GetPixelIndex(image,q),q);
479 p+=quantum_info->pad;
486 if (quantum_info->format == FloatingPointQuantumFormat)
491 for (x=0; x < (ssize_t) number_pixels; x++)
493 p=PushDoublePixel(&quantum_state,p,&pixel);
494 SetPixelIndex(image,PushColormapIndex(image,
495 ClampToQuantum(pixel),&range_exception),q);
496 SetPixelPacket(image,image->colormap+(ssize_t)
497 GetPixelIndex(image,q),q);
498 p+=quantum_info->pad;
506 for (x=0; x < (ssize_t) number_pixels; x++)
508 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
509 SetPixelIndex(image,PushColormapIndex(image,pixel,
510 &range_exception),q);
511 SetPixelPacket(image,image->colormap+(ssize_t)
512 GetPixelIndex(image,q),q);
513 p+=quantum_info->pad;
519 if (range_exception != MagickFalse)
520 (void) ThrowMagickException(exception,GetMagickModule(),
521 CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
524 case IndexAlphaQuantum:
529 if (image->storage_class != PseudoClass)
531 (void) ThrowMagickException(exception,GetMagickModule(),
532 ImageError,"ColormappedImageRequired","`%s'",image->filename);
535 range_exception=MagickFalse;
536 switch (quantum_info->depth)
540 register unsigned char
543 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
545 for (bit=0; bit < 8; bit+=2)
547 if (quantum_info->min_is_white == MagickFalse)
548 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
551 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
553 SetPixelRed(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
554 SetPixelGreen(image,GetPixelRed(image,q),q);
555 SetPixelBlue(image,GetPixelRed(image,q),q);
556 SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
557 (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
558 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
562 if ((number_pixels % 4) != 0)
563 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
565 if (quantum_info->min_is_white == MagickFalse)
566 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
569 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
571 SetPixelIndex(image,(Quantum) (pixel == 0 ? 0 : 1),q);
572 SetPixelRed(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
573 SetPixelGreen(image,GetPixelRed(image,q),q);
574 SetPixelBlue(image,GetPixelRed(image,q),q);
575 SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
576 (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
583 register unsigned char
586 range=GetQuantumRange(image->depth);
587 for (x=0; x < (ssize_t) number_pixels; x++)
589 pixel=(unsigned char) ((*p >> 4) & 0xf);
590 SetPixelIndex(image,PushColormapIndex(image,pixel,
591 &range_exception),q);
592 SetPixelPacket(image,image->colormap+(ssize_t)
593 GetPixelIndex(image,q),q);
594 pixel=(unsigned char) ((*p) & 0xf);
595 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
606 for (x=0; x < (ssize_t) number_pixels; x++)
608 p=PushCharPixel(p,&pixel);
609 SetPixelIndex(image,PushColormapIndex(image,pixel,
610 &range_exception),q);
611 SetPixelPacket(image,image->colormap+(ssize_t)
612 GetPixelIndex(image,q),q);
613 p=PushCharPixel(p,&pixel);
614 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
615 p+=quantum_info->pad;
625 if (quantum_info->format == FloatingPointQuantumFormat)
627 for (x=0; x < (ssize_t) number_pixels; x++)
629 p=PushShortPixel(endian,p,&pixel);
630 SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
631 (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
632 &range_exception),q);
633 SetPixelPacket(image,image->colormap+(ssize_t)
634 GetPixelIndex(image,q),q);
635 p=PushShortPixel(endian,p,&pixel);
636 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
637 QuantumRange*HalfToSinglePrecision(pixel)),q);
638 p+=quantum_info->pad;
643 for (x=0; x < (ssize_t) number_pixels; x++)
645 p=PushShortPixel(endian,p,&pixel);
646 SetPixelIndex(image,PushColormapIndex(image,pixel,
647 &range_exception),q);
648 SetPixelPacket(image,image->colormap+(ssize_t)
649 GetPixelIndex(image,q),q);
650 p=PushShortPixel(endian,p,&pixel);
651 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
652 p+=quantum_info->pad;
662 if (quantum_info->format == FloatingPointQuantumFormat)
667 for (x=0; x < (ssize_t) number_pixels; x++)
669 p=PushFloatPixel(&quantum_state,p,&pixel);
670 SetPixelIndex(image,PushColormapIndex(image,
671 ClampToQuantum(pixel),&range_exception),q);
672 SetPixelPacket(image,image->colormap+(ssize_t)
673 GetPixelIndex(image,q),q);
674 p=PushFloatPixel(&quantum_state,p,&pixel);
675 SetPixelAlpha(image,ClampToQuantum(pixel),q);
676 p+=quantum_info->pad;
681 for (x=0; x < (ssize_t) number_pixels; x++)
683 p=PushLongPixel(endian,p,&pixel);
684 SetPixelIndex(image,PushColormapIndex(image,pixel,
685 &range_exception),q);
686 SetPixelPacket(image,image->colormap+(ssize_t)
687 GetPixelIndex(image,q),q);
688 p=PushLongPixel(endian,p,&pixel);
689 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
690 p+=quantum_info->pad;
697 if (quantum_info->format == FloatingPointQuantumFormat)
702 for (x=0; x < (ssize_t) number_pixels; x++)
704 p=PushDoublePixel(&quantum_state,p,&pixel);
705 SetPixelIndex(image,PushColormapIndex(image,
706 ClampToQuantum(pixel),&range_exception),q);
707 SetPixelPacket(image,image->colormap+(ssize_t)
708 GetPixelIndex(image,q),q);
709 p=PushDoublePixel(&quantum_state,p,&pixel);
710 SetPixelAlpha(image,ClampToQuantum(pixel),q);
711 p+=quantum_info->pad;
719 range=GetQuantumRange(image->depth);
720 for (x=0; x < (ssize_t) number_pixels; x++)
722 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
723 SetPixelIndex(image,PushColormapIndex(image,pixel,
724 &range_exception),q);
725 SetPixelPacket(image,image->colormap+(ssize_t)
726 GetPixelIndex(image,q),q);
727 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
728 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
729 p+=quantum_info->pad;
735 if (range_exception != MagickFalse)
736 (void) ThrowMagickException(exception,GetMagickModule(),
737 CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
742 switch (quantum_info->depth)
749 for (x=0; x < (ssize_t) number_pixels; x++)
751 p=PushCharPixel(p,&pixel);
752 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
753 p=PushCharPixel(p,&pixel);
754 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
755 p=PushCharPixel(p,&pixel);
756 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
757 SetPixelAlpha(image,OpaqueAlpha,q);
758 p+=quantum_info->pad;
765 range=GetQuantumRange(image->depth);
766 if (quantum_info->pack == MagickFalse)
768 for (x=0; x < (ssize_t) number_pixels; x++)
770 p=PushLongPixel(endian,p,&pixel);
771 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
773 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
775 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
777 p+=quantum_info->pad;
782 if (quantum_info->quantum == 32U)
784 for (x=0; x < (ssize_t) number_pixels; x++)
786 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
787 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
788 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
789 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
790 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
791 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
796 for (x=0; x < (ssize_t) number_pixels; x++)
798 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
799 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
800 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
801 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
802 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
803 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
810 range=GetQuantumRange(image->depth);
811 if (quantum_info->pack == MagickFalse)
816 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
818 p=PushShortPixel(endian,p,&pixel);
824 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
825 (pixel >> 4),range),q);
830 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
831 (pixel >> 4),range),q);
836 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
837 (pixel >> 4),range),q);
842 p=PushShortPixel(endian,p,&pixel);
848 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
849 (pixel >> 4),range),q);
854 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
855 (pixel >> 4),range),q);
860 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
861 (pixel >> 4),range),q);
866 p+=quantum_info->pad;
868 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
870 p=PushShortPixel(endian,p,&pixel);
876 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
877 (pixel >> 4),range),q);
882 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
883 (pixel >> 4),range),q);
888 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
889 (pixel >> 4),range),q);
894 p+=quantum_info->pad;
900 if (quantum_info->quantum == 32U)
902 for (x=0; x < (ssize_t) number_pixels; x++)
904 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
905 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
906 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
907 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
908 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
909 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
914 for (x=0; x < (ssize_t) number_pixels; x++)
916 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
917 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
918 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
919 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
920 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
921 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
931 if (quantum_info->format == FloatingPointQuantumFormat)
933 for (x=0; x < (ssize_t) number_pixels; x++)
935 p=PushShortPixel(endian,p,&pixel);
936 SetPixelRed(image,ClampToQuantum((MagickRealType)
937 QuantumRange*HalfToSinglePrecision(pixel)),q);
938 p=PushShortPixel(endian,p,&pixel);
939 SetPixelGreen(image,ClampToQuantum((MagickRealType)
940 QuantumRange*HalfToSinglePrecision(pixel)),q);
941 p=PushShortPixel(endian,p,&pixel);
942 SetPixelBlue(image,ClampToQuantum((MagickRealType)
943 QuantumRange*HalfToSinglePrecision(pixel)),q);
944 p+=quantum_info->pad;
949 for (x=0; x < (ssize_t) number_pixels; x++)
951 p=PushShortPixel(endian,p,&pixel);
952 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
953 p=PushShortPixel(endian,p,&pixel);
954 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
955 p=PushShortPixel(endian,p,&pixel);
956 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
957 p+=quantum_info->pad;
967 if (quantum_info->format == FloatingPointQuantumFormat)
972 for (x=0; x < (ssize_t) number_pixels; x++)
974 p=PushFloatPixel(&quantum_state,p,&pixel);
975 SetPixelRed(image,ClampToQuantum(pixel),q);
976 p=PushFloatPixel(&quantum_state,p,&pixel);
977 SetPixelGreen(image,ClampToQuantum(pixel),q);
978 p=PushFloatPixel(&quantum_state,p,&pixel);
979 SetPixelBlue(image,ClampToQuantum(pixel),q);
980 p+=quantum_info->pad;
985 for (x=0; x < (ssize_t) number_pixels; x++)
987 p=PushLongPixel(endian,p,&pixel);
988 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
989 p=PushLongPixel(endian,p,&pixel);
990 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
991 p=PushLongPixel(endian,p,&pixel);
992 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
993 p+=quantum_info->pad;
1000 if (quantum_info->format == FloatingPointQuantumFormat)
1005 for (x=0; x < (ssize_t) number_pixels; x++)
1007 p=PushDoublePixel(&quantum_state,p,&pixel);
1008 SetPixelRed(image,ClampToQuantum(pixel),q);
1009 p=PushDoublePixel(&quantum_state,p,&pixel);
1010 SetPixelGreen(image,ClampToQuantum(pixel),q);
1011 p=PushDoublePixel(&quantum_state,p,&pixel);
1012 SetPixelBlue(image,ClampToQuantum(pixel),q);
1013 p+=quantum_info->pad;
1021 range=GetQuantumRange(image->depth);
1022 for (x=0; x < (ssize_t) number_pixels; x++)
1024 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1025 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1026 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1027 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1028 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1029 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1040 switch (quantum_info->depth)
1047 for (x=0; x < (ssize_t) number_pixels; x++)
1049 p=PushCharPixel(p,&pixel);
1050 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
1051 p=PushCharPixel(p,&pixel);
1052 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1053 p=PushCharPixel(p,&pixel);
1054 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1055 p=PushCharPixel(p,&pixel);
1056 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
1057 p+=quantum_info->pad;
1065 if (quantum_info->pack == MagickFalse)
1078 for (x=0; x < (ssize_t) number_pixels; x++)
1080 for (i=0; i < 4; i++)
1086 p=PushLongPixel(endian,p,&pixel);
1087 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1088 (((pixel >> 22) & 0x3ff) << 6)));
1093 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1094 (((pixel >> 12) & 0x3ff) << 6)));
1099 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
1100 (((pixel >> 2) & 0x3ff) << 6)));
1106 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
1107 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
1108 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
1109 case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
1113 p+=quantum_info->pad;
1118 for (x=0; x < (ssize_t) number_pixels; x++)
1120 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1121 SetPixelRed(image,ScaleShortToQuantum((unsigned short)
1123 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1124 SetPixelGreen(image,ScaleShortToQuantum((unsigned short)
1126 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1127 SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
1129 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1130 SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
1141 if (quantum_info->format == FloatingPointQuantumFormat)
1143 for (x=0; x < (ssize_t) number_pixels; x++)
1145 p=PushShortPixel(endian,p,&pixel);
1146 SetPixelRed(image,ClampToQuantum((MagickRealType)
1147 QuantumRange*HalfToSinglePrecision(pixel)),q);
1148 p=PushShortPixel(endian,p,&pixel);
1149 SetPixelGreen(image,ClampToQuantum((MagickRealType)
1150 QuantumRange*HalfToSinglePrecision(pixel)),q);
1151 p=PushShortPixel(endian,p,&pixel);
1152 SetPixelBlue(image,ClampToQuantum((MagickRealType)
1153 QuantumRange*HalfToSinglePrecision(pixel)),q);
1154 p=PushShortPixel(endian,p,&pixel);
1155 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
1156 QuantumRange*HalfToSinglePrecision(pixel)),q);
1157 p+=quantum_info->pad;
1162 for (x=0; x < (ssize_t) number_pixels; x++)
1164 p=PushShortPixel(endian,p,&pixel);
1165 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
1166 p=PushShortPixel(endian,p,&pixel);
1167 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1168 p=PushShortPixel(endian,p,&pixel);
1169 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1170 p=PushShortPixel(endian,p,&pixel);
1171 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
1172 p+=quantum_info->pad;
1182 if (quantum_info->format == FloatingPointQuantumFormat)
1187 for (x=0; x < (ssize_t) number_pixels; x++)
1189 p=PushFloatPixel(&quantum_state,p,&pixel);
1190 SetPixelRed(image,ClampToQuantum(pixel),q);
1191 p=PushFloatPixel(&quantum_state,p,&pixel);
1192 SetPixelGreen(image,ClampToQuantum(pixel),q);
1193 p=PushFloatPixel(&quantum_state,p,&pixel);
1194 SetPixelBlue(image,ClampToQuantum(pixel),q);
1195 p=PushFloatPixel(&quantum_state,p,&pixel);
1196 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1197 p+=quantum_info->pad;
1202 for (x=0; x < (ssize_t) number_pixels; x++)
1204 p=PushLongPixel(endian,p,&pixel);
1205 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
1206 p=PushLongPixel(endian,p,&pixel);
1207 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
1208 p=PushLongPixel(endian,p,&pixel);
1209 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1210 p=PushLongPixel(endian,p,&pixel);
1211 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
1212 p+=quantum_info->pad;
1219 if (quantum_info->format == FloatingPointQuantumFormat)
1224 for (x=0; x < (ssize_t) number_pixels; x++)
1226 p=PushDoublePixel(&quantum_state,p,&pixel);
1227 SetPixelRed(image,ClampToQuantum(pixel),q);
1228 p=PushDoublePixel(&quantum_state,p,&pixel);
1229 SetPixelGreen(image,ClampToQuantum(pixel),q);
1230 p=PushDoublePixel(&quantum_state,p,&pixel);
1231 SetPixelBlue(image,ClampToQuantum(pixel),q);
1232 p=PushDoublePixel(&quantum_state,p,&pixel);
1233 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1234 p+=quantum_info->pad;
1242 range=GetQuantumRange(image->depth);
1243 for (x=0; x < (ssize_t) number_pixels; x++)
1245 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1246 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
1247 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1248 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
1249 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1250 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1251 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1252 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1262 switch (quantum_info->depth)
1271 white=(Quantum) QuantumRange;
1272 if (quantum_info->min_is_white != MagickFalse)
1274 black=(Quantum) QuantumRange;
1277 for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
1279 for (bit=0; bit < 8; bit++)
1281 SetPixelRed(image,((*p) & (1 << (7-bit))) == 0 ? black :
1283 SetPixelGreen(image,GetPixelRed(image,q),q);
1284 SetPixelBlue(image,GetPixelRed(image,q),q);
1289 for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
1291 SetPixelRed(image,((*p) & (0x01 << (7-bit))) == 0 ? black :
1293 SetPixelGreen(image,GetPixelRed(image,q),q);
1294 SetPixelBlue(image,GetPixelRed(image,q),q);
1303 register unsigned char
1306 range=GetQuantumRange(image->depth);
1307 for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
1309 pixel=(unsigned char) ((*p >> 4) & 0xf);
1310 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1311 SetPixelGreen(image,GetPixelRed(image,q),q);
1312 SetPixelBlue(image,GetPixelRed(image,q),q);
1314 pixel=(unsigned char) ((*p) & 0xf);
1315 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1316 SetPixelGreen(image,GetPixelRed(image,q),q);
1317 SetPixelBlue(image,GetPixelRed(image,q),q);
1321 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
1323 pixel=(unsigned char) (*p++ >> 4);
1324 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1325 SetPixelGreen(image,GetPixelRed(image,q),q);
1326 SetPixelBlue(image,GetPixelRed(image,q),q);
1336 if (quantum_info->min_is_white != MagickFalse)
1338 for (x=0; x < (ssize_t) number_pixels; x++)
1340 p=PushCharPixel(p,&pixel);
1341 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1342 SetPixelGreen(image,GetPixelRed(image,q),q);
1343 SetPixelBlue(image,GetPixelRed(image,q),q);
1344 SetPixelAlpha(image,OpaqueAlpha,q);
1345 p+=quantum_info->pad;
1350 for (x=0; x < (ssize_t) number_pixels; x++)
1352 p=PushCharPixel(p,&pixel);
1353 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1354 SetPixelGreen(image,GetPixelRed(image,q),q);
1355 SetPixelBlue(image,GetPixelRed(image,q),q);
1356 SetPixelAlpha(image,OpaqueAlpha,q);
1357 p+=quantum_info->pad;
1364 range=GetQuantumRange(image->depth);
1365 if (quantum_info->pack == MagickFalse)
1367 if (image->endian != LSBEndian)
1369 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
1371 p=PushLongPixel(endian,p,&pixel);
1372 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
1374 SetPixelGreen(image,GetPixelRed(image,q),q);
1375 SetPixelBlue(image,GetPixelRed(image,q),q);
1377 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
1379 SetPixelGreen(image,GetPixelRed(image,q),q);
1380 SetPixelBlue(image,GetPixelRed(image,q),q);
1382 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
1384 SetPixelGreen(image,GetPixelRed(image,q),q);
1385 SetPixelBlue(image,GetPixelRed(image,q),q);
1386 p+=quantum_info->pad;
1389 p=PushLongPixel(endian,p,&pixel);
1390 if (x++ < (ssize_t) (number_pixels-1))
1392 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
1394 SetPixelGreen(image,GetPixelRed(image,q),q);
1395 SetPixelBlue(image,GetPixelRed(image,q),q);
1398 if (x++ < (ssize_t) number_pixels)
1400 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
1402 SetPixelGreen(image,GetPixelRed(image,q),q);
1403 SetPixelBlue(image,GetPixelRed(image,q),q);
1408 for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
1410 p=PushLongPixel(endian,p,&pixel);
1411 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
1413 SetPixelGreen(image,GetPixelRed(image,q),q);
1414 SetPixelBlue(image,GetPixelRed(image,q),q);
1416 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
1418 SetPixelGreen(image,GetPixelRed(image,q),q);
1419 SetPixelBlue(image,GetPixelRed(image,q),q);
1421 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
1423 SetPixelGreen(image,GetPixelRed(image,q),q);
1424 SetPixelBlue(image,GetPixelRed(image,q),q);
1425 p+=quantum_info->pad;
1428 p=PushLongPixel(endian,p,&pixel);
1429 if (x++ < (ssize_t) (number_pixels-1))
1431 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
1433 SetPixelGreen(image,GetPixelRed(image,q),q);
1434 SetPixelBlue(image,GetPixelRed(image,q),q);
1437 if (x++ < (ssize_t) number_pixels)
1439 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
1441 SetPixelGreen(image,GetPixelRed(image,q),q);
1442 SetPixelBlue(image,GetPixelRed(image,q),q);
1447 for (x=0; x < (ssize_t) number_pixels; x++)
1449 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1450 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1451 SetPixelGreen(image,GetPixelRed(image,q),q);
1452 SetPixelBlue(image,GetPixelRed(image,q),q);
1453 p+=quantum_info->pad;
1460 range=GetQuantumRange(image->depth);
1461 if (quantum_info->pack == MagickFalse)
1466 for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
1468 p=PushShortPixel(endian,p,&pixel);
1469 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
1470 (pixel >> 4),range),q);
1471 SetPixelGreen(image,GetPixelRed(image,q),q);
1472 SetPixelBlue(image,GetPixelRed(image,q),q);
1474 p=PushShortPixel(endian,p,&pixel);
1475 SetPixelRed(image,ScaleAnyToQuantum(
1476 (QuantumAny) (pixel >> 4),range),q);
1477 SetPixelGreen(image,GetPixelRed(image,q),q);
1478 SetPixelBlue(image,GetPixelRed(image,q),q);
1479 p+=quantum_info->pad;
1482 for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
1484 p=PushShortPixel(endian,p,&pixel);
1485 SetPixelRed(image,ScaleAnyToQuantum(
1486 (QuantumAny) (pixel >> 4),range),q);
1487 SetPixelGreen(image,GetPixelRed(image,q),q);
1488 SetPixelBlue(image,GetPixelRed(image,q),q);
1489 p+=quantum_info->pad;
1496 for (x=0; x < (ssize_t) number_pixels; x++)
1498 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1499 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1500 SetPixelGreen(image,GetPixelRed(image,q),q);
1501 SetPixelBlue(image,GetPixelRed(image,q),q);
1502 p+=quantum_info->pad;
1512 if (quantum_info->min_is_white != MagickFalse)
1514 for (x=0; x < (ssize_t) number_pixels; x++)
1516 p=PushShortPixel(endian,p,&pixel);
1517 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1518 SetPixelGreen(image,GetPixelRed(image,q),q);
1519 SetPixelBlue(image,GetPixelRed(image,q),q);
1520 p+=quantum_info->pad;
1525 if (quantum_info->format == FloatingPointQuantumFormat)
1527 for (x=0; x < (ssize_t) number_pixels; x++)
1529 p=PushShortPixel(endian,p,&pixel);
1530 SetPixelRed(image,ClampToQuantum((MagickRealType)
1531 QuantumRange*HalfToSinglePrecision(pixel)),q);
1532 SetPixelGreen(image,GetPixelRed(image,q),q);
1533 SetPixelBlue(image,GetPixelRed(image,q),q);
1534 p+=quantum_info->pad;
1539 for (x=0; x < (ssize_t) number_pixels; x++)
1541 p=PushShortPixel(endian,p,&pixel);
1542 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1543 SetPixelGreen(image,GetPixelRed(image,q),q);
1544 SetPixelBlue(image,GetPixelRed(image,q),q);
1545 p+=quantum_info->pad;
1555 if (quantum_info->format == FloatingPointQuantumFormat)
1560 for (x=0; x < (ssize_t) number_pixels; x++)
1562 p=PushFloatPixel(&quantum_state,p,&pixel);
1563 SetPixelRed(image,ClampToQuantum(pixel),q);
1564 SetPixelGreen(image,GetPixelRed(image,q),q);
1565 SetPixelBlue(image,GetPixelRed(image,q),q);
1566 p+=quantum_info->pad;
1571 for (x=0; x < (ssize_t) number_pixels; x++)
1573 p=PushLongPixel(endian,p,&pixel);
1574 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1575 SetPixelGreen(image,GetPixelRed(image,q),q);
1576 SetPixelBlue(image,GetPixelRed(image,q),q);
1577 p+=quantum_info->pad;
1584 if (quantum_info->format == FloatingPointQuantumFormat)
1589 for (x=0; x < (ssize_t) number_pixels; x++)
1591 p=PushDoublePixel(&quantum_state,p,&pixel);
1592 SetPixelRed(image,ClampToQuantum(pixel),q);
1593 SetPixelGreen(image,GetPixelRed(image,q),q);
1594 SetPixelBlue(image,GetPixelRed(image,q),q);
1595 p+=quantum_info->pad;
1603 range=GetQuantumRange(image->depth);
1604 for (x=0; x < (ssize_t) number_pixels; x++)
1606 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1607 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1608 SetPixelGreen(image,GetPixelRed(image,q),q);
1609 SetPixelBlue(image,GetPixelRed(image,q),q);
1610 p+=quantum_info->pad;
1618 case GrayAlphaQuantum:
1620 switch (quantum_info->depth)
1624 register unsigned char
1627 for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
1629 for (bit=0; bit < 8; bit+=2)
1631 pixel=(unsigned char)
1632 (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
1633 SetPixelRed(image,(Quantum) (pixel == 0 ? 0 : QuantumRange),q);
1634 SetPixelGreen(image,GetPixelRed(image,q),q);
1635 SetPixelBlue(image,GetPixelRed(image,q),q);
1636 SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
1637 (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
1642 if ((number_pixels % 4) != 0)
1643 for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
1645 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 :
1647 SetPixelRed(image,(Quantum) (pixel != 0 ? 0 : QuantumRange),q);
1648 SetPixelGreen(image,GetPixelRed(image,q),q);
1649 SetPixelBlue(image,GetPixelRed(image,q),q);
1650 SetPixelAlpha(image,((*p) & (1UL << (unsigned char)
1651 (6-bit))) == 0 ? TransparentAlpha : OpaqueAlpha,q);
1660 register unsigned char
1663 range=GetQuantumRange(image->depth);
1664 for (x=0; x < (ssize_t) number_pixels; x++)
1666 pixel=(unsigned char) ((*p >> 4) & 0xf);
1667 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1668 SetPixelGreen(image,GetPixelRed(image,q),q);
1669 SetPixelBlue(image,GetPixelRed(image,q),q);
1670 pixel=(unsigned char) ((*p) & 0xf);
1671 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1682 for (x=0; x < (ssize_t) number_pixels; x++)
1684 p=PushCharPixel(p,&pixel);
1685 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1686 SetPixelGreen(image,GetPixelRed(image,q),q);
1687 SetPixelBlue(image,GetPixelRed(image,q),q);
1688 p=PushCharPixel(p,&pixel);
1689 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
1690 p+=quantum_info->pad;
1697 range=GetQuantumRange(image->depth);
1698 for (x=0; x < (ssize_t) number_pixels; x++)
1700 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1701 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1702 SetPixelGreen(image,GetPixelRed(image,q),q);
1703 SetPixelBlue(image,GetPixelRed(image,q),q);
1704 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1705 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1706 p+=quantum_info->pad;
1713 range=GetQuantumRange(image->depth);
1714 for (x=0; x < (ssize_t) number_pixels; x++)
1716 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1717 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1718 SetPixelGreen(image,GetPixelRed(image,q),q);
1719 SetPixelBlue(image,GetPixelRed(image,q),q);
1720 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1721 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1722 p+=quantum_info->pad;
1732 if (quantum_info->format == FloatingPointQuantumFormat)
1734 for (x=0; x < (ssize_t) number_pixels; x++)
1736 p=PushShortPixel(endian,p,&pixel);
1737 SetPixelRed(image,ClampToQuantum((MagickRealType)
1738 QuantumRange*HalfToSinglePrecision(pixel)),q);
1739 SetPixelGreen(image,GetPixelRed(image,q),q);
1740 SetPixelBlue(image,GetPixelRed(image,q),q);
1741 p=PushShortPixel(endian,p,&pixel);
1742 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
1743 QuantumRange*HalfToSinglePrecision(pixel)),q);
1744 p+=quantum_info->pad;
1749 for (x=0; x < (ssize_t) number_pixels; x++)
1751 p=PushShortPixel(endian,p,&pixel);
1752 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1753 SetPixelGreen(image,GetPixelRed(image,q),q);
1754 SetPixelBlue(image,GetPixelRed(image,q),q);
1755 p=PushShortPixel(endian,p,&pixel);
1756 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
1757 p+=quantum_info->pad;
1767 if (quantum_info->format == FloatingPointQuantumFormat)
1772 for (x=0; x < (ssize_t) number_pixels; x++)
1774 p=PushFloatPixel(&quantum_state,p,&pixel);
1775 SetPixelRed(image,ClampToQuantum(pixel),q);
1776 SetPixelGreen(image,GetPixelRed(image,q),q);
1777 SetPixelBlue(image,GetPixelRed(image,q),q);
1778 p=PushFloatPixel(&quantum_state,p,&pixel);
1779 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1780 p+=quantum_info->pad;
1785 for (x=0; x < (ssize_t) number_pixels; x++)
1787 p=PushLongPixel(endian,p,&pixel);
1788 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1789 SetPixelGreen(image,GetPixelRed(image,q),q);
1790 SetPixelBlue(image,GetPixelRed(image,q),q);
1791 p=PushLongPixel(endian,p,&pixel);
1792 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
1793 p+=quantum_info->pad;
1800 if (quantum_info->format == FloatingPointQuantumFormat)
1805 for (x=0; x < (ssize_t) number_pixels; x++)
1807 p=PushDoublePixel(&quantum_state,p,&pixel);
1808 SetPixelRed(image,ClampToQuantum(pixel),q);
1809 SetPixelGreen(image,GetPixelRed(image,q),q);
1810 SetPixelBlue(image,GetPixelRed(image,q),q);
1811 p=PushDoublePixel(&quantum_state,p,&pixel);
1812 SetPixelAlpha(image,ClampToQuantum(pixel),q);
1813 p+=quantum_info->pad;
1821 range=GetQuantumRange(image->depth);
1822 for (x=0; x < (ssize_t) number_pixels; x++)
1824 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1825 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1826 SetPixelGreen(image,GetPixelRed(image,q),q);
1827 SetPixelBlue(image,GetPixelRed(image,q),q);
1828 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1829 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
1830 p+=quantum_info->pad;
1841 switch (quantum_info->depth)
1848 for (x=0; x < (ssize_t) number_pixels; x++)
1850 p=PushCharPixel(p,&pixel);
1851 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
1852 p+=quantum_info->pad;
1862 if (quantum_info->format == FloatingPointQuantumFormat)
1864 for (x=0; x < (ssize_t) number_pixels; x++)
1866 p=PushShortPixel(endian,p,&pixel);
1867 SetPixelRed(image,ClampToQuantum((MagickRealType)
1868 QuantumRange*HalfToSinglePrecision(pixel)),q);
1869 p+=quantum_info->pad;
1874 for (x=0; x < (ssize_t) number_pixels; x++)
1876 p=PushShortPixel(endian,p,&pixel);
1877 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
1878 p+=quantum_info->pad;
1888 if (quantum_info->format == FloatingPointQuantumFormat)
1893 for (x=0; x < (ssize_t) number_pixels; x++)
1895 p=PushFloatPixel(&quantum_state,p,&pixel);
1896 SetPixelRed(image,ClampToQuantum(pixel),q);
1897 p+=quantum_info->pad;
1902 for (x=0; x < (ssize_t) number_pixels; x++)
1904 p=PushLongPixel(endian,p,&pixel);
1905 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
1906 p+=quantum_info->pad;
1913 if (quantum_info->format == FloatingPointQuantumFormat)
1918 for (x=0; x < (ssize_t) number_pixels; x++)
1920 p=PushDoublePixel(&quantum_state,p,&pixel);
1921 SetPixelRed(image,ClampToQuantum(pixel),q);
1922 p+=quantum_info->pad;
1930 range=GetQuantumRange(image->depth);
1931 for (x=0; x < (ssize_t) number_pixels; x++)
1933 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1934 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
1935 p+=quantum_info->pad;
1944 case MagentaQuantum:
1946 switch (quantum_info->depth)
1953 for (x=0; x < (ssize_t) number_pixels; x++)
1955 p=PushCharPixel(p,&pixel);
1956 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
1957 p+=quantum_info->pad;
1967 if (quantum_info->format == FloatingPointQuantumFormat)
1969 for (x=0; x < (ssize_t) number_pixels; x++)
1971 p=PushShortPixel(endian,p,&pixel);
1972 SetPixelGreen(image,ClampToQuantum((MagickRealType)
1973 QuantumRange*HalfToSinglePrecision(pixel)),q);
1974 p+=quantum_info->pad;
1979 for (x=0; x < (ssize_t) number_pixels; x++)
1981 p=PushShortPixel(endian,p,&pixel);
1982 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
1983 p+=quantum_info->pad;
1993 if (quantum_info->format == FloatingPointQuantumFormat)
1998 for (x=0; x < (ssize_t) number_pixels; x++)
2000 p=PushFloatPixel(&quantum_state,p,&pixel);
2001 SetPixelGreen(image,ClampToQuantum(pixel),q);
2002 p+=quantum_info->pad;
2007 for (x=0; x < (ssize_t) number_pixels; x++)
2009 p=PushLongPixel(endian,p,&pixel);
2010 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2011 p+=quantum_info->pad;
2018 if (quantum_info->format == FloatingPointQuantumFormat)
2023 for (x=0; x < (ssize_t) number_pixels; x++)
2025 p=PushDoublePixel(&quantum_state,p,&pixel);
2026 SetPixelGreen(image,ClampToQuantum(pixel),q);
2027 p+=quantum_info->pad;
2035 range=GetQuantumRange(image->depth);
2036 for (x=0; x < (ssize_t) number_pixels; x++)
2038 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2039 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2040 p+=quantum_info->pad;
2051 switch (quantum_info->depth)
2058 for (x=0; x < (ssize_t) number_pixels; x++)
2060 p=PushCharPixel(p,&pixel);
2061 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
2062 p+=quantum_info->pad;
2072 if (quantum_info->format == FloatingPointQuantumFormat)
2074 for (x=0; x < (ssize_t) number_pixels; x++)
2076 p=PushShortPixel(endian,p,&pixel);
2077 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2078 QuantumRange*HalfToSinglePrecision(pixel)),q);
2079 p+=quantum_info->pad;
2084 for (x=0; x < (ssize_t) number_pixels; x++)
2086 p=PushShortPixel(endian,p,&pixel);
2087 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
2088 p+=quantum_info->pad;
2098 if (quantum_info->format == FloatingPointQuantumFormat)
2103 for (x=0; x < (ssize_t) number_pixels; x++)
2105 p=PushFloatPixel(&quantum_state,p,&pixel);
2106 SetPixelBlue(image,ClampToQuantum(pixel),q);
2107 p+=quantum_info->pad;
2112 for (x=0; x < (ssize_t) number_pixels; x++)
2114 p=PushLongPixel(endian,p,&pixel);
2115 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2116 p+=quantum_info->pad;
2123 if (quantum_info->format == FloatingPointQuantumFormat)
2128 for (x=0; x < (ssize_t) number_pixels; x++)
2130 p=PushDoublePixel(&quantum_state,p,&pixel);
2131 SetPixelBlue(image,ClampToQuantum(pixel),q);
2132 p+=quantum_info->pad;
2140 range=GetQuantumRange(image->depth);
2141 for (x=0; x < (ssize_t) number_pixels; x++)
2143 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2144 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2145 p+=quantum_info->pad;
2155 switch (quantum_info->depth)
2162 for (x=0; x < (ssize_t) number_pixels; x++)
2164 p=PushCharPixel(p,&pixel);
2165 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2166 p+=quantum_info->pad;
2176 if (quantum_info->format == FloatingPointQuantumFormat)
2178 for (x=0; x < (ssize_t) number_pixels; x++)
2180 p=PushShortPixel(endian,p,&pixel);
2181 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2182 QuantumRange*HalfToSinglePrecision(pixel)),q);
2183 p+=quantum_info->pad;
2188 for (x=0; x < (ssize_t) number_pixels; x++)
2190 p=PushShortPixel(endian,p,&pixel);
2191 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
2192 p+=quantum_info->pad;
2202 if (quantum_info->format == FloatingPointQuantumFormat)
2207 for (x=0; x < (ssize_t) number_pixels; x++)
2209 p=PushFloatPixel(&quantum_state,p,&pixel);
2210 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2211 p+=quantum_info->pad;
2216 for (x=0; x < (ssize_t) number_pixels; x++)
2218 p=PushLongPixel(endian,p,&pixel);
2219 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2220 p+=quantum_info->pad;
2227 if (quantum_info->format == FloatingPointQuantumFormat)
2232 for (x=0; x < (ssize_t) number_pixels; x++)
2234 p=PushDoublePixel(&quantum_state,p,&pixel);
2235 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2236 p+=quantum_info->pad;
2244 range=GetQuantumRange(image->depth);
2245 for (x=0; x < (ssize_t) number_pixels; x++)
2247 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2248 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2249 p+=quantum_info->pad;
2259 if (image->colorspace != CMYKColorspace)
2261 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2262 "ColorSeparatedImageRequired","`%s'",image->filename);
2265 switch (quantum_info->depth)
2272 for (x=0; x < (ssize_t) number_pixels; x++)
2274 p=PushCharPixel(p,&pixel);
2275 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
2276 p+=quantum_info->pad;
2286 if (quantum_info->format == FloatingPointQuantumFormat)
2288 for (x=0; x < (ssize_t) number_pixels; x++)
2290 p=PushShortPixel(endian,p,&pixel);
2291 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2292 QuantumRange*HalfToSinglePrecision(pixel)),q);
2293 p+=quantum_info->pad;
2298 for (x=0; x < (ssize_t) number_pixels; x++)
2300 p=PushShortPixel(endian,p,&pixel);
2301 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
2302 p+=quantum_info->pad;
2312 if (quantum_info->format == FloatingPointQuantumFormat)
2317 for (x=0; x < (ssize_t) number_pixels; x++)
2319 p=PushFloatPixel(&quantum_state,p,&pixel);
2320 SetPixelBlack(image,ClampToQuantum(pixel),q);
2321 p+=quantum_info->pad;
2326 for (x=0; x < (ssize_t) number_pixels; x++)
2328 p=PushLongPixel(endian,p,&pixel);
2329 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
2330 p+=quantum_info->pad;
2337 if (quantum_info->format == FloatingPointQuantumFormat)
2342 for (x=0; x < (ssize_t) number_pixels; x++)
2344 p=PushDoublePixel(&quantum_state,p,&pixel);
2345 SetPixelBlack(image,ClampToQuantum(pixel),q);
2346 p+=quantum_info->pad;
2354 range=GetQuantumRange(image->depth);
2355 for (x=0; x < (ssize_t) number_pixels; x++)
2357 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2358 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
2359 p+=quantum_info->pad;
2370 switch (quantum_info->depth)
2377 for (x=0; x < (ssize_t) number_pixels; x++)
2379 p=PushCharPixel(p,&pixel);
2380 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
2381 p=PushCharPixel(p,&pixel);
2382 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2383 p=PushCharPixel(p,&pixel);
2384 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
2385 SetPixelAlpha(image,OpaqueAlpha,q);
2386 p+=quantum_info->pad;
2393 range=GetQuantumRange(image->depth);
2394 if (quantum_info->pack == MagickFalse)
2396 for (x=0; x < (ssize_t) number_pixels; x++)
2398 p=PushLongPixel(endian,p,&pixel);
2399 SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
2401 SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
2403 SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
2405 p+=quantum_info->pad;
2410 if (quantum_info->quantum == 32U)
2412 for (x=0; x < (ssize_t) number_pixels; x++)
2414 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2415 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2416 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2417 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2418 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2419 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2424 for (x=0; x < (ssize_t) number_pixels; x++)
2426 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2427 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2428 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2429 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2430 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2431 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2438 range=GetQuantumRange(image->depth);
2439 if (quantum_info->pack == MagickFalse)
2444 for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
2446 p=PushShortPixel(endian,p,&pixel);
2452 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
2453 (pixel >> 4),range),q);
2458 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
2459 (pixel >> 4),range),q);
2464 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
2465 (pixel >> 4),range),q);
2470 p=PushShortPixel(endian,p,&pixel);
2476 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
2477 (pixel >> 4),range),q);
2482 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
2483 (pixel >> 4),range),q);
2488 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
2489 (pixel >> 4),range),q);
2494 p+=quantum_info->pad;
2496 for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
2498 p=PushShortPixel(endian,p,&pixel);
2499 switch ((x+bit) % 3)
2504 SetPixelRed(image,ScaleAnyToQuantum((QuantumAny)
2505 (pixel >> 4),range),q);
2510 SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny)
2511 (pixel >> 4),range),q);
2516 SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny)
2517 (pixel >> 4),range),q);
2522 p+=quantum_info->pad;
2528 if (quantum_info->quantum == 32U)
2530 for (x=0; x < (ssize_t) number_pixels; x++)
2532 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2533 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2534 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2535 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2536 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2537 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2542 for (x=0; x < (ssize_t) number_pixels; x++)
2544 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2545 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2546 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2547 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2548 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2549 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2559 if (quantum_info->format == FloatingPointQuantumFormat)
2561 for (x=0; x < (ssize_t) number_pixels; x++)
2563 p=PushShortPixel(endian,p,&pixel);
2564 SetPixelRed(image,ClampToQuantum((MagickRealType)
2565 QuantumRange*HalfToSinglePrecision(pixel)),q);
2566 p=PushShortPixel(endian,p,&pixel);
2567 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2568 QuantumRange*HalfToSinglePrecision(pixel)),q);
2569 p=PushShortPixel(endian,p,&pixel);
2570 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2571 QuantumRange*HalfToSinglePrecision(pixel)),q);
2572 p+=quantum_info->pad;
2577 for (x=0; x < (ssize_t) number_pixels; x++)
2579 p=PushShortPixel(endian,p,&pixel);
2580 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
2581 p=PushShortPixel(endian,p,&pixel);
2582 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2583 p=PushShortPixel(endian,p,&pixel);
2584 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
2585 p+=quantum_info->pad;
2595 if (quantum_info->format == FloatingPointQuantumFormat)
2600 for (x=0; x < (ssize_t) number_pixels; x++)
2602 p=PushFloatPixel(&quantum_state,p,&pixel);
2603 SetPixelRed(image,ClampToQuantum(pixel),q);
2604 p=PushFloatPixel(&quantum_state,p,&pixel);
2605 SetPixelGreen(image,ClampToQuantum(pixel),q);
2606 p=PushFloatPixel(&quantum_state,p,&pixel);
2607 SetPixelBlue(image,ClampToQuantum(pixel),q);
2608 p+=quantum_info->pad;
2613 for (x=0; x < (ssize_t) number_pixels; x++)
2615 p=PushLongPixel(endian,p,&pixel);
2616 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
2617 p=PushLongPixel(endian,p,&pixel);
2618 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2619 p=PushLongPixel(endian,p,&pixel);
2620 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2621 p+=quantum_info->pad;
2628 if (quantum_info->format == FloatingPointQuantumFormat)
2633 for (x=0; x < (ssize_t) number_pixels; x++)
2635 p=PushDoublePixel(&quantum_state,p,&pixel);
2636 SetPixelRed(image,ClampToQuantum(pixel),q);
2637 p=PushDoublePixel(&quantum_state,p,&pixel);
2638 SetPixelGreen(image,ClampToQuantum(pixel),q);
2639 p=PushDoublePixel(&quantum_state,p,&pixel);
2640 SetPixelBlue(image,ClampToQuantum(pixel),q);
2641 p+=quantum_info->pad;
2649 range=GetQuantumRange(image->depth);
2650 for (x=0; x < (ssize_t) number_pixels; x++)
2652 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2653 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2654 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2655 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2656 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2657 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2669 switch (quantum_info->depth)
2676 for (x=0; x < (ssize_t) number_pixels; x++)
2678 p=PushCharPixel(p,&pixel);
2679 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
2680 p=PushCharPixel(p,&pixel);
2681 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2682 p=PushCharPixel(p,&pixel);
2683 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
2684 p=PushCharPixel(p,&pixel);
2685 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
2686 p+=quantum_info->pad;
2694 if (quantum_info->pack == MagickFalse)
2707 for (x=0; x < (ssize_t) number_pixels; x++)
2709 for (i=0; i < 4; i++)
2715 p=PushLongPixel(endian,p,&pixel);
2716 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
2717 (((pixel >> 22) & 0x3ff) << 6)));
2722 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
2723 (((pixel >> 12) & 0x3ff) << 6)));
2728 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
2729 (((pixel >> 2) & 0x3ff) << 6)));
2735 case 0: SetPixelRed(image,(Quantum) quantum,q); break;
2736 case 1: SetPixelGreen(image,(Quantum) quantum,q); break;
2737 case 2: SetPixelBlue(image,(Quantum) quantum,q); break;
2738 case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;
2742 p+=quantum_info->pad;
2747 for (x=0; x < (ssize_t) number_pixels; x++)
2749 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2750 SetPixelRed(image,ScaleShortToQuantum((unsigned short)
2752 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2753 SetPixelGreen(image,ScaleShortToQuantum((unsigned short)
2755 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2756 SetPixelBlue(image,ScaleShortToQuantum((unsigned short)
2758 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2759 SetPixelAlpha(image,ScaleShortToQuantum((unsigned short)
2770 if (quantum_info->format == FloatingPointQuantumFormat)
2772 for (x=0; x < (ssize_t) number_pixels; x++)
2774 p=PushShortPixel(endian,p,&pixel);
2775 SetPixelRed(image,ClampToQuantum((MagickRealType)
2776 QuantumRange*HalfToSinglePrecision(pixel)),q);
2777 p=PushShortPixel(endian,p,&pixel);
2778 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2779 QuantumRange*HalfToSinglePrecision(pixel)),q);
2780 p=PushShortPixel(endian,p,&pixel);
2781 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2782 QuantumRange*HalfToSinglePrecision(pixel)),q);
2783 p=PushShortPixel(endian,p,&pixel);
2784 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2785 QuantumRange*HalfToSinglePrecision(pixel)),q);
2786 p+=quantum_info->pad;
2791 for (x=0; x < (ssize_t) number_pixels; x++)
2793 p=PushShortPixel(endian,p,&pixel);
2794 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
2795 p=PushShortPixel(endian,p,&pixel);
2796 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2797 p=PushShortPixel(endian,p,&pixel);
2798 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
2799 p=PushShortPixel(endian,p,&pixel);
2800 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
2801 p+=quantum_info->pad;
2811 if (quantum_info->format == FloatingPointQuantumFormat)
2816 for (x=0; x < (ssize_t) number_pixels; x++)
2818 p=PushFloatPixel(&quantum_state,p,&pixel);
2819 SetPixelRed(image,ClampToQuantum(pixel),q);
2820 p=PushFloatPixel(&quantum_state,p,&pixel);
2821 SetPixelGreen(image,ClampToQuantum(pixel),q);
2822 p=PushFloatPixel(&quantum_state,p,&pixel);
2823 SetPixelBlue(image,ClampToQuantum(pixel),q);
2824 p=PushFloatPixel(&quantum_state,p,&pixel);
2825 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2826 p+=quantum_info->pad;
2831 for (x=0; x < (ssize_t) number_pixels; x++)
2833 p=PushLongPixel(endian,p,&pixel);
2834 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
2835 p=PushLongPixel(endian,p,&pixel);
2836 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2837 p=PushLongPixel(endian,p,&pixel);
2838 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2839 p=PushLongPixel(endian,p,&pixel);
2840 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
2841 p+=quantum_info->pad;
2848 if (quantum_info->format == FloatingPointQuantumFormat)
2853 for (x=0; x < (ssize_t) number_pixels; x++)
2855 p=PushDoublePixel(&quantum_state,p,&pixel);
2856 SetPixelRed(image,ClampToQuantum(pixel),q);
2857 p=PushDoublePixel(&quantum_state,p,&pixel);
2858 SetPixelGreen(image,ClampToQuantum(pixel),q);
2859 p=PushDoublePixel(&quantum_state,p,&pixel);
2860 SetPixelBlue(image,ClampToQuantum(pixel),q);
2861 p=PushDoublePixel(&quantum_state,p,&pixel);
2862 SetPixelAlpha(image,ClampToQuantum(pixel),q);
2863 p+=quantum_info->pad;
2871 range=GetQuantumRange(image->depth);
2872 for (x=0; x < (ssize_t) number_pixels; x++)
2874 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2875 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
2876 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2877 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
2878 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2879 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
2880 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2881 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
2891 if (image->colorspace != CMYKColorspace)
2893 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2894 "ColorSeparatedImageRequired","`%s'",image->filename);
2897 switch (quantum_info->depth)
2904 for (x=0; x < (ssize_t) number_pixels; x++)
2906 p=PushCharPixel(p,&pixel);
2907 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
2908 p=PushCharPixel(p,&pixel);
2909 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
2910 p=PushCharPixel(p,&pixel);
2911 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
2912 p=PushCharPixel(p,&pixel);
2913 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
2914 p+=quantum_info->pad;
2924 if (quantum_info->format == FloatingPointQuantumFormat)
2926 for (x=0; x < (ssize_t) number_pixels; x++)
2928 p=PushShortPixel(endian,p,&pixel);
2929 SetPixelRed(image,ClampToQuantum((MagickRealType)
2930 QuantumRange*HalfToSinglePrecision(pixel)),q);
2931 p=PushShortPixel(endian,p,&pixel);
2932 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2933 QuantumRange*HalfToSinglePrecision(pixel)),q);
2934 p=PushShortPixel(endian,p,&pixel);
2935 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2936 QuantumRange*HalfToSinglePrecision(pixel)),q);
2937 p=PushShortPixel(endian,p,&pixel);
2938 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2939 QuantumRange*HalfToSinglePrecision(pixel)),q);
2940 p+=quantum_info->pad;
2945 for (x=0; x < (ssize_t) number_pixels; x++)
2947 p=PushShortPixel(endian,p,&pixel);
2948 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
2949 p=PushShortPixel(endian,p,&pixel);
2950 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
2951 p=PushShortPixel(endian,p,&pixel);
2952 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
2953 p=PushShortPixel(endian,p,&pixel);
2954 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
2955 p+=quantum_info->pad;
2965 if (quantum_info->format == FloatingPointQuantumFormat)
2970 for (x=0; x < (ssize_t) number_pixels; x++)
2972 p=PushFloatPixel(&quantum_state,p,&pixel);
2973 SetPixelRed(image,ClampToQuantum(pixel),q);
2974 p=PushFloatPixel(&quantum_state,p,&pixel);
2975 SetPixelGreen(image,ClampToQuantum(pixel),q);
2976 p=PushFloatPixel(&quantum_state,p,&pixel);
2977 SetPixelBlue(image,ClampToQuantum(pixel),q);
2978 p=PushFloatPixel(&quantum_state,p,&pixel);
2979 SetPixelBlack(image,ClampToQuantum(pixel),q);
2980 p+=quantum_info->pad;
2985 for (x=0; x < (ssize_t) number_pixels; x++)
2987 p=PushLongPixel(endian,p,&pixel);
2988 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
2989 p=PushLongPixel(endian,p,&pixel);
2990 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
2991 p=PushLongPixel(endian,p,&pixel);
2992 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
2993 p=PushLongPixel(endian,p,&pixel);
2994 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
2995 p+=quantum_info->pad;
3002 if (quantum_info->format == FloatingPointQuantumFormat)
3007 for (x=0; x < (ssize_t) number_pixels; x++)
3009 p=PushDoublePixel(&quantum_state,p,&pixel);
3010 SetPixelRed(image,ClampToQuantum(pixel),q);
3011 p=PushDoublePixel(&quantum_state,p,&pixel);
3012 SetPixelGreen(image,ClampToQuantum(pixel),q);
3013 p=PushDoublePixel(&quantum_state,p,&pixel);
3014 SetPixelBlue(image,ClampToQuantum(pixel),q);
3015 p=PushDoublePixel(&quantum_state,p,&pixel);
3016 SetPixelBlack(image,ClampToQuantum(pixel),q);
3017 p+=quantum_info->pad;
3025 range=GetQuantumRange(image->depth);
3026 for (x=0; x < (ssize_t) number_pixels; x++)
3028 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3029 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3030 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3031 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3032 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3033 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3034 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3035 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
3046 if (image->colorspace != CMYKColorspace)
3048 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3049 "ColorSeparatedImageRequired","`%s'",image->filename);
3052 switch (quantum_info->depth)
3059 for (x=0; x < (ssize_t) number_pixels; x++)
3061 p=PushCharPixel(p,&pixel);
3062 SetPixelRed(image,ScaleCharToQuantum(pixel),q);
3063 p=PushCharPixel(p,&pixel);
3064 SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
3065 p=PushCharPixel(p,&pixel);
3066 SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
3067 p=PushCharPixel(p,&pixel);
3068 SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
3069 p=PushCharPixel(p,&pixel);
3070 SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
3071 p+=quantum_info->pad;
3081 if (quantum_info->format == FloatingPointQuantumFormat)
3083 for (x=0; x < (ssize_t) number_pixels; x++)
3085 p=PushShortPixel(endian,p,&pixel);
3086 SetPixelRed(image,ClampToQuantum((MagickRealType)
3087 QuantumRange*HalfToSinglePrecision(pixel)),q);
3088 p=PushShortPixel(endian,p,&pixel);
3089 SetPixelGreen(image,ClampToQuantum((MagickRealType)
3090 QuantumRange*HalfToSinglePrecision(pixel)),q);
3091 p=PushShortPixel(endian,p,&pixel);
3092 SetPixelBlue(image,ClampToQuantum((MagickRealType)
3093 QuantumRange*HalfToSinglePrecision(pixel)),q);
3094 p=PushShortPixel(endian,p,&pixel);
3095 SetPixelBlack(image,ClampToQuantum((MagickRealType)
3096 QuantumRange*HalfToSinglePrecision(pixel)),q);
3097 p=PushShortPixel(endian,p,&pixel);
3098 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
3099 QuantumRange*HalfToSinglePrecision(pixel)),q);
3100 p+=quantum_info->pad;
3105 for (x=0; x < (ssize_t) number_pixels; x++)
3107 p=PushShortPixel(endian,p,&pixel);
3108 SetPixelRed(image,ScaleShortToQuantum(pixel),q);
3109 p=PushShortPixel(endian,p,&pixel);
3110 SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
3111 p=PushShortPixel(endian,p,&pixel);
3112 SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
3113 p=PushShortPixel(endian,p,&pixel);
3114 SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
3115 p=PushShortPixel(endian,p,&pixel);
3116 SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
3117 p+=quantum_info->pad;
3127 if (quantum_info->format == FloatingPointQuantumFormat)
3132 for (x=0; x < (ssize_t) number_pixels; x++)
3134 p=PushFloatPixel(&quantum_state,p,&pixel);
3135 SetPixelRed(image,ClampToQuantum(pixel),q);
3136 p=PushFloatPixel(&quantum_state,p,&pixel);
3137 SetPixelGreen(image,ClampToQuantum(pixel),q);
3138 p=PushFloatPixel(&quantum_state,p,&pixel);
3139 SetPixelBlue(image,ClampToQuantum(pixel),q);
3140 p=PushFloatPixel(&quantum_state,p,&pixel);
3141 SetPixelBlack(image,ClampToQuantum(pixel),q);
3142 p=PushFloatPixel(&quantum_state,p,&pixel);
3143 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3144 p+=quantum_info->pad;
3149 for (x=0; x < (ssize_t) number_pixels; x++)
3151 p=PushLongPixel(endian,p,&pixel);
3152 SetPixelRed(image,ScaleLongToQuantum(pixel),q);
3153 p=PushLongPixel(endian,p,&pixel);
3154 SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
3155 p=PushLongPixel(endian,p,&pixel);
3156 SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
3157 p=PushLongPixel(endian,p,&pixel);
3158 SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
3159 p=PushLongPixel(endian,p,&pixel);
3160 SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
3161 p+=quantum_info->pad;
3168 if (quantum_info->format == FloatingPointQuantumFormat)
3173 for (x=0; x < (ssize_t) number_pixels; x++)
3175 p=PushDoublePixel(&quantum_state,p,&pixel);
3176 SetPixelRed(image,ClampToQuantum(pixel),q);
3177 p=PushDoublePixel(&quantum_state,p,&pixel);
3178 SetPixelGreen(image,ClampToQuantum(pixel),q);
3179 p=PushDoublePixel(&quantum_state,p,&pixel);
3180 SetPixelBlue(image,ClampToQuantum(pixel),q);
3181 p=PushDoublePixel(&quantum_state,p,&pixel);
3182 SetPixelBlack(image,ClampToQuantum(pixel),q);
3183 p=PushDoublePixel(&quantum_state,p,&pixel);
3184 SetPixelAlpha(image,ClampToQuantum(pixel),q);
3185 p=PushDoublePixel(&quantum_state,p,&pixel);
3186 p+=quantum_info->pad;
3194 range=GetQuantumRange(image->depth);
3195 for (x=0; x < (ssize_t) number_pixels; x++)
3197 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3198 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3199 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3200 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3201 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3202 SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
3203 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3204 SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
3205 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3206 SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
3216 switch (quantum_info->depth)
3224 if (quantum_info->pack == MagickFalse)
3237 for (x=0; x < (ssize_t) number_pixels; x+=2)
3239 for (i=0; i < 4; i++)
3245 p=PushLongPixel(endian,p,&pixel);
3246 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3247 (((pixel >> 22) & 0x3ff) << 6)));
3252 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3253 (((pixel >> 12) & 0x3ff) << 6)));
3258 quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3259 (((pixel >> 2) & 0x3ff) << 6)));
3263 cbcr[i]=(Quantum) (quantum);
3266 p+=quantum_info->pad;
3267 SetPixelRed(image,cbcr[1],q);
3268 SetPixelGreen(image,cbcr[0],q);
3269 SetPixelBlue(image,cbcr[2],q);
3271 SetPixelRed(image,cbcr[3],q);
3272 SetPixelGreen(image,cbcr[0],q);
3273 SetPixelBlue(image,cbcr[2],q);
3281 range=GetQuantumRange(image->depth);
3282 for (x=0; x < (ssize_t) number_pixels; x++)
3284 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3285 SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
3286 p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3287 SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
3298 if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3306 q=GetAuthenticPixelQueue(image);
3307 if (image_view != (CacheView *) NULL)
3308 q=GetCacheViewAuthenticPixelQueue(image_view);
3309 for (x=0; x < (ssize_t) number_pixels; x++)
3311 quantum=GetPixelRed(image,q);
3312 SetPixelRed(image,GetPixelGreen(image,q),q);
3313 SetPixelGreen(image,quantum,q);
3317 if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
3322 q=GetAuthenticPixelQueue(image);
3323 if (image_view != (CacheView *) NULL)
3324 q=GetCacheViewAuthenticPixelQueue(image_view);
3325 for (x=0; x < (ssize_t) number_pixels; x++)
3327 SetPixelAlpha(image,GetPixelAlpha(image,q),q);
3331 if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
3342 q=GetAuthenticPixelQueue(image);
3343 if (image_view != (CacheView *) NULL)
3344 q=GetCacheViewAuthenticPixelQueue(image_view);
3345 for (x=0; x < (ssize_t) number_pixels; x++)
3347 alpha=QuantumScale*GetPixelAlpha(image,q);
3348 alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
3349 SetPixelRed(image,ClampToQuantum(alpha*GetPixelRed(image,q)),q);
3350 SetPixelGreen(image,ClampToQuantum(alpha*GetPixelGreen(image,q)),q);
3351 SetPixelBlue(image,ClampToQuantum(alpha*GetPixelBlue(image,q)),q);