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

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