granicus.if.org Git - imagemagick/blob - magick/quantum-import.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 %                   IIIII  M   M  PPPP    OOO   RRRR   TTTTT                  %
  13 %                     I    MM MM  P   P  O   O  R   R    T                    %
  14 %                     I    M M M  PPPP   O   O  RRRR     T                    %
  15 %                     I    M   M  P      O   O  R R      T                    %
  16 %                   IIIII  M   M  P       OOO   R  R     T                    %
  17 %                                                                             %
  18 %                 MagickCore Methods to Import 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 %   I m p o r t Q u a n t u m P i x e l s                                     %
  80 %                                                                             %
  81 %                                                                             %
  82 %                                                                             %
  83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  84 %
  85 %  ImportQuantumPixels() transfers one or more pixel components from a user
  86 %  supplied buffer into the image pixel cache of an image.  The pixels are
  87 %  expected in network byte order.  It returns MagickTrue if the pixels are
  88 %  successfully transferred, otherwise MagickFalse.
  89 %
  90 %  The format of the ImportQuantumPixels method is:
  91 %
  92 %      size_t ImportQuantumPixels(Image *image,CacheView *image_view,
  93 %        const QuantumInfo *quantum_info,const QuantumType quantum_type,
  94 %        const 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 (red, green,
 105 %      blue, opacity, RGB, or RGBA).
 106 %
 107 %    o pixels:  The pixel components are transferred from this buffer.
 108 %
 109 %    o exception: return any errors or warnings in this structure.
 110 %
 111 */
 112
 113 static inline IndexPacket PushColormapIndex(Image *image,
 114   const size_t index,MagickBooleanType *range_exception)
 115 {
 116   if (index < image->colors)
 117     return((IndexPacket) index);
 118   *range_exception=MagickTrue;
 119   return((IndexPacket) 0);
 120 }
 121
 122 static inline const unsigned char *PushDoublePixel(
 123   const QuantumState *quantum_state,const unsigned char *pixels,double *pixel)
 124 {
 125   double
 126     *p;
 127
 128   unsigned char
 129     quantum[8];
 130
 131   if (quantum_state->endian != LSBEndian)
 132     {
 133       quantum[7]=(*pixels++);
 134       quantum[6]=(*pixels++);
 135       quantum[5]=(*pixels++);
 136       quantum[5]=(*pixels++);
 137       quantum[3]=(*pixels++);
 138       quantum[2]=(*pixels++);
 139       quantum[1]=(*pixels++);
 140       quantum[0]=(*pixels++);
 141       p=(double *) quantum;
 142       *pixel=(*p);
 143       *pixel-=quantum_state->minimum;
 144       *pixel*=quantum_state->scale;
 145       return(pixels);
 146     }
 147   quantum[0]=(*pixels++);
 148   quantum[1]=(*pixels++);
 149   quantum[2]=(*pixels++);
 150   quantum[3]=(*pixels++);
 151   quantum[4]=(*pixels++);
 152   quantum[5]=(*pixels++);
 153   quantum[6]=(*pixels++);
 154   quantum[7]=(*pixels++);
 155   p=(double *) quantum;
 156   *pixel=(*p);
 157   *pixel-=quantum_state->minimum;
 158   *pixel*=quantum_state->scale;
 159   return(pixels);
 160 }
 161
 162 static inline const unsigned char *PushFloatPixel(
 163   const QuantumState *quantum_state,const unsigned char *pixels,float *pixel)
 164 {
 165   float
 166     *p;
 167
 168   unsigned char
 169     quantum[4];
 170
 171   if (quantum_state->endian != LSBEndian)
 172     {
 173       quantum[3]=(*pixels++);
 174       quantum[2]=(*pixels++);
 175       quantum[1]=(*pixels++);
 176       quantum[0]=(*pixels++);
 177       p=(float *) quantum;
 178       *pixel=(*p);
 179       *pixel-=quantum_state->minimum;
 180       *pixel*=quantum_state->scale;
 181       return(pixels);
 182     }
 183   quantum[0]=(*pixels++);
 184   quantum[1]=(*pixels++);
 185   quantum[2]=(*pixels++);
 186   quantum[3]=(*pixels++);
 187   p=(float *) quantum;
 188   *pixel=(*p);
 189   *pixel-=quantum_state->minimum;
 190   *pixel*=quantum_state->scale;
 191   return(pixels);
 192 }
 193
 194 static inline const unsigned char *PushQuantumPixel(
 195   QuantumState *quantum_state,const size_t depth,
 196   const unsigned char *pixels,unsigned int *quantum)
 197 {
 198   register ssize_t
 199     i;
 200
 201   register size_t
 202     quantum_bits;
 203
 204   *quantum=(QuantumAny) 0;
 205   for (i=(ssize_t) depth; i > 0L; )
 206   {
 207     if (quantum_state->bits == 0UL)
 208       {
 209         quantum_state->pixel=(*pixels++);
 210         quantum_state->bits=8UL;
 211       }
 212     quantum_bits=(size_t) i;
 213     if (quantum_bits > quantum_state->bits)
 214       quantum_bits=quantum_state->bits;
 215     i-=(ssize_t) quantum_bits;
 216     quantum_state->bits-=quantum_bits;
 217     *quantum=(unsigned int) ((*quantum << quantum_bits) |
 218       ((quantum_state->pixel >> quantum_state->bits) &~ ((~0UL) <<
 219       quantum_bits)));
 220   }
 221   return(pixels);
 222 }
 223
 224 static inline const unsigned char *PushQuantumLongPixel(
 225   QuantumState *quantum_state,const size_t depth,
 226   const unsigned char *pixels,unsigned int *quantum)
 227 {
 228   register ssize_t
 229     i;
 230
 231   register size_t
 232     quantum_bits;
 233
 234   *quantum=0UL;
 235   for (i=(ssize_t) depth; i > 0; )
 236   {
 237     if (quantum_state->bits == 0)
 238       {
 239         pixels=PushLongPixel(quantum_state->endian,pixels,
 240           &quantum_state->pixel);
 241         quantum_state->bits=32U;
 242       }
 243     quantum_bits=(size_t) i;
 244     if (quantum_bits > quantum_state->bits)
 245       quantum_bits=quantum_state->bits;
 246     *quantum|=(((quantum_state->pixel >> (32U-quantum_state->bits)) &
 247       quantum_state->mask[quantum_bits]) << (depth-i));
 248     i-=(ssize_t) quantum_bits;
 249     quantum_state->bits-=quantum_bits;
 250   }
 251   return(pixels);
 252 }
 253
 254 MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 255   const QuantumInfo *quantum_info,const QuantumType quantum_type,
 256   const unsigned char *pixels,ExceptionInfo *exception)
 257 {
 258   EndianType
 259     endian;
 260
 261   MagickSizeType
 262     number_pixels;
 263
 264   QuantumAny
 265     range;
 266
 267   QuantumState
 268     quantum_state;
 269
 270   register const unsigned char
 271     *restrict p;
 272
 273   register IndexPacket
 274     *restrict indexes;
 275
 276   register ssize_t
 277     x;
 278
 279   register PixelPacket
 280     *restrict q;
 281
 282   size_t
 283     extent;
 284
 285   ssize_t
 286     bit;
 287
 288   unsigned int
 289     pixel;
 290
 291   assert(image != (Image *) NULL);
 292   assert(image->signature == MagickSignature);
 293   if (image->debug != MagickFalse)
 294     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 295   assert(quantum_info != (QuantumInfo *) NULL);
 296   assert(quantum_info->signature == MagickSignature);
 297   if (pixels == (const unsigned char *) NULL)
 298     pixels=GetQuantumPixels(quantum_info);
 299   x=0;
 300   p=pixels;
 301   if (image_view == (CacheView *) NULL)
 302     {
 303       number_pixels=GetImageExtent(image);
 304       q=GetAuthenticPixelQueue(image);
 305       indexes=GetAuthenticIndexQueue(image);
 306     }
 307   else
 308     {
 309       number_pixels=GetCacheViewExtent(image_view);
 310       q=GetCacheViewAuthenticPixelQueue(image_view);
 311       indexes=GetCacheViewAuthenticIndexQueue(image_view);
 312     }
 313   InitializeQuantumState(quantum_info,image->endian,&quantum_state);
 314   extent=GetQuantumExtent(image,quantum_info,quantum_type);
 315   endian=quantum_state.endian;
 316   switch (quantum_type)
 317   {
 318     case IndexQuantum:
 319     {
 320       MagickBooleanType
 321         range_exception;
 322
 323       if (image->storage_class != PseudoClass)
 324         {
 325           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 326             "ColormappedImageRequired","`%s'",image->filename);
 327           return(extent);
 328         }
 329       range_exception=MagickFalse;
 330       switch (quantum_info->depth)
 331       {
 332         case 1:
 333         {
 334           register unsigned char
 335             pixel;
 336
 337           for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
 338           {
 339             for (bit=0; bit < 8; bit++)
 340             {
 341               if (quantum_info->min_is_white == MagickFalse)
 342                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 343                   0x00 : 0x01);
 344               else
 345                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 346                   0x00 : 0x01);
 347               SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,
 348                 pixel,&range_exception));
 349               SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 350                 GetIndexPixelComponent(indexes+x+bit));
 351               q++;
 352             }
 353             p++;
 354           }
 355           for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
 356           {
 357             if (quantum_info->min_is_white == MagickFalse)
 358               pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 359                 0x00 : 0x01);
 360             else
 361               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 362                 0x00 : 0x01);
 363             SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
 364               &range_exception));
 365             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 366               GetIndexPixelComponent(indexes+x+bit));
 367             q++;
 368           }
 369           break;
 370         }
 371         case 4:
 372         {
 373           register unsigned char
 374             pixel;
 375
 376           for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
 377           {
 378             pixel=(unsigned char) ((*p >> 4) & 0xf);
 379             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 380               &range_exception));
 381             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 382               GetIndexPixelComponent(indexes+x));
 383             q++;
 384             pixel=(unsigned char) ((*p) & 0xf);
 385             SetIndexPixelComponent(indexes+x+1,PushColormapIndex(image,pixel,
 386               &range_exception));
 387             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 388               GetIndexPixelComponent(indexes+x+1));
 389             p++;
 390             q++;
 391           }
 392           for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
 393           {
 394             pixel=(unsigned char) ((*p++ >> 4) & 0xf);
 395             SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
 396               &range_exception));
 397             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 398               GetIndexPixelComponent(indexes+x+bit));
 399             q++;
 400           }
 401           break;
 402         }
 403         case 8:
 404         {
 405           unsigned char
 406             pixel;
 407
 408           for (x=0; x < (ssize_t) number_pixels; x++)
 409           {
 410             p=PushCharPixel(p,&pixel);
 411             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 412               &range_exception));
 413             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 414               GetIndexPixelComponent(indexes+x));
 415             p+=quantum_info->pad;
 416             q++;
 417           }
 418           break;
 419         }
 420         case 16:
 421         {
 422           unsigned short
 423             pixel;
 424
 425           if (quantum_info->format == FloatingPointQuantumFormat)
 426             {
 427               for (x=0; x < (ssize_t) number_pixels; x++)
 428               {
 429                 p=PushShortPixel(endian,p,&pixel);
 430                 SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
 431                   ClampToQuantum((MagickRealType) QuantumRange*
 432                   HalfToSinglePrecision(pixel)),&range_exception));
 433                 SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 434                   GetIndexPixelComponent(indexes+x));
 435                 p+=quantum_info->pad;
 436                 q++;
 437               }
 438               break;
 439             }
 440           for (x=0; x < (ssize_t) number_pixels; x++)
 441           {
 442             p=PushShortPixel(endian,p,&pixel);
 443             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 444               &range_exception));
 445             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 446               GetIndexPixelComponent(indexes+x));
 447             p+=quantum_info->pad;
 448             q++;
 449           }
 450           break;
 451         }
 452         case 32:
 453         {
 454           unsigned int
 455             pixel;
 456
 457           if (quantum_info->format == FloatingPointQuantumFormat)
 458             {
 459               float
 460                 pixel;
 461
 462               for (x=0; x < (ssize_t) number_pixels; x++)
 463               {
 464                 p=PushFloatPixel(&quantum_state,p,&pixel);
 465                 SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
 466                   ClampToQuantum(pixel),&range_exception));
 467                 SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 468                   GetIndexPixelComponent(indexes+x));
 469                 p+=quantum_info->pad;
 470                 q++;
 471               }
 472               break;
 473             }
 474           for (x=0; x < (ssize_t) number_pixels; x++)
 475           {
 476             p=PushLongPixel(endian,p,&pixel);
 477             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 478               &range_exception));
 479             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 480               GetIndexPixelComponent(indexes+x));
 481             p+=quantum_info->pad;
 482             q++;
 483           }
 484           break;
 485         }
 486         case 64:
 487         {
 488           if (quantum_info->format == FloatingPointQuantumFormat)
 489             {
 490               double
 491                 pixel;
 492
 493               for (x=0; x < (ssize_t) number_pixels; x++)
 494               {
 495                 p=PushDoublePixel(&quantum_state,p,&pixel);
 496                 SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
 497                   ClampToQuantum(pixel),&range_exception));
 498                 SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 499                   GetIndexPixelComponent(indexes+x));
 500                 p+=quantum_info->pad;
 501                 q++;
 502               }
 503               break;
 504             }
 505         }
 506         default:
 507         {
 508           for (x=0; x < (ssize_t) number_pixels; x++)
 509           {
 510             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 511             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 512               &range_exception));
 513             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 514               GetIndexPixelComponent(indexes+x));
 515             p+=quantum_info->pad;
 516             q++;
 517           }
 518           break;
 519         }
 520       }
 521       if (range_exception != MagickFalse)
 522         (void) ThrowMagickException(exception,GetMagickModule(),
 523           CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
 524       break;
 525     }
 526     case IndexAlphaQuantum:
 527     {
 528       MagickBooleanType
 529         range_exception;
 530
 531       if (image->storage_class != PseudoClass)
 532         {
 533           (void) ThrowMagickException(exception,GetMagickModule(),
 534             ImageError,"ColormappedImageRequired","`%s'",image->filename);
 535           return(extent);
 536         }
 537       range_exception=MagickFalse;
 538       switch (quantum_info->depth)
 539       {
 540         case 1:
 541         {
 542           register unsigned char
 543             pixel;
 544
 545           for (x=0; x < ((ssize_t) number_pixels-3); x+=4)
 546           {
 547             for (bit=0; bit < 8; bit+=2)
 548             {
 549               if (quantum_info->min_is_white == MagickFalse)
 550                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 551                   0x00 : 0x01);
 552               else
 553                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 554                   0x00 : 0x01);
 555               SetIndexPixelComponent(indexes+x+bit/2,pixel == 0 ? 0 : 1);
 556               SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
 557               SetGreenPixelComponent(q,GetRedPixelComponent(q));
 558               SetBluePixelComponent(q,GetRedPixelComponent(q));
 559               SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
 560                 (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
 561               q++;
 562             }
 563           }
 564           for (bit=0; bit < (ssize_t) (number_pixels % 4); bit+=2)
 565           {
 566             if (quantum_info->min_is_white == MagickFalse)
 567               pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 568                 0x00 : 0x01);
 569             else
 570               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 571                 0x00 : 0x01);
 572             SetIndexPixelComponent(indexes+x+bit/2,pixel == 0 ? 0 : 1);
 573             SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
 574             SetGreenPixelComponent(q,GetRedPixelComponent(q));
 575             SetBluePixelComponent(q,GetRedPixelComponent(q));
 576             SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
 577               (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
 578             q++;
 579           }
 580           break;
 581         }
 582         case 4:
 583         {
 584           register unsigned char
 585             pixel;
 586
 587           range=GetQuantumRange(image->depth);
 588           for (x=0; x < (ssize_t) number_pixels; x++)
 589           {
 590             pixel=(unsigned char) ((*p >> 4) & 0xf);
 591             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 592               &range_exception));
 593             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 594               GetIndexPixelComponent(indexes+x));
 595             pixel=(unsigned char) ((*p) & 0xf);
 596             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
 597               range));
 598             p++;
 599             q++;
 600           }
 601           break;
 602         }
 603         case 8:
 604         {
 605           unsigned char
 606             pixel;
 607
 608           for (x=0; x < (ssize_t) number_pixels; x++)
 609           {
 610             p=PushCharPixel(p,&pixel);
 611             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 612               &range_exception));
 613             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 614               GetIndexPixelComponent(indexes+x));
 615             p=PushCharPixel(p,&pixel);
 616             SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
 617             p+=quantum_info->pad;
 618             q++;
 619           }
 620           break;
 621         }
 622         case 16:
 623         {
 624           unsigned short
 625             pixel;
 626
 627           if (quantum_info->format == FloatingPointQuantumFormat)
 628             {
 629               for (x=0; x < (ssize_t) number_pixels; x++)
 630               {
 631                 p=PushShortPixel(endian,p,&pixel);
 632                 SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
 633                   ClampToQuantum((MagickRealType) QuantumRange*
 634                   HalfToSinglePrecision(pixel)),&range_exception));
 635                 SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 636                   GetIndexPixelComponent(indexes+x));
 637                 p=PushShortPixel(endian,p,&pixel);
 638                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
 639                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
 640                 p+=quantum_info->pad;
 641                 q++;
 642               }
 643               break;
 644             }
 645           for (x=0; x < (ssize_t) number_pixels; x++)
 646           {
 647             p=PushShortPixel(endian,p,&pixel);
 648             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 649               &range_exception));
 650             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 651               GetIndexPixelComponent(indexes+x));
 652             p=PushShortPixel(endian,p,&pixel);
 653             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
 654             p+=quantum_info->pad;
 655             q++;
 656           }
 657           break;
 658         }
 659         case 32:
 660         {
 661           unsigned int
 662             pixel;
 663
 664           if (quantum_info->format == FloatingPointQuantumFormat)
 665             {
 666               float
 667                 pixel;
 668
 669               for (x=0; x < (ssize_t) number_pixels; x++)
 670               {
 671                 p=PushFloatPixel(&quantum_state,p,&pixel);
 672                 SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
 673                   ClampToQuantum(pixel),&range_exception));
 674                 SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 675                   GetIndexPixelComponent(indexes+x));
 676                 p=PushFloatPixel(&quantum_state,p,&pixel);
 677                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
 678                 p+=quantum_info->pad;
 679                 q++;
 680               }
 681               break;
 682             }
 683           for (x=0; x < (ssize_t) number_pixels; x++)
 684           {
 685             p=PushLongPixel(endian,p,&pixel);
 686             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 687               &range_exception));
 688             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 689               GetIndexPixelComponent(indexes+x));
 690             p=PushLongPixel(endian,p,&pixel);
 691             SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(pixel));
 692             p+=quantum_info->pad;
 693             q++;
 694           }
 695           break;
 696         }
 697         case 64:
 698         {
 699           if (quantum_info->format == FloatingPointQuantumFormat)
 700             {
 701               double
 702                 pixel;
 703
 704               for (x=0; x < (ssize_t) number_pixels; x++)
 705               {
 706                 p=PushDoublePixel(&quantum_state,p,&pixel);
 707                 SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
 708                   ClampToQuantum(pixel),&range_exception));
 709                 SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 710                   GetIndexPixelComponent(indexes+x));
 711                 p=PushDoublePixel(&quantum_state,p,&pixel);
 712                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
 713                 p+=quantum_info->pad;
 714                 q++;
 715               }
 716               break;
 717             }
 718         }
 719         default:
 720         {
 721           range=GetQuantumRange(image->depth);
 722           for (x=0; x < (ssize_t) number_pixels; x++)
 723           {
 724             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 725             SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
 726               &range_exception));
 727             SetRGBOPixelComponents(q,image->colormap+(ssize_t)
 728               GetIndexPixelComponent(indexes+x));
 729             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 730             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
 731               range));
 732             p+=quantum_info->pad;
 733             q++;
 734           }
 735           break;
 736         }
 737       }
 738       if (range_exception != MagickFalse)
 739         (void) ThrowMagickException(exception,GetMagickModule(),
 740           CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
 741       break;
 742     }
 743     case BGRQuantum:
 744     {
 745       switch (quantum_info->depth)
 746       {
 747         case 8:
 748         {
 749           unsigned char
 750             pixel;
 751
 752           for (x=0; x < (ssize_t) number_pixels; x++)
 753           {
 754             p=PushCharPixel(p,&pixel);
 755             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
 756             p=PushCharPixel(p,&pixel);
 757             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
 758             p=PushCharPixel(p,&pixel);
 759             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
 760             SetOpacityPixelComponent(q,OpaqueOpacity);
 761             p+=quantum_info->pad;
 762             q++;
 763           }
 764           break;
 765         }
 766         case 10:
 767         {
 768           range=GetQuantumRange(image->depth);
 769           if (quantum_info->pack == MagickFalse)
 770             {
 771               for (x=0; x < (ssize_t) number_pixels; x++)
 772               {
 773                 p=PushLongPixel(endian,p,&pixel);
 774                 SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
 775                   range));
 776                 SetGreenPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
 777                   0x3ff,range));
 778                 SetBluePixelComponent(q,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
 779                   range));
 780                 p+=quantum_info->pad;
 781                 q++;
 782               }
 783               break;
 784             }
 785           if (quantum_info->quantum == 32U)
 786             {
 787               for (x=0; x < (ssize_t) number_pixels; x++)
 788               {
 789                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
 790                 SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
 791                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
 792                 SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 793                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
 794                 SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 795                 q++;
 796               }
 797               break;
 798             }
 799           for (x=0; x < (ssize_t) number_pixels; x++)
 800           {
 801             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 802             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
 803             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 804             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 805             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 806             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 807             q++;
 808           }
 809           break;
 810         }
 811         case 12:
 812         {
 813           range=GetQuantumRange(image->depth);
 814           if (quantum_info->pack == MagickFalse)
 815             {
 816               unsigned short
 817                 pixel;
 818
 819               for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
 820               {
 821                 p=PushShortPixel(endian,p,&pixel);
 822                 switch (x % 3)
 823                 {
 824                   default:
 825                   case 0:
 826                   {
 827                     SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 828                       (pixel >> 4),range));
 829                     break;
 830                   }
 831                   case 1:
 832                   {
 833                     SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 834                       (pixel >> 4),range));
 835                     break;
 836                   }
 837                   case 2:
 838                   {
 839                     SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 840                       (pixel >> 4),range));
 841                     q++;
 842                     break;
 843                   }
 844                 }
 845                 p=PushShortPixel(endian,p,&pixel);
 846                 switch ((x+1) % 3)
 847                 {
 848                   default:
 849                   case 0:
 850                   {
 851                     SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 852                       (pixel >> 4),range));
 853                     break;
 854                   }
 855                   case 1:
 856                   {
 857                     SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 858                       (pixel >> 4),range));
 859                     break;
 860                   }
 861                   case 2:
 862                   {
 863                     SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 864                       (pixel >> 4),range));
 865                     q++;
 866                     break;
 867                   }
 868                 }
 869                 p+=quantum_info->pad;
 870               }
 871               for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
 872               {
 873                 p=PushShortPixel(endian,p,&pixel);
 874                 switch ((x+bit) % 3)
 875                 {
 876                   default:
 877                   case 0:
 878                   {
 879                     SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 880                       (pixel >> 4),range));
 881                     break;
 882                   }
 883                   case 1:
 884                   {
 885                     SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 886                       (pixel >> 4),range));
 887                     break;
 888                   }
 889                   case 2:
 890                   {
 891                     SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
 892                       (pixel >> 4),range));
 893                     q++;
 894                     break;
 895                   }
 896                 }
 897                 p+=quantum_info->pad;
 898               }
 899               if (bit != 0)
 900                 p++;
 901               break;
 902             }
 903           if (quantum_info->quantum == 32U)
 904             {
 905               for (x=0; x < (ssize_t) number_pixels; x++)
 906               {
 907                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
 908                 SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
 909                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
 910                 SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 911                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
 912                 SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 913                 q++;
 914               }
 915               break;
 916             }
 917           for (x=0; x < (ssize_t) number_pixels; x++)
 918           {
 919             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 920             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
 921             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 922             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 923             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 924             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
 925             q++;
 926           }
 927           break;
 928         }
 929         case 16:
 930         {
 931           unsigned short
 932             pixel;
 933
 934           if (quantum_info->format == FloatingPointQuantumFormat)
 935             {
 936               for (x=0; x < (ssize_t) number_pixels; x++)
 937               {
 938                 p=PushShortPixel(endian,p,&pixel);
 939                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
 940                   QuantumRange*HalfToSinglePrecision(pixel)));
 941                 p=PushShortPixel(endian,p,&pixel);
 942                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
 943                   QuantumRange*HalfToSinglePrecision(pixel)));
 944                 p=PushShortPixel(endian,p,&pixel);
 945                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
 946                   QuantumRange*HalfToSinglePrecision(pixel)));
 947                 p+=quantum_info->pad;
 948                 q++;
 949               }
 950               break;
 951             }
 952           for (x=0; x < (ssize_t) number_pixels; x++)
 953           {
 954             p=PushShortPixel(endian,p,&pixel);
 955             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
 956             p=PushShortPixel(endian,p,&pixel);
 957             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
 958             p=PushShortPixel(endian,p,&pixel);
 959             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
 960             p+=quantum_info->pad;
 961             q++;
 962           }
 963           break;
 964         }
 965         case 32:
 966         {
 967           unsigned int
 968             pixel;
 969
 970           if (quantum_info->format == FloatingPointQuantumFormat)
 971             {
 972               float
 973                 pixel;
 974
 975               for (x=0; x < (ssize_t) number_pixels; x++)
 976               {
 977                 p=PushFloatPixel(&quantum_state,p,&pixel);
 978                 SetRedPixelComponent(q,ClampToQuantum(pixel));
 979                 p=PushFloatPixel(&quantum_state,p,&pixel);
 980                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
 981                 p=PushFloatPixel(&quantum_state,p,&pixel);
 982                 SetBluePixelComponent(q,ClampToQuantum(pixel));
 983                 p+=quantum_info->pad;
 984                 q++;
 985               }
 986               break;
 987             }
 988           for (x=0; x < (ssize_t) number_pixels; x++)
 989           {
 990             p=PushLongPixel(endian,p,&pixel);
 991             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
 992             p=PushLongPixel(endian,p,&pixel);
 993             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
 994             p=PushLongPixel(endian,p,&pixel);
 995             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
 996             p+=quantum_info->pad;
 997             q++;
 998           }
 999           break;
1000         }
1001         case 64:
1002         {
1003           if (quantum_info->format == FloatingPointQuantumFormat)
1004             {
1005               double
1006                 pixel;
1007
1008               for (x=0; x < (ssize_t) number_pixels; x++)
1009               {
1010                 p=PushDoublePixel(&quantum_state,p,&pixel);
1011                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1012                 p=PushDoublePixel(&quantum_state,p,&pixel);
1013                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
1014                 p=PushDoublePixel(&quantum_state,p,&pixel);
1015                 SetBluePixelComponent(q,ClampToQuantum(pixel));
1016                 p+=quantum_info->pad;
1017                 q++;
1018               }
1019               break;
1020             }
1021         }
1022         default:
1023         {
1024           range=GetQuantumRange(image->depth);
1025           for (x=0; x < (ssize_t) number_pixels; x++)
1026           {
1027             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1028             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
1029             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1030             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1031             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1032             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1033             q++;
1034           }
1035           break;
1036         }
1037       }
1038       break;
1039     }
1040     case BGRAQuantum:
1041     case BGROQuantum:
1042     {
1043       switch (quantum_info->depth)
1044       {
1045         case 8:
1046         {
1047           unsigned char
1048             pixel;
1049
1050           for (x=0; x < (ssize_t) number_pixels; x++)
1051           {
1052             p=PushCharPixel(p,&pixel);
1053             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
1054             p=PushCharPixel(p,&pixel);
1055             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
1056             p=PushCharPixel(p,&pixel);
1057             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
1058             p=PushCharPixel(p,&pixel);
1059             SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
1060             p+=quantum_info->pad;
1061             q++;
1062           }
1063           break;
1064         }
1065         case 10:
1066         {
1067           pixel=0;
1068           if (quantum_info->pack == MagickFalse)
1069             {
1070               register ssize_t
1071                 i;
1072
1073               size_t
1074                 quantum;
1075
1076               ssize_t
1077                 n;
1078
1079               n=0;
1080               quantum=0;
1081               for (x=0; x < (ssize_t) number_pixels; x++)
1082               {
1083                 for (i=0; i < 4; i++)
1084                 {
1085                   switch (n % 3)
1086                   {
1087                     case 0:
1088                     {
1089                       p=PushLongPixel(endian,p,&pixel);
1090                       quantum=(size_t) (ScaleShortToQuantum(
1091                         (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
1092                       break;
1093                     }
1094                     case 1:
1095                     {
1096                       quantum=(size_t) (ScaleShortToQuantum(
1097                         (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
1098                       break;
1099                     }
1100                     case 2:
1101                     {
1102                       quantum=(size_t) (ScaleShortToQuantum(
1103                         (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
1104                       break;
1105                     }
1106                   }
1107                   switch (i)
1108                   {
1109                     case 0: SetRedPixelComponent(q,quantum); break;
1110                     case 1: SetGreenPixelComponent(q,quantum); break;
1111                     case 2: SetBluePixelComponent(q,quantum); break;
1112                     case 3: SetOpacityPixelComponent(q,QuantumRange-quantum); break;
1113                   }
1114                   n++;
1115                 }
1116                 p+=quantum_info->pad;
1117                 q++;
1118               }
1119               break;
1120             }
1121           for (x=0; x < (ssize_t) number_pixels; x++)
1122           {
1123             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1124             SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
1125               (pixel << 6)));
1126             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1127             SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
1128               (pixel << 6)));
1129             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1130             SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
1131               (pixel << 6)));
1132             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1133             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(
1134               (unsigned short) (pixel << 6)));
1135             q++;
1136           }
1137           break;
1138         }
1139         case 16:
1140         {
1141           unsigned short
1142             pixel;
1143
1144           if (quantum_info->format == FloatingPointQuantumFormat)
1145             {
1146               for (x=0; x < (ssize_t) number_pixels; x++)
1147               {
1148                 p=PushShortPixel(endian,p,&pixel);
1149                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
1150                   QuantumRange*HalfToSinglePrecision(pixel)));
1151                 p=PushShortPixel(endian,p,&pixel);
1152                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
1153                   QuantumRange*HalfToSinglePrecision(pixel)));
1154                 p=PushShortPixel(endian,p,&pixel);
1155                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
1156                   QuantumRange*HalfToSinglePrecision(pixel)));
1157                 p=PushShortPixel(endian,p,&pixel);
1158                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
1159                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
1160                 p+=quantum_info->pad;
1161                 q++;
1162               }
1163               break;
1164             }
1165           for (x=0; x < (ssize_t) number_pixels; x++)
1166           {
1167             p=PushShortPixel(endian,p,&pixel);
1168             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
1169             p=PushShortPixel(endian,p,&pixel);
1170             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
1171             p=PushShortPixel(endian,p,&pixel);
1172             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
1173             p=PushShortPixel(endian,p,&pixel);
1174             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
1175             p+=quantum_info->pad;
1176             q++;
1177           }
1178           break;
1179         }
1180         case 32:
1181         {
1182           unsigned int
1183             pixel;
1184
1185           if (quantum_info->format == FloatingPointQuantumFormat)
1186             {
1187               float
1188                 pixel;
1189
1190               for (x=0; x < (ssize_t) number_pixels; x++)
1191               {
1192                 p=PushFloatPixel(&quantum_state,p,&pixel);
1193                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1194                 p=PushFloatPixel(&quantum_state,p,&pixel);
1195                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
1196                 p=PushFloatPixel(&quantum_state,p,&pixel);
1197                 SetBluePixelComponent(q,ClampToQuantum(pixel));
1198                 p=PushFloatPixel(&quantum_state,p,&pixel);
1199                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
1200                 p+=quantum_info->pad;
1201                 q++;
1202               }
1203               break;
1204             }
1205           for (x=0; x < (ssize_t) number_pixels; x++)
1206           {
1207             p=PushLongPixel(endian,p,&pixel);
1208             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
1209             p=PushLongPixel(endian,p,&pixel);
1210             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
1211             p=PushLongPixel(endian,p,&pixel);
1212             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
1213             p=PushLongPixel(endian,p,&pixel);
1214             SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(pixel));
1215             p+=quantum_info->pad;
1216             q++;
1217           }
1218           break;
1219         }
1220         case 64:
1221         {
1222           if (quantum_info->format == FloatingPointQuantumFormat)
1223             {
1224               double
1225                 pixel;
1226
1227               for (x=0; x < (ssize_t) number_pixels; x++)
1228               {
1229                 p=PushDoublePixel(&quantum_state,p,&pixel);
1230                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1231                 p=PushDoublePixel(&quantum_state,p,&pixel);
1232                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
1233                 p=PushDoublePixel(&quantum_state,p,&pixel);
1234                 SetBluePixelComponent(q,ClampToQuantum(pixel));
1235                 p=PushDoublePixel(&quantum_state,p,&pixel);
1236                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
1237                 p+=quantum_info->pad;
1238                 q++;
1239               }
1240               break;
1241             }
1242         }
1243         default:
1244         {
1245           range=GetQuantumRange(image->depth);
1246           for (x=0; x < (ssize_t) number_pixels; x++)
1247           {
1248             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1249             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
1250             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1251             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1252             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1253             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1254             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1255             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
1256               range));
1257             q++;
1258           }
1259           break;
1260         }
1261       }
1262       break;
1263     }
1264     case GrayQuantum:
1265     {
1266       switch (quantum_info->depth)
1267       {
1268         case 1:
1269         {
1270           register Quantum
1271             black,
1272             white;
1273
1274           black=0;
1275           white=(Quantum) QuantumRange;
1276           if (quantum_info->min_is_white != MagickFalse)
1277             {
1278               black=(Quantum) QuantumRange;
1279               white=0;
1280             }
1281           for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
1282           {
1283             for (bit=0; bit < 8; bit++)
1284             {
1285               SetRedPixelComponent(q,((*p) & (1 << (7-bit))) == 0 ?
1286                 black : white);
1287               SetGreenPixelComponent(q,GetRedPixelComponent(q));
1288               SetBluePixelComponent(q,GetRedPixelComponent(q));
1289               q++;
1290             }
1291             p++;
1292           }
1293           for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
1294           {
1295             SetRedPixelComponent(q,((*p) & (0x01 << (7-bit))) == 0 ?
1296               black : white);
1297             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1298             SetBluePixelComponent(q,GetRedPixelComponent(q));
1299             q++;
1300           }
1301           if (bit != 0)
1302             p++;
1303           break;
1304         }
1305         case 4:
1306         {
1307           register unsigned char
1308             pixel;
1309
1310           range=GetQuantumRange(image->depth);
1311           for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
1312           {
1313             pixel=(unsigned char) ((*p >> 4) & 0xf);
1314             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1315             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1316             SetBluePixelComponent(q,GetRedPixelComponent(q));
1317             q++;
1318             pixel=(unsigned char) ((*p) & 0xf);
1319             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1320             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1321             SetBluePixelComponent(q,GetRedPixelComponent(q));
1322             p++;
1323             q++;
1324           }
1325           for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
1326           {
1327             pixel=(unsigned char) (*p++ >> 4);
1328             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1329             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1330             SetBluePixelComponent(q,GetRedPixelComponent(q));
1331             q++;
1332           }
1333           break;
1334         }
1335         case 8:
1336         {
1337           unsigned char
1338             pixel;
1339
1340           if (quantum_info->min_is_white != MagickFalse)
1341             {
1342               for (x=0; x < (ssize_t) number_pixels; x++)
1343               {
1344                 p=PushCharPixel(p,&pixel);
1345                 SetRedPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
1346                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1347                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1348                 SetOpacityPixelComponent(q,OpaqueOpacity);
1349                 p+=quantum_info->pad;
1350                 q++;
1351               }
1352               break;
1353             }
1354           for (x=0; x < (ssize_t) number_pixels; x++)
1355           {
1356             p=PushCharPixel(p,&pixel);
1357             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
1358             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1359             SetBluePixelComponent(q,GetRedPixelComponent(q));
1360             SetOpacityPixelComponent(q,OpaqueOpacity);
1361             p+=quantum_info->pad;
1362             q++;
1363           }
1364           break;
1365         }
1366         case 10:
1367         {
1368           range=GetQuantumRange(image->depth);
1369           if (quantum_info->pack == MagickFalse)
1370             {
1371               if (image->endian != LSBEndian)
1372                 {
1373                   for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
1374                   {
1375                     p=PushLongPixel(endian,p,&pixel);
1376                     SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
1377                       0x3ff,range));
1378                     SetGreenPixelComponent(q,GetRedPixelComponent(q));
1379                     SetBluePixelComponent(q,GetRedPixelComponent(q));
1380                     q++;
1381                     SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
1382                       0x3ff,range));
1383                     SetGreenPixelComponent(q,GetRedPixelComponent(q));
1384                     SetBluePixelComponent(q,GetRedPixelComponent(q));
1385                     q++;
1386                     SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
1387                       0x3ff,range));
1388                     SetGreenPixelComponent(q,GetRedPixelComponent(q));
1389                     SetBluePixelComponent(q,GetRedPixelComponent(q));
1390                     p+=quantum_info->pad;
1391                     q++;
1392                   }
1393                   p=PushLongPixel(endian,p,&pixel);
1394                   if (x++ < (ssize_t) (number_pixels-1))
1395                     {
1396                       SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
1397                         0x3ff,range));
1398                       SetGreenPixelComponent(q,GetRedPixelComponent(q));
1399                       SetBluePixelComponent(q,GetRedPixelComponent(q));
1400                       q++;
1401                     }
1402                   if (x++ < (ssize_t) number_pixels)
1403                     {
1404                       SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
1405                         0x3ff,range));
1406                       SetGreenPixelComponent(q,GetRedPixelComponent(q));
1407                       SetBluePixelComponent(q,GetRedPixelComponent(q));
1408                       q++;
1409                     }
1410                   break;
1411                 }
1412               for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
1413               {
1414                 p=PushLongPixel(endian,p,&pixel);
1415                 SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
1416                   0x3ff,range));
1417                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1418                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1419                 q++;
1420                 SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
1421                   0x3ff,range));
1422                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1423                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1424                 q++;
1425                 SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
1426                   0x3ff,range));
1427                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1428                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1429                 p+=quantum_info->pad;
1430                 q++;
1431               }
1432               p=PushLongPixel(endian,p,&pixel);
1433               if (x++ < (ssize_t) (number_pixels-1))
1434                 {
1435                   SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
1436                     0x3ff,range));
1437                   SetGreenPixelComponent(q,GetRedPixelComponent(q));
1438                   SetBluePixelComponent(q,GetRedPixelComponent(q));
1439                   q++;
1440                 }
1441               if (x++ < (ssize_t) number_pixels)
1442                 {
1443                   SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
1444                     0x3ff,range));
1445                   SetGreenPixelComponent(q,GetRedPixelComponent(q));
1446                   SetBluePixelComponent(q,GetRedPixelComponent(q));
1447                   q++;
1448                 }
1449               break;
1450             }
1451           for (x=0; x < (ssize_t) number_pixels; x++)
1452           {
1453             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1454             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1455             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1456             SetBluePixelComponent(q,GetRedPixelComponent(q));
1457             p+=quantum_info->pad;
1458             q++;
1459           }
1460           break;
1461         }
1462         case 12:
1463         {
1464           range=GetQuantumRange(image->depth);
1465           if (quantum_info->pack == MagickFalse)
1466             {
1467               unsigned short
1468                 pixel;
1469
1470               for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
1471               {
1472                 p=PushShortPixel(endian,p,&pixel);
1473                 SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
1474                   (pixel >> 4),range));
1475                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1476                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1477                 q++;
1478                 p=PushShortPixel(endian,p,&pixel);
1479                 SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
1480                   (pixel >> 4),range));
1481                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1482                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1483                 p+=quantum_info->pad;
1484                 q++;
1485               }
1486               for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
1487               {
1488                 p=PushShortPixel(endian,p,&pixel);
1489                 SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
1490                   (pixel >> 4),range));
1491                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1492                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1493                 p+=quantum_info->pad;
1494                 q++;
1495               }
1496               if (bit != 0)
1497                 p++;
1498               break;
1499             }
1500           for (x=0; x < (ssize_t) number_pixels; x++)
1501           {
1502             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1503             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1504             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1505             SetBluePixelComponent(q,GetRedPixelComponent(q));
1506             p+=quantum_info->pad;
1507             q++;
1508           }
1509           break;
1510         }
1511         case 16:
1512         {
1513           unsigned short
1514             pixel;
1515
1516           if (quantum_info->min_is_white != MagickFalse)
1517             {
1518               for (x=0; x < (ssize_t) number_pixels; x++)
1519               {
1520                 p=PushShortPixel(endian,p,&pixel);
1521                 SetRedPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
1522                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1523                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1524                 p+=quantum_info->pad;
1525                 q++;
1526               }
1527               break;
1528             }
1529           if (quantum_info->format == FloatingPointQuantumFormat)
1530             {
1531               for (x=0; x < (ssize_t) number_pixels; x++)
1532               {
1533                 p=PushShortPixel(endian,p,&pixel);
1534                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
1535                   QuantumRange*HalfToSinglePrecision(pixel)));
1536                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1537                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1538                 p+=quantum_info->pad;
1539                 q++;
1540               }
1541               break;
1542             }
1543           for (x=0; x < (ssize_t) number_pixels; x++)
1544           {
1545             p=PushShortPixel(endian,p,&pixel);
1546             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
1547             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1548             SetBluePixelComponent(q,GetRedPixelComponent(q));
1549             p+=quantum_info->pad;
1550             q++;
1551           }
1552           break;
1553         }
1554         case 32:
1555         {
1556           unsigned int
1557             pixel;
1558
1559           if (quantum_info->format == FloatingPointQuantumFormat)
1560             {
1561               float
1562                 pixel;
1563
1564               for (x=0; x < (ssize_t) number_pixels; x++)
1565               {
1566                 p=PushFloatPixel(&quantum_state,p,&pixel);
1567                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1568                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1569                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1570                 p+=quantum_info->pad;
1571                 q++;
1572               }
1573               break;
1574             }
1575           for (x=0; x < (ssize_t) number_pixels; x++)
1576           {
1577             p=PushLongPixel(endian,p,&pixel);
1578             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
1579             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1580             SetBluePixelComponent(q,GetRedPixelComponent(q));
1581             p+=quantum_info->pad;
1582             q++;
1583           }
1584           break;
1585         }
1586         case 64:
1587         {
1588           if (quantum_info->format == FloatingPointQuantumFormat)
1589             {
1590               double
1591                 pixel;
1592
1593               for (x=0; x < (ssize_t) number_pixels; x++)
1594               {
1595                 p=PushDoublePixel(&quantum_state,p,&pixel);
1596                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1597                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1598                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1599                 p+=quantum_info->pad;
1600                 q++;
1601               }
1602               break;
1603             }
1604         }
1605         default:
1606         {
1607           range=GetQuantumRange(image->depth);
1608           for (x=0; x < (ssize_t) number_pixels; x++)
1609           {
1610             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1611             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1612             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1613             SetBluePixelComponent(q,GetRedPixelComponent(q));
1614             p+=quantum_info->pad;
1615             q++;
1616           }
1617           break;
1618         }
1619       }
1620       break;
1621     }
1622     case GrayAlphaQuantum:
1623     {
1624       switch (quantum_info->depth)
1625       {
1626         case 1:
1627         {
1628           register unsigned char
1629             pixel;
1630
1631           for (x=0; x < ((ssize_t) number_pixels-3); x+=4)
1632           {
1633             for (bit=0; bit < 8; bit+=2)
1634             {
1635               pixel=(unsigned char)
1636                 (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
1637               SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
1638               SetGreenPixelComponent(q,GetRedPixelComponent(q));
1639               SetBluePixelComponent(q,GetRedPixelComponent(q));
1640               SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
1641                 (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
1642               q++;
1643             }
1644             p++;
1645           }
1646           for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
1647           {
1648             pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
1649             SetRedPixelComponent(q,pixel != 0 ? 0 : QuantumRange);
1650             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1651             SetBluePixelComponent(q,GetRedPixelComponent(q));
1652             SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
1653               (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
1654             q++;
1655           }
1656           if (bit != 0)
1657             p++;
1658           break;
1659         }
1660         case 4:
1661         {
1662           register unsigned char
1663             pixel;
1664
1665           range=GetQuantumRange(image->depth);
1666           for (x=0; x < (ssize_t) number_pixels; x++)
1667           {
1668             pixel=(unsigned char) ((*p >> 4) & 0xf);
1669             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1670             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1671             SetBluePixelComponent(q,GetRedPixelComponent(q));
1672             pixel=(unsigned char) ((*p) & 0xf);
1673             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
1674               range));
1675             p++;
1676             q++;
1677           }
1678           break;
1679         }
1680         case 8:
1681         {
1682           unsigned char
1683             pixel;
1684
1685           for (x=0; x < (ssize_t) number_pixels; x++)
1686           {
1687             p=PushCharPixel(p,&pixel);
1688             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
1689             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1690             SetBluePixelComponent(q,GetRedPixelComponent(q));
1691             p=PushCharPixel(p,&pixel);
1692             SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
1693             p+=quantum_info->pad;
1694             q++;
1695           }
1696           break;
1697         }
1698         case 10:
1699         {
1700           range=GetQuantumRange(image->depth);
1701           for (x=0; x < (ssize_t) number_pixels; x++)
1702           {
1703             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1704             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1705             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1706             SetBluePixelComponent(q,GetRedPixelComponent(q));
1707             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1708             SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1709             p+=quantum_info->pad;
1710             q++;
1711           }
1712           break;
1713         }
1714         case 12:
1715         {
1716           range=GetQuantumRange(image->depth);
1717           for (x=0; x < (ssize_t) number_pixels; x++)
1718           {
1719             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1720             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1721             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1722             SetBluePixelComponent(q,GetRedPixelComponent(q));
1723             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1724             SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1725             p+=quantum_info->pad;
1726             q++;
1727           }
1728           break;
1729         }
1730         case 16:
1731         {
1732           unsigned short
1733             pixel;
1734
1735           if (quantum_info->format == FloatingPointQuantumFormat)
1736             {
1737               for (x=0; x < (ssize_t) number_pixels; x++)
1738               {
1739                 p=PushShortPixel(endian,p,&pixel);
1740                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
1741                   QuantumRange*HalfToSinglePrecision(pixel)));
1742                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1743                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1744                 p=PushShortPixel(endian,p,&pixel);
1745                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
1746                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
1747                 p+=quantum_info->pad;
1748                 q++;
1749               }
1750               break;
1751             }
1752           for (x=0; x < (ssize_t) number_pixels; x++)
1753           {
1754             p=PushShortPixel(endian,p,&pixel);
1755             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
1756             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1757             SetBluePixelComponent(q,GetRedPixelComponent(q));
1758             p=PushShortPixel(endian,p,&pixel);
1759             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
1760             p+=quantum_info->pad;
1761             q++;
1762           }
1763           break;
1764         }
1765         case 32:
1766         {
1767           unsigned int
1768             pixel;
1769
1770           if (quantum_info->format == FloatingPointQuantumFormat)
1771             {
1772               float
1773                 pixel;
1774
1775               for (x=0; x < (ssize_t) number_pixels; x++)
1776               {
1777                 p=PushFloatPixel(&quantum_state,p,&pixel);
1778                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1779                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1780                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1781                 p=PushFloatPixel(&quantum_state,p,&pixel);
1782                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
1783                 p+=quantum_info->pad;
1784                 q++;
1785               }
1786               break;
1787             }
1788           for (x=0; x < (ssize_t) number_pixels; x++)
1789           {
1790             p=PushLongPixel(endian,p,&pixel);
1791             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
1792             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1793             SetBluePixelComponent(q,GetRedPixelComponent(q));
1794             p=PushLongPixel(endian,p,&pixel);
1795             SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(pixel));
1796             p+=quantum_info->pad;
1797             q++;
1798           }
1799           break;
1800         }
1801         case 64:
1802         {
1803           if (quantum_info->format == FloatingPointQuantumFormat)
1804             {
1805               double
1806                 pixel;
1807
1808               for (x=0; x < (ssize_t) number_pixels; x++)
1809               {
1810                 p=PushDoublePixel(&quantum_state,p,&pixel);
1811                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1812                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1813                 SetBluePixelComponent(q,GetRedPixelComponent(q));
1814                 p=PushDoublePixel(&quantum_state,p,&pixel);
1815                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
1816                 p+=quantum_info->pad;
1817                 q++;
1818               }
1819               break;
1820             }
1821         }
1822         default:
1823         {
1824           range=GetQuantumRange(image->depth);
1825           for (x=0; x < (ssize_t) number_pixels; x++)
1826           {
1827             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1828             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1829             SetGreenPixelComponent(q,GetRedPixelComponent(q));
1830             SetBluePixelComponent(q,GetRedPixelComponent(q));
1831             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1832             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
1833               range));
1834             p+=quantum_info->pad;
1835             q++;
1836           }
1837           break;
1838         }
1839       }
1840       break;
1841     }
1842     case RedQuantum:
1843     case CyanQuantum:
1844     {
1845       switch (quantum_info->depth)
1846       {
1847         case 8:
1848         {
1849           unsigned char
1850             pixel;
1851
1852           for (x=0; x < (ssize_t) number_pixels; x++)
1853           {
1854             p=PushCharPixel(p,&pixel);
1855             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
1856             p+=quantum_info->pad;
1857             q++;
1858           }
1859           break;
1860         }
1861         case 16:
1862         {
1863           unsigned short
1864             pixel;
1865
1866           if (quantum_info->format == FloatingPointQuantumFormat)
1867             {
1868               for (x=0; x < (ssize_t) number_pixels; x++)
1869               {
1870                 p=PushShortPixel(endian,p,&pixel);
1871                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
1872                   QuantumRange*HalfToSinglePrecision(pixel)));
1873                 p+=quantum_info->pad;
1874                 q++;
1875               }
1876               break;
1877             }
1878           for (x=0; x < (ssize_t) number_pixels; x++)
1879           {
1880             p=PushShortPixel(endian,p,&pixel);
1881             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
1882             p+=quantum_info->pad;
1883             q++;
1884           }
1885           break;
1886         }
1887         case 32:
1888         {
1889           unsigned int
1890             pixel;
1891
1892           if (quantum_info->format == FloatingPointQuantumFormat)
1893             {
1894               float
1895                 pixel;
1896
1897               for (x=0; x < (ssize_t) number_pixels; x++)
1898               {
1899                 p=PushFloatPixel(&quantum_state,p,&pixel);
1900                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1901                 p+=quantum_info->pad;
1902                 q++;
1903               }
1904               break;
1905             }
1906           for (x=0; x < (ssize_t) number_pixels; x++)
1907           {
1908             p=PushLongPixel(endian,p,&pixel);
1909             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
1910             p+=quantum_info->pad;
1911             q++;
1912           }
1913           break;
1914         }
1915         case 64:
1916         {
1917           if (quantum_info->format == FloatingPointQuantumFormat)
1918             {
1919               double
1920                 pixel;
1921
1922               for (x=0; x < (ssize_t) number_pixels; x++)
1923               {
1924                 p=PushDoublePixel(&quantum_state,p,&pixel);
1925                 SetRedPixelComponent(q,ClampToQuantum(pixel));
1926                 p+=quantum_info->pad;
1927                 q++;
1928               }
1929               break;
1930             }
1931         }
1932         default:
1933         {
1934           range=GetQuantumRange(image->depth);
1935           for (x=0; x < (ssize_t) number_pixels; x++)
1936           {
1937             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1938             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
1939             p+=quantum_info->pad;
1940             q++;
1941           }
1942           break;
1943         }
1944       }
1945       break;
1946     }
1947     case GreenQuantum:
1948     case MagentaQuantum:
1949     {
1950       switch (quantum_info->depth)
1951       {
1952         case 8:
1953         {
1954           unsigned char
1955             pixel;
1956
1957           for (x=0; x < (ssize_t) number_pixels; x++)
1958           {
1959             p=PushCharPixel(p,&pixel);
1960             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
1961             p+=quantum_info->pad;
1962             q++;
1963           }
1964           break;
1965         }
1966         case 16:
1967         {
1968           unsigned short
1969             pixel;
1970
1971           if (quantum_info->format == FloatingPointQuantumFormat)
1972             {
1973               for (x=0; x < (ssize_t) number_pixels; x++)
1974               {
1975                 p=PushShortPixel(endian,p,&pixel);
1976                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
1977                   QuantumRange*HalfToSinglePrecision(pixel)));
1978                 p+=quantum_info->pad;
1979                 q++;
1980               }
1981               break;
1982             }
1983           for (x=0; x < (ssize_t) number_pixels; x++)
1984           {
1985             p=PushShortPixel(endian,p,&pixel);
1986             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
1987             p+=quantum_info->pad;
1988             q++;
1989           }
1990           break;
1991         }
1992         case 32:
1993         {
1994           unsigned int
1995             pixel;
1996
1997           if (quantum_info->format == FloatingPointQuantumFormat)
1998             {
1999               float
2000                 pixel;
2001
2002               for (x=0; x < (ssize_t) number_pixels; x++)
2003               {
2004                 p=PushFloatPixel(&quantum_state,p,&pixel);
2005                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
2006                 p+=quantum_info->pad;
2007                 q++;
2008               }
2009               break;
2010             }
2011           for (x=0; x < (ssize_t) number_pixels; x++)
2012           {
2013             p=PushLongPixel(endian,p,&pixel);
2014             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
2015             p+=quantum_info->pad;
2016             q++;
2017           }
2018           break;
2019         }
2020         case 64:
2021         {
2022           if (quantum_info->format == FloatingPointQuantumFormat)
2023             {
2024               double
2025                 pixel;
2026
2027               for (x=0; x < (ssize_t) number_pixels; x++)
2028               {
2029                 p=PushDoublePixel(&quantum_state,p,&pixel);
2030                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
2031                 p+=quantum_info->pad;
2032                 q++;
2033               }
2034               break;
2035             }
2036         }
2037         default:
2038         {
2039           range=GetQuantumRange(image->depth);
2040           for (x=0; x < (ssize_t) number_pixels; x++)
2041           {
2042             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2043             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2044             p+=quantum_info->pad;
2045             q++;
2046           }
2047           break;
2048         }
2049       }
2050       break;
2051     }
2052     case BlueQuantum:
2053     case YellowQuantum:
2054     {
2055       switch (quantum_info->depth)
2056       {
2057         case 8:
2058         {
2059           unsigned char
2060             pixel;
2061
2062           for (x=0; x < (ssize_t) number_pixels; x++)
2063           {
2064             p=PushCharPixel(p,&pixel);
2065             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
2066             p+=quantum_info->pad;
2067             q++;
2068           }
2069           break;
2070         }
2071         case 16:
2072         {
2073           unsigned short
2074             pixel;
2075
2076           if (quantum_info->format == FloatingPointQuantumFormat)
2077             {
2078               for (x=0; x < (ssize_t) number_pixels; x++)
2079               {
2080                 p=PushShortPixel(endian,p,&pixel);
2081                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2082                   QuantumRange*HalfToSinglePrecision(pixel)));
2083                 p+=quantum_info->pad;
2084                 q++;
2085               }
2086               break;
2087             }
2088           for (x=0; x < (ssize_t) number_pixels; x++)
2089           {
2090             p=PushShortPixel(endian,p,&pixel);
2091             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
2092             p+=quantum_info->pad;
2093             q++;
2094           }
2095           break;
2096         }
2097         case 32:
2098         {
2099           unsigned int
2100             pixel;
2101
2102           if (quantum_info->format == FloatingPointQuantumFormat)
2103             {
2104               float
2105                 pixel;
2106
2107               for (x=0; x < (ssize_t) number_pixels; x++)
2108               {
2109                 p=PushFloatPixel(&quantum_state,p,&pixel);
2110                 SetBluePixelComponent(q,ClampToQuantum(pixel));
2111                 p+=quantum_info->pad;
2112                 q++;
2113               }
2114               break;
2115             }
2116           for (x=0; x < (ssize_t) number_pixels; x++)
2117           {
2118             p=PushLongPixel(endian,p,&pixel);
2119             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
2120             p+=quantum_info->pad;
2121             q++;
2122           }
2123           break;
2124         }
2125         case 64:
2126         {
2127           if (quantum_info->format == FloatingPointQuantumFormat)
2128             {
2129               double
2130                 pixel;
2131
2132               for (x=0; x < (ssize_t) number_pixels; x++)
2133               {
2134                 p=PushDoublePixel(&quantum_state,p,&pixel);
2135                 SetBluePixelComponent(q,ClampToQuantum(pixel));
2136                 p+=quantum_info->pad;
2137                 q++;
2138               }
2139               break;
2140             }
2141         }
2142         default:
2143         {
2144           range=GetQuantumRange(image->depth);
2145           for (x=0; x < (ssize_t) number_pixels; x++)
2146           {
2147             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2148             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
2149             p+=quantum_info->pad;
2150             q++;
2151           }
2152           break;
2153         }
2154       }
2155       break;
2156     }
2157     case AlphaQuantum:
2158     {
2159       switch (quantum_info->depth)
2160       {
2161         case 8:
2162         {
2163           unsigned char
2164             pixel;
2165
2166           for (x=0; x < (ssize_t) number_pixels; x++)
2167           {
2168             p=PushCharPixel(p,&pixel);
2169             SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
2170             p+=quantum_info->pad;
2171             q++;
2172           }
2173           break;
2174         }
2175         case 16:
2176         {
2177           unsigned short
2178             pixel;
2179
2180           if (quantum_info->format == FloatingPointQuantumFormat)
2181             {
2182               for (x=0; x < (ssize_t) number_pixels; x++)
2183               {
2184                 p=PushShortPixel(endian,p,&pixel);
2185                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
2186                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
2187                 p+=quantum_info->pad;
2188                 q++;
2189               }
2190               break;
2191             }
2192           for (x=0; x < (ssize_t) number_pixels; x++)
2193           {
2194             p=PushShortPixel(endian,p,&pixel);
2195             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
2196             p+=quantum_info->pad;
2197             q++;
2198           }
2199           break;
2200         }
2201         case 32:
2202         {
2203           unsigned int
2204             pixel;
2205
2206           if (quantum_info->format == FloatingPointQuantumFormat)
2207             {
2208               float
2209                 pixel;
2210
2211               for (x=0; x < (ssize_t) number_pixels; x++)
2212               {
2213                 p=PushFloatPixel(&quantum_state,p,&pixel);
2214                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
2215                 p+=quantum_info->pad;
2216                 q++;
2217               }
2218               break;
2219             }
2220           for (x=0; x < (ssize_t) number_pixels; x++)
2221           {
2222             p=PushLongPixel(endian,p,&pixel);
2223             SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(pixel));
2224             p+=quantum_info->pad;
2225             q++;
2226           }
2227           break;
2228         }
2229         case 64:
2230         {
2231           if (quantum_info->format == FloatingPointQuantumFormat)
2232             {
2233               double
2234                 pixel;
2235
2236               for (x=0; x < (ssize_t) number_pixels; x++)
2237               {
2238                 p=PushDoublePixel(&quantum_state,p,&pixel);
2239                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
2240                 p+=quantum_info->pad;
2241                 q++;
2242               }
2243               break;
2244             }
2245         }
2246         default:
2247         {
2248           range=GetQuantumRange(image->depth);
2249           for (x=0; x < (ssize_t) number_pixels; x++)
2250           {
2251             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2252             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
2253               range));
2254             p+=quantum_info->pad;
2255             q++;
2256           }
2257           break;
2258         }
2259       }
2260       break;
2261     }
2262     case BlackQuantum:
2263     {
2264       if (image->colorspace != CMYKColorspace)
2265         {
2266           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2267             "ColorSeparatedImageRequired","`%s'",image->filename);
2268           return(extent);
2269         }
2270       switch (quantum_info->depth)
2271       {
2272         case 8:
2273         {
2274           unsigned char
2275             pixel;
2276
2277           for (x=0; x < (ssize_t) number_pixels; x++)
2278           {
2279             p=PushCharPixel(p,&pixel);
2280             SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
2281             p+=quantum_info->pad;
2282           }
2283           break;
2284         }
2285         case 16:
2286         {
2287           unsigned short
2288             pixel;
2289
2290           if (quantum_info->format == FloatingPointQuantumFormat)
2291             {
2292               for (x=0; x < (ssize_t) number_pixels; x++)
2293               {
2294                 p=PushShortPixel(endian,p,&pixel);
2295                 SetIndexPixelComponent(indexes+x,ClampToQuantum((MagickRealType)
2296                   QuantumRange*HalfToSinglePrecision(pixel)));
2297                 p+=quantum_info->pad;
2298               }
2299               break;
2300             }
2301           for (x=0; x < (ssize_t) number_pixels; x++)
2302           {
2303             p=PushShortPixel(endian,p,&pixel);
2304             SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
2305             p+=quantum_info->pad;
2306           }
2307           break;
2308         }
2309         case 32:
2310         {
2311           unsigned int
2312             pixel;
2313
2314           if (quantum_info->format == FloatingPointQuantumFormat)
2315             {
2316               float
2317                 pixel;
2318
2319               for (x=0; x < (ssize_t) number_pixels; x++)
2320               {
2321                 p=PushFloatPixel(&quantum_state,p,&pixel);
2322                 SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
2323                 p+=quantum_info->pad;
2324                 q++;
2325               }
2326               break;
2327             }
2328           for (x=0; x < (ssize_t) number_pixels; x++)
2329           {
2330             p=PushLongPixel(endian,p,&pixel);
2331             SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
2332             p+=quantum_info->pad;
2333             q++;
2334           }
2335           break;
2336         }
2337         case 64:
2338         {
2339           if (quantum_info->format == FloatingPointQuantumFormat)
2340             {
2341               double
2342                 pixel;
2343
2344               for (x=0; x < (ssize_t) number_pixels; x++)
2345               {
2346                 p=PushDoublePixel(&quantum_state,p,&pixel);
2347                 SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
2348                 p+=quantum_info->pad;
2349                 q++;
2350               }
2351               break;
2352             }
2353         }
2354         default:
2355         {
2356           range=GetQuantumRange(image->depth);
2357           for (x=0; x < (ssize_t) number_pixels; x++)
2358           {
2359             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2360             SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
2361             p+=quantum_info->pad;
2362             q++;
2363           }
2364           break;
2365         }
2366       }
2367       break;
2368     }
2369     case RGBQuantum:
2370     case CbYCrQuantum:
2371     {
2372       switch (quantum_info->depth)
2373       {
2374         case 8:
2375         {
2376           unsigned char
2377             pixel;
2378
2379           for (x=0; x < (ssize_t) number_pixels; x++)
2380           {
2381             p=PushCharPixel(p,&pixel);
2382             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
2383             p=PushCharPixel(p,&pixel);
2384             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
2385             p=PushCharPixel(p,&pixel);
2386             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
2387             SetOpacityPixelComponent(q,OpaqueOpacity);
2388             p+=quantum_info->pad;
2389             q++;
2390           }
2391           break;
2392         }
2393         case 10:
2394         {
2395           range=GetQuantumRange(image->depth);
2396           if (quantum_info->pack == MagickFalse)
2397             {
2398               for (x=0; x < (ssize_t) number_pixels; x++)
2399               {
2400                 p=PushLongPixel(endian,p,&pixel);
2401                 SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
2402                   0x3ff,range));
2403                 SetGreenPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
2404                   0x3ff,range));
2405                 SetBluePixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
2406                   0x3ff,range));
2407                 p+=quantum_info->pad;
2408                 q++;
2409               }
2410               break;
2411             }
2412           if (quantum_info->quantum == 32U)
2413             {
2414               for (x=0; x < (ssize_t) number_pixels; x++)
2415               {
2416                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2417                 SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2418                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2419                 SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2420                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2421                 SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
2422                 q++;
2423               }
2424               break;
2425             }
2426           for (x=0; x < (ssize_t) number_pixels; x++)
2427           {
2428             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2429             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2430             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2431             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2432             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2433             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
2434             q++;
2435           }
2436           break;
2437         }
2438         case 12:
2439         {
2440           range=GetQuantumRange(image->depth);
2441           if (quantum_info->pack == MagickFalse)
2442             {
2443               unsigned short
2444                 pixel;
2445
2446               for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
2447               {
2448                 p=PushShortPixel(endian,p,&pixel);
2449                 switch (x % 3)
2450                 {
2451                   default:
2452                   case 0:
2453                   {
2454                     SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2455                       (pixel >> 4),range));
2456                     break;
2457                   }
2458                   case 1:
2459                   {
2460                     SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2461                       (pixel >> 4),range));
2462                     break;
2463                   }
2464                   case 2:
2465                   {
2466                     SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2467                       (pixel >> 4),range));
2468                     q++;
2469                     break;
2470                   }
2471                 }
2472                 p=PushShortPixel(endian,p,&pixel);
2473                 switch ((x+1) % 3)
2474                 {
2475                   default:
2476                   case 0:
2477                   {
2478                     SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2479                       (pixel >> 4),range));
2480                     break;
2481                   }
2482                   case 1:
2483                   {
2484                     SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2485                       (pixel >> 4),range));
2486                     break;
2487                   }
2488                   case 2:
2489                   {
2490                     SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2491                       (pixel >> 4),range));
2492                     q++;
2493                     break;
2494                   }
2495                 }
2496                 p+=quantum_info->pad;
2497               }
2498               for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
2499               {
2500                 p=PushShortPixel(endian,p,&pixel);
2501                 switch ((x+bit) % 3)
2502                 {
2503                   default:
2504                   case 0:
2505                   {
2506                     SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2507                       (pixel >> 4),range));
2508                     break;
2509                   }
2510                   case 1:
2511                   {
2512                     SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2513                       (pixel >> 4),range));
2514                     break;
2515                   }
2516                   case 2:
2517                   {
2518                     SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
2519                       (pixel >> 4),range));
2520                     q++;
2521                     break;
2522                   }
2523                 }
2524                 p+=quantum_info->pad;
2525               }
2526               if (bit != 0)
2527                 p++;
2528               break;
2529             }
2530           if (quantum_info->quantum == 32U)
2531             {
2532               for (x=0; x < (ssize_t) number_pixels; x++)
2533               {
2534                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2535                 SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2536                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2537                 SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2538                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
2539                 SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
2540                 q++;
2541               }
2542               break;
2543             }
2544           for (x=0; x < (ssize_t) number_pixels; x++)
2545           {
2546             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2547             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2548             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2549             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2550             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2551             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
2552             q++;
2553           }
2554           break;
2555         }
2556         case 16:
2557         {
2558           unsigned short
2559             pixel;
2560
2561           if (quantum_info->format == FloatingPointQuantumFormat)
2562             {
2563               for (x=0; x < (ssize_t) number_pixels; x++)
2564               {
2565                 p=PushShortPixel(endian,p,&pixel);
2566                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2567                   QuantumRange*HalfToSinglePrecision(pixel)));
2568                 p=PushShortPixel(endian,p,&pixel);
2569                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2570                   QuantumRange*HalfToSinglePrecision(pixel)));
2571                 p=PushShortPixel(endian,p,&pixel);
2572                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2573                   QuantumRange*HalfToSinglePrecision(pixel)));
2574                 p+=quantum_info->pad;
2575                 q++;
2576               }
2577               break;
2578             }
2579           for (x=0; x < (ssize_t) number_pixels; x++)
2580           {
2581             p=PushShortPixel(endian,p,&pixel);
2582             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
2583             p=PushShortPixel(endian,p,&pixel);
2584             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
2585             p=PushShortPixel(endian,p,&pixel);
2586             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
2587             p+=quantum_info->pad;
2588             q++;
2589           }
2590           break;
2591         }
2592         case 32:
2593         {
2594           unsigned int
2595             pixel;
2596
2597           if (quantum_info->format == FloatingPointQuantumFormat)
2598             {
2599               float
2600                 pixel;
2601
2602               for (x=0; x < (ssize_t) number_pixels; x++)
2603               {
2604                 p=PushFloatPixel(&quantum_state,p,&pixel);
2605                 SetRedPixelComponent(q,ClampToQuantum(pixel));
2606                 p=PushFloatPixel(&quantum_state,p,&pixel);
2607                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
2608                 p=PushFloatPixel(&quantum_state,p,&pixel);
2609                 SetBluePixelComponent(q,ClampToQuantum(pixel));
2610                 p+=quantum_info->pad;
2611                 q++;
2612               }
2613               break;
2614             }
2615           for (x=0; x < (ssize_t) number_pixels; x++)
2616           {
2617             p=PushLongPixel(endian,p,&pixel);
2618             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
2619             p=PushLongPixel(endian,p,&pixel);
2620             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
2621             p=PushLongPixel(endian,p,&pixel);
2622             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
2623             p+=quantum_info->pad;
2624             q++;
2625           }
2626           break;
2627         }
2628         case 64:
2629         {
2630           if (quantum_info->format == FloatingPointQuantumFormat)
2631             {
2632               double
2633                 pixel;
2634
2635               for (x=0; x < (ssize_t) number_pixels; x++)
2636               {
2637                 p=PushDoublePixel(&quantum_state,p,&pixel);
2638                 SetRedPixelComponent(q,ClampToQuantum(pixel));
2639                 p=PushDoublePixel(&quantum_state,p,&pixel);
2640                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
2641                 p=PushDoublePixel(&quantum_state,p,&pixel);
2642                 SetBluePixelComponent(q,ClampToQuantum(pixel));
2643                 p+=quantum_info->pad;
2644                 q++;
2645               }
2646               break;
2647             }
2648         }
2649         default:
2650         {
2651           range=GetQuantumRange(image->depth);
2652           for (x=0; x < (ssize_t) number_pixels; x++)
2653           {
2654             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2655             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2656             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2657             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2658             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2659             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
2660             q++;
2661           }
2662           break;
2663         }
2664       }
2665       break;
2666     }
2667     case RGBAQuantum:
2668     case RGBOQuantum:
2669     case CbYCrAQuantum:
2670     {
2671       switch (quantum_info->depth)
2672       {
2673         case 8:
2674         {
2675           unsigned char
2676             pixel;
2677
2678           for (x=0; x < (ssize_t) number_pixels; x++)
2679           {
2680             p=PushCharPixel(p,&pixel);
2681             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
2682             p=PushCharPixel(p,&pixel);
2683             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
2684             p=PushCharPixel(p,&pixel);
2685             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
2686             p=PushCharPixel(p,&pixel);
2687             SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
2688             p+=quantum_info->pad;
2689             q++;
2690           }
2691           break;
2692         }
2693         case 10:
2694         {
2695           pixel=0;
2696           if (quantum_info->pack == MagickFalse)
2697             {
2698               register ssize_t
2699                 i;
2700
2701               size_t
2702                 quantum;
2703
2704               ssize_t
2705                 n;
2706
2707               n=0;
2708               quantum=0;
2709               for (x=0; x < (ssize_t) number_pixels; x++)
2710               {
2711                 for (i=0; i < 4; i++)
2712                 {
2713                   switch (n % 3)
2714                   {
2715                     case 0:
2716                     {
2717                       p=PushLongPixel(endian,p,&pixel);
2718                       quantum=(size_t) (ScaleShortToQuantum((unsigned short)
2719                         (((pixel >> 22) & 0x3ff) << 6)));
2720                       break;
2721                     }
2722                     case 1:
2723                     {
2724                       quantum=(size_t) (ScaleShortToQuantum((unsigned short)
2725                         (((pixel >> 12) & 0x3ff) << 6)));
2726                       break;
2727                     }
2728                     case 2:
2729                     {
2730                       quantum=(size_t) (ScaleShortToQuantum((unsigned short)
2731                         (((pixel >> 2) & 0x3ff) << 6)));
2732                       break;
2733                     }
2734                   }
2735                   switch (i)
2736                   {
2737                     case 0: SetRedPixelComponent(q,quantum); break;
2738                     case 1: SetGreenPixelComponent(q,quantum); break;
2739                     case 2: SetBluePixelComponent(q,quantum); break;
2740                     case 3: SetAlphaPixelComponent(q,quantum); break;
2741                   }
2742                   n++;
2743                 }
2744                 p+=quantum_info->pad;
2745                 q++;
2746               }
2747               break;
2748             }
2749           for (x=0; x < (ssize_t) number_pixels; x++)
2750           {
2751             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2752             SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
2753               (pixel << 6)));
2754             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2755             SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
2756               (pixel << 6)));
2757             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2758             SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
2759               (pixel << 6)));
2760             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2761             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(
2762               (unsigned short) (pixel << 6)));
2763             q++;
2764           }
2765           break;
2766         }
2767         case 16:
2768         {
2769           unsigned short
2770             pixel;
2771
2772           if (quantum_info->format == FloatingPointQuantumFormat)
2773             {
2774               for (x=0; x < (ssize_t) number_pixels; x++)
2775               {
2776                 p=PushShortPixel(endian,p,&pixel);
2777                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2778                   QuantumRange*HalfToSinglePrecision(pixel)));
2779                 p=PushShortPixel(endian,p,&pixel);
2780                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2781                   QuantumRange*HalfToSinglePrecision(pixel)));
2782                 p=PushShortPixel(endian,p,&pixel);
2783                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2784                   QuantumRange*HalfToSinglePrecision(pixel)));
2785                 p=PushShortPixel(endian,p,&pixel);
2786                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
2787                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
2788                 p+=quantum_info->pad;
2789                 q++;
2790               }
2791               break;
2792             }
2793           for (x=0; x < (ssize_t) number_pixels; x++)
2794           {
2795             p=PushShortPixel(endian,p,&pixel);
2796             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
2797             p=PushShortPixel(endian,p,&pixel);
2798             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
2799             p=PushShortPixel(endian,p,&pixel);
2800             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
2801             p=PushShortPixel(endian,p,&pixel);
2802             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
2803             p+=quantum_info->pad;
2804             q++;
2805           }
2806           break;
2807         }
2808         case 32:
2809         {
2810           unsigned int
2811             pixel;
2812
2813           if (quantum_info->format == FloatingPointQuantumFormat)
2814             {
2815               float
2816                 pixel;
2817
2818               for (x=0; x < (ssize_t) number_pixels; x++)
2819               {
2820                 p=PushFloatPixel(&quantum_state,p,&pixel);
2821                 SetRedPixelComponent(q,ClampToQuantum(pixel));
2822                 p=PushFloatPixel(&quantum_state,p,&pixel);
2823                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
2824                 p=PushFloatPixel(&quantum_state,p,&pixel);
2825                 SetBluePixelComponent(q,ClampToQuantum(pixel));
2826                 p=PushFloatPixel(&quantum_state,p,&pixel);
2827                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
2828                 p+=quantum_info->pad;
2829                 q++;
2830               }
2831               break;
2832             }
2833           for (x=0; x < (ssize_t) number_pixels; x++)
2834           {
2835             p=PushLongPixel(endian,p,&pixel);
2836             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
2837             p=PushLongPixel(endian,p,&pixel);
2838             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
2839             p=PushLongPixel(endian,p,&pixel);
2840             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
2841             p=PushLongPixel(endian,p,&pixel);
2842             SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(pixel));
2843             p+=quantum_info->pad;
2844             q++;
2845           }
2846           break;
2847         }
2848         case 64:
2849         {
2850           if (quantum_info->format == FloatingPointQuantumFormat)
2851             {
2852               double
2853                 pixel;
2854
2855               for (x=0; x < (ssize_t) number_pixels; x++)
2856               {
2857                 p=PushDoublePixel(&quantum_state,p,&pixel);
2858                 SetRedPixelComponent(q,ClampToQuantum(pixel));
2859                 p=PushDoublePixel(&quantum_state,p,&pixel);
2860                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
2861                 p=PushDoublePixel(&quantum_state,p,&pixel);
2862                 SetBluePixelComponent(q,ClampToQuantum(pixel));
2863                 p=PushDoublePixel(&quantum_state,p,&pixel);
2864                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
2865                 p+=quantum_info->pad;
2866                 q++;
2867               }
2868               break;
2869             }
2870         }
2871         default:
2872         {
2873           range=GetQuantumRange(image->depth);
2874           for (x=0; x < (ssize_t) number_pixels; x++)
2875           {
2876             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2877             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2878             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2879             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
2880             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2881             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
2882             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2883             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
2884               range));
2885             q++;
2886           }
2887           break;
2888         }
2889       }
2890       break;
2891     }
2892     case CMYKQuantum:
2893     {
2894       if (image->colorspace != CMYKColorspace)
2895         {
2896           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2897             "ColorSeparatedImageRequired","`%s'",image->filename);
2898           return(extent);
2899         }
2900       switch (quantum_info->depth)
2901       {
2902         case 8:
2903         {
2904           unsigned char
2905             pixel;
2906
2907           for (x=0; x < (ssize_t) number_pixels; x++)
2908           {
2909             p=PushCharPixel(p,&pixel);
2910             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
2911             p=PushCharPixel(p,&pixel);
2912             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
2913             p=PushCharPixel(p,&pixel);
2914             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
2915             p=PushCharPixel(p,&pixel);
2916             SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
2917             p+=quantum_info->pad;
2918             q++;
2919           }
2920           break;
2921         }
2922         case 16:
2923         {
2924           unsigned short
2925             pixel;
2926
2927           if (quantum_info->format == FloatingPointQuantumFormat)
2928             {
2929               for (x=0; x < (ssize_t) number_pixels; x++)
2930               {
2931                 p=PushShortPixel(endian,p,&pixel);
2932                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2933                   QuantumRange*HalfToSinglePrecision(pixel)));
2934                 p=PushShortPixel(endian,p,&pixel);
2935                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2936                   QuantumRange*HalfToSinglePrecision(pixel)));
2937                 p=PushShortPixel(endian,p,&pixel);
2938                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2939                   QuantumRange*HalfToSinglePrecision(pixel)));
2940                 p=PushShortPixel(endian,p,&pixel);
2941                 SetIndexPixelComponent(indexes+x,ClampToQuantum(
2942                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
2943                 p+=quantum_info->pad;
2944                 q++;
2945               }
2946               break;
2947             }
2948           for (x=0; x < (ssize_t) number_pixels; x++)
2949           {
2950             p=PushShortPixel(endian,p,&pixel);
2951             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
2952             p=PushShortPixel(endian,p,&pixel);
2953             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
2954             p=PushShortPixel(endian,p,&pixel);
2955             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
2956             p=PushShortPixel(endian,p,&pixel);
2957             SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
2958             p+=quantum_info->pad;
2959             q++;
2960           }
2961           break;
2962         }
2963         case 32:
2964         {
2965           unsigned int
2966             pixel;
2967
2968           if (quantum_info->format == FloatingPointQuantumFormat)
2969             {
2970               float
2971                 pixel;
2972
2973               for (x=0; x < (ssize_t) number_pixels; x++)
2974               {
2975                 p=PushFloatPixel(&quantum_state,p,&pixel);
2976                 SetRedPixelComponent(q,ClampToQuantum(pixel));
2977                 p=PushFloatPixel(&quantum_state,p,&pixel);
2978                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
2979                 p=PushFloatPixel(&quantum_state,p,&pixel);
2980                 SetBluePixelComponent(q,ClampToQuantum(pixel));
2981                 p=PushFloatPixel(&quantum_state,p,&pixel);
2982                 SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
2983                 p+=quantum_info->pad;
2984                 q++;
2985               }
2986               break;
2987             }
2988           for (x=0; x < (ssize_t) number_pixels; x++)
2989           {
2990             p=PushLongPixel(endian,p,&pixel);
2991             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
2992             p=PushLongPixel(endian,p,&pixel);
2993             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
2994             p=PushLongPixel(endian,p,&pixel);
2995             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
2996             p=PushLongPixel(endian,p,&pixel);
2997             SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
2998             p+=quantum_info->pad;
2999             q++;
3000           }
3001           break;
3002         }
3003         case 64:
3004         {
3005           if (quantum_info->format == FloatingPointQuantumFormat)
3006             {
3007               double
3008                 pixel;
3009
3010               for (x=0; x < (ssize_t) number_pixels; x++)
3011               {
3012                 p=PushDoublePixel(&quantum_state,p,&pixel);
3013                 SetRedPixelComponent(q,ClampToQuantum(pixel));
3014                 p=PushDoublePixel(&quantum_state,p,&pixel);
3015                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
3016                 p=PushDoublePixel(&quantum_state,p,&pixel);
3017                 SetBluePixelComponent(q,ClampToQuantum(pixel));
3018                 p=PushDoublePixel(&quantum_state,p,&pixel);
3019                 SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
3020                 p+=quantum_info->pad;
3021                 q++;
3022               }
3023               break;
3024             }
3025         }
3026         default:
3027         {
3028           range=GetQuantumRange(image->depth);
3029           for (x=0; x < (ssize_t) number_pixels; x++)
3030           {
3031             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3032             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
3033             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3034             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
3035             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3036             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
3037             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3038             SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
3039             q++;
3040           }
3041           break;
3042         }
3043       }
3044       break;
3045     }
3046     case CMYKAQuantum:
3047     case CMYKOQuantum:
3048     {
3049       if (image->colorspace != CMYKColorspace)
3050         {
3051           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3052             "ColorSeparatedImageRequired","`%s'",image->filename);
3053           return(extent);
3054         }
3055       switch (quantum_info->depth)
3056       {
3057         case 8:
3058         {
3059           unsigned char
3060             pixel;
3061
3062           for (x=0; x < (ssize_t) number_pixels; x++)
3063           {
3064             p=PushCharPixel(p,&pixel);
3065             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
3066             p=PushCharPixel(p,&pixel);
3067             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
3068             p=PushCharPixel(p,&pixel);
3069             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
3070             p=PushCharPixel(p,&pixel);
3071             SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
3072             p=PushCharPixel(p,&pixel);
3073             SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
3074             p+=quantum_info->pad;
3075             q++;
3076           }
3077           break;
3078         }
3079         case 16:
3080         {
3081           unsigned short
3082             pixel;
3083
3084           if (quantum_info->format == FloatingPointQuantumFormat)
3085             {
3086               for (x=0; x < (ssize_t) number_pixels; x++)
3087               {
3088                 p=PushShortPixel(endian,p,&pixel);
3089                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
3090                   QuantumRange*HalfToSinglePrecision(pixel)));
3091                 p=PushShortPixel(endian,p,&pixel);
3092                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
3093                   QuantumRange*HalfToSinglePrecision(pixel)));
3094                 p=PushShortPixel(endian,p,&pixel);
3095                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
3096                   QuantumRange*HalfToSinglePrecision(pixel)));
3097                 p=PushShortPixel(endian,p,&pixel);
3098                 SetIndexPixelComponent(indexes+x,ClampToQuantum(
3099                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
3100                 p=PushShortPixel(endian,p,&pixel);
3101                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(
3102                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
3103                 p+=quantum_info->pad;
3104                 q++;
3105               }
3106               break;
3107             }
3108           for (x=0; x < (ssize_t) number_pixels; x++)
3109           {
3110             p=PushShortPixel(endian,p,&pixel);
3111             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
3112             p=PushShortPixel(endian,p,&pixel);
3113             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
3114             p=PushShortPixel(endian,p,&pixel);
3115             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
3116             p=PushShortPixel(endian,p,&pixel);
3117             SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
3118             p=PushShortPixel(endian,p,&pixel);
3119             SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
3120             p+=quantum_info->pad;
3121             q++;
3122           }
3123           break;
3124         }
3125         case 32:
3126         {
3127           unsigned int
3128             pixel;
3129
3130           if (quantum_info->format == FloatingPointQuantumFormat)
3131             {
3132               float
3133                 pixel;
3134
3135               for (x=0; x < (ssize_t) number_pixels; x++)
3136               {
3137                 p=PushFloatPixel(&quantum_state,p,&pixel);
3138                 SetRedPixelComponent(q,ClampToQuantum(pixel));
3139                 p=PushFloatPixel(&quantum_state,p,&pixel);
3140                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
3141                 p=PushFloatPixel(&quantum_state,p,&pixel);
3142                 SetBluePixelComponent(q,ClampToQuantum(pixel));
3143                 p=PushFloatPixel(&quantum_state,p,&pixel);
3144                 SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
3145                 p=PushFloatPixel(&quantum_state,p,&pixel);
3146                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
3147                 p+=quantum_info->pad;
3148                 q++;
3149               }
3150               break;
3151             }
3152           for (x=0; x < (ssize_t) number_pixels; x++)
3153           {
3154             p=PushLongPixel(endian,p,&pixel);
3155             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
3156             p=PushLongPixel(endian,p,&pixel);
3157             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
3158             p=PushLongPixel(endian,p,&pixel);
3159             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
3160             p=PushLongPixel(endian,p,&pixel);
3161             SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
3162             p=PushLongPixel(endian,p,&pixel);
3163             SetOpacityPixelComponent(q,QuantumRange-ScaleLongToQuantum(pixel));
3164             p+=quantum_info->pad;
3165             q++;
3166           }
3167           break;
3168         }
3169         case 64:
3170         {
3171           if (quantum_info->format == FloatingPointQuantumFormat)
3172             {
3173               double
3174                 pixel;
3175
3176               for (x=0; x < (ssize_t) number_pixels; x++)
3177               {
3178                 p=PushDoublePixel(&quantum_state,p,&pixel);
3179                 SetRedPixelComponent(q,ClampToQuantum(pixel));
3180                 p=PushDoublePixel(&quantum_state,p,&pixel);
3181                 SetGreenPixelComponent(q,ClampToQuantum(pixel));
3182                 p=PushDoublePixel(&quantum_state,p,&pixel);
3183                 SetBluePixelComponent(q,ClampToQuantum(pixel));
3184                 p=PushDoublePixel(&quantum_state,p,&pixel);
3185                 SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
3186                 p=PushDoublePixel(&quantum_state,p,&pixel);
3187                 SetOpacityPixelComponent(q,QuantumRange-ClampToQuantum(pixel));
3188                 p=PushDoublePixel(&quantum_state,p,&pixel);
3189                 p+=quantum_info->pad;
3190                 q++;
3191               }
3192               break;
3193             }
3194         }
3195         default:
3196         {
3197           range=GetQuantumRange(image->depth);
3198           for (x=0; x < (ssize_t) number_pixels; x++)
3199           {
3200             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3201             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
3202             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3203             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
3204             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3205             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
3206             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3207             SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
3208             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3209             SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(pixel,
3210               range));
3211             q++;
3212           }
3213           break;
3214         }
3215       }
3216       break;
3217     }
3218     case CbYCrYQuantum:
3219     {
3220       switch (quantum_info->depth)
3221       {
3222         case 10:
3223         {
3224           Quantum
3225             cbcr[4];
3226
3227           pixel=0;
3228           if (quantum_info->pack == MagickFalse)
3229             {
3230               register ssize_t
3231                 i;
3232
3233               size_t
3234                 quantum;
3235
3236               ssize_t
3237                 n;
3238
3239               n=0;
3240               quantum=0;
3241               for (x=0; x < (ssize_t) number_pixels; x+=2)
3242               {
3243                 for (i=0; i < 4; i++)
3244                 {
3245                   switch (n % 3)
3246                   {
3247                     case 0:
3248                     {
3249                       p=PushLongPixel(endian,p,&pixel);
3250                       quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3251                         (((pixel >> 22) & 0x3ff) << 6)));
3252                       break;
3253                     }
3254                     case 1:
3255                     {
3256                       quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3257                         (((pixel >> 12) & 0x3ff) << 6)));
3258                       break;
3259                     }
3260                     case 2:
3261                     {
3262                       quantum=(size_t) (ScaleShortToQuantum((unsigned short)
3263                         (((pixel >> 2) & 0x3ff) << 6)));
3264                       break;
3265                     }
3266                   }
3267                   cbcr[i]=(Quantum) (quantum);
3268                   n++;
3269                 }
3270                 p+=quantum_info->pad;
3271                 SetRedPixelComponent(q,cbcr[1]);
3272                 SetGreenPixelComponent(q,cbcr[0]);
3273                 SetBluePixelComponent(q,cbcr[2]);
3274                 q++;
3275                 SetRedPixelComponent(q,cbcr[3]);
3276                 SetGreenPixelComponent(q,cbcr[0]);
3277                 SetBluePixelComponent(q,cbcr[2]);
3278                 q++;
3279               }
3280               break;
3281             }
3282         }
3283         default:
3284         {
3285           range=GetQuantumRange(image->depth);
3286           for (x=0; x < (ssize_t) number_pixels; x++)
3287           {
3288             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3289             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
3290             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
3291             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
3292             q++;
3293           }
3294           break;
3295         }
3296       }
3297       break;
3298     }
3299     default:
3300       break;
3301   }
3302   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
3303     {
3304       Quantum
3305         quantum;
3306
3307       register PixelPacket
3308         *restrict q;
3309
3310       q=GetAuthenticPixelQueue(image);
3311       if (image_view != (CacheView *) NULL)
3312         q=GetCacheViewAuthenticPixelQueue(image_view);
3313       for (x=0; x < (ssize_t) number_pixels; x++)
3314       {
3315         quantum=GetRedPixelComponent(q);
3316         SetRedPixelComponent(q,GetGreenPixelComponent(q));
3317         SetGreenPixelComponent(q,quantum);
3318         q++;
3319       }
3320     }
3321   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
3322     {
3323       register PixelPacket
3324         *restrict q;
3325
3326       q=GetAuthenticPixelQueue(image);
3327       if (image_view != (CacheView *) NULL)
3328         q=GetCacheViewAuthenticPixelQueue(image_view);
3329       for (x=0; x < (ssize_t) number_pixels; x++)
3330       {
3331         SetOpacityPixelComponent(q,GetAlphaPixelComponent(q));
3332         q++;
3333       }
3334     }
3335   if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
3336     {
3337       MagickRealType
3338         alpha;
3339
3340       register PixelPacket
3341         *restrict q;
3342
3343       /*
3344         Disassociate alpha.
3345       */
3346       q=GetAuthenticPixelQueue(image);
3347       if (image_view != (CacheView *) NULL)
3348         q=GetCacheViewAuthenticPixelQueue(image_view);
3349       for (x=0; x < (ssize_t) number_pixels; x++)
3350       {
3351         alpha=QuantumScale*GetAlphaPixelComponent(q);
3352         alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
3353         SetRedPixelComponent(q,ClampToQuantum(alpha*
3354           GetRedPixelComponent(q)));
3355         SetGreenPixelComponent(q,ClampToQuantum(alpha*
3356           GetGreenPixelComponent(q)));
3357         SetBluePixelComponent(q,ClampToQuantum(alpha*
3358           GetBluePixelComponent(q)));
3359         q++;
3360       }
3361     }
3362   return(extent);
3363 }