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

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