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,
  93 %        const CacheView *image_view,const QuantumInfo *quantum_info,
  94 %        const QuantumType quantum_type,unsigned char *pixels,
  95 %        ExceptionInfo *exception)
  96 %
  97 %  A description of each parameter follows:
  98 %
  99 %    o image: the image.
 100 %
 101 %    o image_view: the image cache view.
 102 %
 103 %    o quantum_info: the quantum info.
 104 %
 105 %    o quantum_type: Declare which pixel components to transfer (RGB, RGBA,
 106 %      etc).
 107 %
 108 %    o pixels:  The components are transferred to this buffer.
 109 %
 110 %    o exception: return any errors or warnings in this structure.
 111 %
 112 */
 113
 114 static inline unsigned char *PopDoublePixel(const QuantumState *quantum_state,
 115   const double pixel,unsigned char *pixels)
 116 {
 117   double
 118     *p;
 119
 120   unsigned char
 121     quantum[8];
 122
 123   p=(double *) quantum;
 124   *p=(double) (pixel*quantum_state->inverse_scale+quantum_state->minimum);
 125   if (quantum_state->endian != LSBEndian)
 126     {
 127       *pixels++=quantum[7];
 128       *pixels++=quantum[6];
 129       *pixels++=quantum[5];
 130       *pixels++=quantum[4];
 131       *pixels++=quantum[3];
 132       *pixels++=quantum[2];
 133       *pixels++=quantum[1];
 134       *pixels++=quantum[0];
 135       return(pixels);
 136     }
 137   *pixels++=quantum[0];
 138   *pixels++=quantum[1];
 139   *pixels++=quantum[2];
 140   *pixels++=quantum[3];
 141   *pixels++=quantum[4];
 142   *pixels++=quantum[5];
 143   *pixels++=quantum[6];
 144   *pixels++=quantum[7];
 145   return(pixels);
 146 }
 147
 148 static inline unsigned char *PopFloatPixel(const QuantumState *quantum_state,
 149   const float pixel,unsigned char *pixels)
 150 {
 151   float
 152     *p;
 153
 154   unsigned char
 155     quantum[4];
 156
 157   p=(float *) quantum;
 158   *p=(float) ((double) pixel*quantum_state->inverse_scale+
 159     quantum_state->minimum);
 160   if (quantum_state->endian != LSBEndian)
 161     {
 162       *pixels++=quantum[3];
 163       *pixels++=quantum[2];
 164       *pixels++=quantum[1];
 165       *pixels++=quantum[0];
 166       return(pixels);
 167     }
 168   *pixels++=quantum[0];
 169   *pixels++=quantum[1];
 170   *pixels++=quantum[2];
 171   *pixels++=quantum[3];
 172   return(pixels);
 173 }
 174
 175 static inline unsigned char *PopQuantumPixel(QuantumState *quantum_state,
 176   const size_t depth,const QuantumAny pixel,unsigned char *pixels)
 177 {
 178   register ssize_t
 179     i;
 180
 181   size_t
 182     quantum_bits;
 183
 184   if (quantum_state->bits == 0UL)
 185     quantum_state->bits=8U;
 186   for (i=(ssize_t) depth; i > 0L; )
 187   {
 188     quantum_bits=(size_t) i;
 189     if (quantum_bits > quantum_state->bits)
 190       quantum_bits=quantum_state->bits;
 191     i-=(ssize_t) quantum_bits;
 192     if (quantum_state->bits == 8UL)
 193       *pixels='\0';
 194     quantum_state->bits-=quantum_bits;
 195     *pixels|=(((pixel >> i) &~ ((~0UL) << quantum_bits)) <<
 196       quantum_state->bits);
 197     if (quantum_state->bits == 0UL)
 198       {
 199         pixels++;
 200         quantum_state->bits=8UL;
 201       }
 202   }
 203   return(pixels);
 204 }
 205
 206 static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
 207   const size_t depth,const size_t pixel,unsigned char *pixels)
 208 {
 209   register ssize_t
 210     i;
 211
 212   size_t
 213     quantum_bits;
 214
 215   if (quantum_state->bits == 0U)
 216     quantum_state->bits=32UL;
 217   for (i=(ssize_t) depth; i > 0; )
 218   {
 219     quantum_bits=(size_t) i;
 220     if (quantum_bits > quantum_state->bits)
 221       quantum_bits=quantum_state->bits;
 222     quantum_state->pixel|=(((pixel >> (depth-i)) &
 223       quantum_state->mask[quantum_bits]) << (32U-quantum_state->bits));
 224     i-=(ssize_t) quantum_bits;
 225     quantum_state->bits-=quantum_bits;
 226     if (quantum_state->bits == 0U)
 227       {
 228         pixels=PopLongPixel(quantum_state->endian,quantum_state->pixel,pixels);
 229         quantum_state->pixel=0U;
 230         quantum_state->bits=32U;
 231       }
 232   }
 233   return(pixels);
 234 }
 235
 236 MagickExport size_t ExportQuantumPixels(const Image *image,
 237   const CacheView *image_view,const QuantumInfo *quantum_info,
 238   const QuantumType quantum_type,unsigned char *pixels,ExceptionInfo *exception)
 239 {
 240   EndianType
 241     endian;
 242
 243   ssize_t
 244     bit;
 245
 246   MagickRealType
 247     alpha;
 248
 249   MagickSizeType
 250     number_pixels;
 251
 252   QuantumAny
 253     range;
 254
 255   QuantumState
 256     quantum_state;
 257
 258   register const IndexPacket
 259     *restrict indexes;
 260
 261   register const PixelPacket
 262     *restrict p;
 263
 264   register ssize_t
 265     x;
 266
 267   register unsigned char
 268     *restrict q;
 269
 270   size_t
 271     extent;
 272
 273   assert(image != (Image *) NULL);
 274   assert(image->signature == MagickSignature);
 275   if (image->debug != MagickFalse)
 276     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 277   assert(quantum_info != (QuantumInfo *) NULL);
 278   assert(quantum_info->signature == MagickSignature);
 279   if (pixels == (unsigned char *) NULL)
 280     pixels=GetQuantumPixels(quantum_info);
 281   if (image_view == (CacheView *) NULL)
 282     {
 283       number_pixels=GetImageExtent(image);
 284       p=GetVirtualPixelQueue(image);
 285       indexes=GetVirtualIndexQueue(image);
 286     }
 287   else
 288     {
 289       number_pixels=GetCacheViewExtent(image_view);
 290       p=GetCacheViewVirtualPixelQueue(image_view);
 291       indexes=GetCacheViewVirtualIndexQueue(image_view);
 292     }
 293   if (quantum_info->alpha_type == AssociatedQuantumAlpha)
 294     {
 295       register PixelPacket
 296         *restrict q;
 297
 298       /*
 299         Associate alpha.
 300       */
 301       q=GetAuthenticPixelQueue(image);
 302       if (image_view != (CacheView *) NULL)
 303         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
 304       for (x=0; x < (ssize_t) image->columns; x++)
 305       {
 306         alpha=QuantumScale*((double) QuantumRange-q->opacity);
 307         q->red=ClampToQuantum(alpha*q->red);
 308         q->green=ClampToQuantum(alpha*q->green);
 309         q->blue=ClampToQuantum(alpha*q->blue);
 310         q++;
 311       }
 312     }
 313   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
 314       (quantum_type == BGROQuantum))
 315     {
 316       register PixelPacket
 317         *restrict q;
 318
 319       q=GetAuthenticPixelQueue(image);
 320       if (image_view != (CacheView *) NULL)
 321         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
 322       for (x=0; x < (ssize_t) number_pixels; x++)
 323       {
 324         q->opacity=(Quantum) GetAlphaPixelComponent(q);
 325         q++;
 326       }
 327     }
 328   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
 329     {
 330       Quantum
 331         quantum;
 332
 333       register PixelPacket
 334         *restrict q;
 335
 336       q=GetAuthenticPixelQueue(image);
 337       if (image_view != (CacheView *) NULL)
 338         q=GetAuthenticPixelQueue(image);
 339       for (x=0; x < (ssize_t) number_pixels; x++)
 340       {
 341         quantum=q->red;
 342         q->red=q->green;
 343         q->green=quantum;
 344         q++;
 345       }
 346     }
 347   x=0;
 348   q=pixels;
 349   InitializeQuantumState(quantum_info,image->endian,&quantum_state);
 350   extent=GetQuantumExtent(image,quantum_info,quantum_type);
 351   endian=quantum_state.endian;
 352   switch (quantum_type)
 353   {
 354     case IndexQuantum:
 355     {
 356       if (image->storage_class != PseudoClass)
 357         {
 358           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 359             "ColormappedImageRequired","`%s'",image->filename);
 360           return(extent);
 361         }
 362       switch (quantum_info->depth)
 363       {
 364         case 1:
 365         {
 366           register unsigned char
 367             pixel;
 368
 369           for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
 370           {
 371             pixel=(unsigned char) *indexes++;
 372             *q=((pixel & 0x01) << 7);
 373             pixel=(unsigned char) *indexes++;
 374             *q|=((pixel & 0x01) << 6);
 375             pixel=(unsigned char) *indexes++;
 376             *q|=((pixel & 0x01) << 5);
 377             pixel=(unsigned char) *indexes++;
 378             *q|=((pixel & 0x01) << 4);
 379             pixel=(unsigned char) *indexes++;
 380             *q|=((pixel & 0x01) << 3);
 381             pixel=(unsigned char) *indexes++;
 382             *q|=((pixel & 0x01) << 2);
 383             pixel=(unsigned char) *indexes++;
 384             *q|=((pixel & 0x01) << 1);
 385             pixel=(unsigned char) *indexes++;
 386             *q|=((pixel & 0x01) << 0);
 387             q++;
 388           }
 389           if ((number_pixels % 8) != 0)
 390             {
 391               *q='\0';
 392               for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
 393               {
 394                 pixel=(unsigned char) *indexes++;
 395                 *q|=((pixel & 0x01) << (unsigned char) bit);
 396               }
 397               q++;
 398             }
 399           break;
 400         }
 401         case 4:
 402         {
 403           register unsigned char
 404             pixel;
 405
 406           for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
 407           {
 408             pixel=(unsigned char) *indexes++;
 409             *q=((pixel & 0xf) << 4);
 410             pixel=(unsigned char) *indexes++;
 411             *q|=((pixel & 0xf) << 0);
 412             q++;
 413           }
 414           if ((number_pixels % 2) != 0)
 415             {
 416               pixel=(unsigned char) *indexes++;
 417               *q=((pixel & 0xf) << 4);
 418               q++;
 419             }
 420           break;
 421         }
 422         case 8:
 423         {
 424           for (x=0; x < (ssize_t) number_pixels; x++)
 425           {
 426             q=PopCharPixel((unsigned char) indexes[x],q);
 427             q+=quantum_info->pad;
 428           }
 429           break;
 430         }
 431         case 16:
 432         {
 433           if (quantum_info->format == FloatingPointQuantumFormat)
 434             {
 435               for (x=0; x < (ssize_t) number_pixels; x++)
 436               {
 437                 q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
 438                   indexes[x]),q);
 439                 q+=quantum_info->pad;
 440               }
 441               break;
 442             }
 443           for (x=0; x < (ssize_t) number_pixels; x++)
 444           {
 445             q=PopShortPixel(endian,(unsigned short) indexes[x],q);
 446             q+=quantum_info->pad;
 447           }
 448           break;
 449         }
 450         case 32:
 451         {
 452           if (quantum_info->format == FloatingPointQuantumFormat)
 453             {
 454               for (x=0; x < (ssize_t) number_pixels; x++)
 455               {
 456                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
 457                 p++;
 458                 q+=quantum_info->pad;
 459               }
 460               break;
 461             }
 462           for (x=0; x < (ssize_t) number_pixels; x++)
 463           {
 464             q=PopLongPixel(endian,(unsigned int) indexes[x],q);
 465             q+=quantum_info->pad;
 466           }
 467           break;
 468         }
 469         case 64:
 470         {
 471           if (quantum_info->format == FloatingPointQuantumFormat)
 472             {
 473               for (x=0; x < (ssize_t) number_pixels; x++)
 474               {
 475                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
 476                 p++;
 477                 q+=quantum_info->pad;
 478               }
 479               break;
 480             }
 481         }
 482         default:
 483         {
 484           for (x=0; x < (ssize_t) number_pixels; x++)
 485           {
 486             q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
 487             p++;
 488             q+=quantum_info->pad;
 489           }
 490           break;
 491         }
 492       }
 493       break;
 494     }
 495     case IndexAlphaQuantum:
 496     {
 497       if (image->storage_class != PseudoClass)
 498         {
 499           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 500             "ColormappedImageRequired","`%s'",image->filename);
 501           return(extent);
 502         }
 503       switch (quantum_info->depth)
 504       {
 505         case 1:
 506         {
 507           register unsigned char
 508             pixel;
 509
 510           for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
 511           {
 512             pixel=(unsigned char) *indexes++;
 513             *q=((pixel & 0x01) << 7);
 514             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
 515               1 : 0);
 516             *q|=((pixel & 0x01) << 6);
 517             p++;
 518             pixel=(unsigned char) *indexes++;
 519             *q|=((pixel & 0x01) << 5);
 520             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
 521               1 : 0);
 522             *q|=((pixel & 0x01) << 4);
 523             p++;
 524             pixel=(unsigned char) *indexes++;
 525             *q|=((pixel & 0x01) << 3);
 526             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
 527               1 : 0);
 528             *q|=((pixel & 0x01) << 2);
 529             p++;
 530             pixel=(unsigned char) *indexes++;
 531             *q|=((pixel & 0x01) << 1);
 532             pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
 533               1 : 0);
 534             *q|=((pixel & 0x01) << 0);
 535             p++;
 536             q++;
 537           }
 538           if ((number_pixels % 4) != 0)
 539             {
 540               *q='\0';
 541               for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
 542               {
 543                 pixel=(unsigned char) *indexes++;
 544                 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
 545                 pixel=(unsigned char) (p->opacity == (Quantum)
 546                   TransparentOpacity ? 1 : 0);
 547                 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
 548                 p++;
 549               }
 550               q++;
 551             }
 552           break;
 553         }
 554         case 4:
 555         {
 556           register unsigned char
 557             pixel;
 558
 559           for (x=0; x < (ssize_t) number_pixels ; x++)
 560           {
 561             pixel=(unsigned char) *indexes++;
 562             *q=((pixel & 0xf) << 4);
 563             pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
 564               GetOpacityPixelComponent(p)))+0.5);
 565             *q|=((pixel & 0xf) << 0);
 566             p++;
 567             q++;
 568           }
 569           break;
 570         }
 571         case 8:
 572         {
 573           register unsigned char
 574             pixel;
 575
 576           for (x=0; x < (ssize_t) number_pixels; x++)
 577           {
 578             q=PopCharPixel((unsigned char) indexes[x],q);
 579             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
 580               GetOpacityPixelComponent(p)));
 581             q=PopCharPixel(pixel,q);
 582             p++;
 583             q+=quantum_info->pad;
 584           }
 585           break;
 586         }
 587         case 16:
 588         {
 589           register unsigned short
 590             pixel;
 591
 592           if (quantum_info->format == FloatingPointQuantumFormat)
 593             {
 594               for (x=0; x < (ssize_t) number_pixels; x++)
 595               {
 596                 q=PopShortPixel(endian,(unsigned short) indexes[x],q);
 597                 pixel=SinglePrecisionToHalf(QuantumScale*
 598                   GetAlphaPixelComponent(p));
 599                 q=PopShortPixel(endian,pixel,q);
 600                 p++;
 601                 q+=quantum_info->pad;
 602               }
 603               break;
 604             }
 605           for (x=0; x < (ssize_t) number_pixels; x++)
 606           {
 607             q=PopShortPixel(endian,(unsigned short) indexes[x],q);
 608             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
 609               GetOpacityPixelComponent(p)));
 610             q=PopShortPixel(endian,pixel,q);
 611             p++;
 612             q+=quantum_info->pad;
 613           }
 614           break;
 615         }
 616         case 32:
 617         {
 618           register unsigned int
 619             pixel;
 620
 621           if (quantum_info->format == FloatingPointQuantumFormat)
 622             {
 623               for (x=0; x < (ssize_t) number_pixels; x++)
 624               {
 625                 float
 626                   pixel;
 627
 628                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
 629                 pixel=(float)  (GetAlphaPixelComponent(p));
 630                 q=PopFloatPixel(&quantum_state,pixel,q);
 631                 p++;
 632                 q+=quantum_info->pad;
 633               }
 634               break;
 635             }
 636           for (x=0; x < (ssize_t) number_pixels; x++)
 637           {
 638             q=PopLongPixel(endian,(unsigned int) indexes[x],q);
 639             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
 640               GetOpacityPixelComponent(p)));
 641             q=PopLongPixel(endian,pixel,q);
 642             p++;
 643             q+=quantum_info->pad;
 644           }
 645           break;
 646         }
 647         case 64:
 648         {
 649           if (quantum_info->format == FloatingPointQuantumFormat)
 650             {
 651               for (x=0; x < (ssize_t) number_pixels; x++)
 652               {
 653                 double
 654                   pixel;
 655
 656                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
 657                 pixel=(double) (GetAlphaPixelComponent(p));
 658                 q=PopDoublePixel(&quantum_state,pixel,q);
 659                 p++;
 660                 q+=quantum_info->pad;
 661               }
 662               break;
 663             }
 664         }
 665         default:
 666         {
 667           range=GetQuantumRange(image->depth);
 668           for (x=0; x < (ssize_t) number_pixels; x++)
 669           {
 670             q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
 671             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
 672               (Quantum) (GetAlphaPixelComponent(p)),range),q);
 673             p++;
 674             q+=quantum_info->pad;
 675           }
 676           break;
 677         }
 678       }
 679       break;
 680     }
 681     case BGRQuantum:
 682     {
 683       switch (quantum_info->depth)
 684       {
 685         case 8:
 686         {
 687           for (x=0; x < (ssize_t) number_pixels; x++)
 688           {
 689             q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
 690             q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
 691             q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
 692             p++;
 693             q+=quantum_info->pad;
 694           }
 695           break;
 696         }
 697         case 10:
 698         {
 699           register unsigned int
 700             pixel;
 701
 702           range=GetQuantumRange(image->depth);
 703           if (quantum_info->pack == MagickFalse)
 704             {
 705               for (x=0; x < (ssize_t) number_pixels; x++)
 706               {
 707                 pixel=(unsigned int) (ScaleQuantumToAny(p->red,range) << 22 |
 708                   ScaleQuantumToAny(p->green,range) << 12 |
 709                   ScaleQuantumToAny(p->blue,range) << 2);
 710                 q=PopLongPixel(endian,pixel,q);
 711                 p++;
 712                 q+=quantum_info->pad;
 713               }
 714               break;
 715             }
 716           if (quantum_info->quantum == 32UL)
 717             {
 718               for (x=0; x < (ssize_t) number_pixels; x++)
 719               {
 720                 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
 721                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
 722                 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
 723                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
 724                 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
 725                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
 726                 p++;
 727                 q+=quantum_info->pad;
 728               }
 729               break;
 730             }
 731           for (x=0; x < (ssize_t) number_pixels; x++)
 732           {
 733             pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
 734             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
 735             pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
 736             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
 737             pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
 738             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
 739             p++;
 740             q+=quantum_info->pad;
 741           }
 742           break;
 743         }
 744         case 12:
 745         {
 746           register unsigned int
 747             pixel;
 748
 749           range=GetQuantumRange(image->depth);
 750           if (quantum_info->pack == MagickFalse)
 751             {
 752               for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
 753               {
 754                 switch (x % 3)
 755                 {
 756                   default:
 757                   case 0:
 758                   {
 759                     pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
 760                     break;
 761                   }
 762                   case 1:
 763                   {
 764                     pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
 765                     break;
 766                   }
 767                   case 2:
 768                   {
 769                     pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
 770                     p++;
 771                     break;
 772                   }
 773                 }
 774                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
 775                 switch ((x+1) % 3)
 776                 {
 777                   default:
 778                   case 0:
 779                   {
 780                     pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
 781                     break;
 782                   }
 783                   case 1:
 784                   {
 785                     pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
 786                     break;
 787                   }
 788                   case 2:
 789                   {
 790                     pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
 791                     p++;
 792                     break;
 793                   }
 794                 }
 795                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
 796                 q+=quantum_info->pad;
 797               }
 798               for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
 799               {
 800                 switch ((x+bit) % 3)
 801                 {
 802                   default:
 803                   case 0:
 804                   {
 805                     pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
 806                     break;
 807                   }
 808                   case 1:
 809                   {
 810                     pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
 811                     break;
 812                   }
 813                   case 2:
 814                   {
 815                     pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
 816                     p++;
 817                     break;
 818                   }
 819                 }
 820                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
 821                 q+=quantum_info->pad;
 822               }
 823               if (bit != 0)
 824                 p++;
 825               break;
 826             }
 827           if (quantum_info->quantum == 32UL)
 828             {
 829               for (x=0; x < (ssize_t) number_pixels; x++)
 830               {
 831                 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
 832                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
 833                 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
 834                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
 835                 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
 836                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
 837                 p++;
 838                 q+=quantum_info->pad;
 839               }
 840               break;
 841             }
 842           for (x=0; x < (ssize_t) number_pixels; x++)
 843           {
 844             pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
 845             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
 846             pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
 847             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
 848             pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
 849             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
 850             p++;
 851             q+=quantum_info->pad;
 852           }
 853           break;
 854         }
 855         case 16:
 856         {
 857           register unsigned short
 858             pixel;
 859
 860           if (quantum_info->format == FloatingPointQuantumFormat)
 861             {
 862               for (x=0; x < (ssize_t) number_pixels; x++)
 863               {
 864                 pixel=SinglePrecisionToHalf(QuantumScale*
 865                   GetBluePixelComponent(p));
 866                 q=PopShortPixel(endian,pixel,q);
 867                 pixel=SinglePrecisionToHalf(QuantumScale*
 868                   GetGreenPixelComponent(p));
 869                 q=PopShortPixel(endian,pixel,q);
 870                 pixel=SinglePrecisionToHalf(QuantumScale*
 871                   GetRedPixelComponent(p));
 872                 q=PopShortPixel(endian,pixel,q);
 873                 p++;
 874                 q+=quantum_info->pad;
 875               }
 876               break;
 877             }
 878           for (x=0; x < (ssize_t) number_pixels; x++)
 879           {
 880             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
 881             q=PopShortPixel(endian,pixel,q);
 882             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
 883             q=PopShortPixel(endian,pixel,q);
 884             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
 885             q=PopShortPixel(endian,pixel,q);
 886             p++;
 887             q+=quantum_info->pad;
 888           }
 889           break;
 890         }
 891         case 32:
 892         {
 893           register unsigned int
 894             pixel;
 895
 896           if (quantum_info->format == FloatingPointQuantumFormat)
 897             {
 898               for (x=0; x < (ssize_t) number_pixels; x++)
 899               {
 900                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
 901                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
 902                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
 903                 p++;
 904                 q+=quantum_info->pad;
 905               }
 906               break;
 907             }
 908           for (x=0; x < (ssize_t) number_pixels; x++)
 909           {
 910             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
 911             q=PopLongPixel(endian,pixel,q);
 912             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
 913             q=PopLongPixel(endian,pixel,q);
 914             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
 915             q=PopLongPixel(endian,pixel,q);
 916             p++;
 917             q+=quantum_info->pad;
 918           }
 919           break;
 920         }
 921         case 64:
 922         {
 923           if (quantum_info->format == FloatingPointQuantumFormat)
 924             {
 925               for (x=0; x < (ssize_t) number_pixels; x++)
 926               {
 927                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
 928                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
 929                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
 930                 p++;
 931                 q+=quantum_info->pad;
 932               }
 933               break;
 934             }
 935         }
 936         default:
 937         {
 938           range=GetQuantumRange(image->depth);
 939           for (x=0; x < (ssize_t) number_pixels; x++)
 940           {
 941             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
 942               p->red,range),q);
 943             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
 944               p->green,range),q);
 945             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
 946               p->blue,range),q);
 947             p++;
 948             q+=quantum_info->pad;
 949           }
 950           break;
 951         }
 952       }
 953       break;
 954     }
 955     case BGRAQuantum:
 956     case BGROQuantum:
 957     {
 958       switch (quantum_info->depth)
 959       {
 960         case 8:
 961         {
 962           register unsigned char
 963             pixel;
 964
 965           for (x=0; x < (ssize_t) number_pixels; x++)
 966           {
 967             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
 968             q=PopCharPixel(pixel,q);
 969             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
 970             q=PopCharPixel(pixel,q);
 971             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
 972             q=PopCharPixel(pixel,q);
 973             pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
 974             q=PopCharPixel(pixel,q);
 975             p++;
 976             q+=quantum_info->pad;
 977           }
 978           break;
 979         }
 980         case 10:
 981         {
 982           register unsigned int
 983             pixel;
 984
 985           range=GetQuantumRange(image->depth);
 986           if (quantum_info->pack == MagickFalse)
 987             {
 988               ssize_t
 989                 n;
 990
 991               register ssize_t
 992                 i;
 993
 994               size_t
 995                 quantum;
 996
 997               n=0;
 998               quantum=0;
 999               pixel=0;
1000               for (x=0; x < (ssize_t) number_pixels; x++)
1001               {
1002                 for (i=0; i < 4; i++)
1003                 {
1004                   switch (i)
1005                   {
1006                     case 0: quantum=p->red; break;
1007                     case 1: quantum=p->green; break;
1008                     case 2: quantum=p->blue; break;
1009                     case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
1010                   }
1011                   switch (n % 3)
1012                   {
1013                     case 0:
1014                     {
1015                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1016                         range) << 22);
1017                       break;
1018                     }
1019                     case 1:
1020                     {
1021                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1022                         range) << 12);
1023                       break;
1024                     }
1025                     case 2:
1026                     {
1027                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1028                         range) << 2);
1029                       q=PopLongPixel(endian,pixel,q);
1030                       pixel=0;
1031                       break;
1032                     }
1033                   }
1034                   n++;
1035                 }
1036                 p++;
1037                 q+=quantum_info->pad;
1038               }
1039               break;
1040             }
1041           if (quantum_info->quantum == 32UL)
1042             {
1043               for (x=0; x < (ssize_t) number_pixels; x++)
1044               {
1045                 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
1046                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1047                 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
1048                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1049                 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
1050                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1051                 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
1052                   p->opacity),range);
1053                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
1054                 p++;
1055                 q+=quantum_info->pad;
1056               }
1057               break;
1058             }
1059           for (x=0; x < (ssize_t) number_pixels; x++)
1060           {
1061             pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
1062             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1063             pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
1064             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1065             pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
1066             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1067             pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
1068               p->opacity),range);
1069             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
1070             p++;
1071             q+=quantum_info->pad;
1072           }
1073           break;
1074         }
1075         case 16:
1076         {
1077           register unsigned short
1078             pixel;
1079
1080           if (quantum_info->format == FloatingPointQuantumFormat)
1081             {
1082               for (x=0; x < (ssize_t) number_pixels; x++)
1083               {
1084                 pixel=SinglePrecisionToHalf(QuantumScale*
1085                   GetBluePixelComponent(p));
1086                 q=PopShortPixel(endian,pixel,q);
1087                 pixel=SinglePrecisionToHalf(QuantumScale*
1088                   GetGreenPixelComponent(p));
1089                 q=PopShortPixel(endian,pixel,q);
1090                 pixel=SinglePrecisionToHalf(QuantumScale*
1091                   GetRedPixelComponent(p));
1092                 q=PopShortPixel(endian,pixel,q);
1093                 pixel=SinglePrecisionToHalf(QuantumScale*
1094                   GetAlphaPixelComponent(p));
1095                 q=PopShortPixel(endian,pixel,q);
1096                 p++;
1097                 q+=quantum_info->pad;
1098               }
1099               break;
1100             }
1101           for (x=0; x < (ssize_t) number_pixels; x++)
1102           {
1103             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1104             q=PopShortPixel(endian,pixel,q);
1105             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1106             q=PopShortPixel(endian,pixel,q);
1107             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1108             q=PopShortPixel(endian,pixel,q);
1109             pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
1110             q=PopShortPixel(endian,pixel,q);
1111             p++;
1112             q+=quantum_info->pad;
1113           }
1114           break;
1115         }
1116         case 32:
1117         {
1118           register unsigned int
1119             pixel;
1120
1121           if (quantum_info->format == FloatingPointQuantumFormat)
1122             {
1123               for (x=0; x < (ssize_t) number_pixels; x++)
1124               {
1125                 float
1126                   pixel;
1127
1128                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1129                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1130                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1131                 pixel=(float) GetAlphaPixelComponent(p);
1132                 q=PopFloatPixel(&quantum_state,pixel,q);
1133                 p++;
1134                 q+=quantum_info->pad;
1135               }
1136               break;
1137             }
1138           for (x=0; x < (ssize_t) number_pixels; x++)
1139           {
1140             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1141             q=PopLongPixel(endian,pixel,q);
1142             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1143             q=PopLongPixel(endian,pixel,q);
1144             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1145             q=PopLongPixel(endian,pixel,q);
1146             pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
1147             q=PopLongPixel(endian,pixel,q);
1148             p++;
1149             q+=quantum_info->pad;
1150           }
1151           break;
1152         }
1153         case 64:
1154         {
1155           if (quantum_info->format == FloatingPointQuantumFormat)
1156             {
1157               double
1158                 pixel;
1159
1160               for (x=0; x < (ssize_t) number_pixels; x++)
1161               {
1162                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1163                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1164                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1165                 pixel=(double) GetAlphaPixelComponent(p);
1166                 q=PopDoublePixel(&quantum_state,pixel,q);
1167                 p++;
1168                 q+=quantum_info->pad;
1169               }
1170               break;
1171             }
1172         }
1173         default:
1174         {
1175           range=GetQuantumRange(image->depth);
1176           for (x=0; x < (ssize_t) number_pixels; x++)
1177           {
1178             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1179               GetBluePixelComponent(p),range),q);
1180             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1181               GetGreenPixelComponent(p),range),q);
1182             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1183               GetRedPixelComponent(p),range),q);
1184             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1185               (Quantum) GetAlphaPixelComponent(p),range),q);
1186             p++;
1187             q+=quantum_info->pad;
1188           }
1189           break;
1190         }
1191       }
1192       break;
1193     }
1194     case GrayQuantum:
1195     {
1196       switch (quantum_info->depth)
1197       {
1198         case 1:
1199         {
1200           register Quantum
1201             threshold;
1202
1203           register unsigned char
1204             black,
1205             white;
1206
1207           black=0x00;
1208           white=0x01;
1209           if (quantum_info->min_is_white != MagickFalse)
1210             {
1211               black=0x01;
1212               white=0x00;
1213             }
1214           threshold=(Quantum) (QuantumRange/2);
1215           for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1216           {
1217             *q='\0';
1218             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
1219             p++;
1220             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
1221             p++;
1222             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
1223             p++;
1224             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
1225             p++;
1226             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
1227             p++;
1228             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
1229             p++;
1230             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
1231             p++;
1232             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
1233             p++;
1234             q++;
1235           }
1236           if ((number_pixels % 8) != 0)
1237             {
1238               *q='\0';
1239               for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1240               {
1241                 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
1242                   bit;
1243                 p++;
1244               }
1245               q++;
1246             }
1247           break;
1248         }
1249         case 4:
1250         {
1251           register unsigned char
1252             pixel;
1253
1254           for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
1255           {
1256             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1257             *q=(((pixel >> 4) & 0xf) << 4);
1258             p++;
1259             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1260             *q|=pixel >> 4;
1261             p++;
1262             q++;
1263           }
1264           if ((number_pixels % 2) != 0)
1265             {
1266               pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1267               *q=(((pixel >> 4) & 0xf) << 4);
1268               p++;
1269               q++;
1270             }
1271           break;
1272         }
1273         case 8:
1274         {
1275           register unsigned char
1276             pixel;
1277
1278           for (x=0; x < (ssize_t) number_pixels; x++)
1279           {
1280             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1281             q=PopCharPixel(pixel,q);
1282             p++;
1283             q+=quantum_info->pad;
1284           }
1285           break;
1286         }
1287         case 10:
1288         {
1289           range=GetQuantumRange(image->depth);
1290           if (quantum_info->pack == MagickFalse)
1291             {
1292               register unsigned int
1293                 pixel;
1294
1295               for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
1296               {
1297                 pixel=(unsigned int) (
1298                   ScaleQuantumToAny(PixelIntensityToQuantum(p+2),range) << 22 |
1299                   ScaleQuantumToAny(PixelIntensityToQuantum(p+1),range) << 12 |
1300                   ScaleQuantumToAny(PixelIntensityToQuantum(p+0),range) << 2);
1301                 q=PopLongPixel(endian,pixel,q);
1302                 p+=3;
1303                 q+=quantum_info->pad;
1304               }
1305               pixel=0UL;
1306               if (x++ < (ssize_t) (number_pixels-1))
1307                 pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+1),
1308                   range) << 12;
1309               if (x++ < (ssize_t) number_pixels)
1310                 pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+0),
1311                   range) << 2;
1312               q=PopLongPixel(endian,pixel,q);
1313               break;
1314             }
1315           for (x=0; x < (ssize_t) number_pixels; x++)
1316           {
1317             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1318               PixelIntensityToQuantum(p),range),q);
1319             p++;
1320             q+=quantum_info->pad;
1321           }
1322           break;
1323         }
1324         case 12:
1325         {
1326           register unsigned short
1327             pixel;
1328
1329           range=GetQuantumRange(image->depth);
1330           if (quantum_info->pack == MagickFalse)
1331             {
1332               for (x=0; x < (ssize_t) number_pixels; x++)
1333               {
1334                 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1335                 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
1336                 p++;
1337                 q+=quantum_info->pad;
1338               }
1339               break;
1340             }
1341           for (x=0; x < (ssize_t) number_pixels; x++)
1342           {
1343             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1344               PixelIntensityToQuantum(p),range),q);
1345             p++;
1346             q+=quantum_info->pad;
1347           }
1348           break;
1349         }
1350         case 16:
1351         {
1352           register unsigned short
1353             pixel;
1354
1355           if (quantum_info->format == FloatingPointQuantumFormat)
1356             {
1357               for (x=0; x < (ssize_t) number_pixels; x++)
1358               {
1359                 pixel=SinglePrecisionToHalf(QuantumScale*
1360                   PixelIntensityToQuantum(p));
1361                 q=PopShortPixel(endian,pixel,q);
1362                 p++;
1363                 q+=quantum_info->pad;
1364               }
1365               break;
1366             }
1367           for (x=0; x < (ssize_t) number_pixels; x++)
1368           {
1369             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1370             q=PopShortPixel(endian,pixel,q);
1371             p++;
1372             q+=quantum_info->pad;
1373           }
1374           break;
1375         }
1376         case 32:
1377         {
1378           register unsigned int
1379             pixel;
1380
1381           if (quantum_info->format == FloatingPointQuantumFormat)
1382             {
1383               for (x=0; x < (ssize_t) number_pixels; x++)
1384               {
1385                 float
1386                   pixel;
1387
1388                 pixel=(float) PixelIntensityToQuantum(p);
1389                 q=PopFloatPixel(&quantum_state,pixel,q);
1390                 p++;
1391                 q+=quantum_info->pad;
1392               }
1393               break;
1394             }
1395           for (x=0; x < (ssize_t) number_pixels; x++)
1396           {
1397             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1398             q=PopLongPixel(endian,pixel,q);
1399             p++;
1400             q+=quantum_info->pad;
1401           }
1402           break;
1403         }
1404         case 64:
1405         {
1406           if (quantum_info->format == FloatingPointQuantumFormat)
1407             {
1408               for (x=0; x < (ssize_t) number_pixels; x++)
1409               {
1410                 double
1411                   pixel;
1412
1413                 pixel=(double) PixelIntensityToQuantum(p);
1414                 q=PopDoublePixel(&quantum_state,pixel,q);
1415                 p++;
1416                 q+=quantum_info->pad;
1417               }
1418               break;
1419             }
1420         }
1421         default:
1422         {
1423           range=GetQuantumRange(image->depth);
1424           for (x=0; x < (ssize_t) number_pixels; x++)
1425           {
1426             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1427               PixelIntensityToQuantum(p),range),q);
1428             p++;
1429             q+=quantum_info->pad;
1430           }
1431           break;
1432         }
1433       }
1434       break;
1435     }
1436     case GrayAlphaQuantum:
1437     {
1438       switch (quantum_info->depth)
1439       {
1440         case 1:
1441         {
1442           register Quantum
1443             threshold;
1444
1445           register unsigned char
1446             black,
1447             pixel,
1448             white;
1449
1450           black=0x00;
1451           white=0x01;
1452           if (quantum_info->min_is_white == MagickFalse)
1453             {
1454               black=0x01;
1455               white=0x00;
1456             }
1457           threshold=(Quantum) (QuantumRange/2);
1458           for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
1459           {
1460             *q='\0';
1461             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 7;
1462             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1463             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
1464             p++;
1465             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 5;
1466             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1467             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
1468             p++;
1469             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 3;
1470             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1471             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
1472             p++;
1473             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 1;
1474             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1475             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
1476             p++;
1477             q++;
1478           }
1479           if ((number_pixels % 4) != 0)
1480             {
1481               *q='\0';
1482               for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
1483               {
1484                 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) <<
1485                   (7-bit);
1486                 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
1487                   0x01);
1488                 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
1489                   (7-bit-1));
1490                 p++;
1491               }
1492               q++;
1493             }
1494           break;
1495         }
1496         case 4:
1497         {
1498           register unsigned char
1499             pixel;
1500
1501           for (x=0; x < (ssize_t) number_pixels ; x++)
1502           {
1503             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1504             *q=(((pixel >> 4) & 0xf) << 4);
1505             pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
1506               GetOpacityPixelComponent(p)))+0.5);
1507             *q|=pixel & 0xf;
1508             p++;
1509             q++;
1510           }
1511           break;
1512         }
1513         case 8:
1514         {
1515           register unsigned char
1516             pixel;
1517
1518           for (x=0; x < (ssize_t) number_pixels; x++)
1519           {
1520             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1521             q=PopCharPixel(pixel,q);
1522             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1523               GetOpacityPixelComponent(p)));
1524             q=PopCharPixel(pixel,q);
1525             p++;
1526             q+=quantum_info->pad;
1527           }
1528           break;
1529         }
1530         case 16:
1531         {
1532           register unsigned short
1533             pixel;
1534
1535           if (quantum_info->format == FloatingPointQuantumFormat)
1536             {
1537               for (x=0; x < (ssize_t) number_pixels; x++)
1538               {
1539                 pixel=SinglePrecisionToHalf(QuantumScale*
1540                   PixelIntensityToQuantum(p));
1541                 q=PopShortPixel(endian,pixel,q);
1542                 pixel=SinglePrecisionToHalf(QuantumScale*
1543                   GetAlphaPixelComponent(p));
1544                 q=PopShortPixel(endian,pixel,q);
1545                 p++;
1546                 q+=quantum_info->pad;
1547               }
1548               break;
1549             }
1550           for (x=0; x < (ssize_t) number_pixels; x++)
1551           {
1552             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1553             q=PopShortPixel(endian,pixel,q);
1554             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1555               GetOpacityPixelComponent(p)));
1556             q=PopShortPixel(endian,pixel,q);
1557             p++;
1558             q+=quantum_info->pad;
1559           }
1560           break;
1561         }
1562         case 32:
1563         {
1564           register unsigned int
1565             pixel;
1566
1567           if (quantum_info->format == FloatingPointQuantumFormat)
1568             {
1569               for (x=0; x < (ssize_t) number_pixels; x++)
1570               {
1571                 float
1572                   pixel;
1573
1574                 pixel=(float) PixelIntensityToQuantum(p);
1575                 q=PopFloatPixel(&quantum_state,pixel,q);
1576                 pixel=(float) (GetAlphaPixelComponent(p));
1577                 q=PopFloatPixel(&quantum_state,pixel,q);
1578                 p++;
1579                 q+=quantum_info->pad;
1580               }
1581               break;
1582             }
1583           for (x=0; x < (ssize_t) number_pixels; x++)
1584           {
1585             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1586             q=PopLongPixel(endian,pixel,q);
1587             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1588               GetOpacityPixelComponent(p)));
1589             q=PopLongPixel(endian,pixel,q);
1590             p++;
1591             q+=quantum_info->pad;
1592           }
1593           break;
1594         }
1595         case 64:
1596         {
1597           if (quantum_info->format == FloatingPointQuantumFormat)
1598             {
1599               for (x=0; x < (ssize_t) number_pixels; x++)
1600               {
1601                 double
1602                   pixel;
1603
1604                 pixel=(double) PixelIntensityToQuantum(p);
1605                 q=PopDoublePixel(&quantum_state,pixel,q);
1606                 pixel=(double) (GetAlphaPixelComponent(p));
1607                 q=PopDoublePixel(&quantum_state,pixel,q);
1608                 p++;
1609                 q+=quantum_info->pad;
1610               }
1611               break;
1612             }
1613         }
1614         default:
1615         {
1616           range=GetQuantumRange(image->depth);
1617           for (x=0; x < (ssize_t) number_pixels; x++)
1618           {
1619             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1620               PixelIntensityToQuantum(p),range),q);
1621             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1622               (Quantum) (GetAlphaPixelComponent(p)),range),q);
1623             p++;
1624             q+=quantum_info->pad;
1625           }
1626           break;
1627         }
1628       }
1629       break;
1630     }
1631     case RedQuantum:
1632     case CyanQuantum:
1633     {
1634       switch (quantum_info->depth)
1635       {
1636         case 8:
1637         {
1638           register unsigned char
1639             pixel;
1640
1641           for (x=0; x < (ssize_t) number_pixels; x++)
1642           {
1643             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1644             q=PopCharPixel(pixel,q);
1645             p++;
1646             q+=quantum_info->pad;
1647           }
1648           break;
1649         }
1650         case 16:
1651         {
1652           register unsigned short
1653             pixel;
1654
1655           if (quantum_info->format == FloatingPointQuantumFormat)
1656             {
1657               for (x=0; x < (ssize_t) number_pixels; x++)
1658               {
1659                 pixel=SinglePrecisionToHalf(QuantumScale*
1660                   GetRedPixelComponent(p));
1661                 q=PopShortPixel(endian,pixel,q);
1662                 p++;
1663                 q+=quantum_info->pad;
1664               }
1665               break;
1666             }
1667           for (x=0; x < (ssize_t) number_pixels; x++)
1668           {
1669             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1670             q=PopShortPixel(endian,pixel,q);
1671             p++;
1672             q+=quantum_info->pad;
1673           }
1674           break;
1675         }
1676         case 32:
1677         {
1678           register unsigned int
1679             pixel;
1680
1681           if (quantum_info->format == FloatingPointQuantumFormat)
1682             {
1683               for (x=0; x < (ssize_t) number_pixels; x++)
1684               {
1685                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1686                 p++;
1687                 q+=quantum_info->pad;
1688               }
1689               break;
1690             }
1691           for (x=0; x < (ssize_t) number_pixels; x++)
1692           {
1693             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1694             q=PopLongPixel(endian,pixel,q);
1695             p++;
1696             q+=quantum_info->pad;
1697           }
1698           break;
1699         }
1700         case 64:
1701         {
1702           if (quantum_info->format == FloatingPointQuantumFormat)
1703             {
1704               for (x=0; x < (ssize_t) number_pixels; x++)
1705               {
1706                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1707                 p++;
1708                 q+=quantum_info->pad;
1709               }
1710               break;
1711             }
1712         }
1713         default:
1714         {
1715           range=GetQuantumRange(image->depth);
1716           for (x=0; x < (ssize_t) number_pixels; x++)
1717           {
1718             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1719               p->red,range),q);
1720             p++;
1721             q+=quantum_info->pad;
1722           }
1723           break;
1724         }
1725       }
1726       break;
1727     }
1728     case GreenQuantum:
1729     case MagentaQuantum:
1730     {
1731       switch (quantum_info->depth)
1732       {
1733         case 8:
1734         {
1735           register unsigned char
1736             pixel;
1737
1738           for (x=0; x < (ssize_t) number_pixels; x++)
1739           {
1740             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1741             q=PopCharPixel(pixel,q);
1742             p++;
1743             q+=quantum_info->pad;
1744           }
1745           break;
1746         }
1747         case 16:
1748         {
1749           register unsigned short
1750             pixel;
1751
1752           if (quantum_info->format == FloatingPointQuantumFormat)
1753             {
1754               for (x=0; x < (ssize_t) number_pixels; x++)
1755               {
1756                 pixel=SinglePrecisionToHalf(QuantumScale*
1757                   GetGreenPixelComponent(p));
1758                 q=PopShortPixel(endian,pixel,q);
1759                 p++;
1760                 q+=quantum_info->pad;
1761               }
1762               break;
1763             }
1764           for (x=0; x < (ssize_t) number_pixels; x++)
1765           {
1766             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1767             q=PopShortPixel(endian,pixel,q);
1768             p++;
1769             q+=quantum_info->pad;
1770           }
1771           break;
1772         }
1773         case 32:
1774         {
1775           register unsigned int
1776             pixel;
1777
1778           if (quantum_info->format == FloatingPointQuantumFormat)
1779             {
1780               for (x=0; x < (ssize_t) number_pixels; x++)
1781               {
1782                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1783                 p++;
1784                 q+=quantum_info->pad;
1785               }
1786               break;
1787             }
1788           for (x=0; x < (ssize_t) number_pixels; x++)
1789           {
1790             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1791             q=PopLongPixel(endian,pixel,q);
1792             p++;
1793             q+=quantum_info->pad;
1794           }
1795           break;
1796         }
1797         case 64:
1798         {
1799           if (quantum_info->format == FloatingPointQuantumFormat)
1800             {
1801               for (x=0; x < (ssize_t) number_pixels; x++)
1802               {
1803                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1804                 p++;
1805                 q+=quantum_info->pad;
1806               }
1807               break;
1808             }
1809         }
1810         default:
1811         {
1812           range=GetQuantumRange(image->depth);
1813           for (x=0; x < (ssize_t) number_pixels; x++)
1814           {
1815             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1816               p->green,range),q);
1817             p++;
1818             q+=quantum_info->pad;
1819           }
1820           break;
1821         }
1822       }
1823       break;
1824     }
1825     case BlueQuantum:
1826     case YellowQuantum:
1827     {
1828       switch (quantum_info->depth)
1829       {
1830         case 8:
1831         {
1832           register unsigned char
1833             pixel;
1834
1835           for (x=0; x < (ssize_t) number_pixels; x++)
1836           {
1837             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1838             q=PopCharPixel(pixel,q);
1839             p++;
1840             q+=quantum_info->pad;
1841           }
1842           break;
1843         }
1844         case 16:
1845         {
1846           register unsigned short
1847             pixel;
1848
1849           if (quantum_info->format == FloatingPointQuantumFormat)
1850             {
1851               for (x=0; x < (ssize_t) number_pixels; x++)
1852               {
1853                 pixel=SinglePrecisionToHalf(QuantumScale*
1854                   GetBluePixelComponent(p));
1855                 q=PopShortPixel(endian,pixel,q);
1856                 p++;
1857                 q+=quantum_info->pad;
1858               }
1859               break;
1860             }
1861           for (x=0; x < (ssize_t) number_pixels; x++)
1862           {
1863             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1864             q=PopShortPixel(endian,pixel,q);
1865             p++;
1866             q+=quantum_info->pad;
1867           }
1868           break;
1869         }
1870         case 32:
1871         {
1872           register unsigned int
1873             pixel;
1874
1875           if (quantum_info->format == FloatingPointQuantumFormat)
1876             {
1877               for (x=0; x < (ssize_t) number_pixels; x++)
1878               {
1879                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1880                 p++;
1881                 q+=quantum_info->pad;
1882               }
1883               break;
1884             }
1885           for (x=0; x < (ssize_t) number_pixels; x++)
1886           {
1887             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1888             q=PopLongPixel(endian,pixel,q);
1889             p++;
1890             q+=quantum_info->pad;
1891           }
1892           break;
1893         }
1894         case 64:
1895         {
1896           if (quantum_info->format == FloatingPointQuantumFormat)
1897             {
1898               for (x=0; x < (ssize_t) number_pixels; x++)
1899               {
1900                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1901                 p++;
1902                 q+=quantum_info->pad;
1903               }
1904               break;
1905             }
1906         }
1907         default:
1908         {
1909           range=GetQuantumRange(image->depth);
1910           for (x=0; x < (ssize_t) number_pixels; x++)
1911           {
1912             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
1913               p->blue,range),q);
1914             p++;
1915             q+=quantum_info->pad;
1916           }
1917           break;
1918         }
1919       }
1920       break;
1921     }
1922     case AlphaQuantum:
1923     {
1924       switch (quantum_info->depth)
1925       {
1926         case 8:
1927         {
1928           register unsigned char
1929             pixel;
1930
1931           for (x=0; x < (ssize_t) number_pixels; x++)
1932           {
1933             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1934               GetOpacityPixelComponent(p)));
1935             q=PopCharPixel(pixel,q);
1936             p++;
1937             q+=quantum_info->pad;
1938           }
1939           break;
1940         }
1941         case 16:
1942         {
1943           register unsigned short
1944             pixel;
1945
1946           if (quantum_info->format == FloatingPointQuantumFormat)
1947             {
1948               for (x=0; x < (ssize_t) number_pixels; x++)
1949               {
1950                 pixel=SinglePrecisionToHalf(QuantumScale*
1951                   GetAlphaPixelComponent(p));
1952                 q=PopShortPixel(endian,pixel,q);
1953                 p++;
1954                 q+=quantum_info->pad;
1955               }
1956               break;
1957             }
1958           for (x=0; x < (ssize_t) number_pixels; x++)
1959           {
1960             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1961               GetOpacityPixelComponent(p)));
1962             q=PopShortPixel(endian,pixel,q);
1963             p++;
1964             q+=quantum_info->pad;
1965           }
1966           break;
1967         }
1968         case 32:
1969         {
1970           register unsigned int
1971             pixel;
1972
1973           if (quantum_info->format == FloatingPointQuantumFormat)
1974             {
1975               for (x=0; x < (ssize_t) number_pixels; x++)
1976               {
1977                 float
1978                   pixel;
1979
1980                 pixel=(float) (GetAlphaPixelComponent(p));
1981                 q=PopFloatPixel(&quantum_state,pixel,q);
1982                 p++;
1983                 q+=quantum_info->pad;
1984               }
1985               break;
1986             }
1987           for (x=0; x < (ssize_t) number_pixels; x++)
1988           {
1989             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1990               GetOpacityPixelComponent(p)));
1991             q=PopLongPixel(endian,pixel,q);
1992             p++;
1993             q+=quantum_info->pad;
1994           }
1995           break;
1996         }
1997         case 64:
1998         {
1999           if (quantum_info->format == FloatingPointQuantumFormat)
2000             {
2001               for (x=0; x < (ssize_t) number_pixels; x++)
2002               {
2003                 double
2004                   pixel;
2005
2006                 pixel=(double) (GetAlphaPixelComponent(p));
2007                 q=PopDoublePixel(&quantum_state,pixel,q);
2008                 p++;
2009                 q+=quantum_info->pad;
2010               }
2011               break;
2012             }
2013         }
2014         default:
2015         {
2016           range=GetQuantumRange(image->depth);
2017           for (x=0; x < (ssize_t) number_pixels; x++)
2018           {
2019             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2020               (Quantum) (GetAlphaPixelComponent(p)),range),q);
2021             p++;
2022             q+=quantum_info->pad;
2023           }
2024           break;
2025         }
2026       }
2027       break;
2028     }
2029     case OpacityQuantum:
2030     {
2031       switch (quantum_info->depth)
2032       {
2033         case 8:
2034         {
2035           register unsigned char
2036             pixel;
2037
2038           for (x=0; x < (ssize_t) number_pixels; x++)
2039           {
2040             pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
2041             q=PopCharPixel(pixel,q);
2042             p++;
2043             q+=quantum_info->pad;
2044           }
2045           break;
2046         }
2047         case 16:
2048         {
2049           register unsigned short
2050             pixel;
2051
2052           if (quantum_info->format == FloatingPointQuantumFormat)
2053             {
2054               for (x=0; x < (ssize_t) number_pixels; x++)
2055               {
2056                 pixel=SinglePrecisionToHalf(QuantumScale*
2057                   GetOpacityPixelComponent(p));
2058                 q=PopShortPixel(endian,pixel,q);
2059                 p++;
2060                 q+=quantum_info->pad;
2061               }
2062               break;
2063             }
2064           for (x=0; x < (ssize_t) number_pixels; x++)
2065           {
2066             pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
2067             q=PopShortPixel(endian,pixel,q);
2068             p++;
2069             q+=quantum_info->pad;
2070           }
2071           break;
2072         }
2073         case 32:
2074         {
2075           register unsigned int
2076             pixel;
2077
2078           if (quantum_info->format == FloatingPointQuantumFormat)
2079             {
2080               for (x=0; x < (ssize_t) number_pixels; x++)
2081               {
2082                 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
2083                 p++;
2084                 q+=quantum_info->pad;
2085               }
2086               break;
2087             }
2088           for (x=0; x < (ssize_t) number_pixels; x++)
2089           {
2090             pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
2091             q=PopLongPixel(endian,pixel,q);
2092             p++;
2093             q+=quantum_info->pad;
2094           }
2095           break;
2096         }
2097         case 64:
2098         {
2099           if (quantum_info->format == FloatingPointQuantumFormat)
2100             {
2101               for (x=0; x < (ssize_t) number_pixels; x++)
2102               {
2103                 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
2104                 p++;
2105                 q+=quantum_info->pad;
2106               }
2107               break;
2108             }
2109         }
2110         default:
2111         {
2112           range=GetQuantumRange(image->depth);
2113           for (x=0; x < (ssize_t) number_pixels; x++)
2114           {
2115             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2116               p->opacity,range),q);
2117             p++;
2118             q+=quantum_info->pad;
2119           }
2120           break;
2121         }
2122       }
2123       break;
2124     }
2125     case BlackQuantum:
2126     {
2127       if (image->colorspace != CMYKColorspace)
2128         {
2129           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2130             "ColorSeparatedImageRequired","`%s'",image->filename);
2131           return(extent);
2132         }
2133       switch (quantum_info->depth)
2134       {
2135         case 8:
2136         {
2137           register unsigned char
2138             pixel;
2139
2140           for (x=0; x < (ssize_t) number_pixels; x++)
2141           {
2142             pixel=ScaleQuantumToChar(indexes[x]);
2143             q=PopCharPixel(pixel,q);
2144             p++;
2145             q+=quantum_info->pad;
2146           }
2147           break;
2148         }
2149         case 16:
2150         {
2151           register unsigned short
2152             pixel;
2153
2154           if (quantum_info->format == FloatingPointQuantumFormat)
2155             {
2156               for (x=0; x < (ssize_t) number_pixels; x++)
2157               {
2158                 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2159                 q=PopShortPixel(endian,pixel,q);
2160                 p++;
2161                 q+=quantum_info->pad;
2162               }
2163               break;
2164             }
2165           for (x=0; x < (ssize_t) number_pixels; x++)
2166           {
2167             pixel=ScaleQuantumToShort(indexes[x]);
2168             q=PopShortPixel(endian,pixel,q);
2169             p++;
2170             q+=quantum_info->pad;
2171           }
2172           break;
2173         }
2174         case 32:
2175         {
2176           register unsigned int
2177             pixel;
2178
2179           if (quantum_info->format == FloatingPointQuantumFormat)
2180             {
2181               for (x=0; x < (ssize_t) number_pixels; x++)
2182               {
2183                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2184                 p++;
2185                 q+=quantum_info->pad;
2186               }
2187               break;
2188             }
2189           for (x=0; x < (ssize_t) number_pixels; x++)
2190           {
2191             pixel=ScaleQuantumToLong(indexes[x]);
2192             q=PopLongPixel(endian,pixel,q);
2193             p++;
2194             q+=quantum_info->pad;
2195           }
2196           break;
2197         }
2198         case 64:
2199         {
2200           if (quantum_info->format == FloatingPointQuantumFormat)
2201             {
2202               for (x=0; x < (ssize_t) number_pixels; x++)
2203               {
2204                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2205                 p++;
2206                 q+=quantum_info->pad;
2207               }
2208               break;
2209             }
2210         }
2211         default:
2212         {
2213           range=GetQuantumRange(image->depth);
2214           for (x=0; x < (ssize_t) number_pixels; x++)
2215           {
2216             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2217               (Quantum) indexes[x],range),q);
2218             p++;
2219             q+=quantum_info->pad;
2220           }
2221           break;
2222         }
2223       }
2224       break;
2225     }
2226     case RGBQuantum:
2227     case CbYCrQuantum:
2228     {
2229       switch (quantum_info->depth)
2230       {
2231         case 8:
2232         {
2233           for (x=0; x < (ssize_t) number_pixels; x++)
2234           {
2235             q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
2236             q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
2237             q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
2238             p++;
2239             q+=quantum_info->pad;
2240           }
2241           break;
2242         }
2243         case 10:
2244         {
2245           register unsigned int
2246             pixel;
2247
2248           range=GetQuantumRange(image->depth);
2249           if (quantum_info->pack == MagickFalse)
2250             {
2251               for (x=0; x < (ssize_t) number_pixels; x++)
2252               {
2253                 pixel=(unsigned int) (ScaleQuantumToAny(p->red,range) << 22 |
2254                   ScaleQuantumToAny(p->green,range) << 12 |
2255                   ScaleQuantumToAny(p->blue,range) << 2);
2256                 q=PopLongPixel(endian,pixel,q);
2257                 p++;
2258                 q+=quantum_info->pad;
2259               }
2260               break;
2261             }
2262           if (quantum_info->quantum == 32UL)
2263             {
2264               for (x=0; x < (ssize_t) number_pixels; x++)
2265               {
2266                 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2267                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2268                 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2269                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2270                 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2271                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2272                 p++;
2273                 q+=quantum_info->pad;
2274               }
2275               break;
2276             }
2277           for (x=0; x < (ssize_t) number_pixels; x++)
2278           {
2279             pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2280             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2281             pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2282             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2283             pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2284             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2285             p++;
2286             q+=quantum_info->pad;
2287           }
2288           break;
2289         }
2290         case 12:
2291         {
2292           register unsigned int
2293             pixel;
2294
2295           range=GetQuantumRange(image->depth);
2296           if (quantum_info->pack == MagickFalse)
2297             {
2298               for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
2299               {
2300                 switch (x % 3)
2301                 {
2302                   default:
2303                   case 0:
2304                   {
2305                     pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2306                     break;
2307                   }
2308                   case 1:
2309                   {
2310                     pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2311                     break;
2312                   }
2313                   case 2:
2314                   {
2315                     pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2316                     p++;
2317                     break;
2318                   }
2319                 }
2320                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2321                 switch ((x+1) % 3)
2322                 {
2323                   default:
2324                   case 0:
2325                   {
2326                     pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2327                     break;
2328                   }
2329                   case 1:
2330                   {
2331                     pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2332                     break;
2333                   }
2334                   case 2:
2335                   {
2336                     pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2337                     p++;
2338                     break;
2339                   }
2340                 }
2341                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2342                 q+=quantum_info->pad;
2343               }
2344               for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
2345               {
2346                 switch ((x+bit) % 3)
2347                 {
2348                   default:
2349                   case 0:
2350                   {
2351                     pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2352                     break;
2353                   }
2354                   case 1:
2355                   {
2356                     pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2357                     break;
2358                   }
2359                   case 2:
2360                   {
2361                     pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2362                     p++;
2363                     break;
2364                   }
2365                 }
2366                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2367                 q+=quantum_info->pad;
2368               }
2369               if (bit != 0)
2370                 p++;
2371               break;
2372             }
2373           if (quantum_info->quantum == 32UL)
2374             {
2375               for (x=0; x < (ssize_t) number_pixels; x++)
2376               {
2377                 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2378                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2379                 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2380                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2381                 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2382                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2383                 p++;
2384                 q+=quantum_info->pad;
2385               }
2386               break;
2387             }
2388           for (x=0; x < (ssize_t) number_pixels; x++)
2389           {
2390             pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2391             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2392             pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2393             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2394             pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2395             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2396             p++;
2397             q+=quantum_info->pad;
2398           }
2399           break;
2400         }
2401         case 16:
2402         {
2403           register unsigned short
2404             pixel;
2405
2406           if (quantum_info->format == FloatingPointQuantumFormat)
2407             {
2408               for (x=0; x < (ssize_t) number_pixels; x++)
2409               {
2410                 pixel=SinglePrecisionToHalf(QuantumScale*
2411                   GetRedPixelComponent(p));
2412                 q=PopShortPixel(endian,pixel,q);
2413                 pixel=SinglePrecisionToHalf(QuantumScale*
2414                   GetGreenPixelComponent(p));
2415                 q=PopShortPixel(endian,pixel,q);
2416                 pixel=SinglePrecisionToHalf(QuantumScale*
2417                   GetBluePixelComponent(p));
2418                 q=PopShortPixel(endian,pixel,q);
2419                 p++;
2420                 q+=quantum_info->pad;
2421               }
2422               break;
2423             }
2424           for (x=0; x < (ssize_t) number_pixels; x++)
2425           {
2426             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2427             q=PopShortPixel(endian,pixel,q);
2428             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2429             q=PopShortPixel(endian,pixel,q);
2430             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2431             q=PopShortPixel(endian,pixel,q);
2432             p++;
2433             q+=quantum_info->pad;
2434           }
2435           break;
2436         }
2437         case 32:
2438         {
2439           register unsigned int
2440             pixel;
2441
2442           if (quantum_info->format == FloatingPointQuantumFormat)
2443             {
2444               for (x=0; x < (ssize_t) number_pixels; x++)
2445               {
2446                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2447                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2448                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2449                 p++;
2450                 q+=quantum_info->pad;
2451               }
2452               break;
2453             }
2454           for (x=0; x < (ssize_t) number_pixels; x++)
2455           {
2456             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2457             q=PopLongPixel(endian,pixel,q);
2458             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2459             q=PopLongPixel(endian,pixel,q);
2460             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2461             q=PopLongPixel(endian,pixel,q);
2462             p++;
2463             q+=quantum_info->pad;
2464           }
2465           break;
2466         }
2467         case 64:
2468         {
2469           if (quantum_info->format == FloatingPointQuantumFormat)
2470             {
2471               for (x=0; x < (ssize_t) number_pixels; x++)
2472               {
2473                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2474                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2475                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2476                 p++;
2477                 q+=quantum_info->pad;
2478               }
2479               break;
2480             }
2481         }
2482         default:
2483         {
2484           range=GetQuantumRange(image->depth);
2485           for (x=0; x < (ssize_t) number_pixels; x++)
2486           {
2487             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2488               p->red,range),q);
2489             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2490               p->green,range),q);
2491             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2492               p->blue,range),q);
2493             p++;
2494             q+=quantum_info->pad;
2495           }
2496           break;
2497         }
2498       }
2499       break;
2500     }
2501     case RGBAQuantum:
2502     case RGBOQuantum:
2503     case CbYCrAQuantum:
2504     {
2505       switch (quantum_info->depth)
2506       {
2507         case 8:
2508         {
2509           register unsigned char
2510             pixel;
2511
2512           for (x=0; x < (ssize_t) number_pixels; x++)
2513           {
2514             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2515             q=PopCharPixel(pixel,q);
2516             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2517             q=PopCharPixel(pixel,q);
2518             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2519             q=PopCharPixel(pixel,q);
2520             pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
2521             q=PopCharPixel(pixel,q);
2522             p++;
2523             q+=quantum_info->pad;
2524           }
2525           break;
2526         }
2527         case 10:
2528         {
2529           register unsigned int
2530             pixel;
2531
2532           range=GetQuantumRange(image->depth);
2533           if (quantum_info->pack == MagickFalse)
2534             {
2535               ssize_t
2536                 n;
2537
2538               register ssize_t
2539                 i;
2540
2541               size_t
2542                 quantum;
2543
2544               n=0;
2545               quantum=0;
2546               pixel=0;
2547               for (x=0; x < (ssize_t) number_pixels; x++)
2548               {
2549                 for (i=0; i < 4; i++)
2550                 {
2551                   switch (i)
2552                   {
2553                     case 0: quantum=p->red; break;
2554                     case 1: quantum=p->green; break;
2555                     case 2: quantum=p->blue; break;
2556                     case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
2557                   }
2558                   switch (n % 3)
2559                   {
2560                     case 0:
2561                     {
2562                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2563                         range) << 22);
2564                       break;
2565                     }
2566                     case 1:
2567                     {
2568                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2569                         range) << 12);
2570                       break;
2571                     }
2572                     case 2:
2573                     {
2574                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2575                         range) << 2);
2576                       q=PopLongPixel(endian,pixel,q);
2577                       pixel=0;
2578                       break;
2579                     }
2580                   }
2581                   n++;
2582                 }
2583                 p++;
2584                 q+=quantum_info->pad;
2585               }
2586               break;
2587             }
2588           if (quantum_info->quantum == 32UL)
2589             {
2590               for (x=0; x < (ssize_t) number_pixels; x++)
2591               {
2592                 pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2593                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2594                 pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2595                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2596                 pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2597                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2598                 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
2599                   p->opacity),range);
2600                 q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
2601                 p++;
2602                 q+=quantum_info->pad;
2603               }
2604               break;
2605             }
2606           for (x=0; x < (ssize_t) number_pixels; x++)
2607           {
2608             pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
2609             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2610             pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
2611             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2612             pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
2613             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2614             pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
2615               p->opacity),range);
2616             q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
2617             p++;
2618             q+=quantum_info->pad;
2619           }
2620           break;
2621         }
2622         case 16:
2623         {
2624           register unsigned short
2625             pixel;
2626
2627           if (quantum_info->format == FloatingPointQuantumFormat)
2628             {
2629               for (x=0; x < (ssize_t) number_pixels; x++)
2630               {
2631                 pixel=SinglePrecisionToHalf(QuantumScale*
2632                   GetRedPixelComponent(p));
2633                 q=PopShortPixel(endian,pixel,q);
2634                 pixel=SinglePrecisionToHalf(QuantumScale*
2635                   GetGreenPixelComponent(p));
2636                 q=PopShortPixel(endian,pixel,q);
2637                 pixel=SinglePrecisionToHalf(QuantumScale*
2638                   GetBluePixelComponent(p));
2639                 q=PopShortPixel(endian,pixel,q);
2640                 pixel=SinglePrecisionToHalf(QuantumScale*
2641                   GetAlphaPixelComponent(p));
2642                 q=PopShortPixel(endian,pixel,q);
2643                 p++;
2644                 q+=quantum_info->pad;
2645               }
2646               break;
2647             }
2648           for (x=0; x < (ssize_t) number_pixels; x++)
2649           {
2650             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2651             q=PopShortPixel(endian,pixel,q);
2652             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2653             q=PopShortPixel(endian,pixel,q);
2654             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2655             q=PopShortPixel(endian,pixel,q);
2656             pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
2657             q=PopShortPixel(endian,pixel,q);
2658             p++;
2659             q+=quantum_info->pad;
2660           }
2661           break;
2662         }
2663         case 32:
2664         {
2665           register unsigned int
2666             pixel;
2667
2668           if (quantum_info->format == FloatingPointQuantumFormat)
2669             {
2670               for (x=0; x < (ssize_t) number_pixels; x++)
2671               {
2672                 float
2673                   pixel;
2674
2675                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2676                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2677                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2678                 pixel=(float) GetAlphaPixelComponent(p);
2679                 q=PopFloatPixel(&quantum_state,pixel,q);
2680                 p++;
2681                 q+=quantum_info->pad;
2682               }
2683               break;
2684             }
2685           for (x=0; x < (ssize_t) number_pixels; x++)
2686           {
2687             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2688             q=PopLongPixel(endian,pixel,q);
2689             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2690             q=PopLongPixel(endian,pixel,q);
2691             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2692             q=PopLongPixel(endian,pixel,q);
2693             pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
2694             q=PopLongPixel(endian,pixel,q);
2695             p++;
2696             q+=quantum_info->pad;
2697           }
2698           break;
2699         }
2700         case 64:
2701         {
2702           if (quantum_info->format == FloatingPointQuantumFormat)
2703             {
2704               double
2705                 pixel;
2706
2707               for (x=0; x < (ssize_t) number_pixels; x++)
2708               {
2709                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2710                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2711                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2712                 pixel=(double) GetAlphaPixelComponent(p);
2713                 q=PopDoublePixel(&quantum_state,pixel,q);
2714                 p++;
2715                 q+=quantum_info->pad;
2716               }
2717               break;
2718             }
2719         }
2720         default:
2721         {
2722           range=GetQuantumRange(image->depth);
2723           for (x=0; x < (ssize_t) number_pixels; x++)
2724           {
2725             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2726               GetRedPixelComponent(p),range),q);
2727             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2728               GetGreenPixelComponent(p),range),q);
2729             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2730               GetBluePixelComponent(p),range),q);
2731             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2732               (Quantum) GetAlphaPixelComponent(p),range),q);
2733             p++;
2734             q+=quantum_info->pad;
2735           }
2736           break;
2737         }
2738       }
2739       break;
2740     }
2741     case CMYKQuantum:
2742     {
2743       if (image->colorspace != CMYKColorspace)
2744         {
2745           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2746             "ColorSeparatedImageRequired","`%s'",image->filename);
2747           return(extent);
2748         }
2749       switch (quantum_info->depth)
2750       {
2751         case 8:
2752         {
2753           register unsigned char
2754             pixel;
2755
2756           for (x=0; x < (ssize_t) number_pixels; x++)
2757           {
2758             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2759             q=PopCharPixel(pixel,q);
2760             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2761             q=PopCharPixel(pixel,q);
2762             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2763             q=PopCharPixel(pixel,q);
2764             pixel=ScaleQuantumToChar(indexes[x]);
2765             q=PopCharPixel(pixel,q);
2766             p++;
2767             q+=quantum_info->pad;
2768           }
2769           break;
2770         }
2771         case 16:
2772         {
2773           register unsigned short
2774             pixel;
2775
2776           if (quantum_info->format == FloatingPointQuantumFormat)
2777             {
2778               for (x=0; x < (ssize_t) number_pixels; x++)
2779               {
2780                 pixel=SinglePrecisionToHalf(QuantumScale*
2781                   GetRedPixelComponent(p));
2782                 q=PopShortPixel(endian,pixel,q);
2783                 pixel=SinglePrecisionToHalf(QuantumScale*
2784                   GetGreenPixelComponent(p));
2785                 q=PopShortPixel(endian,pixel,q);
2786                 pixel=SinglePrecisionToHalf(QuantumScale*
2787                   GetBluePixelComponent(p));
2788                 q=PopShortPixel(endian,pixel,q);
2789                 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2790                 q=PopShortPixel(endian,pixel,q);
2791                 p++;
2792                 q+=quantum_info->pad;
2793               }
2794               break;
2795             }
2796           for (x=0; x < (ssize_t) number_pixels; x++)
2797           {
2798             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2799             q=PopShortPixel(endian,pixel,q);
2800             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2801             q=PopShortPixel(endian,pixel,q);
2802             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2803             q=PopShortPixel(endian,pixel,q);
2804             pixel=ScaleQuantumToShort(indexes[x]);
2805             q=PopShortPixel(endian,pixel,q);
2806             p++;
2807             q+=quantum_info->pad;
2808           }
2809           break;
2810         }
2811         case 32:
2812         {
2813           register unsigned int
2814             pixel;
2815
2816           if (quantum_info->format == FloatingPointQuantumFormat)
2817             {
2818               for (x=0; x < (ssize_t) number_pixels; x++)
2819               {
2820                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2821                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2822                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2823                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2824                 p++;
2825                 q+=quantum_info->pad;
2826               }
2827               break;
2828             }
2829           for (x=0; x < (ssize_t) number_pixels; x++)
2830           {
2831             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2832             q=PopLongPixel(endian,pixel,q);
2833             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2834             q=PopLongPixel(endian,pixel,q);
2835             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2836             q=PopLongPixel(endian,pixel,q);
2837             pixel=ScaleQuantumToLong(indexes[x]);
2838             q=PopLongPixel(endian,pixel,q);
2839             p++;
2840             q+=quantum_info->pad;
2841           }
2842           break;
2843         }
2844         case 64:
2845         {
2846           if (quantum_info->format == FloatingPointQuantumFormat)
2847             {
2848               for (x=0; x < (ssize_t) number_pixels; x++)
2849               {
2850                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2851                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2852                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2853                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2854                 p++;
2855                 q+=quantum_info->pad;
2856               }
2857               break;
2858             }
2859         }
2860         default:
2861         {
2862           range=GetQuantumRange(image->depth);
2863           for (x=0; x < (ssize_t) number_pixels; x++)
2864           {
2865             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2866               p->red,range),q);
2867             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2868               p->green,range),q);
2869             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2870               p->blue,range),q);
2871             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
2872               indexes[x],range),q);
2873             p++;
2874             q+=quantum_info->pad;
2875           }
2876           break;
2877         }
2878       }
2879       break;
2880     }
2881     case CMYKAQuantum:
2882     case CMYKOQuantum:
2883     {
2884       if (image->colorspace != CMYKColorspace)
2885         {
2886           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2887             "ColorSeparatedImageRequired","`%s'",image->filename);
2888           return(extent);
2889         }
2890       switch (quantum_info->depth)
2891       {
2892         case 8:
2893         {
2894           register unsigned char
2895             pixel;
2896
2897           for (x=0; x < (ssize_t) number_pixels; x++)
2898           {
2899             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2900             q=PopCharPixel(pixel,q);
2901             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2902             q=PopCharPixel(pixel,q);
2903             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2904             q=PopCharPixel(pixel,q);
2905             pixel=ScaleQuantumToChar(indexes[x]);
2906             q=PopCharPixel(pixel,q);
2907             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2908               GetOpacityPixelComponent(p)));
2909             q=PopCharPixel(pixel,q);
2910             p++;
2911             q+=quantum_info->pad;
2912           }
2913           break;
2914         }
2915         case 16:
2916         {
2917           register unsigned short
2918             pixel;
2919
2920           if (quantum_info->format == FloatingPointQuantumFormat)
2921             {
2922               for (x=0; x < (ssize_t) number_pixels; x++)
2923               {
2924                 pixel=SinglePrecisionToHalf(QuantumScale*
2925                   GetRedPixelComponent(p));
2926                 q=PopShortPixel(endian,pixel,q);
2927                 pixel=SinglePrecisionToHalf(QuantumScale*
2928                   GetGreenPixelComponent(p));
2929                 q=PopShortPixel(endian,pixel,q);
2930                 pixel=SinglePrecisionToHalf(QuantumScale*
2931                   GetBluePixelComponent(p));
2932                 q=PopShortPixel(endian,pixel,q);
2933                 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2934                 q=PopShortPixel(endian,pixel,q);
2935                 pixel=SinglePrecisionToHalf(QuantumScale*
2936                   GetAlphaPixelComponent(p));
2937                 q=PopShortPixel(endian,pixel,q);
2938                 p++;
2939                 q+=quantum_info->pad;
2940               }
2941               break;
2942             }
2943           for (x=0; x < (ssize_t) number_pixels; x++)
2944           {
2945             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2946             q=PopShortPixel(endian,pixel,q);
2947             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2948             q=PopShortPixel(endian,pixel,q);
2949             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2950             q=PopShortPixel(endian,pixel,q);
2951             pixel=ScaleQuantumToShort(indexes[x]);
2952             q=PopShortPixel(endian,pixel,q);
2953             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2954               GetOpacityPixelComponent(p)));
2955             q=PopShortPixel(endian,pixel,q);
2956             p++;
2957             q+=quantum_info->pad;
2958           }
2959           break;
2960         }
2961         case 32:
2962         {
2963           register unsigned int
2964             pixel;
2965
2966           if (quantum_info->format == FloatingPointQuantumFormat)
2967             {
2968               for (x=0; x < (ssize_t) number_pixels; x++)
2969               {
2970                 float
2971                   pixel;
2972
2973                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2974                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2975                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2976                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2977                 pixel=(float) (GetAlphaPixelComponent(p));
2978                 q=PopFloatPixel(&quantum_state,pixel,q);
2979                 p++;
2980                 q+=quantum_info->pad;
2981               }
2982               break;
2983             }
2984           for (x=0; x < (ssize_t) number_pixels; x++)
2985           {
2986             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2987             q=PopLongPixel(endian,pixel,q);
2988             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2989             q=PopLongPixel(endian,pixel,q);
2990             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2991             q=PopLongPixel(endian,pixel,q);
2992             pixel=ScaleQuantumToLong(indexes[x]);
2993             q=PopLongPixel(endian,pixel,q);
2994             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2995               GetOpacityPixelComponent(p)));
2996             q=PopLongPixel(endian,pixel,q);
2997             p++;
2998             q+=quantum_info->pad;
2999           }
3000           break;
3001         }
3002         case 64:
3003         {
3004           if (quantum_info->format == FloatingPointQuantumFormat)
3005             {
3006               double
3007                 pixel;
3008
3009               for (x=0; x < (ssize_t) number_pixels; x++)
3010               {
3011                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
3012                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
3013                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
3014                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
3015                 pixel=(double) (GetAlphaPixelComponent(p));
3016                 q=PopDoublePixel(&quantum_state,pixel,q);
3017                 p++;
3018                 q+=quantum_info->pad;
3019               }
3020               break;
3021             }
3022         }
3023         default:
3024         {
3025           range=GetQuantumRange(image->depth);
3026           for (x=0; x < (ssize_t) number_pixels; x++)
3027           {
3028             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3029               p->red,range),q);
3030             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3031               p->green,range),q);
3032             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3033               p->blue,range),q);
3034             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3035               indexes[x],range),q);
3036             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3037               p->opacity,range),q);
3038             p++;
3039             q+=quantum_info->pad;
3040           }
3041           break;
3042         }
3043       }
3044       break;
3045     }
3046     case CbYCrYQuantum:
3047     {
3048      ssize_t
3049         n;
3050
3051       Quantum
3052         cbcr[4];
3053
3054       register ssize_t
3055         i;
3056
3057       register unsigned int
3058         pixel;
3059
3060       size_t
3061         quantum;
3062
3063       n=0;
3064       quantum=0;
3065       range=GetQuantumRange(image->depth);
3066       switch (quantum_info->depth)
3067       {
3068         case 10:
3069         {
3070           if (quantum_info->pack == MagickFalse)
3071             {
3072               for (x=0; x < (ssize_t) number_pixels; x+=2)
3073               {
3074                 for (i=0; i < 4; i++)
3075                 {
3076                   switch (n % 3)
3077                   {
3078                     case 0:
3079                     {
3080                       quantum=GetRedPixelComponent(p);
3081                       break;
3082                     }
3083                     case 1:
3084                     {
3085                       quantum=GetGreenPixelComponent(p);
3086                       break;
3087                     }
3088                     case 2:
3089                     {
3090                       quantum=GetBluePixelComponent(p);
3091                       break;
3092                     }
3093                   }
3094                   cbcr[i]=(Quantum) quantum;
3095                   n++;
3096                 }
3097                 pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 |
3098                   (size_t) (cbcr[0]) << 12 |
3099                   (size_t) (cbcr[2]) << 2);
3100                 q=PopLongPixel(endian,pixel,q);
3101                 p++;
3102                 pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 |
3103                   (size_t) (cbcr[0]) << 12 |
3104                   (size_t) (cbcr[2]) << 2);
3105                 q=PopLongPixel(endian,pixel,q);
3106                 p++;
3107                 q+=quantum_info->pad;
3108               }
3109               break;
3110             }
3111           break;
3112         }
3113         default:
3114         {
3115           for (x=0; x < (ssize_t) number_pixels; x+=2)
3116           {
3117             for (i=0; i < 4; i++)
3118             {
3119               switch (n % 3)
3120               {
3121                 case 0:
3122                 {
3123                   quantum=GetRedPixelComponent(p);
3124                   break;
3125                 }
3126                 case 1:
3127                 {
3128                   quantum=GetGreenPixelComponent(p);
3129                   break;
3130                 }
3131                 case 2:
3132                 {
3133                   quantum=GetBluePixelComponent(p);
3134                   break;
3135                 }
3136               }
3137               cbcr[i]=(Quantum) quantum;
3138               n++;
3139             }
3140             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3141               cbcr[1],range),q);
3142             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3143               cbcr[0],range),q);
3144             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3145               cbcr[2],range),q);
3146             p++;
3147             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3148               cbcr[3],range),q);
3149             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3150               cbcr[0],range),q);
3151             q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
3152               cbcr[2],range),q);
3153             p++;
3154             q+=quantum_info->pad;
3155           }
3156           break;
3157         }
3158       }
3159       break;
3160     }
3161     default:
3162       break;
3163   }
3164   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3165     {
3166       Quantum
3167         quantum;
3168
3169       register PixelPacket
3170         *restrict q;
3171
3172       q=GetAuthenticPixelQueue(image);
3173       if (image_view != (CacheView *) NULL)
3174         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3175       for (x=0; x < (ssize_t) number_pixels; x++)
3176       {
3177         quantum=q->red;
3178         q->red=q->green;
3179         q->green=quantum;
3180         q++;
3181       }
3182     }
3183   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
3184       (quantum_type == BGROQuantum))
3185     {
3186       register PixelPacket
3187         *restrict q;
3188
3189       q=GetAuthenticPixelQueue(image);
3190       if (image_view != (CacheView *) NULL)
3191         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3192       for (x=0; x < (ssize_t) number_pixels; x++)
3193       {
3194         q->opacity=(Quantum) GetAlphaPixelComponent(q);
3195         q++;
3196       }
3197     }
3198   return(extent);
3199 }