granicus.if.org Git - imagemagick/blob - 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,SinglePrecisionToBinary16(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=SinglePrecisionToBinary16(QuantumScale*
 593                   GetAlphaPixelComponent(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=SinglePrecisionToBinary16(QuantumScale*
 832                   PixelIntensityToQuantum(p));
 833                 q=PopShortPixel(endian,pixel,q);
 834                 p++;
 835                 q+=quantum_info->pad;
 836               }
 837               break;
 838             }
 839           for (x=0; x < (long) number_pixels; x++)
 840           {
 841             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
 842             q=PopShortPixel(endian,pixel,q);
 843             p++;
 844             q+=quantum_info->pad;
 845           }
 846           break;
 847         }
 848         case 32:
 849         {
 850           register unsigned long
 851             pixel;
 852
 853           if (quantum_info->format == FloatingPointQuantumFormat)
 854             {
 855               for (x=0; x < (long) number_pixels; x++)
 856               {
 857                 float
 858                   pixel;
 859
 860                 pixel=(float) PixelIntensityToQuantum(p);
 861                 q=PopFloatPixel(&quantum_state,pixel,q);
 862                 p++;
 863                 q+=quantum_info->pad;
 864               }
 865               break;
 866             }
 867           for (x=0; x < (long) number_pixels; x++)
 868           {
 869             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
 870             q=PopLongPixel(endian,pixel,q);
 871             p++;
 872             q+=quantum_info->pad;
 873           }
 874           break;
 875         }
 876         case 64:
 877         {
 878           if (quantum_info->format == FloatingPointQuantumFormat)
 879             {
 880               for (x=0; x < (long) number_pixels; x++)
 881               {
 882                 double
 883                   pixel;
 884
 885                 pixel=(double) PixelIntensityToQuantum(p);
 886                 q=PopDoublePixel(&quantum_state,pixel,q);
 887                 p++;
 888                 q+=quantum_info->pad;
 889               }
 890               break;
 891             }
 892         }
 893         default:
 894         {
 895           range=GetQuantumRange(image->depth);
 896           for (x=0; x < (long) number_pixels; x++)
 897           {
 898             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
 899               PixelIntensityToQuantum(p),range),q);
 900             p++;
 901             q+=quantum_info->pad;
 902           }
 903           break;
 904         }
 905       }
 906       break;
 907     }
 908     case GrayAlphaQuantum:
 909     {
 910       switch (quantum_info->depth)
 911       {
 912         case 1:
 913         {
 914           register Quantum
 915             threshold;
 916
 917           register unsigned char
 918             black,
 919             pixel,
 920             white;
 921
 922           black=0x00;
 923           white=0x01;
 924           if (quantum_info->min_is_white == MagickFalse)
 925             {
 926               black=0x01;
 927               white=0x00;
 928             }
 929           threshold=(Quantum) (QuantumRange/2);
 930           for (x=((long) number_pixels-3); x > 0; x-=4)
 931           {
 932             *q='\0';
 933             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
 934             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
 935             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
 936             p++;
 937             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
 938             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
 939             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
 940             p++;
 941             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
 942             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
 943             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
 944             p++;
 945             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
 946             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
 947             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
 948             p++;
 949             q++;
 950           }
 951           if ((number_pixels % 4) != 0)
 952             {
 953               *q='\0';
 954               for (bit=3; bit >= (long) (4-(number_pixels % 4)); bit-=2)
 955               {
 956                 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
 957                   (bit+4);
 958                 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
 959                   0x01);
 960                 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
 961                   (bit+4-1));
 962                 p++;
 963               }
 964               q++;
 965             }
 966           break;
 967         }
 968         case 4:
 969         {
 970           register unsigned char
 971             pixel;
 972
 973           for (x=0; x < (long) number_pixels ; x++)
 974           {
 975             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
 976             *q=(((pixel >> 4) & 0xf) << 4);
 977             pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
 978               GetOpacityPixelComponent(p)))+0.5);
 979             *q|=pixel & 0xf;
 980             p++;
 981             q++;
 982           }
 983           break;
 984         }
 985         case 8:
 986         {
 987           register unsigned char
 988             pixel;
 989
 990           for (x=0; x < (long) number_pixels; x++)
 991           {
 992             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
 993             q=PopCharPixel(pixel,q);
 994             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
 995               GetOpacityPixelComponent(p)));
 996             q=PopCharPixel(pixel,q);
 997             p++;
 998             q+=quantum_info->pad;
 999           }
