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

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