]> granicus.if.org Git - imagemagick/blob - magick/quantum-export.c
(no commit message)
[imagemagick] / magick / quantum-export.c
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %                                                                             %
4 %                                                                             %
5 %                                                                             %
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               %
11 %                                                                             %
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                    %
15 %                   E       X X   P      O   O  R R      T                    %
16 %                   EEEEE  X   X  P       OOO   R  R     T                    %
17 %                                                                             %
18 %                 MagickCore Methods to Export Quantum Pixels                 %
19 %                                                                             %
20 %                             Software Design                                 %
21 %                               John Cristy                                   %
22 %                               October 1998                                  %
23 %                                                                             %
24 %                                                                             %
25 %  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
26 %  dedicated to making software imaging solutions freely available.           %
27 %                                                                             %
28 %  You may not use this file except in compliance with the License.  You may  %
29 %  obtain a copy of the License at                                            %
30 %                                                                             %
31 %    http://www.imagemagick.org/script/license.php                            %
32 %                                                                             %
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.                                             %
38 %                                                                             %
39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
40 %
41 %
42 */
43 \f
44 /*
45   Include declarations.
46 */
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"
73 \f
74 /*
75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
76 %                                                                             %
77 %                                                                             %
78 %                                                                             %
79 +   E x p o r t Q u a n t u m P i x e l s                                     %
80 %                                                                             %
81 %                                                                             %
82 %                                                                             %
83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
84 %
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.
89 %
90 %  The format of the ExportQuantumPixels method is:
91 %
92 %      size_t ExportQuantumPixels(const Image *image,const CacheView *image_view,
93 %        const QuantumInfo *quantum_info,const QuantumType quantum_type,
94 %        unsigned char *pixels,ExceptionInfo *exception)
95 %
96 %  A description of each parameter follows:
97 %
98 %    o image: the image.
99 %
100 %    o image_view: the image cache view.
101 %
102 %    o quantum_info: the quantum info.
103 %
104 %    o quantum_type: Declare which pixel components to transfer (RGB, RGBA,
105 %      etc).
106 %
107 %    o pixels:  The components are transferred to this buffer.
108 %
109 %    o exception: return any errors or warnings in this structure.
110 %
111 */
112
113 static inline unsigned char *PopDoublePixel(const QuantumState *quantum_state,
114   const double pixel,unsigned char *pixels)
115 {
116   double
117     *p;
118
119   unsigned char
120     quantum[8];
121
122   p=(double *) quantum;
123   *p=(double) (pixel*quantum_state->inverse_scale+quantum_state->minimum);
124   if (quantum_state->endian != LSBEndian)
125     {
126       *pixels++=quantum[7];
127       *pixels++=quantum[6];
128       *pixels++=quantum[5];
129       *pixels++=quantum[4];
130       *pixels++=quantum[3];
131       *pixels++=quantum[2];
132       *pixels++=quantum[1];
133       *pixels++=quantum[0];
134       return(pixels);
135     }
136   *pixels++=quantum[0];
137   *pixels++=quantum[1];
138   *pixels++=quantum[2];
139   *pixels++=quantum[3];
140   *pixels++=quantum[4];
141   *pixels++=quantum[5];
142   *pixels++=quantum[6];
143   *pixels++=quantum[7];
144   return(pixels);
145 }
146
147 static inline unsigned char *PopFloatPixel(const QuantumState *quantum_state,
148   const float pixel,unsigned char *pixels)
149 {
150   float
151     *p;
152
153   unsigned char
154     quantum[4];
155
156   p=(float *) quantum;
157   *p=(float) ((double) pixel*quantum_state->inverse_scale+
158     quantum_state->minimum);
159   if (quantum_state->endian != LSBEndian)
160     {
161       *pixels++=quantum[3];
162       *pixels++=quantum[2];
163       *pixels++=quantum[1];
164       *pixels++=quantum[0];
165       return(pixels);
166     }
167   *pixels++=quantum[0];
168   *pixels++=quantum[1];
169   *pixels++=quantum[2];
170   *pixels++=quantum[3];
171   return(pixels);
172 }
173
174 static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
175   const unsigned long depth,const QuantumAny pixel,unsigned char *pixels)
176 {
177   register long
178     i;
179
180   register unsigned long
181     quantum_bits;
182
183   if (quantum_state->bits == 0UL)
184     quantum_state->bits=8UL;
185   for (i=(long) depth; i > 0L; )
186   {
187     quantum_bits=(unsigned long) i;
188     if (quantum_bits > quantum_state->bits)
189       quantum_bits=quantum_state->bits;
190     i-=quantum_bits;
191     if (quantum_state->bits == 8)
192       *pixels='\0';
193     quantum_state->bits-=quantum_bits;
194     *pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
195       quantum_state->bits);
196     if (quantum_state->bits == 0UL)
197       {
198         pixels++;
199         quantum_state->bits=8UL;
200       }
201   }
202   return(pixels);
203 }
204
205 static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
206   const unsigned long depth,const unsigned long pixel,unsigned char *pixels)
207 {
208   register long
209     i;
210
211   unsigned long
212     quantum_bits;
213
214   if (quantum_state->bits == 0UL)
215     quantum_state->bits=32UL;
216   for (i=(long) depth; i > 0; )
217   {
218     quantum_bits=(unsigned long) i;
219     if (quantum_bits > quantum_state->bits)
220       quantum_bits=quantum_state->bits;
221     quantum_state->pixel|=(((pixel >> (depth-i)) &
222       quantum_state->mask[quantum_bits]) << (32UL-quantum_state->bits));
223     i-=quantum_bits;
224     quantum_state->bits-=quantum_bits;
225     if (quantum_state->bits == 0U)
226       {
227         pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
228         quantum_state->pixel=0U;
229         quantum_state->bits=32UL;
230       }
231   }
232   return(pixels);
233 }
234
235 MagickExport size_t ExportQuantumPixels(const Image *image,
236   const CacheView *image_view,const QuantumInfo *quantum_info,
237   const QuantumType quantum_type,unsigned char *pixels,ExceptionInfo *exception)
238 {
239   EndianType
240     endian;
241
242   long
243     bit;
244
245   MagickRealType
246     alpha;
247
248   MagickSizeType
249     number_pixels;
250
251   QuantumAny
252     range;
253
254   QuantumState
255     quantum_state;
256
257   register const IndexPacket
258     *restrict indexes;
259
260   register const PixelPacket
261     *restrict p;
262
263   register long
264     x;
265
266   register unsigned char
267     *restrict q;
268
269   size_t
270     extent;
271
272   assert(image != (Image *) NULL);
273   assert(image->signature == MagickSignature);
274   if (image->debug != MagickFalse)
275     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
276   assert(quantum_info != (QuantumInfo *) NULL);
277   assert(quantum_info->signature == MagickSignature);
278   if (pixels == (unsigned char *) NULL)
279     pixels=GetQuantumPixels(quantum_info);
280   number_pixels=GetImageExtent(image);
281   p=GetVirtualPixelQueue(image);
282   indexes=GetVirtualIndexQueue(image);
283   if (image_view != (CacheView *) NULL)
284     {
285       number_pixels=GetCacheViewExtent(image_view);
286       p=GetCacheViewVirtualPixelQueue(image_view);
287       indexes=GetCacheViewVirtualIndexQueue(image_view);
288     }
289   if (quantum_info->alpha_type == AssociatedQuantumAlpha)
290     {
291       register PixelPacket
292         *restrict q;
293
294       /*
295         Associate alpha.
296       */
297       q=GetAuthenticPixelQueue(image);
298       if (image_view != (CacheView *) NULL)
299         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
300       for (x=0; x < (long) image->columns; x++)
301       {
302         alpha=QuantumScale*((double) QuantumRange-q->opacity);
303         q->red=ClampToQuantum(alpha*q->red);
304         q->green=ClampToQuantum(alpha*q->green);
305         q->blue=ClampToQuantum(alpha*q->blue);
306         q++;
307       }
308     }
309   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
310     {
311       register PixelPacket
312         *restrict q;
313
314       q=GetAuthenticPixelQueue(image);
315       if (image_view != (CacheView *) NULL)
316         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
317       for (x=0; x < (long) number_pixels; x++)
318       {
319         q->opacity=(Quantum) GetAlphaPixelComponent(q);
320         q++;
321       }
322     }
323   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
324     {
325       Quantum
326         quantum;
327
328       register PixelPacket
329         *restrict q;
330
331       q=GetAuthenticPixelQueue(image);
332       if (image_view != (CacheView *) NULL)
333         q=GetAuthenticPixelQueue(image);
334       for (x=0; x < (long) number_pixels; x++)
335       {
336         quantum=q->red;
337         q->red=q->green;
338         q->green=quantum;
339         q++;
340       }
341     }
342   x=0;
343   q=pixels;
344   InitializeQuantumState(quantum_info,image->endian,&quantum_state);
345   extent=GetQuantumExtent(image,quantum_info,quantum_type);
346   endian=quantum_state.endian;
347   switch (quantum_type)
348   {
349     case IndexQuantum:
350     {
351       if (image->storage_class != PseudoClass)
352         {
353           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
354             "ColormappedImageRequired","`%s'",image->filename);
355           return(extent);
356         }
357       switch (quantum_info->depth)
358       {
359         case 1:
360         {
361           register unsigned char
362             pixel;
363
364           for (x=((long) number_pixels-7); x > 0; x-=8)
365           {
366             pixel=(unsigned char) *indexes++;
367             *q=((pixel & 0x01) << 7);
368             pixel=(unsigned char) *indexes++;
369             *q|=((pixel & 0x01) << 6);
370             pixel=(unsigned char) *indexes++;
371             *q|=((pixel & 0x01) << 5);
372             pixel=(unsigned char) *indexes++;
373             *q|=((pixel & 0x01) << 4);
374             pixel=(unsigned char) *indexes++;
375             *q|=((pixel & 0x01) << 3);
376             pixel=(unsigned char) *indexes++;
377             *q|=((pixel & 0x01) << 2);
378             pixel=(unsigned char) *indexes++;
379             *q|=((pixel & 0x01) << 1);
380             pixel=(unsigned char) *indexes++;
381             *q|=((pixel & 0x01) << 0);
382             q++;
383           }
384           if ((number_pixels % 8) != 0)
385             {
386               *q='\0';
387               for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
388               {
389                 pixel=(unsigned char) *indexes++;
390                 *q|=((pixel & 0x01) << (unsigned char) bit);
391               }
392               q++;
393             }
394           break;
395         }
396         case 4:
397         {
398           register unsigned char
399             pixel;
400
401           for (x=0; x < (long) (number_pixels-1) ; x+=2)
402           {
403             pixel=(unsigned char) *indexes++;
404             *q=((pixel & 0xf) << 4);
405             pixel=(unsigned char) *indexes++;
406             *q|=((pixel & 0xf) << 0);
407             q++;
408           }
409           if ((number_pixels % 2) != 0)
410             {
411               pixel=(unsigned char) *indexes++;
412               *q=((pixel & 0xf) << 4);
413               q++;
414             }
415           break;
416         }
417         case 8:
418         {
419           for (x=0; x < (long) number_pixels; x++)
420           {
421             q=PopCharPixel((unsigned char) indexes[x],q);
422             q+=quantum_info->pad;
423           }
424           break;
425         }
426         case 16:
427         {
428           if (quantum_info->format == FloatingPointQuantumFormat)
429             {
430               for (x=0; x < (long) number_pixels; x++)
431               {
432                 q=PopShortPixel(endian,ScaleFloatToHalf(QuantumScale*
433                   indexes[x]),q);
434                 q+=quantum_info->pad;
435               }
436               break;
437             }
438           for (x=0; x < (long) number_pixels; x++)
439           {
440             q=PopShortPixel(endian,(unsigned short) indexes[x],q);
441             q+=quantum_info->pad;
442           }
443           break;
444         }
445         case 32:
446         {
447           if (quantum_info->format == FloatingPointQuantumFormat)
448             {
449               for (x=0; x < (long) number_pixels; x++)
450               {
451                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
452                 p++;
453                 q+=quantum_info->pad;
454               }
455               break;
456             }
457           for (x=0; x < (long) number_pixels; x++)
458           {
459             q=PopLongPixel(endian,(unsigned long) indexes[x],q);
460             q+=quantum_info->pad;
461           }
462           break;
463         }
464         case 64:
465         {
466           if (quantum_info->format == FloatingPointQuantumFormat)
467             {
468               for (x=0; x < (long) number_pixels; x++)
469               {
470                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
471                 p++;
472                 q+=quantum_info->pad;
473               }
474               break;
475             }
476         }
477         default:
478         {
479           for (x=0; x < (long) number_pixels; x++)
480           {
481             q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
482             p++;
483             q+=quantum_info->pad;
484           }
485           break;
486         }
487       }
488       break;
489     }
490     case IndexAlphaQuantum:
491     {
492       if (image->storage_class != PseudoClass)
493         {
494           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
495             "ColormappedImageRequired","`%s'",image->filename);
496           return(extent);
497         }
498       switch (quantum_info->depth)
499       {
500         case 1:
501         {
502           register unsigned char
503             pixel;
504
505           for (x=((long) number_pixels-3); x > 0; x-=4)
506           {
507             pixel=(unsigned char) *indexes++;
508             *q=((pixel & 0x01) << 7);
509             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
510               1 : 0);
511             *q|=((pixel & 0x01) << 6);
512             p++;
513             pixel=(unsigned char) *indexes++;
514             *q|=((pixel & 0x01) << 5);
515             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
516               1 : 0);
517             *q|=((pixel & 0x01) << 4);
518             p++;
519             pixel=(unsigned char) *indexes++;
520             *q|=((pixel & 0x01) << 3);
521             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
522               1 : 0);
523             *q|=((pixel & 0x01) << 2);
524             p++;
525             pixel=(unsigned char) *indexes++;
526             *q|=((pixel & 0x01) << 1);
527             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
528               1 : 0);
529             *q|=((pixel & 0x01) << 0);
530             p++;
531             q++;
532           }
533           if ((number_pixels % 4) != 0)
534             {
535               *q='\0';
536               for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
537               {
538                 pixel=(unsigned char) *indexes++;
539                 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
540                 pixel=(unsigned char) (p->opacity == (Quantum)
541                   TransparentOpacity ? 1 : 0);
542                 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
543                 p++;
544               }
545               q++;
546             }
547           break;
548         }
549         case 4:
550         {
551           register unsigned char
552             pixel;
553
554           for (x=0; x < (long) number_pixels ; x++)
555           {
556             pixel=(unsigned char) *indexes++;
557             *q=((pixel & 0xf) << 4);
558             pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
559               GetOpacityPixelComponent(p)))+0.5);
560             *q|=((pixel & 0xf) << 0);
561             p++;
562             q++;
563           }
564           break;
565         }
566         case 8:
567         {
568           register unsigned char
569             pixel;
570
571           for (x=0; x < (long) number_pixels; x++)
572           {
573             q=PopCharPixel((unsigned char) indexes[x],q);
574             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
575               GetOpacityPixelComponent(p)));
576             q=PopCharPixel(pixel,q);
577             p++;
578             q+=quantum_info->pad;
579           }
580           break;
581         }
582         case 16:
583         {
584           register unsigned short
585             pixel;
586
587           if (quantum_info->format == FloatingPointQuantumFormat)
588             {
589               for (x=0; x < (long) number_pixels; x++)
590               {
591                 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
592                 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
593                   GetOpacityPixelComponent(p)));
594                 q=PopShortPixel(endian,pixel,q);
595                 p++;
596                 q+=quantum_info->pad;
597               }
598               break;
599             }
600           for (x=0; x < (long) number_pixels; x++)
601           {
602             q=PopShortPixel(endian,(unsigned short) indexes[x],q);
603             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
604               GetOpacityPixelComponent(p)));
605             q=PopShortPixel(endian,pixel,q);
606             p++;
607             q+=quantum_info->pad;
608           }
609           break;
610         }
611         case 32:
612         {
613           register unsigned long
614             pixel;
615
616           if (quantum_info->format == FloatingPointQuantumFormat)
617             {
618               for (x=0; x < (long) number_pixels; x++)
619               {
620                 float
621                   pixel;
622
623                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
624                 pixel=(float)  (GetAlphaPixelComponent(p));
625                 q=PopFloatPixel(&quantum_state,pixel,q);
626                 p++;
627                 q+=quantum_info->pad;
628               }
629               break;
630             }
631           for (x=0; x < (long) number_pixels; x++)
632           {
633             q=PopLongPixel(endian,(unsigned long) indexes[x],q);
634             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
635               GetOpacityPixelComponent(p)));
636             q=PopLongPixel(endian,pixel,q);
637             p++;
638             q+=quantum_info->pad;
639           }
640           break;
641         }
642         case 64:
643         {
644           if (quantum_info->format == FloatingPointQuantumFormat)
645             {
646               for (x=0; x < (long) number_pixels; x++)
647               {
648                 double
649                   pixel;
650
651                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
652                 pixel=(double) (GetAlphaPixelComponent(p));
653                 q=PopDoublePixel(&quantum_state,pixel,q);
654                 p++;
655                 q+=quantum_info->pad;
656               }
657               break;
658             }
659         }
660         default:
661         {
662           range=GetQuantumRange(image->depth);
663           for (x=0; x < (long) number_pixels; x++)
664           {
665             q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
666             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
667               (Quantum) (GetAlphaPixelComponent(p)),range),q);
668             p++;
669             q+=quantum_info->pad;
670           }
671           break;
672         }
673       }
674       break;
675     }
676     case GrayQuantum:
677     {
678       switch (quantum_info->depth)
679       {
680         case 1:
681         {
682           register Quantum
683             threshold;
684
685           register unsigned char
686             black,
687             white;
688
689           black=0x00;
690           white=0x01;
691           if (quantum_info->min_is_white != MagickFalse)
692             {
693               black=0x01;
694               white=0x00;
695             }
696           threshold=(Quantum) (QuantumRange/2);
697           for (x=((long) number_pixels-7); x > 0; x-=8)
698           {
699             *q='\0';
700             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
701             p++;
702             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
703             p++;
704             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
705             p++;
706             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
707             p++;
708             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
709             p++;
710             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
711             p++;
712             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
713             p++;
714             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
715             p++;
716             q++;
717           }
718           if ((number_pixels % 8) != 0)
719             {
720               *q='\0';
721               for (bit=7; bit >= (long) (8-(number_pixels % 8)); bit--)
722               {
723                 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
724                   bit;
725                 p++;
726               }
727               q++;
728             }
729           break;
730         }
731         case 4:
732         {
733           register unsigned char
734             pixel;
735
736           for (x=0; x < (long) (number_pixels-1) ; x+=2)
737           {
738             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
739             *q=(((pixel >> 4) & 0xf) << 4);
740             p++;
741             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
742             *q|=pixel >> 4;
743             p++;
744             q++;
745           }
746           if ((number_pixels % 2) != 0)
747             {
748               pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
749               *q=(((pixel >> 4) & 0xf) << 4);
750               p++;
751               q++;
752             }
753           break;
754         }
755         case 8:
756         {
757           register unsigned char
758             pixel;
759
760           for (x=0; x < (long) number_pixels; x++)
761           {
762             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
763             q=PopCharPixel(pixel,q);
764             p++;
765             q+=quantum_info->pad;
766           }
767           break;
768         }
769         case 10:
770         {
771           register unsigned short
772             pixel;
773
774           range=GetQuantumRange(image->depth);
775           if (quantum_info->pack == MagickFalse)
776             {
777               for (x=0; x < (long) number_pixels; x++)
778               {
779                 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
780                 q=PopShortPixel(endian,(unsigned short) ScaleQuantumToAny(
781                   (Quantum) pixel,range),q);
782                 p++;
783                 q+=quantum_info->pad;
784               }
785               break;
786             }
787           for (x=0; x < (long) number_pixels; x++)
788           {
789             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
790               PixelIntensityToQuantum(p),range),q);
791             p++;
792             q+=quantum_info->pad;
793           }
794           break;
795         }
796         case 12:
797         {
798           register unsigned short
799             pixel;
800
801           range=GetQuantumRange(image->depth);
802           if (quantum_info->pack == MagickFalse)
803             {
804               for (x=0; x < (long) number_pixels; x++)
805               {
806                 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
807                 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
808                 p++;
809                 q+=quantum_info->pad;
810               }
811               break;
812             }
813           for (x=0; x < (long) number_pixels; x++)
814           {
815             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
816               PixelIntensityToQuantum(p),range),q);
817             p++;
818             q+=quantum_info->pad;
819           }
820           break;
821         }
822         case 16:
823         {
824           register unsigned short
825             pixel;
826
827           if (quantum_info->format == FloatingPointQuantumFormat)
828             {
829               for (x=0; x < (long) number_pixels; x++)
830               {
831                 pixel=ScaleFloatToHalf(QuantumScale*PixelIntensityToQuantum(p));
832                 q=PopShortPixel(endian,pixel,q);
833                 p++;
834                 q+=quantum_info->pad;
835               }
836               break;
837             }
838           for (x=0; x < (long) number_pixels; x++)
839           {
840             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
841             q=PopShortPixel(endian,pixel,q);
842             p++;
843             q+=quantum_info->pad;
844           }
845           break;
846         }
847         case 32:
848         {
849           register unsigned long
850             pixel;
851
852           if (quantum_info->format == FloatingPointQuantumFormat)
853             {
854               for (x=0; x < (long) number_pixels; x++)
855               {
856                 float
857                   pixel;
858
859                 pixel=(float) PixelIntensityToQuantum(p);
860                 q=PopFloatPixel(&quantum_state,pixel,q);
861                 p++;
862                 q+=quantum_info->pad;
863               }
864               break;
865             }
866           for (x=0; x < (long) number_pixels; x++)
867           {
868             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
869             q=PopLongPixel(endian,pixel,q);
870             p++;
871             q+=quantum_info->pad;
872           }
873           break;
874         }
875         case 64:
876         {
877           if (quantum_info->format == FloatingPointQuantumFormat)
878             {
879               for (x=0; x < (long) number_pixels; x++)
880               {
881                 double
882                   pixel;
883
884                 pixel=(double) PixelIntensityToQuantum(p);
885                 q=PopDoublePixel(&quantum_state,pixel,q);
886                 p++;
887                 q+=quantum_info->pad;
888               }
889               break;
890             }
891         }
892         default:
893         {
894           range=GetQuantumRange(image->depth);
895           for (x=0; x < (long) number_pixels; x++)
896           {
897             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
898               PixelIntensityToQuantum(p),range),q);
899             p++;
900             q+=quantum_info->pad;
901           }
902           break;
903         }
904       }
905       break;
906     }
907     case GrayAlphaQuantum:
908     {
909       switch (quantum_info->depth)
910       {
911         case 1:
912         {
913           register Quantum
914             threshold;
915
916           register unsigned char
917             black,
918             pixel,
919             white;
920
921           black=0x00;
922           white=0x01;
923           if (quantum_info->min_is_white == MagickFalse)
924             {
925               black=0x01;
926               white=0x00;
927             }
928           threshold=(Quantum) (QuantumRange/2);
929           for (x=((long) number_pixels-3); x > 0; x-=4)
930           {
931             *q='\0';
932             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
933             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
934             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
935             p++;
936             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
937             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
938             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
939             p++;
940             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
941             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
942             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
943             p++;
944             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
945             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
946             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
947             p++;
948             q++;
949           }
950           if ((number_pixels % 4) != 0)
951             {
952               *q='\0';
953               for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
954               {
955                 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
956                   (bit+4);
957                 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
958                   0x01);
959                 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
960                   (bit+4-1));
961                 p++;
962               }
963               q++;
964             }
965           break;
966         }
967         case 4:
968         {
969           register unsigned char
970             pixel;
971
972           for (x=0; x < (long) number_pixels ; x++)
973           {
974             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
975             *q=(((pixel >> 4) & 0xf) << 4);
976             pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
977               GetOpacityPixelComponent(p)))+0.5);
978             *q|=pixel & 0xf;
979             p++;
980             q++;
981           }
982           break;
983         }
984         case 8:
985         {
986           register unsigned char
987             pixel;
988
989           for (x=0; x < (long) number_pixels; x++)
990           {
991             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
992             q=PopCharPixel(pixel,q);
993             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
994               GetOpacityPixelComponent(p)));
995             q=PopCharPixel(pixel,q);
996             p++;
997             q+=quantum_info->pad;
998           }
999           break;
1000         }
1001         case 16:
1002         {
1003           register unsigned short
1004             pixel;
1005
1006           if (quantum_info->format == FloatingPointQuantumFormat)
1007             {
1008               for (x=0; x < (long) number_pixels; x++)
1009               {
1010                 pixel=ScaleFloatToHalf(QuantumScale*PixelIntensityToQuantum(p));
1011                 q=PopShortPixel(endian,pixel,q);
1012                 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
1013                   GetOpacityPixelComponent(p)));
1014                 q=PopShortPixel(endian,pixel,q);
1015                 p++;
1016                 q+=quantum_info->pad;
1017               }
1018               break;
1019             }
1020           for (x=0; x < (long) number_pixels; x++)
1021           {
1022             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1023             q=PopShortPixel(endian,pixel,q);
1024             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1025               GetOpacityPixelComponent(p)));
1026             q=PopShortPixel(endian,pixel,q);
1027             p++;
1028             q+=quantum_info->pad;
1029           }
1030           break;
1031         }
1032         case 32:
1033         {
1034           register unsigned long
1035             pixel;
1036
1037           if (quantum_info->format == FloatingPointQuantumFormat)
1038             {
1039               for (x=0; x < (long) number_pixels; x++)
1040               {
1041                 float
1042                   pixel;
1043
1044                 pixel=(float) PixelIntensityToQuantum(p);
1045                 q=PopFloatPixel(&quantum_state,pixel,q);
1046                 pixel=(float) (GetAlphaPixelComponent(p));
1047                 q=PopFloatPixel(&quantum_state,pixel,q);
1048                 p++;
1049                 q+=quantum_info->pad;
1050               }
1051               break;
1052             }
1053           for (x=0; x < (long) number_pixels; x++)
1054           {
1055             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1056             q=PopLongPixel(endian,pixel,q);
1057             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1058               GetOpacityPixelComponent(p)));
1059             q=PopLongPixel(endian,pixel,q);
1060             p++;
1061             q+=quantum_info->pad;
1062           }
1063           break;
1064         }
1065         case 64:
1066         {
1067           if (quantum_info->format == FloatingPointQuantumFormat)
1068             {
1069               for (x=0; x < (long) number_pixels; x++)
1070               {
1071                 double
1072                   pixel;
1073
1074                 pixel=(double) PixelIntensityToQuantum(p);
1075                 q=PopDoublePixel(&quantum_state,pixel,q);
1076                 pixel=(double) (GetAlphaPixelComponent(p));
1077                 q=PopDoublePixel(&quantum_state,pixel,q);
1078                 p++;
1079                 q+=quantum_info->pad;
1080               }
1081               break;
1082             }
1083         }
1084         default:
1085         {
1086           range=GetQuantumRange(image->depth);
1087           for (x=0; x < (long) number_pixels; x++)
1088           {
1089             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1090               PixelIntensityToQuantum(p),range),q);
1091             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1092               (Quantum) (GetAlphaPixelComponent(p)),range),q);
1093             p++;
1094             q+=quantum_info->pad;
1095           }
1096           break;
1097         }
1098       }
1099       break;
1100     }
1101     case RedQuantum:
1102     case CyanQuantum:
1103     {
1104       switch (quantum_info->depth)
1105       {
1106         case 8:
1107         {
1108           register unsigned char
1109             pixel;
1110
1111           for (x=0; x < (long) number_pixels; x++)
1112           {
1113             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1114             q=PopCharPixel(pixel,q);
1115             p++;
1116             q+=quantum_info->pad;
1117           }
1118           break;
1119         }
1120         case 16:
1121         {
1122           register unsigned short
1123             pixel;
1124
1125           if (quantum_info->format == FloatingPointQuantumFormat)
1126             {
1127               for (x=0; x < (long) number_pixels; x++)
1128               {
1129                 pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
1130                 q=PopShortPixel(endian,pixel,q);
1131                 p++;
1132                 q+=quantum_info->pad;
1133               }
1134               break;
1135             }
1136           for (x=0; x < (long) number_pixels; x++)
1137           {
1138             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1139             q=PopShortPixel(endian,pixel,q);
1140             p++;
1141             q+=quantum_info->pad;
1142           }
1143           break;
1144         }
1145         case 32:
1146         {
1147           register unsigned long
1148             pixel;
1149
1150           if (quantum_info->format == FloatingPointQuantumFormat)
1151             {
1152               for (x=0; x < (long) number_pixels; x++)
1153               {
1154                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1155                 p++;
1156                 q+=quantum_info->pad;
1157               }
1158               break;
1159             }
1160           for (x=0; x < (long) number_pixels; x++)
1161           {
1162             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1163             q=PopLongPixel(endian,pixel,q);
1164             p++;
1165             q+=quantum_info->pad;
1166           }
1167           break;
1168         }
1169         case 64:
1170         {
1171           if (quantum_info->format == FloatingPointQuantumFormat)
1172             {
1173               for (x=0; x < (long) number_pixels; x++)
1174               {
1175                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1176                 p++;
1177                 q+=quantum_info->pad;
1178               }
1179               break;
1180             }
1181         }
1182         default:
1183         {
1184           range=GetQuantumRange(image->depth);
1185           for (x=0; x < (long) number_pixels; x++)
1186           {
1187             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1188               p->red,range),q);
1189             p++;
1190             q+=quantum_info->pad;
1191           }
1192           break;
1193         }
1194       }
1195       break;
1196     }
1197     case GreenQuantum:
1198     case MagentaQuantum:
1199     {
1200       switch (quantum_info->depth)
1201       {
1202         case 8:
1203         {
1204           register unsigned char
1205             pixel;
1206
1207           for (x=0; x < (long) number_pixels; x++)
1208           {
1209             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1210             q=PopCharPixel(pixel,q);
1211             p++;
1212             q+=quantum_info->pad;
1213           }
1214           break;
1215         }
1216         case 16:
1217         {
1218           register unsigned short
1219             pixel;
1220
1221           if (quantum_info->format == FloatingPointQuantumFormat)
1222             {
1223               for (x=0; x < (long) number_pixels; x++)
1224               {
1225                 pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
1226                 q=PopShortPixel(endian,pixel,q);
1227                 p++;
1228                 q+=quantum_info->pad;
1229               }
1230               break;
1231             }
1232           for (x=0; x < (long) number_pixels; x++)
1233           {
1234             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1235             q=PopShortPixel(endian,pixel,q);
1236             p++;
1237             q+=quantum_info->pad;
1238           }
1239           break;
1240         }
1241         case 32:
1242         {
1243           register unsigned long
1244             pixel;
1245
1246           if (quantum_info->format == FloatingPointQuantumFormat)
1247             {
1248               for (x=0; x < (long) number_pixels; x++)
1249               {
1250                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1251                 p++;
1252                 q+=quantum_info->pad;
1253               }
1254               break;
1255             }
1256           for (x=0; x < (long) number_pixels; x++)
1257           {
1258             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1259             q=PopLongPixel(endian,pixel,q);
1260             p++;
1261             q+=quantum_info->pad;
1262           }
1263           break;
1264         }
1265         case 64:
1266         {
1267           if (quantum_info->format == FloatingPointQuantumFormat)
1268             {
1269               for (x=0; x < (long) number_pixels; x++)
1270               {
1271                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1272                 p++;
1273                 q+=quantum_info->pad;
1274               }
1275               break;
1276             }
1277         }
1278         default:
1279         {
1280           range=GetQuantumRange(image->depth);
1281           for (x=0; x < (long) number_pixels; x++)
1282           {
1283             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1284               p->green,range),q);
1285             p++;
1286             q+=quantum_info->pad;
1287           }
1288           break;
1289         }
1290       }
1291       break;
1292     }
1293     case BlueQuantum:
1294     case YellowQuantum:
1295     {
1296       switch (quantum_info->depth)
1297       {
1298         case 8:
1299         {
1300           register unsigned char
1301             pixel;
1302
1303           for (x=0; x < (long) number_pixels; x++)
1304           {
1305             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1306             q=PopCharPixel(pixel,q);
1307             p++;
1308             q+=quantum_info->pad;
1309           }
1310           break;
1311         }
1312         case 16:
1313         {
1314           register unsigned short
1315             pixel;
1316
1317           if (quantum_info->format == FloatingPointQuantumFormat)
1318             {
1319               for (x=0; x < (long) number_pixels; x++)
1320               {
1321                 pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
1322                 q=PopShortPixel(endian,pixel,q);
1323                 p++;
1324                 q+=quantum_info->pad;
1325               }
1326               break;
1327             }
1328           for (x=0; x < (long) number_pixels; x++)
1329           {
1330             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1331             q=PopShortPixel(endian,pixel,q);
1332             p++;
1333             q+=quantum_info->pad;
1334           }
1335           break;
1336         }
1337         case 32:
1338         {
1339           register unsigned long
1340             pixel;
1341
1342           if (quantum_info->format == FloatingPointQuantumFormat)
1343             {
1344               for (x=0; x < (long) number_pixels; x++)
1345               {
1346                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1347                 p++;
1348                 q+=quantum_info->pad;
1349               }
1350               break;
1351             }
1352           for (x=0; x < (long) number_pixels; x++)
1353           {
1354             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1355             q=PopLongPixel(endian,pixel,q);
1356             p++;
1357             q+=quantum_info->pad;
1358           }
1359           break;
1360         }
1361         case 64:
1362         {
1363           if (quantum_info->format == FloatingPointQuantumFormat)
1364             {
1365               for (x=0; x < (long) number_pixels; x++)
1366               {
1367                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1368                 p++;
1369                 q+=quantum_info->pad;
1370               }
1371               break;
1372             }
1373         }
1374         default:
1375         {
1376           range=GetQuantumRange(image->depth);
1377           for (x=0; x < (long) number_pixels; x++)
1378           {
1379             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1380               p->blue,range),q);
1381             p++;
1382             q+=quantum_info->pad;
1383           }
1384           break;
1385         }
1386       }
1387       break;
1388     }
1389     case AlphaQuantum:
1390     {
1391       switch (quantum_info->depth)
1392       {
1393         case 8:
1394         {
1395           register unsigned char
1396             pixel;
1397
1398           for (x=0; x < (long) number_pixels; x++)
1399           {
1400             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1401               GetOpacityPixelComponent(p)));
1402             q=PopCharPixel(pixel,q);
1403             p++;
1404             q+=quantum_info->pad;
1405           }
1406           break;
1407         }
1408         case 16:
1409         {
1410           register unsigned short
1411             pixel;
1412
1413           if (quantum_info->format == FloatingPointQuantumFormat)
1414             {
1415               for (x=0; x < (long) number_pixels; x++)
1416               {
1417                 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
1418                   GetOpacityPixelComponent(p)));
1419                 q=PopShortPixel(endian,pixel,q);
1420                 p++;
1421                 q+=quantum_info->pad;
1422               }
1423               break;
1424             }
1425           for (x=0; x < (long) number_pixels; x++)
1426           {
1427             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1428               GetOpacityPixelComponent(p)));
1429             q=PopShortPixel(endian,pixel,q);
1430             p++;
1431             q+=quantum_info->pad;
1432           }
1433           break;
1434         }
1435         case 32:
1436         {
1437           register unsigned long
1438             pixel;
1439
1440           if (quantum_info->format == FloatingPointQuantumFormat)
1441             {
1442               for (x=0; x < (long) number_pixels; x++)
1443               {
1444                 float
1445                   pixel;
1446
1447                 pixel=(float) (GetAlphaPixelComponent(p));
1448                 q=PopFloatPixel(&quantum_state,pixel,q);
1449                 p++;
1450                 q+=quantum_info->pad;
1451               }
1452               break;
1453             }
1454           for (x=0; x < (long) number_pixels; x++)
1455           {
1456             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1457               GetOpacityPixelComponent(p)));
1458             q=PopLongPixel(endian,pixel,q);
1459             p++;
1460             q+=quantum_info->pad;
1461           }
1462           break;
1463         }
1464         case 64:
1465         {
1466           if (quantum_info->format == FloatingPointQuantumFormat)
1467             {
1468               for (x=0; x < (long) number_pixels; x++)
1469               {
1470                 double
1471                   pixel;
1472
1473                 pixel=(double) (GetAlphaPixelComponent(p));
1474                 q=PopDoublePixel(&quantum_state,pixel,q);
1475                 p++;
1476                 q+=quantum_info->pad;
1477               }
1478               break;
1479             }
1480         }
1481         default:
1482         {
1483           range=GetQuantumRange(image->depth);
1484           for (x=0; x < (long) number_pixels; x++)
1485           {
1486             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1487               (Quantum) (GetAlphaPixelComponent(p)),range),q);
1488             p++;
1489             q+=quantum_info->pad;
1490           }
1491           break;
1492         }
1493       }
1494       break;
1495     }
1496     case OpacityQuantum:
1497     {
1498       switch (quantum_info->depth)
1499       {
1500         case 8:
1501         {
1502           register unsigned char
1503             pixel;
1504
1505           for (x=0; x < (long) number_pixels; x++)
1506           {
1507             pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
1508             q=PopCharPixel(pixel,q);
1509             p++;
1510             q+=quantum_info->pad;
1511           }
1512           break;
1513         }
1514         case 16:
1515         {
1516           register unsigned short
1517             pixel;
1518
1519           if (quantum_info->format == FloatingPointQuantumFormat)
1520             {
1521               for (x=0; x < (long) number_pixels; x++)
1522               {
1523                 pixel=ScaleFloatToHalf(QuantumScale*GetOpacityPixelComponent(p));
1524                 q=PopShortPixel(endian,pixel,q);
1525                 p++;
1526                 q+=quantum_info->pad;
1527               }
1528               break;
1529             }
1530           for (x=0; x < (long) number_pixels; x++)
1531           {
1532             pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1533             q=PopShortPixel(endian,pixel,q);
1534             p++;
1535             q+=quantum_info->pad;
1536           }
1537           break;
1538         }
1539         case 32:
1540         {
1541           register unsigned long
1542             pixel;
1543
1544           if (quantum_info->format == FloatingPointQuantumFormat)
1545             {
1546               for (x=0; x < (long) number_pixels; x++)
1547               {
1548                 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
1549                 p++;
1550                 q+=quantum_info->pad;
1551               }
1552               break;
1553             }
1554           for (x=0; x < (long) number_pixels; x++)
1555           {
1556             pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1557             q=PopLongPixel(endian,pixel,q);
1558             p++;
1559             q+=quantum_info->pad;
1560           }
1561           break;
1562         }
1563         case 64:
1564         {
1565           if (quantum_info->format == FloatingPointQuantumFormat)
1566             {
1567               for (x=0; x < (long) number_pixels; x++)
1568               {
1569                 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
1570                 p++;
1571                 q+=quantum_info->pad;
1572               }
1573               break;
1574             }
1575         }
1576         default:
1577         {
1578           range=GetQuantumRange(image->depth);
1579           for (x=0; x < (long) number_pixels; x++)
1580           {
1581             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1582               p->opacity,range),q);
1583             p++;
1584             q+=quantum_info->pad;
1585           }
1586           break;
1587         }
1588       }
1589       break;
1590     }
1591     case BlackQuantum:
1592     {
1593       if (image->colorspace != CMYKColorspace)
1594         {
1595           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1596             "ColorSeparatedImageRequired","`%s'",image->filename);
1597           return(extent);
1598         }
1599       switch (quantum_info->depth)
1600       {
1601         case 8:
1602         {
1603           register unsigned char
1604             pixel;
1605
1606           for (x=0; x < (long) number_pixels; x++)
1607           {
1608             pixel=ScaleQuantumToChar(indexes[x]);
1609             q=PopCharPixel(pixel,q);
1610             p++;
1611             q+=quantum_info->pad;
1612           }
1613           break;
1614         }
1615         case 16:
1616         {
1617           register unsigned short
1618             pixel;
1619
1620           if (quantum_info->format == FloatingPointQuantumFormat)
1621             {
1622               for (x=0; x < (long) number_pixels; x++)
1623               {
1624                 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
1625                 q=PopShortPixel(endian,pixel,q);
1626                 p++;
1627                 q+=quantum_info->pad;
1628               }
1629               break;
1630             }
1631           for (x=0; x < (long) number_pixels; x++)
1632           {
1633             pixel=ScaleQuantumToShort(indexes[x]);
1634             q=PopShortPixel(endian,pixel,q);
1635             p++;
1636             q+=quantum_info->pad;
1637           }
1638           break;
1639         }
1640         case 32:
1641         {
1642           register unsigned long
1643             pixel;
1644
1645           if (quantum_info->format == FloatingPointQuantumFormat)
1646             {
1647               for (x=0; x < (long) number_pixels; x++)
1648               {
1649                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
1650                 p++;
1651                 q+=quantum_info->pad;
1652               }
1653               break;
1654             }
1655           for (x=0; x < (long) number_pixels; x++)
1656           {
1657             pixel=ScaleQuantumToLong(indexes[x]);
1658             q=PopLongPixel(endian,pixel,q);
1659             p++;
1660             q+=quantum_info->pad;
1661           }
1662           break;
1663         }
1664         case 64:
1665         {
1666           if (quantum_info->format == FloatingPointQuantumFormat)
1667             {
1668               for (x=0; x < (long) number_pixels; x++)
1669               {
1670                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
1671                 p++;
1672                 q+=quantum_info->pad;
1673               }
1674               break;
1675             }
1676         }
1677         default:
1678         {
1679           range=GetQuantumRange(image->depth);
1680           for (x=0; x < (long) number_pixels; x++)
1681           {
1682             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1683               (Quantum) indexes[x],range),q);
1684             p++;
1685             q+=quantum_info->pad;
1686           }
1687           break;
1688         }
1689       }
1690       break;
1691     }
1692     case RGBQuantum:
1693     case CbYCrQuantum:
1694     {
1695       switch (quantum_info->depth)
1696       {
1697         case 8:
1698         {
1699           for (x=0; x < (long) number_pixels; x++)
1700           {
1701             q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
1702             q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
1703             q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
1704             p++;
1705             q+=quantum_info->pad;
1706           }
1707           break;
1708         }
1709         case 10:
1710         {
1711           register unsigned long
1712             pixel;
1713
1714           range=GetQuantumRange(image->depth);
1715           if (quantum_info->pack == MagickFalse)
1716             {
1717               for (x=0; x < (long) number_pixels; x++)
1718               {
1719                 pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
1720                   ScaleQuantumToAny(p->green,range) <<  12 |
1721                   ScaleQuantumToAny(p->blue,range) << 2);
1722                 q=PopLongPixel(endian,pixel,q);
1723                 p++;
1724                 q+=quantum_info->pad;
1725               }
1726               break;
1727             }
1728           if (quantum_info->quantum == 32UL)
1729             {
1730               for (x=0; x < (long) number_pixels; x++)
1731               {
1732                 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1733                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1734                 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1735                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1736                 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1737                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1738                 p++;
1739                 q+=quantum_info->pad;
1740               }
1741               break;
1742             }
1743           for (x=0; x < (long) number_pixels; x++)
1744           {
1745             pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1746             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1747             pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1748             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1749             pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1750             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1751             p++;
1752             q+=quantum_info->pad;
1753           }
1754           break;
1755         }
1756         case 12:
1757         {
1758           register unsigned long
1759             pixel;
1760
1761           range=GetQuantumRange(image->depth);
1762           if (quantum_info->pack == MagickFalse)
1763             {
1764               for (x=0; x < (long) (3*number_pixels-1); x+=2)
1765               {
1766                 switch (x % 3)
1767                 {
1768                   default:
1769                   case 0:
1770                   {
1771                     pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1772                     break;
1773                   }
1774                   case 1:
1775                   {
1776                     pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1777                     break;
1778                   }
1779                   case 2:
1780                   {
1781                     pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1782                     p++;
1783                     break;
1784                   }
1785                 }
1786                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1787                 switch ((x+1) % 3)
1788                 {
1789                   default:
1790                   case 0:
1791                   {
1792                     pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1793                     break;
1794                   }
1795                   case 1:
1796                   {
1797                     pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1798                     break;
1799                   }
1800                   case 2:
1801                   {
1802                     pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1803                     p++;
1804                     break;
1805                   }
1806                 }
1807                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1808                 q+=quantum_info->pad;
1809               }
1810               for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1811               {
1812                 switch ((x+bit) % 3)
1813                 {
1814                   default:
1815                   case 0:
1816                   {
1817                     pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1818                     break;
1819                   }
1820                   case 1:
1821                   {
1822                     pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1823                     break;
1824                   }
1825                   case 2:
1826                   {
1827                     pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1828                     p++;
1829                     break;
1830                   }
1831                 }
1832                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1833                 q+=quantum_info->pad;
1834               }
1835               if (bit != 0)
1836                 p++;
1837               break;
1838             }
1839           if (quantum_info->quantum == 32UL)
1840             {
1841               for (x=0; x < (long) number_pixels; x++)
1842               {
1843                 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1844                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1845                 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1846                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1847                 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1848                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1849                 p++;
1850                 q+=quantum_info->pad;
1851               }
1852               break;
1853             }
1854           for (x=0; x < (long) number_pixels; x++)
1855           {
1856             pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1857             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1858             pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1859             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1860             pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1861             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1862             p++;
1863             q+=quantum_info->pad;
1864           }
1865           break;
1866         }
1867         case 16:
1868         {
1869           register unsigned short
1870             pixel;
1871
1872           if (quantum_info->format == FloatingPointQuantumFormat)
1873             {
1874               for (x=0; x < (long) number_pixels; x++)
1875               {
1876                 pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
1877                 q=PopShortPixel(endian,pixel,q);
1878                 pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
1879                 q=PopShortPixel(endian,pixel,q);
1880                 pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
1881                 q=PopShortPixel(endian,pixel,q);
1882                 p++;
1883                 q+=quantum_info->pad;
1884               }
1885               break;
1886             }
1887           for (x=0; x < (long) number_pixels; x++)
1888           {
1889             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1890             q=PopShortPixel(endian,pixel,q);
1891             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1892             q=PopShortPixel(endian,pixel,q);
1893             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1894             q=PopShortPixel(endian,pixel,q);
1895             p++;
1896             q+=quantum_info->pad;
1897           }
1898           break;
1899         }
1900         case 32:
1901         {
1902           register unsigned long
1903             pixel;
1904
1905           if (quantum_info->format == FloatingPointQuantumFormat)
1906             {
1907               for (x=0; x < (long) number_pixels; x++)
1908               {
1909                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1910                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1911                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1912                 p++;
1913                 q+=quantum_info->pad;
1914               }
1915               break;
1916             }
1917           for (x=0; x < (long) number_pixels; x++)
1918           {
1919             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1920             q=PopLongPixel(endian,pixel,q);
1921             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1922             q=PopLongPixel(endian,pixel,q);
1923             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1924             q=PopLongPixel(endian,pixel,q);
1925             p++;
1926             q+=quantum_info->pad;
1927           }
1928           break;
1929         }
1930         case 64:
1931         {
1932           if (quantum_info->format == FloatingPointQuantumFormat)
1933             {
1934               for (x=0; x < (long) number_pixels; x++)
1935               {
1936                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1937                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1938                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1939                 p++;
1940                 q+=quantum_info->pad;
1941               }
1942               break;
1943             }
1944         }
1945         default:
1946         {
1947           range=GetQuantumRange(image->depth);
1948           for (x=0; x < (long) number_pixels; x++)
1949           {
1950             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1951               p->red,range),q);
1952             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1953               p->green,range),q);
1954             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1955               p->blue,range),q);
1956             p++;
1957             q+=quantum_info->pad;
1958           }
1959           break;
1960         }
1961       }
1962       break;
1963     }
1964     case RGBAQuantum:
1965     case RGBOQuantum:
1966     case CbYCrAQuantum:
1967     {
1968       switch (quantum_info->depth)
1969       {
1970         case 8:
1971         {
1972           register unsigned char
1973             pixel;
1974
1975           for (x=0; x < (long) number_pixels; x++)
1976           {
1977             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1978             q=PopCharPixel(pixel,q);
1979             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1980             q=PopCharPixel(pixel,q);
1981             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1982             q=PopCharPixel(pixel,q);
1983             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1984               GetOpacityPixelComponent(p)));
1985             q=PopCharPixel(pixel,q);
1986             p++;
1987             q+=quantum_info->pad;
1988           }
1989           break;
1990         }
1991         case 16:
1992         {
1993           register unsigned short
1994             pixel;
1995
1996           if (quantum_info->format == FloatingPointQuantumFormat)
1997             {
1998               for (x=0; x < (long) number_pixels; x++)
1999               {
2000                 pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
2001                 q=PopShortPixel(endian,pixel,q);
2002                 pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
2003                 q=PopShortPixel(endian,pixel,q);
2004                 pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
2005                 q=PopShortPixel(endian,pixel,q);
2006                 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
2007                   GetOpacityPixelComponent(p)));
2008                 q=PopShortPixel(endian,pixel,q);
2009                 p++;
2010                 q+=quantum_info->pad;
2011               }
2012               break;
2013             }
2014           for (x=0; x < (long) number_pixels; x++)
2015           {
2016             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2017             q=PopShortPixel(endian,pixel,q);
2018             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2019             q=PopShortPixel(endian,pixel,q);
2020             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2021             q=PopShortPixel(endian,pixel,q);
2022             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2023               GetOpacityPixelComponent(p)));
2024             q=PopShortPixel(endian,pixel,q);
2025             p++;
2026             q+=quantum_info->pad;
2027           }
2028           break;
2029         }
2030         case 32:
2031         {
2032           register unsigned long
2033             pixel;
2034
2035           if (quantum_info->format == FloatingPointQuantumFormat)
2036             {
2037               for (x=0; x < (long) number_pixels; x++)
2038               {
2039                 float
2040                   pixel;
2041
2042                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2043                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2044                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2045                 pixel=(float) (GetAlphaPixelComponent(p));
2046                 q=PopFloatPixel(&quantum_state,pixel,q);
2047                 p++;
2048                 q+=quantum_info->pad;
2049               }
2050               break;
2051             }
2052           for (x=0; x < (long) number_pixels; x++)
2053           {
2054             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2055             q=PopLongPixel(endian,pixel,q);
2056             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2057             q=PopLongPixel(endian,pixel,q);
2058             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2059             q=PopLongPixel(endian,pixel,q);
2060             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2061               GetOpacityPixelComponent(p)));
2062             q=PopLongPixel(endian,pixel,q);
2063             p++;
2064             q+=quantum_info->pad;
2065           }
2066           break;
2067         }
2068         case 64:
2069         {
2070           if (quantum_info->format == FloatingPointQuantumFormat)
2071             {
2072               double
2073                 pixel;
2074
2075               for (x=0; x < (long) number_pixels; x++)
2076               {
2077                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2078                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2079                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2080                 pixel=(double) (GetAlphaPixelComponent(p));
2081                 q=PopDoublePixel(&quantum_state,pixel,q);
2082                 p++;
2083                 q+=quantum_info->pad;
2084               }
2085               break;
2086             }
2087         }
2088         default:
2089         {
2090           range=GetQuantumRange(image->depth);
2091           for (x=0; x < (long) number_pixels; x++)
2092           {
2093             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2094               p->red,range),q);
2095             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2096               p->green,range),q);
2097             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2098               p->blue,range),q);
2099             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2100               (Quantum) (GetAlphaPixelComponent(p)),range),q);
2101             p++;
2102             q+=quantum_info->pad;
2103           }
2104           break;
2105         }
2106       }
2107       break;
2108     }
2109     case CMYKQuantum:
2110     {
2111       if (image->colorspace != CMYKColorspace)
2112         {
2113           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2114             "ColorSeparatedImageRequired","`%s'",image->filename);
2115           return(extent);
2116         }
2117       switch (quantum_info->depth)
2118       {
2119         case 8:
2120         {
2121           register unsigned char
2122             pixel;
2123
2124           for (x=0; x < (long) number_pixels; x++)
2125           {
2126             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2127             q=PopCharPixel(pixel,q);
2128             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2129             q=PopCharPixel(pixel,q);
2130             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2131             q=PopCharPixel(pixel,q);
2132             pixel=ScaleQuantumToChar(indexes[x]);
2133             q=PopCharPixel(pixel,q);
2134             p++;
2135             q+=quantum_info->pad;
2136           }
2137           break;
2138         }
2139         case 16:
2140         {
2141           register unsigned short
2142             pixel;
2143
2144           if (quantum_info->format == FloatingPointQuantumFormat)
2145             {
2146               for (x=0; x < (long) number_pixels; x++)
2147               {
2148                 pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
2149                 q=PopShortPixel(endian,pixel,q);
2150                 pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
2151                 q=PopShortPixel(endian,pixel,q);
2152                 pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
2153                 q=PopShortPixel(endian,pixel,q);
2154                 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
2155                 q=PopShortPixel(endian,pixel,q);
2156                 p++;
2157                 q+=quantum_info->pad;
2158               }
2159               break;
2160             }
2161           for (x=0; x < (long) number_pixels; x++)
2162           {
2163             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2164             q=PopShortPixel(endian,pixel,q);
2165             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2166             q=PopShortPixel(endian,pixel,q);
2167             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2168             q=PopShortPixel(endian,pixel,q);
2169             pixel=ScaleQuantumToShort(indexes[x]);
2170             q=PopShortPixel(endian,pixel,q);
2171             p++;
2172             q+=quantum_info->pad;
2173           }
2174           break;
2175         }
2176         case 32:
2177         {
2178           register unsigned long
2179             pixel;
2180
2181           if (quantum_info->format == FloatingPointQuantumFormat)
2182             {
2183               for (x=0; x < (long) number_pixels; x++)
2184               {
2185                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2186                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2187                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2188                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2189                 p++;
2190                 q+=quantum_info->pad;
2191               }
2192               break;
2193             }
2194           for (x=0; x < (long) number_pixels; x++)
2195           {
2196             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2197             q=PopLongPixel(endian,pixel,q);
2198             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2199             q=PopLongPixel(endian,pixel,q);
2200             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2201             q=PopLongPixel(endian,pixel,q);
2202             pixel=ScaleQuantumToLong(indexes[x]);
2203             q=PopLongPixel(endian,pixel,q);
2204             p++;
2205             q+=quantum_info->pad;
2206           }
2207           break;
2208         }
2209         case 64:
2210         {
2211           if (quantum_info->format == FloatingPointQuantumFormat)
2212             {
2213               for (x=0; x < (long) number_pixels; x++)
2214               {
2215                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2216                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2217                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2218                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2219                 p++;
2220                 q+=quantum_info->pad;
2221               }
2222               break;
2223             }
2224         }
2225         default:
2226         {
2227           range=GetQuantumRange(image->depth);
2228           for (x=0; x < (long) number_pixels; x++)
2229           {
2230             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2231               p->red,range),q);
2232             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2233               p->green,range),q);
2234             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2235               p->blue,range),q);
2236             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2237               indexes[x],range),q);
2238             p++;
2239             q+=quantum_info->pad;
2240           }
2241           break;
2242         }
2243       }
2244       break;
2245     }
2246     case CMYKAQuantum:
2247     case CMYKOQuantum:
2248     {
2249       if (image->colorspace != CMYKColorspace)
2250         {
2251           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2252             "ColorSeparatedImageRequired","`%s'",image->filename);
2253           return(extent);
2254         }
2255       switch (quantum_info->depth)
2256       {
2257         case 8:
2258         {
2259           register unsigned char
2260             pixel;
2261
2262           for (x=0; x < (long) number_pixels; x++)
2263           {
2264             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2265             q=PopCharPixel(pixel,q);
2266             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2267             q=PopCharPixel(pixel,q);
2268             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2269             q=PopCharPixel(pixel,q);
2270             pixel=ScaleQuantumToChar(indexes[x]);
2271             q=PopCharPixel(pixel,q);
2272             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2273               GetOpacityPixelComponent(p)));
2274             q=PopCharPixel(pixel,q);
2275             p++;
2276             q+=quantum_info->pad;
2277           }
2278           break;
2279         }
2280         case 16:
2281         {
2282           register unsigned short
2283             pixel;
2284
2285           if (quantum_info->format == FloatingPointQuantumFormat)
2286             {
2287               for (x=0; x < (long) number_pixels; x++)
2288               {
2289                 pixel=ScaleFloatToHalf(QuantumScale*GetRedPixelComponent(p));
2290                 q=PopShortPixel(endian,pixel,q);
2291                 pixel=ScaleFloatToHalf(QuantumScale*GetGreenPixelComponent(p));
2292                 q=PopShortPixel(endian,pixel,q);
2293                 pixel=ScaleFloatToHalf(QuantumScale*GetBluePixelComponent(p));
2294                 q=PopShortPixel(endian,pixel,q);
2295                 pixel=ScaleFloatToHalf(QuantumScale*indexes[x]);
2296                 q=PopShortPixel(endian,pixel,q);
2297                 pixel=ScaleFloatToHalf(QuantumScale*(QuantumRange-
2298                   GetOpacityPixelComponent(p)));
2299                 q=PopShortPixel(endian,pixel,q);
2300                 p++;
2301                 q+=quantum_info->pad;
2302               }
2303               break;
2304             }
2305           for (x=0; x < (long) number_pixels; x++)
2306           {
2307             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2308             q=PopShortPixel(endian,pixel,q);
2309             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2310             q=PopShortPixel(endian,pixel,q);
2311             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2312             q=PopShortPixel(endian,pixel,q);
2313             pixel=ScaleQuantumToShort(indexes[x]);
2314             q=PopShortPixel(endian,pixel,q);
2315             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2316               GetOpacityPixelComponent(p)));
2317             q=PopShortPixel(endian,pixel,q);
2318             p++;
2319             q+=quantum_info->pad;
2320           }
2321           break;
2322         }
2323         case 32:
2324         {
2325           register unsigned long
2326             pixel;
2327
2328           if (quantum_info->format == FloatingPointQuantumFormat)
2329             {
2330               for (x=0; x < (long) number_pixels; x++)
2331               {
2332                 float
2333                   pixel;
2334
2335                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2336                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2337                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2338                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2339                 pixel=(float) (GetAlphaPixelComponent(p));
2340                 q=PopFloatPixel(&quantum_state,pixel,q);
2341                 p++;
2342                 q+=quantum_info->pad;
2343               }
2344               break;
2345             }
2346           for (x=0; x < (long) number_pixels; x++)
2347           {
2348             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2349             q=PopLongPixel(endian,pixel,q);
2350             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2351             q=PopLongPixel(endian,pixel,q);
2352             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2353             q=PopLongPixel(endian,pixel,q);
2354             pixel=ScaleQuantumToLong(indexes[x]);
2355             q=PopLongPixel(endian,pixel,q);
2356             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2357               GetOpacityPixelComponent(p)));
2358             q=PopLongPixel(endian,pixel,q);
2359             p++;
2360             q+=quantum_info->pad;
2361           }
2362           break;
2363         }
2364         case 64:
2365         {
2366           if (quantum_info->format == FloatingPointQuantumFormat)
2367             {
2368               double
2369                 pixel;
2370
2371               for (x=0; x < (long) number_pixels; x++)
2372               {
2373                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2374                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2375                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2376                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2377                 pixel=(double) (GetAlphaPixelComponent(p));
2378                 q=PopDoublePixel(&quantum_state,pixel,q);
2379                 p++;
2380                 q+=quantum_info->pad;
2381               }
2382               break;
2383             }
2384         }
2385         default:
2386         {
2387           range=GetQuantumRange(image->depth);
2388           for (x=0; x < (long) number_pixels; x++)
2389           {
2390             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2391               p->red,range),q);
2392             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2393               p->green,range),q);
2394             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2395               p->blue,range),q);
2396             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2397               indexes[x],range),q);
2398             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2399               p->opacity,range),q);
2400             p++;
2401             q+=quantum_info->pad;
2402           }
2403           break;
2404         }
2405       }
2406       break;
2407     }
2408     case CbYCrYQuantum:
2409     {
2410      long
2411         n;
2412
2413       Quantum
2414         cbcr[4];
2415
2416       register long
2417         i;
2418
2419       register unsigned long
2420         pixel;
2421
2422       unsigned long
2423         quantum;
2424
2425       n=0;
2426       quantum=0;
2427       range=GetQuantumRange(image->depth);
2428       switch (quantum_info->depth)
2429       {
2430         case 10:
2431         {
2432           if (quantum_info->pack == MagickFalse)
2433             {
2434               for (x=0; x < (long) number_pixels; x+=2)
2435               {
2436                 for (i=0; i < 4; i++)
2437                 {
2438                   switch (n % 3)
2439                   {
2440                     case 0:
2441                     {
2442                       quantum=GetRedPixelComponent(p);
2443                       break;
2444                     }
2445                     case 1:
2446                     {
2447                       quantum=GetGreenPixelComponent(p);
2448                       break;
2449                     }
2450                     case 2:
2451                     {
2452                       quantum=GetBluePixelComponent(p);
2453                       break;
2454                     }
2455                   }
2456                   cbcr[i]=(Quantum) quantum;
2457                   n++;
2458                 }
2459                 pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
2460                   (unsigned long) (cbcr[0]) <<  12 |
2461                   (unsigned long) (cbcr[2]) << 2);
2462                 q=PopLongPixel(endian,pixel,q);
2463                 p++;
2464                 pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
2465                   (unsigned long) (cbcr[0]) <<  12 |
2466                   (unsigned long) (cbcr[2]) << 2);
2467                 q=PopLongPixel(endian,pixel,q);
2468                 p++;
2469                 q+=quantum_info->pad;
2470               }
2471               break;
2472             }
2473           break;
2474         }
2475         default:
2476         {
2477           for (x=0; x < (long) number_pixels; x+=2)
2478           {
2479             for (i=0; i < 4; i++)
2480             {
2481               switch (n % 3)
2482               {
2483                 case 0:
2484                 {
2485                   quantum=GetRedPixelComponent(p);
2486                   break;
2487                 }
2488                 case 1:
2489                 {
2490                   quantum=GetGreenPixelComponent(p);
2491                   break;
2492                 }
2493                 case 2:
2494                 {
2495                   quantum=GetBluePixelComponent(p);
2496                   break;
2497                 }
2498               }
2499               cbcr[i]=(Quantum) quantum;
2500               n++;
2501             }
2502             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2503               cbcr[1],range),q);
2504             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2505               cbcr[0],range),q);
2506             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2507               cbcr[2],range),q);
2508             p++;
2509             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2510               cbcr[3],range),q);
2511             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2512               cbcr[0],range),q);
2513             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2514               cbcr[2],range),q);
2515             p++;
2516             q+=quantum_info->pad;
2517           }
2518           break;
2519         }
2520       }
2521       break;
2522     }
2523     default:
2524       break;
2525   }
2526   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2527     {
2528       Quantum
2529         quantum;
2530
2531       register PixelPacket
2532         *restrict q;
2533
2534       q=GetAuthenticPixelQueue(image);
2535       if (image_view != (CacheView *) NULL)
2536         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2537       for (x=0; x < (long) number_pixels; x++)
2538       {
2539         quantum=q->red;
2540         q->red=q->green;
2541         q->green=quantum;
2542         q++;
2543       }
2544     }
2545   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2546     {
2547       register PixelPacket
2548         *restrict q;
2549
2550       q=GetAuthenticPixelQueue(image);
2551       if (image_view != (CacheView *) NULL)
2552         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2553       for (x=0; x < (long) number_pixels; x++)
2554       {
2555         q->opacity=(Quantum) GetAlphaPixelComponent(q);
2556         q++;
2557       }
2558     }
2559   return(extent);
2560 }