1000           break;
1001         }
1002         case 16:
1003         {
1004           register unsigned short
1005             pixel;
1006
1007           if (quantum_info->format == FloatingPointQuantumFormat)
1008             {
1009               for (x=0; x < (long) number_pixels; x++)
1010               {
1011                 pixel=SinglePrecisionToBinary16(QuantumScale*
1012                   PixelIntensityToQuantum(p));
1013                 q=PopShortPixel(endian,pixel,q);
1014                 pixel=SinglePrecisionToBinary16(QuantumScale*
1015                   GetAlphaPixelComponent(p));
1016                 q=PopShortPixel(endian,pixel,q);
1017                 p++;
1018                 q+=quantum_info->pad;
1019               }
1020               break;
1021             }
1022           for (x=0; x < (long) number_pixels; x++)
1023           {
1024             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1025             q=PopShortPixel(endian,pixel,q);
1026             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1027               GetOpacityPixelComponent(p)));
1028             q=PopShortPixel(endian,pixel,q);
1029             p++;
1030             q+=quantum_info->pad;
1031           }
1032           break;
1033         }
1034         case 32:
1035         {
1036           register unsigned long
1037             pixel;
1038
1039           if (quantum_info->format == FloatingPointQuantumFormat)
1040             {
1041               for (x=0; x < (long) number_pixels; x++)
1042               {
1043                 float
1044                   pixel;
1045
1046                 pixel=(float) PixelIntensityToQuantum(p);
1047                 q=PopFloatPixel(&quantum_state,pixel,q);
1048                 pixel=(float) (GetAlphaPixelComponent(p));
1049                 q=PopFloatPixel(&quantum_state,pixel,q);
1050                 p++;
1051                 q+=quantum_info->pad;
1052               }
1053               break;
1054             }
1055           for (x=0; x < (long) number_pixels; x++)
1056           {
1057             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1058             q=PopLongPixel(endian,pixel,q);
1059             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1060               GetOpacityPixelComponent(p)));
1061             q=PopLongPixel(endian,pixel,q);
1062             p++;
1063             q+=quantum_info->pad;
1064           }
1065           break;
1066         }
1067         case 64:
1068         {
1069           if (quantum_info->format == FloatingPointQuantumFormat)
1070             {
1071               for (x=0; x < (long) number_pixels; x++)
1072               {
1073                 double
1074                   pixel;
1075
1076                 pixel=(double) PixelIntensityToQuantum(p);
1077                 q=PopDoublePixel(&quantum_state,pixel,q);
1078                 pixel=(double) (GetAlphaPixelComponent(p));
1079                 q=PopDoublePixel(&quantum_state,pixel,q);
1080                 p++;
1081                 q+=quantum_info->pad;
1082               }
1083               break;
1084             }
1085         }
1086         default:
1087         {
1088           range=GetQuantumRange(image->depth);
1089           for (x=0; x < (long) number_pixels; x++)
1090           {
1091             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1092               PixelIntensityToQuantum(p),range),q);
1093             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1094               (Quantum) (GetAlphaPixelComponent(p)),range),q);
1095             p++;
1096             q+=quantum_info->pad;
1097           }
1098           break;
1099         }
1100       }
1101       break;
1102     }
1103     case RedQuantum:
1104     case CyanQuantum:
1105     {
1106       switch (quantum_info->depth)
1107       {
1108         case 8:
1109         {
1110           register unsigned char
1111             pixel;
1112
1113           for (x=0; x < (long) number_pixels; x++)
1114           {
1115             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1116             q=PopCharPixel(pixel,q);
1117             p++;
1118             q+=quantum_info->pad;
1119           }
1120           break;
1121         }
1122         case 16:
1123         {
1124           register unsigned short
1125             pixel;
1126
1127           if (quantum_info->format == FloatingPointQuantumFormat)
1128             {
1129               for (x=0; x < (long) number_pixels; x++)
1130               {
1131                 pixel=SinglePrecisionToBinary16(QuantumScale*
1132                   GetRedPixelComponent(p));
1133                 q=PopShortPixel(endian,pixel,q);
1134                 p++;
1135                 q+=quantum_info->pad;
1136               }
1137               break;
1138             }
1139           for (x=0; x < (long) number_pixels; x++)
1140           {
1141             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1142             q=PopShortPixel(endian,pixel,q);
1143             p++;
1144             q+=quantum_info->pad;
1145           }
1146           break;
1147         }
1148         case 32:
1149         {
1150           register unsigned long
1151             pixel;
1152
1153           if (quantum_info->format == FloatingPointQuantumFormat)
1154             {
1155               for (x=0; x < (long) number_pixels; x++)
1156               {
1157                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1158                 p++;
1159                 q+=quantum_info->pad;
1160               }
1161               break;
1162             }
1163           for (x=0; x < (long) number_pixels; x++)
1164           {
1165             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1166             q=PopLongPixel(endian,pixel,q);
1167             p++;
1168             q+=quantum_info->pad;
1169           }
1170           break;
1171         }
1172         case 64:
1173         {
1174           if (quantum_info->format == FloatingPointQuantumFormat)
1175             {
1176               for (x=0; x < (long) number_pixels; x++)
1177               {
1178                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1179                 p++;
1180                 q+=quantum_info->pad;
1181               }
1182               break;
1183             }
1184         }
1185         default:
1186         {
1187           range=GetQuantumRange(image->depth);
1188           for (x=0; x < (long) number_pixels; x++)
1189           {
1190             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1191               p->red,range),q);
1192             p++;
1193             q+=quantum_info->pad;
1194           }
1195           break;
1196         }
1197       }
1198       break;
1199     }
1200     case GreenQuantum:
1201     case MagentaQuantum:
1202     {
1203       switch (quantum_info->depth)
1204       {
1205         case 8:
1206         {
1207           register unsigned char
1208             pixel;
1209
1210           for (x=0; x < (long) number_pixels; x++)
1211           {
1212             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1213             q=PopCharPixel(pixel,q);
1214             p++;
1215             q+=quantum_info->pad;
1216           }
1217           break;
1218         }
1219         case 16:
1220         {
1221           register unsigned short
1222             pixel;
1223
1224           if (quantum_info->format == FloatingPointQuantumFormat)
1225             {
1226               for (x=0; x < (long) number_pixels; x++)
1227               {
1228                 pixel=SinglePrecisionToBinary16(QuantumScale*
1229                   GetGreenPixelComponent(p));
1230                 q=PopShortPixel(endian,pixel,q);
1231                 p++;
1232                 q+=quantum_info->pad;
1233               }
1234               break;
1235             }
1236           for (x=0; x < (long) number_pixels; x++)
1237           {
1238             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1239             q=PopShortPixel(endian,pixel,q);
1240             p++;
1241             q+=quantum_info->pad;
1242           }
1243           break;
1244         }
1245         case 32:
1246         {
1247           register unsigned long
1248             pixel;
1249
1250           if (quantum_info->format == FloatingPointQuantumFormat)
1251             {
1252               for (x=0; x < (long) number_pixels; x++)
1253               {
1254                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1255                 p++;
1256                 q+=quantum_info->pad;
1257               }
1258               break;
1259             }
1260           for (x=0; x < (long) number_pixels; x++)
1261           {
1262             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1263             q=PopLongPixel(endian,pixel,q);
1264             p++;
1265             q+=quantum_info->pad;
1266           }
1267           break;
1268         }
1269         case 64:
1270         {
1271           if (quantum_info->format == FloatingPointQuantumFormat)
1272             {
1273               for (x=0; x < (long) number_pixels; x++)
1274               {
1275                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1276                 p++;
1277                 q+=quantum_info->pad;
1278               }
1279               break;
1280             }
1281         }
1282         default:
1283         {
1284           range=GetQuantumRange(image->depth);
1285           for (x=0; x < (long) number_pixels; x++)
1286           {
1287             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1288               p->green,range),q);
1289             p++;
1290             q+=quantum_info->pad;
1291           }
1292           break;
1293         }
1294       }
1295       break;
1296     }
1297     case BlueQuantum:
1298     case YellowQuantum:
1299     {
1300       switch (quantum_info->depth)
1301       {
1302         case 8:
1303         {
1304           register unsigned char
1305             pixel;
1306
1307           for (x=0; x < (long) number_pixels; x++)
1308           {
1309             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1310             q=PopCharPixel(pixel,q);
1311             p++;
1312             q+=quantum_info->pad;
1313           }
1314           break;
1315         }
1316         case 16:
1317         {
1318           register unsigned short
1319             pixel;
1320
1321           if (quantum_info->format == FloatingPointQuantumFormat)
1322             {
1323               for (x=0; x < (long) number_pixels; x++)
1324               {
1325                 pixel=SinglePrecisionToBinary16(QuantumScale*
1326                   GetBluePixelComponent(p));
1327                 q=PopShortPixel(endian,pixel,q);
1328                 p++;
1329                 q+=quantum_info->pad;
1330               }
1331               break;
1332             }
1333           for (x=0; x < (long) number_pixels; x++)
1334           {
1335             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1336             q=PopShortPixel(endian,pixel,q);
1337             p++;
1338             q+=quantum_info->pad;
1339           }
1340           break;
1341         }
1342         case 32:
1343         {
1344           register unsigned long
1345             pixel;
1346
1347           if (quantum_info->format == FloatingPointQuantumFormat)
1348             {
1349               for (x=0; x < (long) number_pixels; x++)
1350               {
1351                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1352                 p++;
1353                 q+=quantum_info->pad;
1354               }
1355               break;
1356             }
1357           for (x=0; x < (long) number_pixels; x++)
1358           {
1359             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1360             q=PopLongPixel(endian,pixel,q);
1361             p++;
1362             q+=quantum_info->pad;
1363           }
1364           break;
1365         }
1366         case 64:
1367         {
1368           if (quantum_info->format == FloatingPointQuantumFormat)
1369             {
1370               for (x=0; x < (long) number_pixels; x++)
1371               {
1372                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1373                 p++;
1374                 q+=quantum_info->pad;
1375               }
1376               break;
1377             }
1378         }
1379         default:
1380         {
1381           range=GetQuantumRange(image->depth);
1382           for (x=0; x < (long) number_pixels; x++)
1383           {
1384             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1385               p->blue,range),q);
1386             p++;
1387             q+=quantum_info->pad;
1388           }
1389           break;
1390         }
1391       }
1392       break;
1393     }
1394     case AlphaQuantum:
1395     {
1396       switch (quantum_info->depth)
1397       {
1398         case 8:
1399         {
1400           register unsigned char
1401             pixel;
1402
1403           for (x=0; x < (long) number_pixels; x++)
1404           {
1405             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1406               GetOpacityPixelComponent(p)));
1407             q=PopCharPixel(pixel,q);
1408             p++;
1409             q+=quantum_info->pad;
1410           }
1411           break;
1412         }
1413         case 16:
1414         {
1415           register unsigned short
1416             pixel;
1417
1418           if (quantum_info->format == FloatingPointQuantumFormat)
1419             {
1420               for (x=0; x < (long) number_pixels; x++)
1421               {
1422                 pixel=SinglePrecisionToBinary16(QuantumScale*
1423                   GetAlphaPixelComponent(p));
1424                 q=PopShortPixel(endian,pixel,q);
1425                 p++;
1426                 q+=quantum_info->pad;
1427               }
1428               break;
1429             }
1430           for (x=0; x < (long) number_pixels; x++)
1431           {
1432             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1433               GetOpacityPixelComponent(p)));
1434             q=PopShortPixel(endian,pixel,q);
1435             p++;
1436             q+=quantum_info->pad;
1437           }
1438           break;
1439         }
1440         case 32:
1441         {
1442           register unsigned long
1443             pixel;
1444
1445           if (quantum_info->format == FloatingPointQuantumFormat)
1446             {
1447               for (x=0; x < (long) number_pixels; x++)
1448               {
1449                 float
1450                   pixel;
1451
1452                 pixel=(float) (GetAlphaPixelComponent(p));
1453                 q=PopFloatPixel(&quantum_state,pixel,q);
1454                 p++;
1455                 q+=quantum_info->pad;
1456               }
1457               break;
1458             }
1459           for (x=0; x < (long) number_pixels; x++)
1460           {
1461             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1462               GetOpacityPixelComponent(p)));
1463             q=PopLongPixel(endian,pixel,q);
1464             p++;
1465             q+=quantum_info->pad;
1466           }
1467           break;
1468         }
1469         case 64:
1470         {
1471           if (quantum_info->format == FloatingPointQuantumFormat)
1472             {
1473               for (x=0; x < (long) number_pixels; x++)
1474               {
1475                 double
1476                   pixel;
1477
1478                 pixel=(double) (GetAlphaPixelComponent(p));
1479                 q=PopDoublePixel(&quantum_state,pixel,q);
1480                 p++;
1481                 q+=quantum_info->pad;
1482               }
1483               break;
1484             }
1485         }
1486         default:
1487         {
1488           range=GetQuantumRange(image->depth);
1489           for (x=0; x < (long) number_pixels; x++)
1490           {
1491             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1492               (Quantum) (GetAlphaPixelComponent(p)),range),q);
1493             p++;
1494             q+=quantum_info->pad;
1495           }
1496           break;
1497         }
1498       }
1499       break;
1500     }
1501     case OpacityQuantum:
1502     {
1503       switch (quantum_info->depth)
1504       {
1505         case 8:
1506         {
1507           register unsigned char
1508             pixel;
1509
1510           for (x=0; x < (long) number_pixels; x++)
1511           {
1512             pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
1513             q=PopCharPixel(pixel,q);
1514             p++;
1515             q+=quantum_info->pad;
1516           }
1517           break;
1518         }
1519         case 16:
1520         {
1521           register unsigned short
1522             pixel;
1523
1524           if (quantum_info->format == FloatingPointQuantumFormat)
1525             {
1526               for (x=0; x < (long) number_pixels; x++)
1527               {
1528                 pixel=SinglePrecisionToBinary16(QuantumScale*
1529                   GetOpacityPixelComponent(p));
1530                 q=PopShortPixel(endian,pixel,q);
1531                 p++;
1532                 q+=quantum_info->pad;
1533               }
1534               break;
1535             }
1536           for (x=0; x < (long) number_pixels; x++)
1537           {
1538             pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1539             q=PopShortPixel(endian,pixel,q);
1540             p++;
1541             q+=quantum_info->pad;
1542           }
1543           break;
1544         }
1545         case 32:
1546         {
1547           register unsigned long
1548             pixel;
1549
1550           if (quantum_info->format == FloatingPointQuantumFormat)
1551             {
1552               for (x=0; x < (long) number_pixels; x++)
1553               {
1554                 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
1555                 p++;
1556                 q+=quantum_info->pad;
1557               }
1558               break;
1559             }
1560           for (x=0; x < (long) number_pixels; x++)
1561           {
1562             pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1563             q=PopLongPixel(endian,pixel,q);
1564             p++;
1565             q+=quantum_info->pad;
1566           }
1567           break;
1568         }
1569         case 64:
1570         {
1571           if (quantum_info->format == FloatingPointQuantumFormat)
1572             {
1573               for (x=0; x < (long) number_pixels; x++)
1574               {
1575                 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
1576                 p++;
1577                 q+=quantum_info->pad;
1578               }
1579               break;
1580             }
1581         }
1582         default:
1583         {
1584           range=GetQuantumRange(image->depth);
1585           for (x=0; x < (long) number_pixels; x++)
1586           {
1587             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1588               p->opacity,range),q);
1589             p++;
1590             q+=quantum_info->pad;
1591           }
1592           break;
1593         }
1594       }
1595       break;
1596     }
1597     case BlackQuantum:
1598     {
1599       if (image->colorspace != CMYKColorspace)
1600         {
1601           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1602             "ColorSeparatedImageRequired","`%s'",image->filename);
1603           return(extent);
1604         }
1605       switch (quantum_info->depth)
1606       {
1607         case 8:
1608         {
1609           register unsigned char
1610             pixel;
1611
1612           for (x=0; x < (long) number_pixels; x++)
1613           {
1614             pixel=ScaleQuantumToChar(indexes[x]);
1615             q=PopCharPixel(pixel,q);
1616             p++;
1617             q+=quantum_info->pad;
1618           }
1619           break;
1620         }
1621         case 16:
1622         {
1623           register unsigned short
1624             pixel;
1625
1626           if (quantum_info->format == FloatingPointQuantumFormat)
1627             {
1628               for (x=0; x < (long) number_pixels; x++)
1629               {
1630                 pixel=SinglePrecisionToBinary16(QuantumScale*indexes[x]);
1631                 q=PopShortPixel(endian,pixel,q);
1632                 p++;
1633                 q+=quantum_info->pad;
1634               }
1635               break;
1636             }
1637           for (x=0; x < (long) number_pixels; x++)
1638           {
1639             pixel=ScaleQuantumToShort(indexes[x]);
1640             q=PopShortPixel(endian,pixel,q);
1641             p++;
1642             q+=quantum_info->pad;
1643           }
1644           break;
1645         }
1646         case 32:
1647         {
1648           register unsigned long
1649             pixel;
1650
1651           if (quantum_info->format == FloatingPointQuantumFormat)
1652             {
1653               for (x=0; x < (long) number_pixels; x++)
1654               {
1655                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
1656                 p++;
1657                 q+=quantum_info->pad;
1658               }
1659               break;
1660             }
1661           for (x=0; x < (long) number_pixels; x++)
1662           {
1663             pixel=ScaleQuantumToLong(indexes[x]);
1664             q=PopLongPixel(endian,pixel,q);
1665             p++;
1666             q+=quantum_info->pad;
1667           }
1668           break;
1669         }
1670         case 64:
1671         {
1672           if (quantum_info->format == FloatingPointQuantumFormat)
1673             {
1674               for (x=0; x < (long) number_pixels; x++)
1675               {
1676                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
1677                 p++;
1678                 q+=quantum_info->pad;
1679               }
1680               break;
1681             }
1682         }
1683         default:
1684         {
1685           range=GetQuantumRange(image->depth);
1686           for (x=0; x < (long) number_pixels; x++)
1687           {
1688             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1689               (Quantum) indexes[x],range),q);
1690             p++;
1691             q+=quantum_info->pad;
1692           }
1693           break;
1694         }
1695       }
1696       break;
1697     }
1698     case RGBQuantum:
1699     case CbYCrQuantum:
1700     {
1701       switch (quantum_info->depth)
1702       {
1703         case 8:
1704         {
1705           for (x=0; x < (long) number_pixels; x++)
1706           {
1707             q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
1708             q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
1709             q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
1710             p++;
1711             q+=quantum_info->pad;
1712           }
1713           break;
1714         }
1715         case 10:
1716         {
1717           register unsigned long
1718             pixel;
1719
1720           range=GetQuantumRange(image->depth);
1721           if (quantum_info->pack == MagickFalse)
1722             {
1723               for (x=0; x < (long) number_pixels; x++)
1724               {
1725                 pixel=(unsigned long) (ScaleQuantumToAny(p->red,range) << 22 |
1726                   ScaleQuantumToAny(p->green,range) <<  12 |
1727                   ScaleQuantumToAny(p->blue,range) << 2);
1728                 q=PopLongPixel(endian,pixel,q);
1729                 p++;
1730                 q+=quantum_info->pad;
1731               }
1732               break;
1733             }
1734           if (quantum_info->quantum == 32UL)
1735             {
1736               for (x=0; x < (long) number_pixels; x++)
1737               {
1738                 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1739                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1740                 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1741                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1742                 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1743                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1744                 p++;
1745                 q+=quantum_info->pad;
1746               }
1747               break;
1748             }
1749           for (x=0; x < (long) number_pixels; x++)
1750           {
1751             pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1752             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1753             pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1754             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1755             pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1756             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1757             p++;
1758             q+=quantum_info->pad;
1759           }
1760           break;
1761         }
1762         case 12:
1763         {
1764           register unsigned long
1765             pixel;
1766
1767           range=GetQuantumRange(image->depth);
1768           if (quantum_info->pack == MagickFalse)
1769             {
1770               for (x=0; x < (long) (3*number_pixels-1); x+=2)
1771               {
1772                 switch (x % 3)
1773                 {
1774                   default:
1775                   case 0:
1776                   {
1777                     pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1778                     break;
1779                   }
1780                   case 1:
1781                   {
1782                     pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1783                     break;
1784                   }
1785                   case 2:
1786                   {
1787                     pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1788                     p++;
1789                     break;
1790                   }
1791                 }
1792                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1793                 switch ((x+1) % 3)
1794                 {
1795                   default:
1796                   case 0:
1797                   {
1798                     pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1799                     break;
1800                   }
1801                   case 1:
1802                   {
1803                     pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1804                     break;
1805                   }
1806                   case 2:
1807                   {
1808                     pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1809                     p++;
1810                     break;
1811                   }
1812                 }
1813                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1814                 q+=quantum_info->pad;
1815               }
1816               for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1817               {
1818                 switch ((x+bit) % 3)
1819                 {
1820                   default:
1821                   case 0:
1822                   {
1823                     pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1824                     break;
1825                   }
1826                   case 1:
1827                   {
1828                     pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1829                     break;
1830                   }
1831                   case 2:
1832                   {
1833                     pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1834                     p++;
1835                     break;
1836                   }
1837                 }
1838                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
1839                 q+=quantum_info->pad;
1840               }
1841               if (bit != 0)
1842                 p++;
1843               break;
1844             }
1845           if (quantum_info->quantum == 32UL)
1846             {
1847               for (x=0; x < (long) number_pixels; x++)
1848               {
1849                 pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1850                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1851                 pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1852                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1853                 pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1854                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1855                 p++;
1856                 q+=quantum_info->pad;
1857               }
1858               break;
1859             }
1860           for (x=0; x < (long) number_pixels; x++)
1861           {
1862             pixel=(unsigned long) ScaleQuantumToAny(p->red,range);
1863             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1864             pixel=(unsigned long) ScaleQuantumToAny(p->green,range);
1865             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1866             pixel=(unsigned long) ScaleQuantumToAny(p->blue,range);
1867             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1868             p++;
1869             q+=quantum_info->pad;
1870           }
1871           break;
1872         }
1873         case 16:
1874         {
1875           register unsigned short
1876             pixel;
1877
1878           if (quantum_info->format == FloatingPointQuantumFormat)
1879             {
1880               for (x=0; x < (long) number_pixels; x++)
1881               {
1882                 pixel=SinglePrecisionToBinary16(QuantumScale*
1883                   GetRedPixelComponent(p));
1884                 q=PopShortPixel(endian,pixel,q);
1885                 pixel=SinglePrecisionToBinary16(QuantumScale*
1886                   GetGreenPixelComponent(p));
1887                 q=PopShortPixel(endian,pixel,q);
1888                 pixel=SinglePrecisionToBinary16(QuantumScale*
1889                   GetBluePixelComponent(p));
1890                 q=PopShortPixel(endian,pixel,q);
1891                 p++;
1892                 q+=quantum_info->pad;
1893               }
1894               break;
1895             }
1896           for (x=0; x < (long) number_pixels; x++)
1897           {
1898             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1899             q=PopShortPixel(endian,pixel,q);
1900             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1901             q=PopShortPixel(endian,pixel,q);
1902             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1903             q=PopShortPixel(endian,pixel,q);
1904             p++;
1905             q+=quantum_info->pad;
1906           }
1907           break;
1908         }
1909         case 32:
1910         {
1911           register unsigned long
1912             pixel;
1913
1914           if (quantum_info->format == FloatingPointQuantumFormat)
1915             {
1916               for (x=0; x < (long) number_pixels; x++)
1917               {
1918                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1919                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1920                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1921                 p++;
1922                 q+=quantum_info->pad;
1923               }
1924               break;
1925             }
1926           for (x=0; x < (long) number_pixels; x++)
1927           {
1928             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1929             q=PopLongPixel(endian,pixel,q);
1930             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1931             q=PopLongPixel(endian,pixel,q);
1932             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1933             q=PopLongPixel(endian,pixel,q);
1934             p++;
1935             q+=quantum_info->pad;
1936           }
1937           break;
1938         }
1939         case 64:
1940         {
1941           if (quantum_info->format == FloatingPointQuantumFormat)
1942             {
1943               for (x=0; x < (long) number_pixels; x++)
1944               {
1945                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1946                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1947                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1948                 p++;
1949                 q+=quantum_info->pad;
1950               }
1951               break;
1952             }
1953         }
1954         default:
1955         {
1956           range=GetQuantumRange(image->depth);
1957           for (x=0; x < (long) number_pixels; x++)
1958           {
1959             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1960               p->red,range),q);
1961             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1962               p->green,range),q);
1963             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1964               p->blue,range),q);
1965             p++;
1966             q+=quantum_info->pad;
1967           }
1968           break;
1969         }
1970       }
1971       break;
1972     }
1973     case RGBAQuantum:
1974     case RGBOQuantum:
1975     case CbYCrAQuantum:
1976     {
1977       switch (quantum_info->depth)
1978       {
1979         case 8:
1980         {
1981           register unsigned char
1982             pixel;
1983
1984           for (x=0; x < (long) number_pixels; x++)
1985           {
1986             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1987             q=PopCharPixel(pixel,q);
1988             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1989             q=PopCharPixel(pixel,q);
1990             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1991             q=PopCharPixel(pixel,q);
1992             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1993               GetOpacityPixelComponent(p)));
1994             q=PopCharPixel(pixel,q);
1995             p++;
1996             q+=quantum_info->pad;
1997           }
1998           break;
1999         }
2000         case 16:
2001         {
2002           register unsigned short
2003             pixel;
2004
2005           if (quantum_info->format == FloatingPointQuantumFormat)
2006             {
2007               for (x=0; x < (long) number_pixels; x++)
2008               {
2009                 pixel=SinglePrecisionToBinary16(QuantumScale*
2010                   GetRedPixelComponent(p));
2011                 q=PopShortPixel(endian,pixel,q);
2012                 pixel=SinglePrecisionToBinary16(QuantumScale*
2013                   GetGreenPixelComponent(p));
2014                 q=PopShortPixel(endian,pixel,q);
2015                 pixel=SinglePrecisionToBinary16(QuantumScale*
2016                   GetBluePixelComponent(p));
2017                 q=PopShortPixel(endian,pixel,q);
2018                 pixel=SinglePrecisionToBinary16(QuantumScale*
2019                   GetAlphaPixelComponent(p));
2020                 q=PopShortPixel(endian,pixel,q);
2021                 p++;
2022                 q+=quantum_info->pad;
2023               }
2024               break;
2025             }
2026           for (x=0; x < (long) number_pixels; x++)
2027           {
2028             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2029             q=PopShortPixel(endian,pixel,q);
2030             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2031             q=PopShortPixel(endian,pixel,q);
2032             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2033             q=PopShortPixel(endian,pixel,q);
2034             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2035               GetOpacityPixelComponent(p)));
2036             q=PopShortPixel(endian,pixel,q);
2037             p++;
2038             q+=quantum_info->pad;
2039           }
2040           break;
2041         }
2042         case 32:
2043         {
2044           register unsigned long
2045             pixel;
2046
2047           if (quantum_info->format == FloatingPointQuantumFormat)
2048             {
2049               for (x=0; x < (long) number_pixels; x++)
2050               {
2051                 float
2052                   pixel;
2053
2054                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2055                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2056                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2057                 pixel=(float) (GetAlphaPixelComponent(p));
2058                 q=PopFloatPixel(&quantum_state,pixel,q);
2059                 p++;
2060                 q+=quantum_info->pad;
2061               }
2062               break;
2063             }
2064           for (x=0; x < (long) number_pixels; x++)
2065           {
2066             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2067             q=PopLongPixel(endian,pixel,q);
2068             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2069             q=PopLongPixel(endian,pixel,q);
2070             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2071             q=PopLongPixel(endian,pixel,q);
2072             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2073               GetOpacityPixelComponent(p)));
2074             q=PopLongPixel(endian,pixel,q);
2075             p++;
2076             q+=quantum_info->pad;
2077           }
2078           break;
2079         }
2080         case 64:
2081         {
2082           if (quantum_info->format == FloatingPointQuantumFormat)
2083             {
2084               double
2085                 pixel;
2086
2087               for (x=0; x < (long) number_pixels; x++)
2088               {
2089                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2090                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2091                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2092                 pixel=(double) (GetAlphaPixelComponent(p));
2093                 q=PopDoublePixel(&quantum_state,pixel,q);
2094                 p++;
2095                 q+=quantum_info->pad;
2096               }
2097               break;
2098             }
2099         }
2100         default:
2101         {
2102           range=GetQuantumRange(image->depth);
2103           for (x=0; x < (long) number_pixels; x++)
2104           {
2105             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2106               p->red,range),q);
2107             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2108               p->green,range),q);
2109             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2110               p->blue,range),q);
2111             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2112               (Quantum) (GetAlphaPixelComponent(p)),range),q);
2113             p++;
2114             q+=quantum_info->pad;
2115           }
2116           break;
2117         }
2118       }
2119       break;
2120     }
2121     case CMYKQuantum:
2122     {
2123       if (image->colorspace != CMYKColorspace)
2124         {
2125           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2126             "ColorSeparatedImageRequired","`%s'",image->filename);
2127           return(extent);
2128         }
2129       switch (quantum_info->depth)
2130       {
2131         case 8:
2132         {
2133           register unsigned char
2134             pixel;
2135
2136           for (x=0; x < (long) number_pixels; x++)
2137           {
2138             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2139             q=PopCharPixel(pixel,q);
2140             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2141             q=PopCharPixel(pixel,q);
2142             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2143             q=PopCharPixel(pixel,q);
2144             pixel=ScaleQuantumToChar(indexes[x]);
2145             q=PopCharPixel(pixel,q);
2146             p++;
2147             q+=quantum_info->pad;
2148           }
2149           break;
2150         }
2151         case 16:
2152         {
2153           register unsigned short
2154             pixel;
2155
2156           if (quantum_info->format == FloatingPointQuantumFormat)
2157             {
2158               for (x=0; x < (long) number_pixels; x++)
2159               {
2160                 pixel=SinglePrecisionToBinary16(QuantumScale*
2161                   GetRedPixelComponent(p));
2162                 q=PopShortPixel(endian,pixel,q);
2163                 pixel=SinglePrecisionToBinary16(QuantumScale*
2164                   GetGreenPixelComponent(p));
2165                 q=PopShortPixel(endian,pixel,q);
2166                 pixel=SinglePrecisionToBinary16(QuantumScale*
2167                   GetBluePixelComponent(p));
2168                 q=PopShortPixel(endian,pixel,q);
2169                 pixel=SinglePrecisionToBinary16(QuantumScale*indexes[x]);
2170                 q=PopShortPixel(endian,pixel,q);
2171                 p++;
2172                 q+=quantum_info->pad;
2173               }
2174               break;
2175             }
2176           for (x=0; x < (long) number_pixels; x++)
2177           {
2178             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2179             q=PopShortPixel(endian,pixel,q);
2180             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2181             q=PopShortPixel(endian,pixel,q);
2182             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2183             q=PopShortPixel(endian,pixel,q);
2184             pixel=ScaleQuantumToShort(indexes[x]);
2185             q=PopShortPixel(endian,pixel,q);
2186             p++;
2187             q+=quantum_info->pad;
2188           }
2189           break;
2190         }
2191         case 32:
2192         {
2193           register unsigned long
2194             pixel;
2195
2196           if (quantum_info->format == FloatingPointQuantumFormat)
2197             {
2198               for (x=0; x < (long) number_pixels; x++)
2199               {
2200                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2201                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2202                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2203                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2204                 p++;
2205                 q+=quantum_info->pad;
2206               }
2207               break;
2208             }
2209           for (x=0; x < (long) number_pixels; x++)
2210           {
2211             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2212             q=PopLongPixel(endian,pixel,q);
2213             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2214             q=PopLongPixel(endian,pixel,q);
2215             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2216             q=PopLongPixel(endian,pixel,q);
2217             pixel=ScaleQuantumToLong(indexes[x]);
2218             q=PopLongPixel(endian,pixel,q);
2219             p++;
2220             q+=quantum_info->pad;
2221           }
2222           break;
2223         }
2224         case 64:
2225         {
2226           if (quantum_info->format == FloatingPointQuantumFormat)
2227             {
2228               for (x=0; x < (long) number_pixels; x++)
2229               {
2230                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2231                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2232                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2233                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2234                 p++;
2235                 q+=quantum_info->pad;
2236               }
2237               break;
2238             }
2239         }
2240         default:
2241         {
2242           range=GetQuantumRange(image->depth);
2243           for (x=0; x < (long) number_pixels; x++)
2244           {
2245             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2246               p->red,range),q);
2247             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2248               p->green,range),q);
2249             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2250               p->blue,range),q);
2251             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2252               indexes[x],range),q);
2253             p++;
2254             q+=quantum_info->pad;
2255           }
2256           break;
2257         }
2258       }
2259       break;
2260     }
2261     case CMYKAQuantum:
2262     case CMYKOQuantum:
2263     {
2264       if (image->colorspace != CMYKColorspace)
2265         {
2266           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2267             "ColorSeparatedImageRequired","`%s'",image->filename);
2268           return(extent);
2269         }
2270       switch (quantum_info->depth)
2271       {
2272         case 8:
2273         {
2274           register unsigned char
2275             pixel;
2276
2277           for (x=0; x < (long) number_pixels; x++)
2278           {
2279             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2280             q=PopCharPixel(pixel,q);
2281             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2282             q=PopCharPixel(pixel,q);
2283             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2284             q=PopCharPixel(pixel,q);
2285             pixel=ScaleQuantumToChar(indexes[x]);
2286             q=PopCharPixel(pixel,q);
2287             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2288               GetOpacityPixelComponent(p)));
2289             q=PopCharPixel(pixel,q);
2290             p++;
2291             q+=quantum_info->pad;
2292           }
2293           break;
2294         }
2295         case 16:
2296         {
2297           register unsigned short
2298             pixel;
2299
2300           if (quantum_info->format == FloatingPointQuantumFormat)
2301             {
2302               for (x=0; x < (long) number_pixels; x++)
2303               {
2304                 pixel=SinglePrecisionToBinary16(QuantumScale*
2305                   GetRedPixelComponent(p));
2306                 q=PopShortPixel(endian,pixel,q);
2307                 pixel=SinglePrecisionToBinary16(QuantumScale*
2308                   GetGreenPixelComponent(p));
2309                 q=PopShortPixel(endian,pixel,q);
2310                 pixel=SinglePrecisionToBinary16(QuantumScale*
2311                   GetBluePixelComponent(p));
2312                 q=PopShortPixel(endian,pixel,q);
2313                 pixel=SinglePrecisionToBinary16(QuantumScale*indexes[x]);
2314                 q=PopShortPixel(endian,pixel,q);
2315                 pixel=SinglePrecisionToBinary16(QuantumScale*
2316                   GetAlphaPixelComponent(p));
2317                 q=PopShortPixel(endian,pixel,q);
2318                 p++;
2319                 q+=quantum_info->pad;
2320               }
2321               break;
2322             }
2323           for (x=0; x < (long) number_pixels; x++)
2324           {
2325             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2326             q=PopShortPixel(endian,pixel,q);
2327             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2328             q=PopShortPixel(endian,pixel,q);
2329             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2330             q=PopShortPixel(endian,pixel,q);
2331             pixel=ScaleQuantumToShort(indexes[x]);
2332             q=PopShortPixel(endian,pixel,q);
2333             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2334               GetOpacityPixelComponent(p)));
2335             q=PopShortPixel(endian,pixel,q);
2336             p++;
2337             q+=quantum_info->pad;
2338           }
2339           break;
2340         }
2341         case 32:
2342         {
2343           register unsigned long
2344             pixel;
2345
2346           if (quantum_info->format == FloatingPointQuantumFormat)
2347             {
2348               for (x=0; x < (long) number_pixels; x++)
2349               {
2350                 float
2351                   pixel;
2352
2353                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2354                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2355                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2356                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2357                 pixel=(float) (GetAlphaPixelComponent(p));
2358                 q=PopFloatPixel(&quantum_state,pixel,q);
2359                 p++;
2360                 q+=quantum_info->pad;
2361               }
2362               break;
2363             }
2364           for (x=0; x < (long) number_pixels; x++)
2365           {
2366             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2367             q=PopLongPixel(endian,pixel,q);
2368             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2369             q=PopLongPixel(endian,pixel,q);
2370             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2371             q=PopLongPixel(endian,pixel,q);
2372             pixel=ScaleQuantumToLong(indexes[x]);
2373             q=PopLongPixel(endian,pixel,q);
2374             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2375               GetOpacityPixelComponent(p)));
2376             q=PopLongPixel(endian,pixel,q);
2377             p++;
2378             q+=quantum_info->pad;
2379           }
2380           break;
2381         }
2382         case 64:
2383         {
2384           if (quantum_info->format == FloatingPointQuantumFormat)
2385             {
2386               double
2387                 pixel;
2388
2389               for (x=0; x < (long) number_pixels; x++)
2390               {
2391                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2392                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2393                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2394                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2395                 pixel=(double) (GetAlphaPixelComponent(p));
2396                 q=PopDoublePixel(&quantum_state,pixel,q);
2397                 p++;
2398                 q+=quantum_info->pad;
2399               }
2400               break;
2401             }
2402         }
2403         default:
2404         {
2405           range=GetQuantumRange(image->depth);
2406           for (x=0; x < (long) number_pixels; x++)
2407           {
2408             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2409               p->red,range),q);
2410             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2411               p->green,range),q);
2412             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2413               p->blue,range),q);
2414             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2415               indexes[x],range),q);
2416             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2417               p->opacity,range),q);
2418             p++;
2419             q+=quantum_info->pad;
2420           }
2421           break;
2422         }
2423       }
2424       break;
2425     }
2426     case CbYCrYQuantum:
2427     {
2428      long
2429         n;
2430
2431       Quantum
2432         cbcr[4];
2433
2434       register long
2435         i;
2436
2437       register unsigned long
2438         pixel;
2439
2440       unsigned long
2441         quantum;
2442
2443       n=0;
2444       quantum=0;
2445       range=GetQuantumRange(image->depth);
2446       switch (quantum_info->depth)
2447       {
2448         case 10:
2449         {
2450           if (quantum_info->pack == MagickFalse)
2451             {
2452               for (x=0; x < (long) number_pixels; x+=2)
2453               {
2454                 for (i=0; i < 4; i++)
2455                 {
2456                   switch (n % 3)
2457                   {
2458                     case 0:
2459                     {
2460                       quantum=GetRedPixelComponent(p);
2461                       break;
2462                     }
2463                     case 1:
2464                     {
2465                       quantum=GetGreenPixelComponent(p);
2466                       break;
2467                     }
2468                     case 2:
2469                     {
2470                       quantum=GetBluePixelComponent(p);
2471                       break;
2472                     }
2473                   }
2474                   cbcr[i]=(Quantum) quantum;
2475                   n++;
2476                 }
2477                 pixel=(unsigned long) ((unsigned long) (cbcr[1]) << 22 |
2478                   (unsigned long) (cbcr[0]) <<  12 |
2479                   (unsigned long) (cbcr[2]) << 2);
2480                 q=PopLongPixel(endian,pixel,q);
2481                 p++;
2482                 pixel=(unsigned long) ((unsigned long) (cbcr[3]) << 22 |
2483                   (unsigned long) (cbcr[0]) <<  12 |
2484                   (unsigned long) (cbcr[2]) << 2);
2485                 q=PopLongPixel(endian,pixel,q);
2486                 p++;
2487                 q+=quantum_info->pad;
2488               }
2489               break;
2490             }
2491           break;
2492         }
2493         default:
2494         {
2495           for (x=0; x < (long) number_pixels; x+=2)
2496           {
2497             for (i=0; i < 4; i++)
2498             {
2499               switch (n % 3)
2500               {
2501                 case 0:
2502                 {
2503                   quantum=GetRedPixelComponent(p);
2504                   break;
2505                 }
2506                 case 1:
2507                 {
2508                   quantum=GetGreenPixelComponent(p);
2509                   break;
2510                 }
2511                 case 2:
2512                 {
2513                   quantum=GetBluePixelComponent(p);
2514                   break;
2515                 }
2516               }
2517               cbcr[i]=(Quantum) quantum;
2518               n++;
2519             }
2520             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2521               cbcr[1],range),q);
2522             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2523               cbcr[0],range),q);
2524             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2525               cbcr[2],range),q);
2526             p++;
2527             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2528               cbcr[3],range),q);
2529             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2530               cbcr[0],range),q);
2531             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2532               cbcr[2],range),q);
2533             p++;
2534             q+=quantum_info->pad;
2535           }
2536           break;
2537         }
2538       }
2539       break;
2540     }
2541     default:
2542       break;
2543   }
2544   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2545     {
2546       Quantum
2547         quantum;
2548
2549       register PixelPacket
2550         *restrict q;
2551
2552       q=GetAuthenticPixelQueue(image);
2553       if (image_view != (CacheView *) NULL)
2554         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2555       for (x=0; x < (long) number_pixels; x++)
2556       {
2557         quantum=q->red;
2558         q->red=q->green;
2559         q->green=quantum;
2560         q++;
2561       }
2562     }
2563   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2564     {
2565       register PixelPacket
2566         *restrict q;
2567
2568       q=GetAuthenticPixelQueue(image);
2569       if (image_view != (CacheView *) NULL)
2570         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
2571       for (x=0; x < (long) number_pixels; x++)
2572       {
2573         q->opacity=(Quantum) GetAlphaPixelComponent(q);
2574         q++;
2575       }
2576     }
2577   return(extent);
2578 }