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