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