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