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