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   MagickRealType
 244     alpha;
 245
 246   MagickSizeType
 247     number_pixels;
 248
 249   QuantumAny
 250     range;
 251
 252   QuantumState
 253     quantum_state;
 254
 255   register const IndexPacket
 256     *restrict indexes;
 257
 258   register const PixelPacket
 259     *restrict p;
 260
 261   register ssize_t
 262     x;
 263
 264   register unsigned char
 265     *restrict q;
 266
 267   size_t
 268     extent;
 269
 270   ssize_t
 271     bit;
 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,quantum_info->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(quantum_info->depth);
 668           for (x=0; x < (ssize_t) number_pixels; x++)
 669           {
 670             q=PopQuantumPixel(&quantum_state,quantum_info->depth,indexes[x],q);
 671             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
 672               ScaleQuantumToAny((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(quantum_info->depth);
 703           if (quantum_info->pack == MagickFalse)
 704             {
 705               for (x=0; x < (ssize_t) number_pixels; x++)
 706               {
 707                 pixel=(unsigned int) (ScaleQuantumToAny(GetRedPixelComponent(p),range) << 22 |
 708                   ScaleQuantumToAny(GetGreenPixelComponent(p),range) << 12 |
 709                   ScaleQuantumToAny(GetBluePixelComponent(p),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(GetRedPixelComponent(p),range);
 721                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
 722                   q);
 723                 pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
 724                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
 725                   q);
 726                 pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
 727                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
 728                   q);
 729                 p++;
 730                 q+=quantum_info->pad;
 731               }
 732               break;
 733             }
 734           for (x=0; x < (ssize_t) number_pixels; x++)
 735           {
 736             pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
 737             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
 738             pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
 739             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
 740             pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
 741             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
 742             p++;
 743             q+=quantum_info->pad;
 744           }
 745           break;
 746         }
 747         case 12:
 748         {
 749           register unsigned int
 750             pixel;
 751
 752           range=GetQuantumRange(quantum_info->depth);
 753           if (quantum_info->pack == MagickFalse)
 754             {
 755               for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
 756               {
 757                 switch (x % 3)
 758                 {
 759                   default:
 760                   case 0:
 761                   {
 762                     pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
 763                     break;
 764                   }
 765                   case 1:
 766                   {
 767                     pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
 768                     break;
 769                   }
 770                   case 2:
 771                   {
 772                     pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
 773                     p++;
 774                     break;
 775                   }
 776                 }
 777                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
 778                 switch ((x+1) % 3)
 779                 {
 780                   default:
 781                   case 0:
 782                   {
 783                     pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
 784                     break;
 785                   }
 786                   case 1:
 787                   {
 788                     pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
 789                     break;
 790                   }
 791                   case 2:
 792                   {
 793                     pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
 794                     p++;
 795                     break;
 796                   }
 797                 }
 798                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
 799                 q+=quantum_info->pad;
 800               }
 801               for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
 802               {
 803                 switch ((x+bit) % 3)
 804                 {
 805                   default:
 806                   case 0:
 807                   {
 808                     pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
 809                     break;
 810                   }
 811                   case 1:
 812                   {
 813                     pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
 814                     break;
 815                   }
 816                   case 2:
 817                   {
 818                     pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
 819                     p++;
 820                     break;
 821                   }
 822                 }
 823                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
 824                 q+=quantum_info->pad;
 825               }
 826               if (bit != 0)
 827                 p++;
 828               break;
 829             }
 830           if (quantum_info->quantum == 32UL)
 831             {
 832               for (x=0; x < (ssize_t) number_pixels; x++)
 833               {
 834                 pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
 835                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
 836                   q);
 837                 pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
 838                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
 839                   q);
 840                 pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
 841                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
 842                   q);
 843                 p++;
 844                 q+=quantum_info->pad;
 845               }
 846               break;
 847             }
 848           for (x=0; x < (ssize_t) number_pixels; x++)
 849           {
 850             pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
 851             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
 852             pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
 853             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
 854             pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
 855             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
 856             p++;
 857             q+=quantum_info->pad;
 858           }
 859           break;
 860         }
 861         case 16:
 862         {
 863           register unsigned short
 864             pixel;
 865
 866           if (quantum_info->format == FloatingPointQuantumFormat)
 867             {
 868               for (x=0; x < (ssize_t) number_pixels; x++)
 869               {
 870                 pixel=SinglePrecisionToHalf(QuantumScale*
 871                   GetBluePixelComponent(p));
 872                 q=PopShortPixel(endian,pixel,q);
 873                 pixel=SinglePrecisionToHalf(QuantumScale*
 874                   GetGreenPixelComponent(p));
 875                 q=PopShortPixel(endian,pixel,q);
 876                 pixel=SinglePrecisionToHalf(QuantumScale*
 877                   GetRedPixelComponent(p));
 878                 q=PopShortPixel(endian,pixel,q);
 879                 p++;
 880                 q+=quantum_info->pad;
 881               }
 882               break;
 883             }
 884           for (x=0; x < (ssize_t) number_pixels; x++)
 885           {
 886             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
 887             q=PopShortPixel(endian,pixel,q);
 888             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
 889             q=PopShortPixel(endian,pixel,q);
 890             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
 891             q=PopShortPixel(endian,pixel,q);
 892             p++;
 893             q+=quantum_info->pad;
 894           }
 895           break;
 896         }
 897         case 32:
 898         {
 899           register unsigned int
 900             pixel;
 901
 902           if (quantum_info->format == FloatingPointQuantumFormat)
 903             {
 904               for (x=0; x < (ssize_t) number_pixels; x++)
 905               {
 906                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
 907                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
 908                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
 909                 p++;
 910                 q+=quantum_info->pad;
 911               }
 912               break;
 913             }
 914           for (x=0; x < (ssize_t) number_pixels; x++)
 915           {
 916             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
 917             q=PopLongPixel(endian,pixel,q);
 918             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
 919             q=PopLongPixel(endian,pixel,q);
 920             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
 921             q=PopLongPixel(endian,pixel,q);
 922             p++;
 923             q+=quantum_info->pad;
 924           }
 925           break;
 926         }
 927         case 64:
 928         {
 929           if (quantum_info->format == FloatingPointQuantumFormat)
 930             {
 931               for (x=0; x < (ssize_t) number_pixels; x++)
 932               {
 933                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
 934                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
 935                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
 936                 p++;
 937                 q+=quantum_info->pad;
 938               }
 939               break;
 940             }
 941         }
 942         default:
 943         {
 944           range=GetQuantumRange(quantum_info->depth);
 945           for (x=0; x < (ssize_t) number_pixels; x++)
 946           {
 947             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
 948               ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
 949             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
 950               ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
 951             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
 952               ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
 953             p++;
 954             q+=quantum_info->pad;
 955           }
 956           break;
 957         }
 958       }
 959       break;
 960     }
 961     case BGRAQuantum:
 962     case BGROQuantum:
 963     {
 964       switch (quantum_info->depth)
 965       {
 966         case 8:
 967         {
 968           register unsigned char
 969             pixel;
 970
 971           for (x=0; x < (ssize_t) number_pixels; x++)
 972           {
 973             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
 974             q=PopCharPixel(pixel,q);
 975             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
 976             q=PopCharPixel(pixel,q);
 977             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
 978             q=PopCharPixel(pixel,q);
 979             pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
 980             q=PopCharPixel(pixel,q);
 981             p++;
 982             q+=quantum_info->pad;
 983           }
 984           break;
 985         }
 986         case 10:
 987         {
 988           register unsigned int
 989             pixel;
 990
 991           range=GetQuantumRange(quantum_info->depth);
 992           if (quantum_info->pack == MagickFalse)
 993             {
 994               register ssize_t
 995                 i;
 996
 997               size_t
 998                 quantum;
 999
1000               ssize_t
1001                 n;
1002
1003               n=0;
1004               quantum=0;
1005               pixel=0;
1006               for (x=0; x < (ssize_t) number_pixels; x++)
1007               {
1008                 for (i=0; i < 4; i++)
1009                 {
1010                   switch (i)
1011                   {
1012                     case 0: quantum=p->red; break;
1013                     case 1: quantum=p->green; break;
1014                     case 2: quantum=p->blue; break;
1015                     case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
1016                   }
1017                   switch (n % 3)
1018                   {
1019                     case 0:
1020                     {
1021                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1022                         range) << 22);
1023                       break;
1024                     }
1025                     case 1:
1026                     {
1027                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1028                         range) << 12);
1029                       break;
1030                     }
1031                     case 2:
1032                     {
1033                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
1034                         range) << 2);
1035                       q=PopLongPixel(endian,pixel,q);
1036                       pixel=0;
1037                       break;
1038                     }
1039                   }
1040                   n++;
1041                 }
1042                 p++;
1043                 q+=quantum_info->pad;
1044               }
1045               break;
1046             }
1047           if (quantum_info->quantum == 32UL)
1048             {
1049               for (x=0; x < (ssize_t) number_pixels; x++)
1050               {
1051                 pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
1052                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
1053                   q);
1054                 pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
1055                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
1056                   q);
1057                 pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
1058                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
1059                   q);
1060                 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
1061                   p->opacity),range);
1062                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
1063                   q);
1064                 p++;
1065                 q+=quantum_info->pad;
1066               }
1067               break;
1068             }
1069           for (x=0; x < (ssize_t) number_pixels; x++)
1070           {
1071             pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
1072             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
1073             pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
1074             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
1075             pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
1076             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
1077             pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
1078               p->opacity),range);
1079             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
1080             p++;
1081             q+=quantum_info->pad;
1082           }
1083           break;
1084         }
1085         case 16:
1086         {
1087           register unsigned short
1088             pixel;
1089
1090           if (quantum_info->format == FloatingPointQuantumFormat)
1091             {
1092               for (x=0; x < (ssize_t) number_pixels; x++)
1093               {
1094                 pixel=SinglePrecisionToHalf(QuantumScale*
1095                   GetBluePixelComponent(p));
1096                 q=PopShortPixel(endian,pixel,q);
1097                 pixel=SinglePrecisionToHalf(QuantumScale*
1098                   GetGreenPixelComponent(p));
1099                 q=PopShortPixel(endian,pixel,q);
1100                 pixel=SinglePrecisionToHalf(QuantumScale*
1101                   GetRedPixelComponent(p));
1102                 q=PopShortPixel(endian,pixel,q);
1103                 pixel=SinglePrecisionToHalf(QuantumScale*
1104                   GetAlphaPixelComponent(p));
1105                 q=PopShortPixel(endian,pixel,q);
1106                 p++;
1107                 q+=quantum_info->pad;
1108               }
1109               break;
1110             }
1111           for (x=0; x < (ssize_t) number_pixels; x++)
1112           {
1113             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1114             q=PopShortPixel(endian,pixel,q);
1115             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1116             q=PopShortPixel(endian,pixel,q);
1117             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1118             q=PopShortPixel(endian,pixel,q);
1119             pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
1120             q=PopShortPixel(endian,pixel,q);
1121             p++;
1122             q+=quantum_info->pad;
1123           }
1124           break;
1125         }
1126         case 32:
1127         {
1128           register unsigned int
1129             pixel;
1130
1131           if (quantum_info->format == FloatingPointQuantumFormat)
1132             {
1133               for (x=0; x < (ssize_t) number_pixels; x++)
1134               {
1135                 float
1136                   pixel;
1137
1138                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1139                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1140                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1141                 pixel=(float) GetAlphaPixelComponent(p);
1142                 q=PopFloatPixel(&quantum_state,pixel,q);
1143                 p++;
1144                 q+=quantum_info->pad;
1145               }
1146               break;
1147             }
1148           for (x=0; x < (ssize_t) number_pixels; x++)
1149           {
1150             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1151             q=PopLongPixel(endian,pixel,q);
1152             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1153             q=PopLongPixel(endian,pixel,q);
1154             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1155             q=PopLongPixel(endian,pixel,q);
1156             pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
1157             q=PopLongPixel(endian,pixel,q);
1158             p++;
1159             q+=quantum_info->pad;
1160           }
1161           break;
1162         }
1163         case 64:
1164         {
1165           if (quantum_info->format == FloatingPointQuantumFormat)
1166             {
1167               double
1168                 pixel;
1169
1170               for (x=0; x < (ssize_t) number_pixels; x++)
1171               {
1172                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1173                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1174                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1175                 pixel=(double) GetAlphaPixelComponent(p);
1176                 q=PopDoublePixel(&quantum_state,pixel,q);
1177                 p++;
1178                 q+=quantum_info->pad;
1179               }
1180               break;
1181             }
1182         }
1183         default:
1184         {
1185           range=GetQuantumRange(quantum_info->depth);
1186           for (x=0; x < (ssize_t) number_pixels; x++)
1187           {
1188             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1189               ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
1190             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1191               ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
1192             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1193               ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
1194             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1195               ScaleQuantumToAny((Quantum) GetAlphaPixelComponent(p),range),q);
1196             p++;
1197             q+=quantum_info->pad;
1198           }
1199           break;
1200         }
1201       }
1202       break;
1203     }
1204     case GrayQuantum:
1205     {
1206       switch (quantum_info->depth)
1207       {
1208         case 1:
1209         {
1210           register Quantum
1211             threshold;
1212
1213           register unsigned char
1214             black,
1215             white;
1216
1217           black=0x00;
1218           white=0x01;
1219           if (quantum_info->min_is_white != MagickFalse)
1220             {
1221               black=0x01;
1222               white=0x00;
1223             }
1224           threshold=(Quantum) (QuantumRange/2);
1225           for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
1226           {
1227             *q='\0';
1228             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 7;
1229             p++;
1230             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 6;
1231             p++;
1232             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 5;
1233             p++;
1234             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 4;
1235             p++;
1236             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 3;
1237             p++;
1238             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 2;
1239             p++;
1240             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 1;
1241             p++;
1242             *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) << 0;
1243             p++;
1244             q++;
1245           }
1246           if ((number_pixels % 8) != 0)
1247             {
1248               *q='\0';
1249               for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
1250               {
1251                 *q|=(PixelIntensityToQuantum(p) < threshold ? black : white) <<
1252                   bit;
1253                 p++;
1254               }
1255               q++;
1256             }
1257           break;
1258         }
1259         case 4:
1260         {
1261           register unsigned char
1262             pixel;
1263
1264           for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
1265           {
1266             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1267             *q=(((pixel >> 4) & 0xf) << 4);
1268             p++;
1269             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1270             *q|=pixel >> 4;
1271             p++;
1272             q++;
1273           }
1274           if ((number_pixels % 2) != 0)
1275             {
1276               pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1277               *q=(((pixel >> 4) & 0xf) << 4);
1278               p++;
1279               q++;
1280             }
1281           break;
1282         }
1283         case 8:
1284         {
1285           register unsigned char
1286             pixel;
1287
1288           for (x=0; x < (ssize_t) number_pixels; x++)
1289           {
1290             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1291             q=PopCharPixel(pixel,q);
1292             p++;
1293             q+=quantum_info->pad;
1294           }
1295           break;
1296         }
1297         case 10:
1298         {
1299           range=GetQuantumRange(quantum_info->depth);
1300           if (quantum_info->pack == MagickFalse)
1301             {
1302               register unsigned int
1303                 pixel;
1304
1305               for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
1306               {
1307                 pixel=(unsigned int) (
1308                   ScaleQuantumToAny(PixelIntensityToQuantum(p+2),range) << 22 |
1309                   ScaleQuantumToAny(PixelIntensityToQuantum(p+1),range) << 12 |
1310                   ScaleQuantumToAny(PixelIntensityToQuantum(p+0),range) << 2);
1311                 q=PopLongPixel(endian,pixel,q);
1312                 p+=3;
1313                 q+=quantum_info->pad;
1314               }
1315               pixel=0UL;
1316               if (x++ < (ssize_t) (number_pixels-1))
1317                 pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+1),
1318                   range) << 12;
1319               if (x++ < (ssize_t) number_pixels)
1320                 pixel|=ScaleQuantumToAny(PixelIntensityToQuantum(p+0),
1321                   range) << 2;
1322               q=PopLongPixel(endian,pixel,q);
1323               break;
1324             }
1325           for (x=0; x < (ssize_t) number_pixels; x++)
1326           {
1327             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1328               ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
1329             p++;
1330             q+=quantum_info->pad;
1331           }
1332           break;
1333         }
1334         case 12:
1335         {
1336           register unsigned short
1337             pixel;
1338
1339           range=GetQuantumRange(quantum_info->depth);
1340           if (quantum_info->pack == MagickFalse)
1341             {
1342               for (x=0; x < (ssize_t) number_pixels; x++)
1343               {
1344                 pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1345                 q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
1346                 p++;
1347                 q+=quantum_info->pad;
1348               }
1349               break;
1350             }
1351           for (x=0; x < (ssize_t) number_pixels; x++)
1352           {
1353             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1354               ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
1355             p++;
1356             q+=quantum_info->pad;
1357           }
1358           break;
1359         }
1360         case 16:
1361         {
1362           register unsigned short
1363             pixel;
1364
1365           if (quantum_info->format == FloatingPointQuantumFormat)
1366             {
1367               for (x=0; x < (ssize_t) number_pixels; x++)
1368               {
1369                 pixel=SinglePrecisionToHalf(QuantumScale*
1370                   PixelIntensityToQuantum(p));
1371                 q=PopShortPixel(endian,pixel,q);
1372                 p++;
1373                 q+=quantum_info->pad;
1374               }
1375               break;
1376             }
1377           for (x=0; x < (ssize_t) number_pixels; x++)
1378           {
1379             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1380             q=PopShortPixel(endian,pixel,q);
1381             p++;
1382             q+=quantum_info->pad;
1383           }
1384           break;
1385         }
1386         case 32:
1387         {
1388           register unsigned int
1389             pixel;
1390
1391           if (quantum_info->format == FloatingPointQuantumFormat)
1392             {
1393               for (x=0; x < (ssize_t) number_pixels; x++)
1394               {
1395                 float
1396                   pixel;
1397
1398                 pixel=(float) PixelIntensityToQuantum(p);
1399                 q=PopFloatPixel(&quantum_state,pixel,q);
1400                 p++;
1401                 q+=quantum_info->pad;
1402               }
1403               break;
1404             }
1405           for (x=0; x < (ssize_t) number_pixels; x++)
1406           {
1407             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1408             q=PopLongPixel(endian,pixel,q);
1409             p++;
1410             q+=quantum_info->pad;
1411           }
1412           break;
1413         }
1414         case 64:
1415         {
1416           if (quantum_info->format == FloatingPointQuantumFormat)
1417             {
1418               for (x=0; x < (ssize_t) number_pixels; x++)
1419               {
1420                 double
1421                   pixel;
1422
1423                 pixel=(double) PixelIntensityToQuantum(p);
1424                 q=PopDoublePixel(&quantum_state,pixel,q);
1425                 p++;
1426                 q+=quantum_info->pad;
1427               }
1428               break;
1429             }
1430         }
1431         default:
1432         {
1433           range=GetQuantumRange(quantum_info->depth);
1434           for (x=0; x < (ssize_t) number_pixels; x++)
1435           {
1436             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1437               ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
1438             p++;
1439             q+=quantum_info->pad;
1440           }
1441           break;
1442         }
1443       }
1444       break;
1445     }
1446     case GrayAlphaQuantum:
1447     {
1448       switch (quantum_info->depth)
1449       {
1450         case 1:
1451         {
1452           register Quantum
1453             threshold;
1454
1455           register unsigned char
1456             black,
1457             pixel,
1458             white;
1459
1460           black=0x00;
1461           white=0x01;
1462           if (quantum_info->min_is_white == MagickFalse)
1463             {
1464               black=0x01;
1465               white=0x00;
1466             }
1467           threshold=(Quantum) (QuantumRange/2);
1468           for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
1469           {
1470             *q='\0';
1471             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 7;
1472             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1473             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
1474             p++;
1475             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 5;
1476             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1477             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
1478             p++;
1479             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 3;
1480             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1481             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
1482             p++;
1483             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 1;
1484             pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
1485             *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
1486             p++;
1487             q++;
1488           }
1489           if ((number_pixels % 4) != 0)
1490             {
1491               *q='\0';
1492               for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
1493               {
1494                 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) <<
1495                   (7-bit);
1496                 pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
1497                   0x01);
1498                 *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
1499                   (7-bit-1));
1500                 p++;
1501               }
1502               q++;
1503             }
1504           break;
1505         }
1506         case 4:
1507         {
1508           register unsigned char
1509             pixel;
1510
1511           for (x=0; x < (ssize_t) number_pixels ; x++)
1512           {
1513             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1514             *q=(((pixel >> 4) & 0xf) << 4);
1515             pixel=(unsigned char) (16*QuantumScale*((Quantum) (QuantumRange-
1516               GetOpacityPixelComponent(p)))+0.5);
1517             *q|=pixel & 0xf;
1518             p++;
1519             q++;
1520           }
1521           break;
1522         }
1523         case 8:
1524         {
1525           register unsigned char
1526             pixel;
1527
1528           for (x=0; x < (ssize_t) number_pixels; x++)
1529           {
1530             pixel=ScaleQuantumToChar(PixelIntensityToQuantum(p));
1531             q=PopCharPixel(pixel,q);
1532             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1533               GetOpacityPixelComponent(p)));
1534             q=PopCharPixel(pixel,q);
1535             p++;
1536             q+=quantum_info->pad;
1537           }
1538           break;
1539         }
1540         case 16:
1541         {
1542           register unsigned short
1543             pixel;
1544
1545           if (quantum_info->format == FloatingPointQuantumFormat)
1546             {
1547               for (x=0; x < (ssize_t) number_pixels; x++)
1548               {
1549                 pixel=SinglePrecisionToHalf(QuantumScale*
1550                   PixelIntensityToQuantum(p));
1551                 q=PopShortPixel(endian,pixel,q);
1552                 pixel=SinglePrecisionToHalf(QuantumScale*
1553                   GetAlphaPixelComponent(p));
1554                 q=PopShortPixel(endian,pixel,q);
1555                 p++;
1556                 q+=quantum_info->pad;
1557               }
1558               break;
1559             }
1560           for (x=0; x < (ssize_t) number_pixels; x++)
1561           {
1562             pixel=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1563             q=PopShortPixel(endian,pixel,q);
1564             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1565               GetOpacityPixelComponent(p)));
1566             q=PopShortPixel(endian,pixel,q);
1567             p++;
1568             q+=quantum_info->pad;
1569           }
1570           break;
1571         }
1572         case 32:
1573         {
1574           register unsigned int
1575             pixel;
1576
1577           if (quantum_info->format == FloatingPointQuantumFormat)
1578             {
1579               for (x=0; x < (ssize_t) number_pixels; x++)
1580               {
1581                 float
1582                   pixel;
1583
1584                 pixel=(float) PixelIntensityToQuantum(p);
1585                 q=PopFloatPixel(&quantum_state,pixel,q);
1586                 pixel=(float) (GetAlphaPixelComponent(p));
1587                 q=PopFloatPixel(&quantum_state,pixel,q);
1588                 p++;
1589                 q+=quantum_info->pad;
1590               }
1591               break;
1592             }
1593           for (x=0; x < (ssize_t) number_pixels; x++)
1594           {
1595             pixel=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1596             q=PopLongPixel(endian,pixel,q);
1597             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
1598               GetOpacityPixelComponent(p)));
1599             q=PopLongPixel(endian,pixel,q);
1600             p++;
1601             q+=quantum_info->pad;
1602           }
1603           break;
1604         }
1605         case 64:
1606         {
1607           if (quantum_info->format == FloatingPointQuantumFormat)
1608             {
1609               for (x=0; x < (ssize_t) number_pixels; x++)
1610               {
1611                 double
1612                   pixel;
1613
1614                 pixel=(double) PixelIntensityToQuantum(p);
1615                 q=PopDoublePixel(&quantum_state,pixel,q);
1616                 pixel=(double) (GetAlphaPixelComponent(p));
1617                 q=PopDoublePixel(&quantum_state,pixel,q);
1618                 p++;
1619                 q+=quantum_info->pad;
1620               }
1621               break;
1622             }
1623         }
1624         default:
1625         {
1626           range=GetQuantumRange(quantum_info->depth);
1627           for (x=0; x < (ssize_t) number_pixels; x++)
1628           {
1629             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1630               ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
1631             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1632               ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
1633             p++;
1634             q+=quantum_info->pad;
1635           }
1636           break;
1637         }
1638       }
1639       break;
1640     }
1641     case RedQuantum:
1642     case CyanQuantum:
1643     {
1644       switch (quantum_info->depth)
1645       {
1646         case 8:
1647         {
1648           register unsigned char
1649             pixel;
1650
1651           for (x=0; x < (ssize_t) number_pixels; x++)
1652           {
1653             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
1654             q=PopCharPixel(pixel,q);
1655             p++;
1656             q+=quantum_info->pad;
1657           }
1658           break;
1659         }
1660         case 16:
1661         {
1662           register unsigned short
1663             pixel;
1664
1665           if (quantum_info->format == FloatingPointQuantumFormat)
1666             {
1667               for (x=0; x < (ssize_t) number_pixels; x++)
1668               {
1669                 pixel=SinglePrecisionToHalf(QuantumScale*
1670                   GetRedPixelComponent(p));
1671                 q=PopShortPixel(endian,pixel,q);
1672                 p++;
1673                 q+=quantum_info->pad;
1674               }
1675               break;
1676             }
1677           for (x=0; x < (ssize_t) number_pixels; x++)
1678           {
1679             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
1680             q=PopShortPixel(endian,pixel,q);
1681             p++;
1682             q+=quantum_info->pad;
1683           }
1684           break;
1685         }
1686         case 32:
1687         {
1688           register unsigned int
1689             pixel;
1690
1691           if (quantum_info->format == FloatingPointQuantumFormat)
1692             {
1693               for (x=0; x < (ssize_t) number_pixels; x++)
1694               {
1695                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
1696                 p++;
1697                 q+=quantum_info->pad;
1698               }
1699               break;
1700             }
1701           for (x=0; x < (ssize_t) number_pixels; x++)
1702           {
1703             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
1704             q=PopLongPixel(endian,pixel,q);
1705             p++;
1706             q+=quantum_info->pad;
1707           }
1708           break;
1709         }
1710         case 64:
1711         {
1712           if (quantum_info->format == FloatingPointQuantumFormat)
1713             {
1714               for (x=0; x < (ssize_t) number_pixels; x++)
1715               {
1716                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
1717                 p++;
1718                 q+=quantum_info->pad;
1719               }
1720               break;
1721             }
1722         }
1723         default:
1724         {
1725           range=GetQuantumRange(quantum_info->depth);
1726           for (x=0; x < (ssize_t) number_pixels; x++)
1727           {
1728             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1729               ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
1730             p++;
1731             q+=quantum_info->pad;
1732           }
1733           break;
1734         }
1735       }
1736       break;
1737     }
1738     case GreenQuantum:
1739     case MagentaQuantum:
1740     {
1741       switch (quantum_info->depth)
1742       {
1743         case 8:
1744         {
1745           register unsigned char
1746             pixel;
1747
1748           for (x=0; x < (ssize_t) number_pixels; x++)
1749           {
1750             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
1751             q=PopCharPixel(pixel,q);
1752             p++;
1753             q+=quantum_info->pad;
1754           }
1755           break;
1756         }
1757         case 16:
1758         {
1759           register unsigned short
1760             pixel;
1761
1762           if (quantum_info->format == FloatingPointQuantumFormat)
1763             {
1764               for (x=0; x < (ssize_t) number_pixels; x++)
1765               {
1766                 pixel=SinglePrecisionToHalf(QuantumScale*
1767                   GetGreenPixelComponent(p));
1768                 q=PopShortPixel(endian,pixel,q);
1769                 p++;
1770                 q+=quantum_info->pad;
1771               }
1772               break;
1773             }
1774           for (x=0; x < (ssize_t) number_pixels; x++)
1775           {
1776             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
1777             q=PopShortPixel(endian,pixel,q);
1778             p++;
1779             q+=quantum_info->pad;
1780           }
1781           break;
1782         }
1783         case 32:
1784         {
1785           register unsigned int
1786             pixel;
1787
1788           if (quantum_info->format == FloatingPointQuantumFormat)
1789             {
1790               for (x=0; x < (ssize_t) number_pixels; x++)
1791               {
1792                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
1793                 p++;
1794                 q+=quantum_info->pad;
1795               }
1796               break;
1797             }
1798           for (x=0; x < (ssize_t) number_pixels; x++)
1799           {
1800             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
1801             q=PopLongPixel(endian,pixel,q);
1802             p++;
1803             q+=quantum_info->pad;
1804           }
1805           break;
1806         }
1807         case 64:
1808         {
1809           if (quantum_info->format == FloatingPointQuantumFormat)
1810             {
1811               for (x=0; x < (ssize_t) number_pixels; x++)
1812               {
1813                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
1814                 p++;
1815                 q+=quantum_info->pad;
1816               }
1817               break;
1818             }
1819         }
1820         default:
1821         {
1822           range=GetQuantumRange(quantum_info->depth);
1823           for (x=0; x < (ssize_t) number_pixels; x++)
1824           {
1825             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1826               ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
1827             p++;
1828             q+=quantum_info->pad;
1829           }
1830           break;
1831         }
1832       }
1833       break;
1834     }
1835     case BlueQuantum:
1836     case YellowQuantum:
1837     {
1838       switch (quantum_info->depth)
1839       {
1840         case 8:
1841         {
1842           register unsigned char
1843             pixel;
1844
1845           for (x=0; x < (ssize_t) number_pixels; x++)
1846           {
1847             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
1848             q=PopCharPixel(pixel,q);
1849             p++;
1850             q+=quantum_info->pad;
1851           }
1852           break;
1853         }
1854         case 16:
1855         {
1856           register unsigned short
1857             pixel;
1858
1859           if (quantum_info->format == FloatingPointQuantumFormat)
1860             {
1861               for (x=0; x < (ssize_t) number_pixels; x++)
1862               {
1863                 pixel=SinglePrecisionToHalf(QuantumScale*
1864                   GetBluePixelComponent(p));
1865                 q=PopShortPixel(endian,pixel,q);
1866                 p++;
1867                 q+=quantum_info->pad;
1868               }
1869               break;
1870             }
1871           for (x=0; x < (ssize_t) number_pixels; x++)
1872           {
1873             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
1874             q=PopShortPixel(endian,pixel,q);
1875             p++;
1876             q+=quantum_info->pad;
1877           }
1878           break;
1879         }
1880         case 32:
1881         {
1882           register unsigned int
1883             pixel;
1884
1885           if (quantum_info->format == FloatingPointQuantumFormat)
1886             {
1887               for (x=0; x < (ssize_t) number_pixels; x++)
1888               {
1889                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
1890                 p++;
1891                 q+=quantum_info->pad;
1892               }
1893               break;
1894             }
1895           for (x=0; x < (ssize_t) number_pixels; x++)
1896           {
1897             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
1898             q=PopLongPixel(endian,pixel,q);
1899             p++;
1900             q+=quantum_info->pad;
1901           }
1902           break;
1903         }
1904         case 64:
1905         {
1906           if (quantum_info->format == FloatingPointQuantumFormat)
1907             {
1908               for (x=0; x < (ssize_t) number_pixels; x++)
1909               {
1910                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
1911                 p++;
1912                 q+=quantum_info->pad;
1913               }
1914               break;
1915             }
1916         }
1917         default:
1918         {
1919           range=GetQuantumRange(quantum_info->depth);
1920           for (x=0; x < (ssize_t) number_pixels; x++)
1921           {
1922             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
1923               ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
1924             p++;
1925             q+=quantum_info->pad;
1926           }
1927           break;
1928         }
1929       }
1930       break;
1931     }
1932     case AlphaQuantum:
1933     {
1934       switch (quantum_info->depth)
1935       {
1936         case 8:
1937         {
1938           register unsigned char
1939             pixel;
1940
1941           for (x=0; x < (ssize_t) number_pixels; x++)
1942           {
1943             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
1944               GetOpacityPixelComponent(p)));
1945             q=PopCharPixel(pixel,q);
1946             p++;
1947             q+=quantum_info->pad;
1948           }
1949           break;
1950         }
1951         case 16:
1952         {
1953           register unsigned short
1954             pixel;
1955
1956           if (quantum_info->format == FloatingPointQuantumFormat)
1957             {
1958               for (x=0; x < (ssize_t) number_pixels; x++)
1959               {
1960                 pixel=SinglePrecisionToHalf(QuantumScale*
1961                   GetAlphaPixelComponent(p));
1962                 q=PopShortPixel(endian,pixel,q);
1963                 p++;
1964                 q+=quantum_info->pad;
1965               }
1966               break;
1967             }
1968           for (x=0; x < (ssize_t) number_pixels; x++)
1969           {
1970             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
1971               GetOpacityPixelComponent(p)));
1972             q=PopShortPixel(endian,pixel,q);
1973             p++;
1974             q+=quantum_info->pad;
1975           }
1976           break;
1977         }
1978         case 32:
1979         {
1980           register unsigned int
1981             pixel;
1982
1983           if (quantum_info->format == FloatingPointQuantumFormat)
1984             {
1985               for (x=0; x < (ssize_t) number_pixels; x++)
1986               {
1987                 float
1988                   pixel;
1989
1990                 pixel=(float) (GetAlphaPixelComponent(p));
1991                 q=PopFloatPixel(&quantum_state,pixel,q);
1992                 p++;
1993                 q+=quantum_info->pad;
1994               }
1995               break;
1996             }
1997           for (x=0; x < (ssize_t) number_pixels; x++)
1998           {
1999             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
2000               GetOpacityPixelComponent(p)));
2001             q=PopLongPixel(endian,pixel,q);
2002             p++;
2003             q+=quantum_info->pad;
2004           }
2005           break;
2006         }
2007         case 64:
2008         {
2009           if (quantum_info->format == FloatingPointQuantumFormat)
2010             {
2011               for (x=0; x < (ssize_t) number_pixels; x++)
2012               {
2013                 double
2014                   pixel;
2015
2016                 pixel=(double) (GetAlphaPixelComponent(p));
2017                 q=PopDoublePixel(&quantum_state,pixel,q);
2018                 p++;
2019                 q+=quantum_info->pad;
2020               }
2021               break;
2022             }
2023         }
2024         default:
2025         {
2026           range=GetQuantumRange(quantum_info->depth);
2027           for (x=0; x < (ssize_t) number_pixels; x++)
2028           {
2029             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2030               ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
2031             p++;
2032             q+=quantum_info->pad;
2033           }
2034           break;
2035         }
2036       }
2037       break;
2038     }
2039     case OpacityQuantum:
2040     {
2041       switch (quantum_info->depth)
2042       {
2043         case 8:
2044         {
2045           register unsigned char
2046             pixel;
2047
2048           for (x=0; x < (ssize_t) number_pixels; x++)
2049           {
2050             pixel=ScaleQuantumToChar(GetOpacityPixelComponent(p));
2051             q=PopCharPixel(pixel,q);
2052             p++;
2053             q+=quantum_info->pad;
2054           }
2055           break;
2056         }
2057         case 16:
2058         {
2059           register unsigned short
2060             pixel;
2061
2062           if (quantum_info->format == FloatingPointQuantumFormat)
2063             {
2064               for (x=0; x < (ssize_t) number_pixels; x++)
2065               {
2066                 pixel=SinglePrecisionToHalf(QuantumScale*
2067                   GetOpacityPixelComponent(p));
2068                 q=PopShortPixel(endian,pixel,q);
2069                 p++;
2070                 q+=quantum_info->pad;
2071               }
2072               break;
2073             }
2074           for (x=0; x < (ssize_t) number_pixels; x++)
2075           {
2076             pixel=ScaleQuantumToShort(GetOpacityPixelComponent(p));
2077             q=PopShortPixel(endian,pixel,q);
2078             p++;
2079             q+=quantum_info->pad;
2080           }
2081           break;
2082         }
2083         case 32:
2084         {
2085           register unsigned int
2086             pixel;
2087
2088           if (quantum_info->format == FloatingPointQuantumFormat)
2089             {
2090               for (x=0; x < (ssize_t) number_pixels; x++)
2091               {
2092                 q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
2093                 p++;
2094                 q+=quantum_info->pad;
2095               }
2096               break;
2097             }
2098           for (x=0; x < (ssize_t) number_pixels; x++)
2099           {
2100             pixel=ScaleQuantumToLong(GetOpacityPixelComponent(p));
2101             q=PopLongPixel(endian,pixel,q);
2102             p++;
2103             q+=quantum_info->pad;
2104           }
2105           break;
2106         }
2107         case 64:
2108         {
2109           if (quantum_info->format == FloatingPointQuantumFormat)
2110             {
2111               for (x=0; x < (ssize_t) number_pixels; x++)
2112               {
2113                 q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
2114                 p++;
2115                 q+=quantum_info->pad;
2116               }
2117               break;
2118             }
2119         }
2120         default:
2121         {
2122           range=GetQuantumRange(quantum_info->depth);
2123           for (x=0; x < (ssize_t) number_pixels; x++)
2124           {
2125             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2126               ScaleQuantumToAny(GetOpacityPixelComponent(p),range),q);
2127             p++;
2128             q+=quantum_info->pad;
2129           }
2130           break;
2131         }
2132       }
2133       break;
2134     }
2135     case BlackQuantum:
2136     {
2137       if (image->colorspace != CMYKColorspace)
2138         {
2139           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2140             "ColorSeparatedImageRequired","`%s'",image->filename);
2141           return(extent);
2142         }
2143       switch (quantum_info->depth)
2144       {
2145         case 8:
2146         {
2147           register unsigned char
2148             pixel;
2149
2150           for (x=0; x < (ssize_t) number_pixels; x++)
2151           {
2152             pixel=ScaleQuantumToChar(indexes[x]);
2153             q=PopCharPixel(pixel,q);
2154             p++;
2155             q+=quantum_info->pad;
2156           }
2157           break;
2158         }
2159         case 16:
2160         {
2161           register unsigned short
2162             pixel;
2163
2164           if (quantum_info->format == FloatingPointQuantumFormat)
2165             {
2166               for (x=0; x < (ssize_t) number_pixels; x++)
2167               {
2168                 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2169                 q=PopShortPixel(endian,pixel,q);
2170                 p++;
2171                 q+=quantum_info->pad;
2172               }
2173               break;
2174             }
2175           for (x=0; x < (ssize_t) number_pixels; x++)
2176           {
2177             pixel=ScaleQuantumToShort(indexes[x]);
2178             q=PopShortPixel(endian,pixel,q);
2179             p++;
2180             q+=quantum_info->pad;
2181           }
2182           break;
2183         }
2184         case 32:
2185         {
2186           register unsigned int
2187             pixel;
2188
2189           if (quantum_info->format == FloatingPointQuantumFormat)
2190             {
2191               for (x=0; x < (ssize_t) number_pixels; x++)
2192               {
2193                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2194                 p++;
2195                 q+=quantum_info->pad;
2196               }
2197               break;
2198             }
2199           for (x=0; x < (ssize_t) number_pixels; x++)
2200           {
2201             pixel=ScaleQuantumToLong(indexes[x]);
2202             q=PopLongPixel(endian,pixel,q);
2203             p++;
2204             q+=quantum_info->pad;
2205           }
2206           break;
2207         }
2208         case 64:
2209         {
2210           if (quantum_info->format == FloatingPointQuantumFormat)
2211             {
2212               for (x=0; x < (ssize_t) number_pixels; x++)
2213               {
2214                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2215                 p++;
2216                 q+=quantum_info->pad;
2217               }
2218               break;
2219             }
2220         }
2221         default:
2222         {
2223           range=GetQuantumRange(quantum_info->depth);
2224           for (x=0; x < (ssize_t) number_pixels; x++)
2225           {
2226             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2227               ScaleQuantumToAny((Quantum) indexes[x],range),q);
2228             p++;
2229             q+=quantum_info->pad;
2230           }
2231           break;
2232         }
2233       }
2234       break;
2235     }
2236     case RGBQuantum:
2237     case CbYCrQuantum:
2238     {
2239       switch (quantum_info->depth)
2240       {
2241         case 8:
2242         {
2243           for (x=0; x < (ssize_t) number_pixels; x++)
2244           {
2245             q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
2246             q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
2247             q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
2248             p++;
2249             q+=quantum_info->pad;
2250           }
2251           break;
2252         }
2253         case 10:
2254         {
2255           register unsigned int
2256             pixel;
2257
2258           range=GetQuantumRange(quantum_info->depth);
2259           if (quantum_info->pack == MagickFalse)
2260             {
2261               for (x=0; x < (ssize_t) number_pixels; x++)
2262               {
2263                 pixel=(unsigned int) (ScaleQuantumToAny(GetRedPixelComponent(p),range) << 22 |
2264                   ScaleQuantumToAny(GetGreenPixelComponent(p),range) << 12 |
2265                   ScaleQuantumToAny(GetBluePixelComponent(p),range) << 2);
2266                 q=PopLongPixel(endian,pixel,q);
2267                 p++;
2268                 q+=quantum_info->pad;
2269               }
2270               break;
2271             }
2272           if (quantum_info->quantum == 32UL)
2273             {
2274               for (x=0; x < (ssize_t) number_pixels; x++)
2275               {
2276                 pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2277                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2278                   q);
2279                 pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2280                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2281                   q);
2282                 pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2283                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2284                   q);
2285                 p++;
2286                 q+=quantum_info->pad;
2287               }
2288               break;
2289             }
2290           for (x=0; x < (ssize_t) number_pixels; x++)
2291           {
2292             pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2293             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2294             pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2295             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2296             pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2297             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2298             p++;
2299             q+=quantum_info->pad;
2300           }
2301           break;
2302         }
2303         case 12:
2304         {
2305           register unsigned int
2306             pixel;
2307
2308           range=GetQuantumRange(quantum_info->depth);
2309           if (quantum_info->pack == MagickFalse)
2310             {
2311               for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
2312               {
2313                 switch (x % 3)
2314                 {
2315                   default:
2316                   case 0:
2317                   {
2318                     pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2319                     break;
2320                   }
2321                   case 1:
2322                   {
2323                     pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2324                     break;
2325                   }
2326                   case 2:
2327                   {
2328                     pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2329                     p++;
2330                     break;
2331                   }
2332                 }
2333                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2334                 switch ((x+1) % 3)
2335                 {
2336                   default:
2337                   case 0:
2338                   {
2339                     pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2340                     break;
2341                   }
2342                   case 1:
2343                   {
2344                     pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2345                     break;
2346                   }
2347                   case 2:
2348                   {
2349                     pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2350                     p++;
2351                     break;
2352                   }
2353                 }
2354                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2355                 q+=quantum_info->pad;
2356               }
2357               for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
2358               {
2359                 switch ((x+bit) % 3)
2360                 {
2361                   default:
2362                   case 0:
2363                   {
2364                     pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2365                     break;
2366                   }
2367                   case 1:
2368                   {
2369                     pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2370                     break;
2371                   }
2372                   case 2:
2373                   {
2374                     pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2375                     p++;
2376                     break;
2377                   }
2378                 }
2379                 q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
2380                 q+=quantum_info->pad;
2381               }
2382               if (bit != 0)
2383                 p++;
2384               break;
2385             }
2386           if (quantum_info->quantum == 32UL)
2387             {
2388               for (x=0; x < (ssize_t) number_pixels; x++)
2389               {
2390                 pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2391                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2392                   q);
2393                 pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2394                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2395                   q);
2396                 pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2397                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2398                   q);
2399                 p++;
2400                 q+=quantum_info->pad;
2401               }
2402               break;
2403             }
2404           for (x=0; x < (ssize_t) number_pixels; x++)
2405           {
2406             pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2407             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2408             pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2409             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2410             pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2411             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2412             p++;
2413             q+=quantum_info->pad;
2414           }
2415           break;
2416         }
2417         case 16:
2418         {
2419           register unsigned short
2420             pixel;
2421
2422           if (quantum_info->format == FloatingPointQuantumFormat)
2423             {
2424               for (x=0; x < (ssize_t) number_pixels; x++)
2425               {
2426                 pixel=SinglePrecisionToHalf(QuantumScale*
2427                   GetRedPixelComponent(p));
2428                 q=PopShortPixel(endian,pixel,q);
2429                 pixel=SinglePrecisionToHalf(QuantumScale*
2430                   GetGreenPixelComponent(p));
2431                 q=PopShortPixel(endian,pixel,q);
2432                 pixel=SinglePrecisionToHalf(QuantumScale*
2433                   GetBluePixelComponent(p));
2434                 q=PopShortPixel(endian,pixel,q);
2435                 p++;
2436                 q+=quantum_info->pad;
2437               }
2438               break;
2439             }
2440           for (x=0; x < (ssize_t) number_pixels; x++)
2441           {
2442             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2443             q=PopShortPixel(endian,pixel,q);
2444             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2445             q=PopShortPixel(endian,pixel,q);
2446             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2447             q=PopShortPixel(endian,pixel,q);
2448             p++;
2449             q+=quantum_info->pad;
2450           }
2451           break;
2452         }
2453         case 32:
2454         {
2455           register unsigned int
2456             pixel;
2457
2458           if (quantum_info->format == FloatingPointQuantumFormat)
2459             {
2460               for (x=0; x < (ssize_t) number_pixels; x++)
2461               {
2462                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2463                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2464                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2465                 p++;
2466                 q+=quantum_info->pad;
2467               }
2468               break;
2469             }
2470           for (x=0; x < (ssize_t) number_pixels; x++)
2471           {
2472             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2473             q=PopLongPixel(endian,pixel,q);
2474             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2475             q=PopLongPixel(endian,pixel,q);
2476             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2477             q=PopLongPixel(endian,pixel,q);
2478             p++;
2479             q+=quantum_info->pad;
2480           }
2481           break;
2482         }
2483         case 64:
2484         {
2485           if (quantum_info->format == FloatingPointQuantumFormat)
2486             {
2487               for (x=0; x < (ssize_t) number_pixels; x++)
2488               {
2489                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2490                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2491                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2492                 p++;
2493                 q+=quantum_info->pad;
2494               }
2495               break;
2496             }
2497         }
2498         default:
2499         {
2500           range=GetQuantumRange(quantum_info->depth);
2501           for (x=0; x < (ssize_t) number_pixels; x++)
2502           {
2503             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2504               ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
2505             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2506               ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
2507             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2508               ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
2509             p++;
2510             q+=quantum_info->pad;
2511           }
2512           break;
2513         }
2514       }
2515       break;
2516     }
2517     case RGBAQuantum:
2518     case RGBOQuantum:
2519     case CbYCrAQuantum:
2520     {
2521       switch (quantum_info->depth)
2522       {
2523         case 8:
2524         {
2525           register unsigned char
2526             pixel;
2527
2528           for (x=0; x < (ssize_t) number_pixels; x++)
2529           {
2530             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2531             q=PopCharPixel(pixel,q);
2532             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2533             q=PopCharPixel(pixel,q);
2534             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2535             q=PopCharPixel(pixel,q);
2536             pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
2537             q=PopCharPixel(pixel,q);
2538             p++;
2539             q+=quantum_info->pad;
2540           }
2541           break;
2542         }
2543         case 10:
2544         {
2545           register unsigned int
2546             pixel;
2547
2548           range=GetQuantumRange(quantum_info->depth);
2549           if (quantum_info->pack == MagickFalse)
2550             {
2551               register ssize_t
2552                 i;
2553
2554               size_t
2555                 quantum;
2556
2557               ssize_t
2558                 n;
2559
2560               n=0;
2561               quantum=0;
2562               pixel=0;
2563               for (x=0; x < (ssize_t) number_pixels; x++)
2564               {
2565                 for (i=0; i < 4; i++)
2566                 {
2567                   switch (i)
2568                   {
2569                     case 0: quantum=p->red; break;
2570                     case 1: quantum=p->green; break;
2571                     case 2: quantum=p->blue; break;
2572                     case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
2573                   }
2574                   switch (n % 3)
2575                   {
2576                     case 0:
2577                     {
2578                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2579                         range) << 22);
2580                       break;
2581                     }
2582                     case 1:
2583                     {
2584                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2585                         range) << 12);
2586                       break;
2587                     }
2588                     case 2:
2589                     {
2590                       pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
2591                         range) << 2);
2592                       q=PopLongPixel(endian,pixel,q);
2593                       pixel=0;
2594                       break;
2595                     }
2596                   }
2597                   n++;
2598                 }
2599                 p++;
2600                 q+=quantum_info->pad;
2601               }
2602               break;
2603             }
2604           if (quantum_info->quantum == 32UL)
2605             {
2606               for (x=0; x < (ssize_t) number_pixels; x++)
2607               {
2608                 pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2609                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2610                   q);
2611                 pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2612                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2613                   q);
2614                 pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2615                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2616                   q);
2617                 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
2618                   p->opacity),range);
2619                 q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
2620                   q);
2621                 p++;
2622                 q+=quantum_info->pad;
2623               }
2624               break;
2625             }
2626           for (x=0; x < (ssize_t) number_pixels; x++)
2627           {
2628             pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
2629             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2630             pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
2631             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2632             pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
2633             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2634             pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
2635               p->opacity),range);
2636             q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
2637             p++;
2638             q+=quantum_info->pad;
2639           }
2640           break;
2641         }
2642         case 16:
2643         {
2644           register unsigned short
2645             pixel;
2646
2647           if (quantum_info->format == FloatingPointQuantumFormat)
2648             {
2649               for (x=0; x < (ssize_t) number_pixels; x++)
2650               {
2651                 pixel=SinglePrecisionToHalf(QuantumScale*
2652                   GetRedPixelComponent(p));
2653                 q=PopShortPixel(endian,pixel,q);
2654                 pixel=SinglePrecisionToHalf(QuantumScale*
2655                   GetGreenPixelComponent(p));
2656                 q=PopShortPixel(endian,pixel,q);
2657                 pixel=SinglePrecisionToHalf(QuantumScale*
2658                   GetBluePixelComponent(p));
2659                 q=PopShortPixel(endian,pixel,q);
2660                 pixel=SinglePrecisionToHalf(QuantumScale*
2661                   GetAlphaPixelComponent(p));
2662                 q=PopShortPixel(endian,pixel,q);
2663                 p++;
2664                 q+=quantum_info->pad;
2665               }
2666               break;
2667             }
2668           for (x=0; x < (ssize_t) number_pixels; x++)
2669           {
2670             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2671             q=PopShortPixel(endian,pixel,q);
2672             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2673             q=PopShortPixel(endian,pixel,q);
2674             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2675             q=PopShortPixel(endian,pixel,q);
2676             pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
2677             q=PopShortPixel(endian,pixel,q);
2678             p++;
2679             q+=quantum_info->pad;
2680           }
2681           break;
2682         }
2683         case 32:
2684         {
2685           register unsigned int
2686             pixel;
2687
2688           if (quantum_info->format == FloatingPointQuantumFormat)
2689             {
2690               for (x=0; x < (ssize_t) number_pixels; x++)
2691               {
2692                 float
2693                   pixel;
2694
2695                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2696                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2697                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2698                 pixel=(float) GetAlphaPixelComponent(p);
2699                 q=PopFloatPixel(&quantum_state,pixel,q);
2700                 p++;
2701                 q+=quantum_info->pad;
2702               }
2703               break;
2704             }
2705           for (x=0; x < (ssize_t) number_pixels; x++)
2706           {
2707             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2708             q=PopLongPixel(endian,pixel,q);
2709             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2710             q=PopLongPixel(endian,pixel,q);
2711             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2712             q=PopLongPixel(endian,pixel,q);
2713             pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
2714             q=PopLongPixel(endian,pixel,q);
2715             p++;
2716             q+=quantum_info->pad;
2717           }
2718           break;
2719         }
2720         case 64:
2721         {
2722           if (quantum_info->format == FloatingPointQuantumFormat)
2723             {
2724               double
2725                 pixel;
2726
2727               for (x=0; x < (ssize_t) number_pixels; x++)
2728               {
2729                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2730                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2731                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2732                 pixel=(double) GetAlphaPixelComponent(p);
2733                 q=PopDoublePixel(&quantum_state,pixel,q);
2734                 p++;
2735                 q+=quantum_info->pad;
2736               }
2737               break;
2738             }
2739         }
2740         default:
2741         {
2742           range=GetQuantumRange(quantum_info->depth);
2743           for (x=0; x < (ssize_t) number_pixels; x++)
2744           {
2745             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2746               ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
2747             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2748               ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
2749             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2750               ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
2751             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2752               ScaleQuantumToAny((Quantum) GetAlphaPixelComponent(p),range),q);
2753             p++;
2754             q+=quantum_info->pad;
2755           }
2756           break;
2757         }
2758       }
2759       break;
2760     }
2761     case CMYKQuantum:
2762     {
2763       if (image->colorspace != CMYKColorspace)
2764         {
2765           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2766             "ColorSeparatedImageRequired","`%s'",image->filename);
2767           return(extent);
2768         }
2769       switch (quantum_info->depth)
2770       {
2771         case 8:
2772         {
2773           register unsigned char
2774             pixel;
2775
2776           for (x=0; x < (ssize_t) number_pixels; x++)
2777           {
2778             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2779             q=PopCharPixel(pixel,q);
2780             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2781             q=PopCharPixel(pixel,q);
2782             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2783             q=PopCharPixel(pixel,q);
2784             pixel=ScaleQuantumToChar(indexes[x]);
2785             q=PopCharPixel(pixel,q);
2786             p++;
2787             q+=quantum_info->pad;
2788           }
2789           break;
2790         }
2791         case 16:
2792         {
2793           register unsigned short
2794             pixel;
2795
2796           if (quantum_info->format == FloatingPointQuantumFormat)
2797             {
2798               for (x=0; x < (ssize_t) number_pixels; x++)
2799               {
2800                 pixel=SinglePrecisionToHalf(QuantumScale*
2801                   GetRedPixelComponent(p));
2802                 q=PopShortPixel(endian,pixel,q);
2803                 pixel=SinglePrecisionToHalf(QuantumScale*
2804                   GetGreenPixelComponent(p));
2805                 q=PopShortPixel(endian,pixel,q);
2806                 pixel=SinglePrecisionToHalf(QuantumScale*
2807                   GetBluePixelComponent(p));
2808                 q=PopShortPixel(endian,pixel,q);
2809                 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2810                 q=PopShortPixel(endian,pixel,q);
2811                 p++;
2812                 q+=quantum_info->pad;
2813               }
2814               break;
2815             }
2816           for (x=0; x < (ssize_t) number_pixels; x++)
2817           {
2818             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2819             q=PopShortPixel(endian,pixel,q);
2820             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2821             q=PopShortPixel(endian,pixel,q);
2822             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2823             q=PopShortPixel(endian,pixel,q);
2824             pixel=ScaleQuantumToShort(indexes[x]);
2825             q=PopShortPixel(endian,pixel,q);
2826             p++;
2827             q+=quantum_info->pad;
2828           }
2829           break;
2830         }
2831         case 32:
2832         {
2833           register unsigned int
2834             pixel;
2835
2836           if (quantum_info->format == FloatingPointQuantumFormat)
2837             {
2838               for (x=0; x < (ssize_t) number_pixels; x++)
2839               {
2840                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2841                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2842                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2843                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2844                 p++;
2845                 q+=quantum_info->pad;
2846               }
2847               break;
2848             }
2849           for (x=0; x < (ssize_t) number_pixels; x++)
2850           {
2851             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
2852             q=PopLongPixel(endian,pixel,q);
2853             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
2854             q=PopLongPixel(endian,pixel,q);
2855             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
2856             q=PopLongPixel(endian,pixel,q);
2857             pixel=ScaleQuantumToLong(indexes[x]);
2858             q=PopLongPixel(endian,pixel,q);
2859             p++;
2860             q+=quantum_info->pad;
2861           }
2862           break;
2863         }
2864         case 64:
2865         {
2866           if (quantum_info->format == FloatingPointQuantumFormat)
2867             {
2868               for (x=0; x < (ssize_t) number_pixels; x++)
2869               {
2870                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
2871                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
2872                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
2873                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
2874                 p++;
2875                 q+=quantum_info->pad;
2876               }
2877               break;
2878             }
2879         }
2880         default:
2881         {
2882           range=GetQuantumRange(quantum_info->depth);
2883           for (x=0; x < (ssize_t) number_pixels; x++)
2884           {
2885             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2886               ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
2887             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2888               ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
2889             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2890               ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
2891             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
2892               ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range),q);
2893             p++;
2894             q+=quantum_info->pad;
2895           }
2896           break;
2897         }
2898       }
2899       break;
2900     }
2901     case CMYKAQuantum:
2902     case CMYKOQuantum:
2903     {
2904       if (image->colorspace != CMYKColorspace)
2905         {
2906           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2907             "ColorSeparatedImageRequired","`%s'",image->filename);
2908           return(extent);
2909         }
2910       switch (quantum_info->depth)
2911       {
2912         case 8:
2913         {
2914           register unsigned char
2915             pixel;
2916
2917           for (x=0; x < (ssize_t) number_pixels; x++)
2918           {
2919             pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
2920             q=PopCharPixel(pixel,q);
2921             pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
2922             q=PopCharPixel(pixel,q);
2923             pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
2924             q=PopCharPixel(pixel,q);
2925             pixel=ScaleQuantumToChar(indexes[x]);
2926             q=PopCharPixel(pixel,q);
2927             pixel=ScaleQuantumToChar((Quantum) (QuantumRange-
2928               GetOpacityPixelComponent(p)));
2929             q=PopCharPixel(pixel,q);
2930             p++;
2931             q+=quantum_info->pad;
2932           }
2933           break;
2934         }
2935         case 16:
2936         {
2937           register unsigned short
2938             pixel;
2939
2940           if (quantum_info->format == FloatingPointQuantumFormat)
2941             {
2942               for (x=0; x < (ssize_t) number_pixels; x++)
2943               {
2944                 pixel=SinglePrecisionToHalf(QuantumScale*
2945                   GetRedPixelComponent(p));
2946                 q=PopShortPixel(endian,pixel,q);
2947                 pixel=SinglePrecisionToHalf(QuantumScale*
2948                   GetGreenPixelComponent(p));
2949                 q=PopShortPixel(endian,pixel,q);
2950                 pixel=SinglePrecisionToHalf(QuantumScale*
2951                   GetBluePixelComponent(p));
2952                 q=PopShortPixel(endian,pixel,q);
2953                 pixel=SinglePrecisionToHalf(QuantumScale*indexes[x]);
2954                 q=PopShortPixel(endian,pixel,q);
2955                 pixel=SinglePrecisionToHalf(QuantumScale*
2956                   GetAlphaPixelComponent(p));
2957                 q=PopShortPixel(endian,pixel,q);
2958                 p++;
2959                 q+=quantum_info->pad;
2960               }
2961               break;
2962             }
2963           for (x=0; x < (ssize_t) number_pixels; x++)
2964           {
2965             pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
2966             q=PopShortPixel(endian,pixel,q);
2967             pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
2968             q=PopShortPixel(endian,pixel,q);
2969             pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
2970             q=PopShortPixel(endian,pixel,q);
2971             pixel=ScaleQuantumToShort(indexes[x]);
2972             q=PopShortPixel(endian,pixel,q);
2973             pixel=ScaleQuantumToShort((Quantum) (QuantumRange-
2974               GetOpacityPixelComponent(p)));
2975             q=PopShortPixel(endian,pixel,q);
2976             p++;
2977             q+=quantum_info->pad;
2978           }
2979           break;
2980         }
2981         case 32:
2982         {
2983           register unsigned int
2984             pixel;
2985
2986           if (quantum_info->format == FloatingPointQuantumFormat)
2987             {
2988               for (x=0; x < (ssize_t) number_pixels; x++)
2989               {
2990                 float
2991                   pixel;
2992
2993                 q=PopFloatPixel(&quantum_state,(float) p->red,q);
2994                 q=PopFloatPixel(&quantum_state,(float) p->green,q);
2995                 q=PopFloatPixel(&quantum_state,(float) p->blue,q);
2996                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
2997                 pixel=(float) (GetAlphaPixelComponent(p));
2998                 q=PopFloatPixel(&quantum_state,pixel,q);
2999                 p++;
3000                 q+=quantum_info->pad;
3001               }
3002               break;
3003             }
3004           for (x=0; x < (ssize_t) number_pixels; x++)
3005           {
3006             pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
3007             q=PopLongPixel(endian,pixel,q);
3008             pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
3009             q=PopLongPixel(endian,pixel,q);
3010             pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
3011             q=PopLongPixel(endian,pixel,q);
3012             pixel=ScaleQuantumToLong(indexes[x]);
3013             q=PopLongPixel(endian,pixel,q);
3014             pixel=ScaleQuantumToLong((Quantum) (QuantumRange-
3015               GetOpacityPixelComponent(p)));
3016             q=PopLongPixel(endian,pixel,q);
3017             p++;
3018             q+=quantum_info->pad;
3019           }
3020           break;
3021         }
3022         case 64:
3023         {
3024           if (quantum_info->format == FloatingPointQuantumFormat)
3025             {
3026               double
3027                 pixel;
3028
3029               for (x=0; x < (ssize_t) number_pixels; x++)
3030               {
3031                 q=PopDoublePixel(&quantum_state,(double) p->red,q);
3032                 q=PopDoublePixel(&quantum_state,(double) p->green,q);
3033                 q=PopDoublePixel(&quantum_state,(double) p->blue,q);
3034                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
3035                 pixel=(double) (GetAlphaPixelComponent(p));
3036                 q=PopDoublePixel(&quantum_state,pixel,q);
3037                 p++;
3038                 q+=quantum_info->pad;
3039               }
3040               break;
3041             }
3042         }
3043         default:
3044         {
3045           range=GetQuantumRange(quantum_info->depth);
3046           for (x=0; x < (ssize_t) number_pixels; x++)
3047           {
3048             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3049               ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
3050             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3051               ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
3052             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3053               ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
3054             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3055               ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range),q);
3056             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3057               ScaleQuantumToAny(GetOpacityPixelComponent(p),range),q);
3058             p++;
3059             q+=quantum_info->pad;
3060           }
3061           break;
3062         }
3063       }
3064       break;
3065     }
3066     case CbYCrYQuantum:
3067     {
3068       Quantum
3069         cbcr[4];
3070
3071       register ssize_t
3072         i;
3073
3074       register unsigned int
3075         pixel;
3076
3077       size_t
3078         quantum;
3079
3080      ssize_t
3081         n;
3082
3083       n=0;
3084       quantum=0;
3085       range=GetQuantumRange(quantum_info->depth);
3086       switch (quantum_info->depth)
3087       {
3088         case 10:
3089         {
3090           if (quantum_info->pack == MagickFalse)
3091             {
3092               for (x=0; x < (ssize_t) number_pixels; x+=2)
3093               {
3094                 for (i=0; i < 4; i++)
3095                 {
3096                   switch (n % 3)
3097                   {
3098                     case 0:
3099                     {
3100                       quantum=GetRedPixelComponent(p);
3101                       break;
3102                     }
3103                     case 1:
3104                     {
3105                       quantum=GetGreenPixelComponent(p);
3106                       break;
3107                     }
3108                     case 2:
3109                     {
3110                       quantum=GetBluePixelComponent(p);
3111                       break;
3112                     }
3113                   }
3114                   cbcr[i]=(Quantum) quantum;
3115                   n++;
3116                 }
3117                 pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 |
3118                   (size_t) (cbcr[0]) << 12 |
3119                   (size_t) (cbcr[2]) << 2);
3120                 q=PopLongPixel(endian,pixel,q);
3121                 p++;
3122                 pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 |
3123                   (size_t) (cbcr[0]) << 12 |
3124                   (size_t) (cbcr[2]) << 2);
3125                 q=PopLongPixel(endian,pixel,q);
3126                 p++;
3127                 q+=quantum_info->pad;
3128               }
3129               break;
3130             }
3131           break;
3132         }
3133         default:
3134         {
3135           for (x=0; x < (ssize_t) number_pixels; x+=2)
3136           {
3137             for (i=0; i < 4; i++)
3138             {
3139               switch (n % 3)
3140               {
3141                 case 0:
3142                 {
3143                   quantum=GetRedPixelComponent(p);
3144                   break;
3145                 }
3146                 case 1:
3147                 {
3148                   quantum=GetGreenPixelComponent(p);
3149                   break;
3150                 }
3151                 case 2:
3152                 {
3153                   quantum=GetBluePixelComponent(p);
3154                   break;
3155                 }
3156               }
3157               cbcr[i]=(Quantum) quantum;
3158               n++;
3159             }
3160             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3161               ScaleQuantumToAny(cbcr[1],range),q);
3162             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3163               ScaleQuantumToAny(cbcr[0],range),q);
3164             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3165               ScaleQuantumToAny(cbcr[2],range),q);
3166             p++;
3167             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3168               ScaleQuantumToAny(cbcr[3],range),q);
3169             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3170               ScaleQuantumToAny(cbcr[0],range),q);
3171             q=PopQuantumPixel(&quantum_state,quantum_info->depth,
3172               ScaleQuantumToAny(cbcr[2],range),q);
3173             p++;
3174             q+=quantum_info->pad;
3175           }
3176           break;
3177         }
3178       }
3179       break;
3180     }
3181     default:
3182       break;
3183   }
3184   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3185     {
3186       Quantum
3187         quantum;
3188
3189       register PixelPacket
3190         *restrict q;
3191
3192       q=GetAuthenticPixelQueue(image);
3193       if (image_view != (CacheView *) NULL)
3194         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3195       for (x=0; x < (ssize_t) number_pixels; x++)
3196       {
3197         quantum=q->red;
3198         q->red=q->green;
3199         q->green=quantum;
3200         q++;
3201       }
3202     }
3203   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
3204       (quantum_type == BGROQuantum))
3205     {
3206       register PixelPacket
3207         *restrict q;
3208
3209       q=GetAuthenticPixelQueue(image);
3210       if (image_view != (CacheView *) NULL)
3211         q=(PixelPacket *) GetCacheViewVirtualPixelQueue(image_view);
3212       for (x=0; x < (ssize_t) number_pixels; x++)
3213       {
3214         q->opacity=(Quantum) GetAlphaPixelComponent(q);
3215         q++;
3216       }
3217     }
3218   return(extent);
3219 }