granicus.if.org Git - imagemagick/blob - magick/quantum-export.c

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