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