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