granicus.if.org Git - imagemagick/blob - magick/quantum-import.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                QQQ   U   U   AAA   N   N  TTTTT  U   U  M   M               %
   7 %               Q   Q  U   U  A   A  NN  N    T    U   U  MM MM               %
   8 %               Q   Q  U   U  AAAAA  N N N    T    U   U  M M M               %
   9 %               Q  QQ  U   U  A   A  N  NN    T    U   U  M   M               %
  10 %                QQQQ   UUU   A   A  N   N    T     UUU   M   M               %
  11 %                                                                             %
  12 %                   IIIII  M   M  PPPP    OOO   RRRR   TTTTT                  %
  13 %                     I    MM MM  P   P  O   O  R   R    T                    %
  14 %                     I    M M M  PPPP   O   O  RRRR     T                    %
  15 %                     I    M   M  P      O   O  R R      T                    %
  16 %                   IIIII  M   M  P       OOO   R  R     T                    %
  17 %                                                                             %
  18 %                 MagickCore Methods to Import Quantum Pixels                 %
  19 %                                                                             %
  20 %                             Software Design                                 %
  21 %                               John Cristy                                   %
  22 %                               October 1998                                  %
  23 %                                                                             %
  24 %                                                                             %
  25 %  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
  26 %  dedicated to making software imaging solutions freely available.           %
  27 %                                                                             %
  28 %  You may not use this file except in compliance with the License.  You may  %
  29 %  obtain a copy of the License at                                            %
  30 %                                                                             %
  31 %    http://www.imagemagick.org/script/license.php                            %
  32 %                                                                             %
  33 %  Unless required by applicable law or agreed to in writing, software        %
  34 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  35 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  36 %  See the License for the specific language governing permissions and        %
  37 %  limitations under the License.                                             %
  38 %                                                                             %
  39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  40 %
  41 %
  42 */
  43 \f
  44 /*
  45   Include declarations.
  46 */
  47 #include "magick/studio.h"
  48 #include "magick/property.h"
  49 #include "magick/blob.h"
  50 #include "magick/blob-private.h"
  51 #include "magick/color-private.h"
  52 #include "magick/exception.h"
  53 #include "magick/exception-private.h"
  54 #include "magick/cache.h"
  55 #include "magick/constitute.h"
  56 #include "magick/delegate.h"
  57 #include "magick/geometry.h"
  58 #include "magick/list.h"
  59 #include "magick/magick.h"
  60 #include "magick/memory_.h"
  61 #include "magick/monitor.h"
  62 #include "magick/option.h"
  63 #include "magick/pixel.h"
  64 #include "magick/pixel-private.h"
  65 #include "magick/quantum.h"
  66 #include "magick/quantum-private.h"
  67 #include "magick/resource_.h"
  68 #include "magick/semaphore.h"
  69 #include "magick/statistic.h"
  70 #include "magick/stream.h"
  71 #include "magick/string_.h"
  72 #include "magick/utility.h"
  73 \f
  74 /*
  75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  76 %                                                                             %
  77 %                                                                             %
  78 %                                                                             %
  79 %   I m p o r t Q u a n t u m P i x e l s                                     %
  80 %                                                                             %
  81 %                                                                             %
  82 %                                                                             %
  83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  84 %
  85 %  ImportQuantumPixels() transfers one or more pixel components from a user
  86 %  supplied buffer into the image pixel cache of an image.  The pixels are
  87 %  expected in network byte order.  It returns MagickTrue if the pixels are
  88 %  successfully transferred, otherwise MagickFalse.
  89 %
  90 %  The format of the ImportQuantumPixels method is:
  91 %
  92 %      size_t ImportQuantumPixels(Image *image,CacheView *image_view,
  93 %        const QuantumInfo *quantum_info,const QuantumType quantum_type,
  94 %        const unsigned char *pixels,ExceptionInfo *exception)
  95 %
  96 %  A description of each parameter follows:
  97 %
  98 %    o image: the image.
  99 %
 100 %    o image_view: the image cache view.
 101 %
 102 %    o quantum_info: the quantum info.
 103 %
 104 %    o quantum_type: Declare which pixel components to transfer (red, green,
 105 %      blue, opacity, RGB, or RGBA).
 106 %
 107 %    o pixels:  The pixel components are transferred from this buffer.
 108 %
 109 %    o exception: return any errors or warnings in this structure.
 110 %
 111 */
 112
 113 static inline IndexPacket PushColormapIndex(Image *image,
 114   const unsigned long index,MagickBooleanType *range_exception)
 115 {
 116   if (index < image->colors)
 117     return((IndexPacket) index);
 118   *range_exception=MagickTrue;
 119   return((IndexPacket) 0);
 120 }
 121
 122 static inline const unsigned char *PushDoublePixel(
 123   const QuantumState *quantum_state,const unsigned char *pixels,double *pixel)
 124 {
 125   double
 126     *p;
 127
 128   unsigned char
 129     quantum[8];
 130
 131   if (quantum_state->endian != LSBEndian)
 132     {
 133       quantum[7]=(*pixels++);
 134       quantum[6]=(*pixels++);
 135       quantum[5]=(*pixels++);
 136       quantum[5]=(*pixels++);
 137       quantum[3]=(*pixels++);
 138       quantum[2]=(*pixels++);
 139       quantum[1]=(*pixels++);
 140       quantum[0]=(*pixels++);
 141       p=(double *) quantum;
 142       *pixel=(*p);
 143       *pixel-=quantum_state->minimum;
 144       *pixel*=quantum_state->scale;
 145       return(pixels);
 146     }
 147   quantum[0]=(*pixels++);
 148   quantum[1]=(*pixels++);
 149   quantum[2]=(*pixels++);
 150   quantum[3]=(*pixels++);
 151   quantum[4]=(*pixels++);
 152   quantum[5]=(*pixels++);
 153   quantum[6]=(*pixels++);
 154   quantum[7]=(*pixels++);
 155   p=(double *) quantum;
 156   *pixel=(*p);
 157   *pixel-=quantum_state->minimum;
 158   *pixel*=quantum_state->scale;
 159   return(pixels);
 160 }
 161
 162 static inline const unsigned char *PushFloatPixel(
 163   const QuantumState *quantum_state,const unsigned char *pixels,float *pixel)
 164 {
 165   float
 166     *p;
 167
 168   unsigned char
 169     quantum[4];
 170
 171   if (quantum_state->endian != LSBEndian)
 172     {
 173       quantum[3]=(*pixels++);
 174       quantum[2]=(*pixels++);
 175       quantum[1]=(*pixels++);
 176       quantum[0]=(*pixels++);
 177       p=(float *) quantum;
 178       *pixel=(*p);
 179       *pixel-=quantum_state->minimum;
 180       *pixel*=quantum_state->scale;
 181       return(pixels);
 182     }
 183   quantum[0]=(*pixels++);
 184   quantum[1]=(*pixels++);
 185   quantum[2]=(*pixels++);
 186   quantum[3]=(*pixels++);
 187   p=(float *) quantum;
 188   *pixel=(*p);
 189   *pixel-=quantum_state->minimum;
 190   *pixel*=quantum_state->scale;
 191   return(pixels);
 192 }
 193
 194 static inline const unsigned char *PushQuantumPixel(
 195   QuantumState *quantum_state,const unsigned long depth,
 196   const unsigned char *pixels,unsigned long *quantum)
 197 {
 198   register long
 199     i;
 200
 201   register unsigned long
 202     quantum_bits;
 203
 204   *quantum=(QuantumAny) 0;
 205   for (i=(long) 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=(unsigned long) i;
 213     if (quantum_bits > quantum_state->bits)
 214       quantum_bits=quantum_state->bits;
 215     i-=quantum_bits;
 216     quantum_state->bits-=quantum_bits;
 217     *quantum=(*quantum << quantum_bits) | ((quantum_state->pixel >>
 218       quantum_state->bits) &~ ((~0UL) << quantum_bits));
 219   }
 220   return(pixels);
 221 }
 222
 223 static inline const unsigned char *PushQuantumLongPixel(
 224   QuantumState *quantum_state,const unsigned long depth,
 225   const unsigned char *pixels,unsigned long *quantum)
 226 {
 227   register long
 228     i;
 229
 230   register unsigned long
 231     quantum_bits;
 232
 233   *quantum=0UL;
 234   for (i=(long) depth; i > 0; )
 235   {
 236     if (quantum_state->bits == 0)
 237       {
 238         pixels=PushLongPixel(quantum_state->endian,pixels,
 239           &quantum_state->pixel);
 240         quantum_state->bits=32UL;
 241       }
 242     quantum_bits=(unsigned long) i;
 243     if (quantum_bits > quantum_state->bits)
 244       quantum_bits=quantum_state->bits;
 245     *quantum|=(((quantum_state->pixel >> (32UL-quantum_state->bits)) &
 246       quantum_state->mask[quantum_bits]) << (depth-i));
 247     i-=quantum_bits;
 248     quantum_state->bits-=quantum_bits;
 249   }
 250   return(pixels);
 251 }
 252
 253 MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 254   const QuantumInfo *quantum_info,const QuantumType quantum_type,
 255   const unsigned char *pixels,ExceptionInfo *exception)
 256 {
 257   EndianType
 258     endian;
 259
 260   long
 261     bit;
 262
 263   MagickSizeType
 264     number_pixels;
 265
 266   QuantumAny
 267     range;
 268
 269   QuantumState
 270     quantum_state;
 271
 272   register const unsigned char
 273     *p;
 274
 275   register IndexPacket
 276     *indexes;
 277
 278   register long
 279     x;
 280
 281   register PixelPacket
 282     *__restrict q;
 283
 284   size_t
 285     extent;
 286
 287   unsigned long
 288     pixel;
 289
 290   assert(image != (Image *) NULL);
 291   assert(image->signature == MagickSignature);
 292   if (image->debug != MagickFalse)
 293     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 294   assert(quantum_info != (QuantumInfo *) NULL);
 295   assert(quantum_info->signature == MagickSignature);
 296   if (pixels == (const unsigned char *) NULL)
 297     pixels=GetQuantumPixels(quantum_info);
 298   x=0;
 299   p=pixels;
 300   number_pixels=GetImageExtent(image);
 301   q=GetAuthenticPixelQueue(image);
 302   indexes=GetAuthenticIndexQueue(image);
 303   if (image_view != (CacheView *) NULL)
 304     {
 305       number_pixels=GetCacheViewExtent(image_view);
 306       q=GetCacheViewAuthenticPixelQueue(image_view);
 307       indexes=GetCacheViewAuthenticIndexQueue(image_view);
 308     }
 309   InitializeQuantumState(quantum_info,image->endian,&quantum_state);
 310   extent=GetQuantumExtent(image,quantum_info,quantum_type);
 311   endian=quantum_state.endian;
 312   switch (quantum_type)
 313   {
 314     case IndexQuantum:
 315     {
 316       MagickBooleanType
 317         range_exception;
 318
 319       if (image->storage_class != PseudoClass)
 320         {
 321           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 322             "ColormappedImageRequired","`%s'",image->filename);
 323           return(extent);
 324         }
 325       range_exception=MagickFalse;
 326       switch (quantum_info->depth)
 327       {
 328         case 1:
 329         {
 330           register unsigned char
 331             pixel;
 332
 333           for (x=0; x < ((long) number_pixels-7); x+=8)
 334           {
 335             for (bit=0; bit < 8; bit++)
 336             {
 337               if (quantum_info->min_is_white == MagickFalse)
 338                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 339                   0x00 : 0x01);
 340               else
 341                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 342                   0x00 : 0x01);
 343               indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
 344               *q=image->colormap[(long) indexes[x+bit]];
 345               q++;
 346             }
 347             p++;
 348           }
 349           for (bit=0; bit < (long) (number_pixels % 8); bit++)
 350           {
 351             if (quantum_info->min_is_white == MagickFalse)
 352               pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 353                 0x00 : 0x01);
 354             else
 355               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 356                 0x00 : 0x01);
 357             indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
 358             *q=image->colormap[(long) indexes[x+bit]];
 359             q++;
 360           }
 361           break;
 362         }
 363         case 4:
 364         {
 365           register unsigned char
 366             pixel;
 367
 368           for (x=0; x < ((long) number_pixels-1); x+=2)
 369           {
 370             pixel=(unsigned char) ((*p >> 4) & 0xf);
 371             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 372             *q=image->colormap[(long) indexes[x]];
 373             q++;
 374             pixel=(unsigned char) ((*p) & 0xf);
 375             indexes[x+1]=PushColormapIndex(image,pixel,&range_exception);
 376             *q=image->colormap[(long) indexes[x+1]];
 377             p++;
 378             q++;
 379           }
 380           for (bit=0; bit < (long) (number_pixels % 2); bit++)
 381           {
 382             pixel=(unsigned char) ((*p++ >> 4) & 0xf);
 383             indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
 384             *q=image->colormap[(long) indexes[x+bit]];
 385             q++;
 386           }
 387           break;
 388         }
 389         case 8:
 390         {
 391           unsigned char
 392             pixel;
 393
 394           for (x=0; x < (long) number_pixels; x++)
 395           {
 396             p=PushCharPixel(p,&pixel);
 397             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 398             *q=image->colormap[(long) indexes[x]];
 399             p+=quantum_info->pad;
 400             q++;
 401           }
 402           break;
 403         }
 404         case 16:
 405         {
 406           unsigned short
 407             pixel;
 408
 409           for (x=0; x < (long) number_pixels; x++)
 410           {
 411             p=PushShortPixel(endian,p,&pixel);
 412             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 413             *q=image->colormap[(long) indexes[x]];
 414             p+=quantum_info->pad;
 415             q++;
 416           }
 417           break;
 418         }
 419         case 32:
 420         {
 421           unsigned long
 422             pixel;
 423
 424           if (quantum_info->format == FloatingPointQuantumFormat)
 425             {
 426               float
 427                 pixel;
 428
 429               for (x=0; x < (long) number_pixels; x++)
 430               {
 431                 p=PushFloatPixel(&quantum_state,p,&pixel);
 432                 indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
 433                   &range_exception);
 434                 *q=image->colormap[(long) indexes[x]];
 435                 p+=quantum_info->pad;
 436                 q++;
 437               }
 438               break;
 439             }
 440           for (x=0; x < (long) number_pixels; x++)
 441           {
 442             p=PushLongPixel(endian,p,&pixel);
 443             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 444             *q=image->colormap[(long) indexes[x]];
 445             p+=quantum_info->pad;
 446             q++;
 447           }
 448           break;
 449         }
 450         case 64:
 451         {
 452           if (quantum_info->format == FloatingPointQuantumFormat)
 453             {
 454               double
 455                 pixel;
 456
 457               for (x=0; x < (long) number_pixels; x++)
 458               {
 459                 p=PushDoublePixel(&quantum_state,p,&pixel);
 460                 indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
 461                   &range_exception);
 462                 *q=image->colormap[(long) indexes[x]];
 463                 p+=quantum_info->pad;
 464                 q++;
 465               }
 466               break;
 467             }
 468         }
 469         default:
 470         {
 471           for (x=0; x < (long) number_pixels; x++)
 472           {
 473             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 474             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 475             *q=image->colormap[(long) indexes[x]];
 476             p+=quantum_info->pad;
 477             q++;
 478           }
 479           break;
 480         }
 481       }
 482       if (range_exception != MagickFalse)
 483         (void) ThrowMagickException(exception,GetMagickModule(),
 484           CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
 485       break;
 486     }
 487     case IndexAlphaQuantum:
 488     {
 489       MagickBooleanType
 490         range_exception;
 491
 492       if (image->storage_class != PseudoClass)
 493         {
 494           (void) ThrowMagickException(exception,GetMagickModule(),
 495             ImageError,"ColormappedImageRequired","`%s'",image->filename);
 496           return(extent);
 497         }
 498       range_exception=MagickFalse;
 499       switch (quantum_info->depth)
 500       {
 501         case 1:
 502         {
 503           register unsigned char
 504             pixel;
 505
 506           for (x=0; x < ((long) number_pixels-3); x+=4)
 507           {
 508             for (bit=0; bit < 8; bit+=2)
 509             {
 510               if (quantum_info->min_is_white == MagickFalse)
 511                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 512                   0x00 : 0x01);
 513               else
 514                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 515                   0x00 : 0x01);
 516               indexes[x+bit/2]=(IndexPacket) (pixel == 0 ? 0 : 1);
 517               q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
 518               q->green=q->red;
 519               q->blue=q->red;
 520               q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit)))
 521                 == 0 ? TransparentOpacity : OpaqueOpacity);
 522               q++;
 523             }
 524           }
 525           for (bit=0; bit < (long) (number_pixels % 4); bit+=2)
 526           {
 527             if (quantum_info->min_is_white == MagickFalse)
 528               pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
 529                 0x00 : 0x01);
 530             else
 531               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
 532                 0x00 : 0x01);
 533             indexes[x+bit/2]=(IndexPacket) (pixel == 0 ? 0 : 1);
 534             q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
 535             q->green=q->red;
 536             q->blue=q->red;
 537             q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit))) ==
 538               0 ? TransparentOpacity : OpaqueOpacity);
 539             q++;
 540           }
 541           break;
 542         }
 543         case 4:
 544         {
 545           register unsigned char
 546             pixel;
 547
 548           range=GetQuantumRange(image->depth);
 549           for (x=0; x < (long) number_pixels; x++)
 550           {
 551             pixel=(unsigned char) ((*p >> 4) & 0xf);
 552             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 553             *q=image->colormap[(long) indexes[x]];
 554             pixel=(unsigned char) ((*p) & 0xf);
 555             q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
 556             p++;
 557             q++;
 558           }
 559           break;
 560         }
 561         case 8:
 562         {
 563           unsigned char
 564             pixel;
 565
 566           for (x=0; x < (long) number_pixels; x++)
 567           {
 568             p=PushCharPixel(p,&pixel);
 569             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 570             *q=image->colormap[(long) indexes[x]];
 571             p=PushCharPixel(p,&pixel);
 572             q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
 573             p+=quantum_info->pad;
 574             q++;
 575           }
 576           break;
 577         }
 578         case 16:
 579         {
 580           unsigned short
 581             pixel;
 582
 583           for (x=0; x < (long) number_pixels; x++)
 584           {
 585             p=PushShortPixel(endian,p,&pixel);
 586             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 587             *q=image->colormap[(long) indexes[x]];
 588             p=PushShortPixel(endian,p,&pixel);
 589             q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
 590             p+=quantum_info->pad;
 591             q++;
 592           }
 593           break;
 594         }
 595         case 32:
 596         {
 597           unsigned long
 598             pixel;
 599
 600           if (quantum_info->format == FloatingPointQuantumFormat)
 601             {
 602               float
 603                 pixel;
 604
 605               for (x=0; x < (long) number_pixels; x++)
 606               {
 607                 p=PushFloatPixel(&quantum_state,p,&pixel);
 608                 indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
 609                   &range_exception);
 610                 *q=image->colormap[(long) indexes[x]];
 611                 p=PushFloatPixel(&quantum_state,p,&pixel);
 612                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
 613                 p+=quantum_info->pad;
 614                 q++;
 615               }
 616               break;
 617             }
 618           for (x=0; x < (long) number_pixels; x++)
 619           {
 620             p=PushLongPixel(endian,p,&pixel);
 621             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 622             *q=image->colormap[(long) indexes[x]];
 623             p=PushLongPixel(endian,p,&pixel);
 624             q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
 625             p+=quantum_info->pad;
 626             q++;
 627           }
 628           break;
 629         }
 630         case 64:
 631         {
 632           if (quantum_info->format == FloatingPointQuantumFormat)
 633             {
 634               double
 635                 pixel;
 636
 637               for (x=0; x < (long) number_pixels; x++)
 638               {
 639                 p=PushDoublePixel(&quantum_state,p,&pixel);
 640                 indexes[x]=PushColormapIndex(image,RoundToQuantum(pixel),
 641                   &range_exception);
 642                 *q=image->colormap[(long) indexes[x]];
 643                 p=PushDoublePixel(&quantum_state,p,&pixel);
 644                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
 645                 p+=quantum_info->pad;
 646                 q++;
 647               }
 648               break;
 649             }
 650         }
 651         default:
 652         {
 653           range=GetQuantumRange(image->depth);
 654           for (x=0; x < (long) number_pixels; x++)
 655           {
 656             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 657             indexes[x]=PushColormapIndex(image,pixel,&range_exception);
 658             *q=image->colormap[(long) indexes[x]];
 659             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 660             q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
 661             p+=quantum_info->pad;
 662             q++;
 663           }
 664           break;
 665         }
 666       }
 667       if (range_exception != MagickFalse)
 668         (void) ThrowMagickException(exception,GetMagickModule(),
 669           CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
 670       break;
 671     }
 672     case GrayQuantum:
 673     {
 674       switch (quantum_info->depth)
 675       {
 676         case 1:
 677         {
 678           register Quantum
 679             black,
 680             white;
 681
 682           black=0;
 683           white=(Quantum) QuantumRange;
 684           if (quantum_info->min_is_white != MagickFalse)
 685             {
 686               black=(Quantum) QuantumRange;
 687               white=0;
 688             }
 689           for (x=0; x < ((long) number_pixels-7); x+=8)
 690           {
 691             for (bit=0; bit < 8; bit++)
 692             {
 693               q->red=(((*p) & (1 << (7-bit))) == 0 ? black : white);
 694               q->green=q->red;
 695               q->blue=q->red;
 696               q++;
 697             }
 698             p++;
 699           }
 700           for (bit=0; bit < (long) (number_pixels % 8); bit++)
 701           {
 702             q->red=(((*p) & (1 << (7-bit))) == 0 ? black : white);
 703             q->green=q->red;
 704             q->blue=q->red;
 705             q++;
 706           }
 707           if (bit != 0)
 708             p++;
 709           break;
 710         }
 711         case 4:
 712         {
 713           register unsigned char
 714             pixel;
 715
 716           range=GetQuantumRange(image->depth);
 717           for (x=0; x < ((long) number_pixels-1); x+=2)
 718           {
 719             pixel=(unsigned char) ((*p >> 4) & 0xf);
 720             q->red=ScaleAnyToQuantum(pixel,range);
 721             q->green=q->red;
 722             q->blue=q->red;
 723             q++;
 724             pixel=(unsigned char) ((*p) & 0xf);
 725             q->red=ScaleAnyToQuantum(pixel,range);
 726             q->green=q->red;
 727             q->blue=q->red;
 728             p++;
 729             q++;
 730           }
 731           for (bit=0; bit < (long) (number_pixels % 2); bit++)
 732           {
 733             pixel=(unsigned char) (*p++ >> 4);
 734             q->red=ScaleAnyToQuantum(pixel,range);
 735             q->green=q->red;
 736             q->blue=q->red;
 737             q++;
 738           }
 739           break;
 740         }
 741         case 8:
 742         {
 743           unsigned char
 744             pixel;
 745
 746           if (quantum_info->min_is_white != MagickFalse)
 747             {
 748               for (x=0; x < (long) number_pixels; x++)
 749               {
 750                 p=PushCharPixel(p,&pixel);
 751                 q->red=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
 752                 q->green=q->red;
 753                 q->blue=q->red;
 754                 q->opacity=OpaqueOpacity;
 755                 p+=quantum_info->pad;
 756                 q++;
 757               }
 758               break;
 759             }
 760           for (x=0; x < (long) number_pixels; x++)
 761           {
 762             p=PushCharPixel(p,&pixel);
 763             q->red=ScaleCharToQuantum(pixel);
 764             q->green=q->red;
 765             q->blue=q->red;
 766             q->opacity=OpaqueOpacity;
 767             p+=quantum_info->pad;
 768             q++;
 769           }
 770           break;
 771         }
 772         case 10:
 773         {
 774           range=GetQuantumRange(image->depth);
 775           if (quantum_info->pack == MagickFalse)
 776             {
 777               if (image->endian != LSBEndian)
 778                 {
 779                   for (x=0; x < (long) number_pixels/3; x++)
 780                   {
 781                     p=PushLongPixel(endian,p,&pixel);
 782                     q->red=ScaleAnyToQuantum((pixel >> 0) & 0x3ff,range);
 783                     q->green=q->red;
 784                     q->blue=q->red;
 785                     q++;
 786                     q->red=ScaleAnyToQuantum((pixel >> 10) & 0x3ff,range);
 787                     q->green=q->red;
 788                     q->blue=q->red;
 789                     q++;
 790                     q->red=ScaleAnyToQuantum((pixel >> 20) & 0x3ff,range);
 791                     q->green=q->red;
 792                     q->blue=q->red;
 793                     p+=quantum_info->pad;
 794                     q++;
 795                   }
 796                   break;
 797                 }
 798               for (x=0; x < (long) number_pixels/3; x++)
 799               {
 800                 p=PushLongPixel(endian,p,&pixel);
 801                 q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
 802                 q->green=q->red;
 803                 q->blue=q->red;
 804                 q++;
 805                 q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
 806                 q->green=q->red;
 807                 q->blue=q->red;
 808                 q++;
 809                 q->red=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
 810                 q->green=q->red;
 811                 q->blue=q->red;
 812                 p+=quantum_info->pad;
 813                 q++;
 814               }
 815               break;
 816             }
 817           for (x=0; x < (long) number_pixels; x++)
 818           {
 819             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 820             q->red=ScaleAnyToQuantum(pixel,range);
 821             q->green=q->red;
 822             q->blue=q->red;
 823             p+=quantum_info->pad;
 824             q++;
 825           }
 826           break;
 827         }
 828         case 12:
 829         {
 830           range=GetQuantumRange(image->depth);
 831           if (quantum_info->pack == MagickFalse)
 832             {
 833               unsigned short
 834                 pixel;
 835
 836               for (x=0; x < (long) (number_pixels-1); x+=2)
 837               {
 838                 p=PushShortPixel(endian,p,&pixel);
 839                 q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
 840                 q->green=q->red;
 841                 q->blue=q->red;
 842                 q++;
 843                 p=PushShortPixel(endian,p,&pixel);
 844                 q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
 845                 q->green=q->red;
 846                 q->blue=q->red;
 847                 p+=quantum_info->pad;
 848                 q++;
 849               }
 850               for (bit=0; bit < (long) (number_pixels % 2); bit++)
 851               {
 852                 p=PushShortPixel(endian,p,&pixel);
 853                 q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
 854                 q->green=q->red;
 855                 q->blue=q->red;
 856                 p+=quantum_info->pad;
 857                 q++;
 858               }
 859               if (bit != 0)
 860                 p++;
 861               break;
 862             }
 863           for (x=0; x < (long) number_pixels; x++)
 864           {
 865             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 866             q->red=ScaleAnyToQuantum(pixel,range);
 867             q->green=q->red;
 868             q->blue=q->red;
 869             p+=quantum_info->pad;
 870             q++;
 871           }
 872           break;
 873         }
 874         case 16:
 875         {
 876           unsigned short
 877             pixel;
 878
 879           if (quantum_info->min_is_white != MagickFalse)
 880             {
 881               for (x=0; x < (long) number_pixels; x++)
 882               {
 883                 p=PushShortPixel(endian,p,&pixel);
 884                 q->red=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
 885                 q->green=q->red;
 886                 q->blue=q->red;
 887                 p+=quantum_info->pad;
 888                 q++;
 889               }
 890               break;
 891             }
 892           for (x=0; x < (long) number_pixels; x++)
 893           {
 894             p=PushShortPixel(endian,p,&pixel);
 895             q->red=ScaleShortToQuantum(pixel);
 896             q->green=q->red;
 897             q->blue=q->red;
 898             p+=quantum_info->pad;
 899             q++;
 900           }
 901           break;
 902         }
 903         case 32:
 904         {
 905           unsigned long
 906             pixel;
 907
 908           if (quantum_info->format == FloatingPointQuantumFormat)
 909             {
 910               float
 911                 pixel;
 912
 913               for (x=0; x < (long) number_pixels; x++)
 914               {
 915                 p=PushFloatPixel(&quantum_state,p,&pixel);
 916                 q->red=RoundToQuantum(pixel);
 917                 q->green=q->red;
 918                 q->blue=q->red;
 919                 p+=quantum_info->pad;
 920                 q++;
 921               }
 922               break;
 923             }
 924           for (x=0; x < (long) number_pixels; x++)
 925           {
 926             p=PushLongPixel(endian,p,&pixel);
 927             q->red=ScaleLongToQuantum(pixel);
 928             q->green=q->red;
 929             q->blue=q->red;
 930             p+=quantum_info->pad;
 931             q++;
 932           }
 933           break;
 934         }
 935         case 64:
 936         {
 937           if (quantum_info->format == FloatingPointQuantumFormat)
 938             {
 939               double
 940                 pixel;
 941
 942               for (x=0; x < (long) number_pixels; x++)
 943               {
 944                 p=PushDoublePixel(&quantum_state,p,&pixel);
 945                 q->red=RoundToQuantum(pixel);
 946                 q->green=q->red;
 947                 q->blue=q->red;
 948                 p+=quantum_info->pad;
 949                 q++;
 950               }
 951               break;
 952             }
 953         }
 954         default:
 955         {
 956           range=GetQuantumRange(image->depth);
 957           for (x=0; x < (long) number_pixels; x++)
 958           {
 959             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
 960             q->red=ScaleAnyToQuantum(pixel,range);
 961             q->green=q->red;
 962             q->blue=q->red;
 963             p+=quantum_info->pad;
 964             q++;
 965           }
 966           break;
 967         }
 968       }
 969       break;
 970     }
 971     case GrayAlphaQuantum:
 972     {
 973       switch (quantum_info->depth)
 974       {
 975         case 1:
 976         {
 977           register unsigned char
 978             pixel;
 979
 980           for (x=0; x < ((long) number_pixels-3); x+=4)
 981           {
 982             for (bit=0; bit < 8; bit+=2)
 983             {
 984               pixel=(unsigned char)
 985                 (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
 986               q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
 987               q->green=q->red;
 988               q->blue=q->red;
 989               q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit)))
 990                 == 0 ? TransparentOpacity : OpaqueOpacity);
 991               q++;
 992             }
 993             p++;
 994           }
 995           for (bit=0; bit < (long) (number_pixels % 4); bit+=2)
 996           {
 997             pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
 998             q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
 999             q->green=q->red;
1000             q->blue=q->red;
1001             q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit))) == 0
1002               ? TransparentOpacity : OpaqueOpacity);
1003             q++;
1004           }
1005           if (bit != 0)
1006             p++;
1007           break;
1008         }
1009         case 4:
1010         {
1011           register unsigned char
1012             pixel;
1013
1014           range=GetQuantumRange(image->depth);
1015           for (x=0; x < (long) number_pixels; x++)
1016           {
1017             pixel=(unsigned char) ((*p >> 4) & 0xf);
1018             q->red=ScaleAnyToQuantum(pixel,range);
1019             q->green=q->red;
1020             q->blue=q->red;
1021             pixel=(unsigned char) ((*p) & 0xf);
1022             q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
1023             p++;
1024             q++;
1025           }
1026           break;
1027         }
1028         case 8:
1029         {
1030           unsigned char
1031             pixel;
1032
1033           for (x=0; x < (long) number_pixels; x++)
1034           {
1035             p=PushCharPixel(p,&pixel);
1036             q->red=ScaleCharToQuantum(pixel);
1037             q->green=q->red;
1038             q->blue=q->red;
1039             p=PushCharPixel(p,&pixel);
1040             q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
1041             p+=quantum_info->pad;
1042             q++;
1043           }
1044           break;
1045         }
1046         case 10:
1047         {
1048           range=GetQuantumRange(image->depth);
1049           for (x=0; x < (long) number_pixels; x++)
1050           {
1051             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1052             q->red=ScaleAnyToQuantum(pixel,range);
1053             q->green=q->red;
1054             q->blue=q->red;
1055             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1056             q->opacity=ScaleAnyToQuantum(pixel,range);
1057             p+=quantum_info->pad;
1058             q++;
1059           }
1060           break;
1061         }
1062         case 12:
1063         {
1064           range=GetQuantumRange(image->depth);
1065           for (x=0; x < (long) number_pixels; x++)
1066           {
1067             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1068             q->red=ScaleAnyToQuantum(pixel,range);
1069             q->green=q->red;
1070             q->blue=q->red;
1071             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1072             q->opacity=ScaleAnyToQuantum(pixel,range);
1073             p+=quantum_info->pad;
1074             q++;
1075           }
1076           break;
1077         }
1078         case 16:
1079         {
1080           unsigned short
1081             pixel;
1082
1083           for (x=0; x < (long) number_pixels; x++)
1084           {
1085             p=PushShortPixel(endian,p,&pixel);
1086             q->red=ScaleShortToQuantum(pixel);
1087             q->green=q->red;
1088             q->blue=q->red;
1089             p=PushShortPixel(endian,p,&pixel);
1090             q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
1091             p+=quantum_info->pad;
1092             q++;
1093           }
1094           break;
1095         }
1096         case 32:
1097         {
1098           unsigned long
1099             pixel;
1100
1101           if (quantum_info->format == FloatingPointQuantumFormat)
1102             {
1103               float
1104                 pixel;
1105
1106               for (x=0; x < (long) number_pixels; x++)
1107               {
1108                 p=PushFloatPixel(&quantum_state,p,&pixel);
1109                 q->red=RoundToQuantum(pixel);
1110                 q->green=q->red;
1111                 q->blue=q->red;
1112                 p=PushFloatPixel(&quantum_state,p,&pixel);
1113                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
1114                 p+=quantum_info->pad;
1115                 q++;
1116               }
1117               break;
1118             }
1119           for (x=0; x < (long) number_pixels; x++)
1120           {
1121             p=PushLongPixel(endian,p,&pixel);
1122             q->red=ScaleLongToQuantum(pixel);
1123             q->green=q->red;
1124             q->blue=q->red;
1125             p=PushLongPixel(endian,p,&pixel);
1126             q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
1127             p+=quantum_info->pad;
1128             q++;
1129           }
1130           break;
1131         }
1132         case 64:
1133         {
1134           if (quantum_info->format == FloatingPointQuantumFormat)
1135             {
1136               double
1137                 pixel;
1138
1139               for (x=0; x < (long) number_pixels; x++)
1140               {
1141                 p=PushDoublePixel(&quantum_state,p,&pixel);
1142                 q->red=RoundToQuantum(pixel);
1143                 q->green=q->red;
1144                 q->blue=q->red;
1145                 p=PushDoublePixel(&quantum_state,p,&pixel);
1146                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
1147                 p+=quantum_info->pad;
1148                 q++;
1149               }
1150               break;
1151             }
1152         }
1153         default:
1154         {
1155           range=GetQuantumRange(image->depth);
1156           for (x=0; x < (long) number_pixels; x++)
1157           {
1158             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1159             q->red=ScaleAnyToQuantum(pixel,range);
1160             q->green=q->red;
1161             q->blue=q->red;
1162             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1163             q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
1164             p+=quantum_info->pad;
1165             q++;
1166           }
1167           break;
1168         }
1169       }
1170       break;
1171     }
1172     case RedQuantum:
1173     case CyanQuantum:
1174     {
1175       switch (quantum_info->depth)
1176       {
1177         case 8:
1178         {
1179           unsigned char
1180             pixel;
1181
1182           for (x=0; x < (long) number_pixels; x++)
1183           {
1184             p=PushCharPixel(p,&pixel);
1185             q->red=ScaleCharToQuantum(pixel);
1186             p+=quantum_info->pad;
1187             q++;
1188           }
1189           break;
1190         }
1191         case 16:
1192         {
1193           unsigned short
1194             pixel;
1195
1196           for (x=0; x < (long) number_pixels; x++)
1197           {
1198             p=PushShortPixel(endian,p,&pixel);
1199             q->red=ScaleShortToQuantum(pixel);
1200             p+=quantum_info->pad;
1201             q++;
1202           }
1203           break;
1204         }
1205         case 32:
1206         {
1207           unsigned long
1208             pixel;
1209
1210           if (quantum_info->format == FloatingPointQuantumFormat)
1211             {
1212               float
1213                 pixel;
1214
1215               for (x=0; x < (long) number_pixels; x++)
1216               {
1217                 p=PushFloatPixel(&quantum_state,p,&pixel);
1218                 q->red=RoundToQuantum(pixel);
1219                 p+=quantum_info->pad;
1220                 q++;
1221               }
1222               break;
1223             }
1224           for (x=0; x < (long) number_pixels; x++)
1225           {
1226             p=PushLongPixel(endian,p,&pixel);
1227             q->red=ScaleLongToQuantum(pixel);
1228             p+=quantum_info->pad;
1229             q++;
1230           }
1231           break;
1232         }
1233         case 64:
1234         {
1235           if (quantum_info->format == FloatingPointQuantumFormat)
1236             {
1237               double
1238                 pixel;
1239
1240               for (x=0; x < (long) number_pixels; x++)
1241               {
1242                 p=PushDoublePixel(&quantum_state,p,&pixel);
1243                 q->red=RoundToQuantum(pixel);
1244                 p+=quantum_info->pad;
1245                 q++;
1246               }
1247               break;
1248             }
1249         }
1250         default:
1251         {
1252           range=GetQuantumRange(image->depth);
1253           for (x=0; x < (long) number_pixels; x++)
1254           {
1255             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1256             q->red=ScaleAnyToQuantum(pixel,range);
1257             p+=quantum_info->pad;
1258             q++;
1259           }
1260           break;
1261         }
1262       }
1263       break;
1264     }
1265     case GreenQuantum:
1266     case MagentaQuantum:
1267     {
1268       switch (quantum_info->depth)
1269       {
1270         case 8:
1271         {
1272           unsigned char
1273             pixel;
1274
1275           for (x=0; x < (long) number_pixels; x++)
1276           {
1277             p=PushCharPixel(p,&pixel);
1278             q->green=ScaleCharToQuantum(pixel);
1279             p+=quantum_info->pad;
1280             q++;
1281           }
1282           break;
1283         }
1284         case 16:
1285         {
1286           unsigned short
1287             pixel;
1288
1289           for (x=0; x < (long) number_pixels; x++)
1290           {
1291             p=PushShortPixel(endian,p,&pixel);
1292             q->green=ScaleShortToQuantum(pixel);
1293             p+=quantum_info->pad;
1294             q++;
1295           }
1296           break;
1297         }
1298         case 32:
1299         {
1300           unsigned long
1301             pixel;
1302
1303           if (quantum_info->format == FloatingPointQuantumFormat)
1304             {
1305               float
1306                 pixel;
1307
1308               for (x=0; x < (long) number_pixels; x++)
1309               {
1310                 p=PushFloatPixel(&quantum_state,p,&pixel);
1311                 q->green=RoundToQuantum(pixel);
1312                 p+=quantum_info->pad;
1313                 q++;
1314               }
1315               break;
1316             }
1317           for (x=0; x < (long) number_pixels; x++)
1318           {
1319             p=PushLongPixel(endian,p,&pixel);
1320             q->green=ScaleLongToQuantum(pixel);
1321             p+=quantum_info->pad;
1322             q++;
1323           }
1324           break;
1325         }
1326         case 64:
1327         {
1328           if (quantum_info->format == FloatingPointQuantumFormat)
1329             {
1330               double
1331                 pixel;
1332
1333               for (x=0; x < (long) number_pixels; x++)
1334               {
1335                 p=PushDoublePixel(&quantum_state,p,&pixel);
1336                 q->green=RoundToQuantum(pixel);
1337                 p+=quantum_info->pad;
1338                 q++;
1339               }
1340               break;
1341             }
1342         }
1343         default:
1344         {
1345           range=GetQuantumRange(image->depth);
1346           for (x=0; x < (long) number_pixels; x++)
1347           {
1348             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1349             q->green=ScaleAnyToQuantum(pixel,range);
1350             p+=quantum_info->pad;
1351             q++;
1352           }
1353           break;
1354         }
1355       }
1356       break;
1357     }
1358     case BlueQuantum:
1359     case YellowQuantum:
1360     {
1361       switch (quantum_info->depth)
1362       {
1363         case 8:
1364         {
1365           unsigned char
1366             pixel;
1367
1368           for (x=0; x < (long) number_pixels; x++)
1369           {
1370             p=PushCharPixel(p,&pixel);
1371             q->blue=ScaleCharToQuantum(pixel);
1372             p+=quantum_info->pad;
1373             q++;
1374           }
1375           break;
1376         }
1377         case 16:
1378         {
1379           unsigned short
1380             pixel;
1381
1382           for (x=0; x < (long) number_pixels; x++)
1383           {
1384             p=PushShortPixel(endian,p,&pixel);
1385             q->blue=ScaleShortToQuantum(pixel);
1386             p+=quantum_info->pad;
1387             q++;
1388           }
1389           break;
1390         }
1391         case 32:
1392         {
1393           unsigned long
1394             pixel;
1395
1396           if (quantum_info->format == FloatingPointQuantumFormat)
1397             {
1398               float
1399                 pixel;
1400
1401               for (x=0; x < (long) number_pixels; x++)
1402               {
1403                 p=PushFloatPixel(&quantum_state,p,&pixel);
1404                 q->blue=RoundToQuantum(pixel);
1405                 p+=quantum_info->pad;
1406                 q++;
1407               }
1408               break;
1409             }
1410           for (x=0; x < (long) number_pixels; x++)
1411           {
1412             p=PushLongPixel(endian,p,&pixel);
1413             q->blue=ScaleLongToQuantum(pixel);
1414             p+=quantum_info->pad;
1415             q++;
1416           }
1417           break;
1418         }
1419         case 64:
1420         {
1421           if (quantum_info->format == FloatingPointQuantumFormat)
1422             {
1423               double
1424                 pixel;
1425
1426               for (x=0; x < (long) number_pixels; x++)
1427               {
1428                 p=PushDoublePixel(&quantum_state,p,&pixel);
1429                 q->blue=RoundToQuantum(pixel);
1430                 p+=quantum_info->pad;
1431                 q++;
1432               }
1433               break;
1434             }
1435         }
1436         default:
1437         {
1438           range=GetQuantumRange(image->depth);
1439           for (x=0; x < (long) number_pixels; x++)
1440           {
1441             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1442             q->blue=ScaleAnyToQuantum(pixel,range);
1443             p+=quantum_info->pad;
1444             q++;
1445           }
1446           break;
1447         }
1448       }
1449       break;
1450     }
1451     case AlphaQuantum:
1452     {
1453       switch (quantum_info->depth)
1454       {
1455         case 8:
1456         {
1457           unsigned char
1458             pixel;
1459
1460           for (x=0; x < (long) number_pixels; x++)
1461           {
1462             p=PushCharPixel(p,&pixel);
1463             q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
1464             p+=quantum_info->pad;
1465             q++;
1466           }
1467           break;
1468         }
1469         case 16:
1470         {
1471           unsigned short
1472             pixel;
1473
1474           for (x=0; x < (long) number_pixels; x++)
1475           {
1476             p=PushShortPixel(endian,p,&pixel);
1477             q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
1478             p+=quantum_info->pad;
1479             q++;
1480           }
1481           break;
1482         }
1483         case 32:
1484         {
1485           unsigned long
1486             pixel;
1487
1488           if (quantum_info->format == FloatingPointQuantumFormat)
1489             {
1490               float
1491                 pixel;
1492
1493               for (x=0; x < (long) number_pixels; x++)
1494               {
1495                 p=PushFloatPixel(&quantum_state,p,&pixel);
1496                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
1497                 p+=quantum_info->pad;
1498                 q++;
1499               }
1500               break;
1501             }
1502           for (x=0; x < (long) number_pixels; x++)
1503           {
1504             p=PushLongPixel(endian,p,&pixel);
1505             q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
1506             p+=quantum_info->pad;
1507             q++;
1508           }
1509           break;
1510         }
1511         case 64:
1512         {
1513           if (quantum_info->format == FloatingPointQuantumFormat)
1514             {
1515               double
1516                 pixel;
1517
1518               for (x=0; x < (long) number_pixels; x++)
1519               {
1520                 p=PushDoublePixel(&quantum_state,p,&pixel);
1521                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
1522                 p+=quantum_info->pad;
1523                 q++;
1524               }
1525               break;
1526             }
1527         }
1528         default:
1529         {
1530           range=GetQuantumRange(image->depth);
1531           for (x=0; x < (long) number_pixels; x++)
1532           {
1533             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1534             q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
1535             p+=quantum_info->pad;
1536             q++;
1537           }
1538           break;
1539         }
1540       }
1541       break;
1542     }
1543     case BlackQuantum:
1544     {
1545       if (image->colorspace != CMYKColorspace)
1546         {
1547           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1548             "ColorSeparatedImageRequired","`%s'",image->filename);
1549           return(extent);
1550         }
1551       switch (quantum_info->depth)
1552       {
1553         case 8:
1554         {
1555           unsigned char
1556             pixel;
1557
1558           for (x=0; x < (long) number_pixels; x++)
1559           {
1560             p=PushCharPixel(p,&pixel);
1561             indexes[x]=ScaleCharToQuantum(pixel);
1562             p+=quantum_info->pad;
1563           }
1564           break;
1565         }
1566         case 16:
1567         {
1568           unsigned short
1569             pixel;
1570
1571           for (x=0; x < (long) number_pixels; x++)
1572           {
1573             p=PushShortPixel(endian,p,&pixel);
1574             indexes[x]=ScaleShortToQuantum(pixel);
1575             p+=quantum_info->pad;
1576           }
1577           break;
1578         }
1579         case 32:
1580         {
1581           unsigned long
1582             pixel;
1583
1584           if (quantum_info->format == FloatingPointQuantumFormat)
1585             {
1586               float
1587                 pixel;
1588
1589               for (x=0; x < (long) number_pixels; x++)
1590               {
1591                 p=PushFloatPixel(&quantum_state,p,&pixel);
1592                 indexes[x]=RoundToQuantum(pixel);
1593                 p+=quantum_info->pad;
1594                 q++;
1595               }
1596               break;
1597             }
1598           for (x=0; x < (long) number_pixels; x++)
1599           {
1600             p=PushLongPixel(endian,p,&pixel);
1601             indexes[x]=ScaleLongToQuantum(pixel);
1602             p+=quantum_info->pad;
1603             q++;
1604           }
1605           break;
1606         }
1607         case 64:
1608         {
1609           if (quantum_info->format == FloatingPointQuantumFormat)
1610             {
1611               double
1612                 pixel;
1613
1614               for (x=0; x < (long) number_pixels; x++)
1615               {
1616                 p=PushDoublePixel(&quantum_state,p,&pixel);
1617                 indexes[x]=RoundToQuantum(pixel);
1618                 p+=quantum_info->pad;
1619                 q++;
1620               }
1621               break;
1622             }
1623         }
1624         default:
1625         {
1626           range=GetQuantumRange(image->depth);
1627           for (x=0; x < (long) number_pixels; x++)
1628           {
1629             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1630             indexes[x]=ScaleAnyToQuantum(pixel,range);
1631             p+=quantum_info->pad;
1632             q++;
1633           }
1634           break;
1635         }
1636       }
1637       break;
1638     }
1639     case RGBQuantum:
1640     case CbYCrQuantum:
1641     {
1642       switch (quantum_info->depth)
1643       {
1644         case 8:
1645         {
1646           unsigned char
1647             pixel;
1648
1649           for (x=0; x < (long) number_pixels; x++)
1650           {
1651             p=PushCharPixel(p,&pixel);
1652             q->red=ScaleCharToQuantum(pixel);
1653             p=PushCharPixel(p,&pixel);
1654             q->green=ScaleCharToQuantum(pixel);
1655             p=PushCharPixel(p,&pixel);
1656             q->blue=ScaleCharToQuantum(pixel);
1657             q->opacity=OpaqueOpacity;
1658             p+=quantum_info->pad;
1659             q++;
1660           }
1661           break;
1662         }
1663         case 10:
1664         {
1665           range=GetQuantumRange(image->depth);
1666           if (quantum_info->pack == MagickFalse)
1667             {
1668               for (x=0; x < (long) number_pixels; x++)
1669               {
1670                 p=PushLongPixel(endian,p,&pixel);
1671                 q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
1672                 q->green=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
1673                 q->blue=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
1674                 p+=quantum_info->pad;
1675                 q++;
1676               }
1677               break;
1678             }
1679           if (quantum_info->quantum == 32UL)
1680             {
1681               for (x=0; x < (long) number_pixels; x++)
1682               {
1683                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
1684                 q->red=ScaleAnyToQuantum(pixel,range);
1685                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
1686                 q->green=ScaleAnyToQuantum(pixel,range);
1687                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
1688                 q->blue=ScaleAnyToQuantum(pixel,range);
1689                 q++;
1690               }
1691               break;
1692             }
1693           for (x=0; x < (long) number_pixels; x++)
1694           {
1695             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1696             q->red=ScaleAnyToQuantum(pixel,range);
1697             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1698             q->green=ScaleAnyToQuantum(pixel,range);
1699             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1700             q->blue=ScaleAnyToQuantum(pixel,range);
1701             q++;
1702           }
1703           break;
1704         }
1705         case 12:
1706         {
1707           range=GetQuantumRange(image->depth);
1708           if (quantum_info->pack == MagickFalse)
1709             {
1710               unsigned short
1711                 pixel;
1712
1713               for (x=0; x < (long) (3*number_pixels-1); x+=2)
1714               {
1715                 p=PushShortPixel(endian,p,&pixel);
1716                 switch (x % 3)
1717                 {
1718                   default:
1719                   case 0:
1720                   {
1721                     q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1722                     break;
1723                   }
1724                   case 1:
1725                   {
1726                     q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1727                     break;
1728                   }
1729                   case 2:
1730                   {
1731                     q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1732                     q++;
1733                     break;
1734                   }
1735                 }
1736                 p=PushShortPixel(endian,p,&pixel);
1737                 switch ((x+1) % 3)
1738                 {
1739                   default:
1740                   case 0:
1741                   {
1742                     q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1743                     break;
1744                   }
1745                   case 1:
1746                   {
1747                     q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1748                     break;
1749                   }
1750                   case 2:
1751                   {
1752                     q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1753                     q++;
1754                     break;
1755                   }
1756                 }
1757                 p+=quantum_info->pad;
1758               }
1759               for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
1760               {
1761                 p=PushShortPixel(endian,p,&pixel);
1762                 switch ((x+bit) % 3)
1763                 {
1764                   default:
1765                   case 0:
1766                   {
1767                     q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1768                     break;
1769                   }
1770                   case 1:
1771                   {
1772                     q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1773                     break;
1774                   }
1775                   case 2:
1776                   {
1777                     q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
1778                     q++;
1779                     break;
1780                   }
1781                 }
1782                 p+=quantum_info->pad;
1783               }
1784               if (bit != 0)
1785                 p++;
1786               break;
1787             }
1788           if (quantum_info->quantum == 32UL)
1789             {
1790               for (x=0; x < (long) number_pixels; x++)
1791               {
1792                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
1793                 q->red=ScaleAnyToQuantum(pixel,range);
1794                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
1795                 q->green=ScaleAnyToQuantum(pixel,range);
1796                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
1797                 q->blue=ScaleAnyToQuantum(pixel,range);
1798                 q++;
1799               }
1800               break;
1801             }
1802           for (x=0; x < (long) number_pixels; x++)
1803           {
1804             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1805             q->red=ScaleAnyToQuantum(pixel,range);
1806             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1807             q->green=ScaleAnyToQuantum(pixel,range);
1808             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1809             q->blue=ScaleAnyToQuantum(pixel,range);
1810             q++;
1811           }
1812           break;
1813         }
1814         case 16:
1815         {
1816           unsigned short
1817             pixel;
1818
1819           for (x=0; x < (long) number_pixels; x++)
1820           {
1821             p=PushShortPixel(endian,p,&pixel);
1822             q->red=ScaleShortToQuantum(pixel);
1823             p=PushShortPixel(endian,p,&pixel);
1824             q->green=ScaleShortToQuantum(pixel);
1825             p=PushShortPixel(endian,p,&pixel);
1826             q->blue=ScaleShortToQuantum(pixel);
1827             p+=quantum_info->pad;
1828             q++;
1829           }
1830           break;
1831         }
1832         case 32:
1833         {
1834           unsigned long
1835             pixel;
1836
1837           if (quantum_info->format == FloatingPointQuantumFormat)
1838             {
1839               float
1840                 pixel;
1841
1842               for (x=0; x < (long) number_pixels; x++)
1843               {
1844                 p=PushFloatPixel(&quantum_state,p,&pixel);
1845                 q->red=RoundToQuantum(pixel);
1846                 p=PushFloatPixel(&quantum_state,p,&pixel);
1847                 q->green=RoundToQuantum(pixel);
1848                 p=PushFloatPixel(&quantum_state,p,&pixel);
1849                 q->blue=RoundToQuantum(pixel);
1850                 p+=quantum_info->pad;
1851                 q++;
1852               }
1853               break;
1854             }
1855           for (x=0; x < (long) number_pixels; x++)
1856           {
1857             p=PushLongPixel(endian,p,&pixel);
1858             q->red=ScaleLongToQuantum(pixel);
1859             p=PushLongPixel(endian,p,&pixel);
1860             q->green=ScaleLongToQuantum(pixel);
1861             p=PushLongPixel(endian,p,&pixel);
1862             q->blue=ScaleLongToQuantum(pixel);
1863             p+=quantum_info->pad;
1864             q++;
1865           }
1866           break;
1867         }
1868         case 64:
1869         {
1870           if (quantum_info->format == FloatingPointQuantumFormat)
1871             {
1872               double
1873                 pixel;
1874
1875               for (x=0; x < (long) number_pixels; x++)
1876               {
1877                 p=PushDoublePixel(&quantum_state,p,&pixel);
1878                 q->red=RoundToQuantum(pixel);
1879                 p=PushDoublePixel(&quantum_state,p,&pixel);
1880                 q->green=RoundToQuantum(pixel);
1881                 p=PushDoublePixel(&quantum_state,p,&pixel);
1882                 q->blue=RoundToQuantum(pixel);
1883                 p+=quantum_info->pad;
1884                 q++;
1885               }
1886               break;
1887             }
1888         }
1889         default:
1890         {
1891           range=GetQuantumRange(image->depth);
1892           for (x=0; x < (long) number_pixels; x++)
1893           {
1894             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1895             q->red=ScaleAnyToQuantum(pixel,range);
1896             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1897             q->green=ScaleAnyToQuantum(pixel,range);
1898             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1899             q->blue=ScaleAnyToQuantum(pixel,range);
1900             q++;
1901           }
1902           break;
1903         }
1904       }
1905       break;
1906     }
1907     case RGBAQuantum:
1908     case RGBOQuantum:
1909     case CbYCrAQuantum:
1910     {
1911       switch (quantum_info->depth)
1912       {
1913         case 8:
1914         {
1915           unsigned char
1916             pixel;
1917
1918           for (x=0; x < (long) number_pixels; x++)
1919           {
1920             p=PushCharPixel(p,&pixel);
1921             q->red=ScaleCharToQuantum(pixel);
1922             p=PushCharPixel(p,&pixel);
1923             q->green=ScaleCharToQuantum(pixel);
1924             p=PushCharPixel(p,&pixel);
1925             q->blue=ScaleCharToQuantum(pixel);
1926             p=PushCharPixel(p,&pixel);
1927             q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
1928             p+=quantum_info->pad;
1929             q++;
1930           }
1931           break;
1932         }
1933         case 10:
1934         {
1935           pixel=0;
1936           if (quantum_info->pack == MagickFalse)
1937             {
1938               long
1939                 n;
1940
1941               register long
1942                 i;
1943
1944               unsigned long
1945                 quantum;
1946
1947               n=0;
1948               quantum=0;
1949               for (x=0; x < (long) number_pixels; x++)
1950               {
1951                 for (i=0; i < 4; i++)
1952                 {
1953                   switch (n % 3)
1954                   {
1955                     case 0:
1956                     {
1957                       p=PushLongPixel(endian,p,&pixel);
1958                       quantum=(unsigned long) (ScaleShortToQuantum(
1959                         (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
1960                       break;
1961                     }
1962                     case 1:
1963                     {
1964                       quantum=(unsigned long) (ScaleShortToQuantum(
1965                         (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
1966                       break;
1967                     }
1968                     case 2:
1969                     {
1970                       quantum=(unsigned long) (ScaleShortToQuantum(
1971                         (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
1972                       break;
1973                     }
1974                   }
1975                   switch (i)
1976                   {
1977                     case 0: q->red=(Quantum) (quantum); break;
1978                     case 1: q->green=(Quantum) (quantum); break;
1979                     case 2: q->blue=(Quantum) (quantum); break;
1980                     case 3: q->opacity=(Quantum) (QuantumRange-quantum); break;
1981                   }
1982                   n++;
1983                 }
1984                 p+=quantum_info->pad;
1985                 q++;
1986               }
1987               break;
1988             }
1989           for (x=0; x < (long) number_pixels; x++)
1990           {
1991             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1992             q->red=ScaleShortToQuantum((unsigned short) (pixel << 6));
1993             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1994             q->green=ScaleShortToQuantum((unsigned short) (pixel << 6));
1995             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1996             q->blue=ScaleShortToQuantum((unsigned short) (pixel << 6));
1997             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
1998             q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(
1999               (unsigned short) (pixel << 6)));
2000             q++;
2001           }
2002           break;
2003         }
2004         case 16:
2005         {
2006           unsigned short
2007             pixel;
2008
2009           for (x=0; x < (long) number_pixels; x++)
2010           {
2011             p=PushShortPixel(endian,p,&pixel);
2012             q->red=ScaleShortToQuantum(pixel);
2013             p=PushShortPixel(endian,p,&pixel);
2014             q->green=ScaleShortToQuantum(pixel);
2015             p=PushShortPixel(endian,p,&pixel);
2016             q->blue=ScaleShortToQuantum(pixel);
2017             p=PushShortPixel(endian,p,&pixel);
2018             q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
2019             p+=quantum_info->pad;
2020             q++;
2021           }
2022           break;
2023         }
2024         case 32:
2025         {
2026           unsigned long
2027             pixel;
2028
2029           if (quantum_info->format == FloatingPointQuantumFormat)
2030             {
2031               float
2032                 pixel;
2033
2034               for (x=0; x < (long) number_pixels; x++)
2035               {
2036                 p=PushFloatPixel(&quantum_state,p,&pixel);
2037                 q->red=RoundToQuantum(pixel);
2038                 p=PushFloatPixel(&quantum_state,p,&pixel);
2039                 q->green=RoundToQuantum(pixel);
2040                 p=PushFloatPixel(&quantum_state,p,&pixel);
2041                 q->blue=RoundToQuantum(pixel);
2042                 p=PushFloatPixel(&quantum_state,p,&pixel);
2043                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
2044                 p+=quantum_info->pad;
2045                 q++;
2046               }
2047               break;
2048             }
2049           for (x=0; x < (long) number_pixels; x++)
2050           {
2051             p=PushLongPixel(endian,p,&pixel);
2052             q->red=ScaleLongToQuantum(pixel);
2053             p=PushLongPixel(endian,p,&pixel);
2054             q->green=ScaleLongToQuantum(pixel);
2055             p=PushLongPixel(endian,p,&pixel);
2056             q->blue=ScaleLongToQuantum(pixel);
2057             p=PushLongPixel(endian,p,&pixel);
2058             q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
2059             p+=quantum_info->pad;
2060             q++;
2061           }
2062           break;
2063         }
2064         case 64:
2065         {
2066           if (quantum_info->format == FloatingPointQuantumFormat)
2067             {
2068               double
2069                 pixel;
2070
2071               for (x=0; x < (long) number_pixels; x++)
2072               {
2073                 p=PushDoublePixel(&quantum_state,p,&pixel);
2074                 q->red=RoundToQuantum(pixel);
2075                 p=PushDoublePixel(&quantum_state,p,&pixel);
2076                 q->green=RoundToQuantum(pixel);
2077                 p=PushDoublePixel(&quantum_state,p,&pixel);
2078                 q->blue=RoundToQuantum(pixel);
2079                 p=PushDoublePixel(&quantum_state,p,&pixel);
2080                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
2081                 p+=quantum_info->pad;
2082                 q++;
2083               }
2084               break;
2085             }
2086         }
2087         default:
2088         {
2089           range=GetQuantumRange(image->depth);
2090           for (x=0; x < (long) number_pixels; x++)
2091           {
2092             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2093             q->red=ScaleAnyToQuantum(pixel,range);
2094             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2095             q->green=ScaleAnyToQuantum(pixel,range);
2096             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2097             q->blue=ScaleAnyToQuantum(pixel,range);
2098             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2099             q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
2100             q++;
2101           }
2102           break;
2103         }
2104       }
2105       break;
2106     }
2107     case CMYKQuantum:
2108     {
2109       if (image->colorspace != CMYKColorspace)
2110         {
2111           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2112             "ColorSeparatedImageRequired","`%s'",image->filename);
2113           return(extent);
2114         }
2115       switch (quantum_info->depth)
2116       {
2117         case 8:
2118         {
2119           unsigned char
2120             pixel;
2121
2122           for (x=0; x < (long) number_pixels; x++)
2123           {
2124             p=PushCharPixel(p,&pixel);
2125             q->red=ScaleCharToQuantum(pixel);
2126             p=PushCharPixel(p,&pixel);
2127             q->green=ScaleCharToQuantum(pixel);
2128             p=PushCharPixel(p,&pixel);
2129             q->blue=ScaleCharToQuantum(pixel);
2130             p=PushCharPixel(p,&pixel);
2131             indexes[x]=ScaleCharToQuantum(pixel);
2132             p+=quantum_info->pad;
2133             q++;
2134           }
2135           break;
2136         }
2137         case 16:
2138         {
2139           unsigned short
2140             pixel;
2141
2142           for (x=0; x < (long) number_pixels; x++)
2143           {
2144             p=PushShortPixel(endian,p,&pixel);
2145             q->red=ScaleShortToQuantum(pixel);
2146             p=PushShortPixel(endian,p,&pixel);
2147             q->green=ScaleShortToQuantum(pixel);
2148             p=PushShortPixel(endian,p,&pixel);
2149             q->blue=ScaleShortToQuantum(pixel);
2150             p=PushShortPixel(endian,p,&pixel);
2151             indexes[x]=ScaleShortToQuantum(pixel);
2152             p+=quantum_info->pad;
2153             q++;
2154           }
2155           break;
2156         }
2157         case 32:
2158         {
2159           unsigned long
2160             pixel;
2161
2162           if (quantum_info->format == FloatingPointQuantumFormat)
2163             {
2164               float
2165                 pixel;
2166
2167               for (x=0; x < (long) number_pixels; x++)
2168               {
2169                 p=PushFloatPixel(&quantum_state,p,&pixel);
2170                 q->red=RoundToQuantum(pixel);
2171                 p=PushFloatPixel(&quantum_state,p,&pixel);
2172                 q->green=RoundToQuantum(pixel);
2173                 p=PushFloatPixel(&quantum_state,p,&pixel);
2174                 q->blue=RoundToQuantum(pixel);
2175                 p=PushFloatPixel(&quantum_state,p,&pixel);
2176                 indexes[x]=(IndexPacket) RoundToQuantum(pixel);
2177                 p+=quantum_info->pad;
2178                 q++;
2179               }
2180               break;
2181             }
2182           for (x=0; x < (long) number_pixels; x++)
2183           {
2184             p=PushLongPixel(endian,p,&pixel);
2185             q->red=ScaleLongToQuantum(pixel);
2186             p=PushLongPixel(endian,p,&pixel);
2187             q->green=ScaleLongToQuantum(pixel);
2188             p=PushLongPixel(endian,p,&pixel);
2189             q->blue=ScaleLongToQuantum(pixel);
2190             p=PushLongPixel(endian,p,&pixel);
2191             indexes[x]=ScaleLongToQuantum(pixel);
2192             p+=quantum_info->pad;
2193             q++;
2194           }
2195           break;
2196         }
2197         case 64:
2198         {
2199           if (quantum_info->format == FloatingPointQuantumFormat)
2200             {
2201               double
2202                 pixel;
2203
2204               for (x=0; x < (long) number_pixels; x++)
2205               {
2206                 p=PushDoublePixel(&quantum_state,p,&pixel);
2207                 q->red=RoundToQuantum(pixel);
2208                 p=PushDoublePixel(&quantum_state,p,&pixel);
2209                 q->green=RoundToQuantum(pixel);
2210                 p=PushDoublePixel(&quantum_state,p,&pixel);
2211                 q->blue=RoundToQuantum(pixel);
2212                 p=PushDoublePixel(&quantum_state,p,&pixel);
2213                 indexes[x]=(IndexPacket) RoundToQuantum(pixel);
2214                 p+=quantum_info->pad;
2215                 q++;
2216               }
2217               break;
2218             }
2219         }
2220         default:
2221         {
2222           range=GetQuantumRange(image->depth);
2223           for (x=0; x < (long) number_pixels; x++)
2224           {
2225             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2226             q->red=ScaleAnyToQuantum(pixel,range);
2227             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2228             q->green=ScaleAnyToQuantum(pixel,range);
2229             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2230             q->blue=ScaleAnyToQuantum(pixel,range);
2231             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2232             indexes[x]=ScaleAnyToQuantum(pixel,range);
2233             q++;
2234           }
2235           break;
2236         }
2237       }
2238       break;
2239     }
2240     case CMYKAQuantum:
2241     case CMYKOQuantum:
2242     {
2243       if (image->colorspace != CMYKColorspace)
2244         {
2245           (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2246             "ColorSeparatedImageRequired","`%s'",image->filename);
2247           return(extent);
2248         }
2249       switch (quantum_info->depth)
2250       {
2251         case 8:
2252         {
2253           unsigned char
2254             pixel;
2255
2256           for (x=0; x < (long) number_pixels; x++)
2257           {
2258             p=PushCharPixel(p,&pixel);
2259             q->red=ScaleCharToQuantum(pixel);
2260             p=PushCharPixel(p,&pixel);
2261             q->green=ScaleCharToQuantum(pixel);
2262             p=PushCharPixel(p,&pixel);
2263             q->blue=ScaleCharToQuantum(pixel);
2264             p=PushCharPixel(p,&pixel);
2265             indexes[x]=ScaleCharToQuantum(pixel);
2266             p=PushCharPixel(p,&pixel);
2267             q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
2268             p+=quantum_info->pad;
2269             q++;
2270           }
2271           break;
2272         }
2273         case 16:
2274         {
2275           unsigned short
2276             pixel;
2277
2278           for (x=0; x < (long) number_pixels; x++)
2279           {
2280             p=PushShortPixel(endian,p,&pixel);
2281             q->red=ScaleShortToQuantum(pixel);
2282             p=PushShortPixel(endian,p,&pixel);
2283             q->green=ScaleShortToQuantum(pixel);
2284             p=PushShortPixel(endian,p,&pixel);
2285             q->blue=ScaleShortToQuantum(pixel);
2286             p=PushShortPixel(endian,p,&pixel);
2287             indexes[x]=ScaleShortToQuantum(pixel);
2288             p=PushShortPixel(endian,p,&pixel);
2289             q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
2290             p+=quantum_info->pad;
2291             q++;
2292           }
2293           break;
2294         }
2295         case 32:
2296         {
2297           unsigned long
2298             pixel;
2299
2300           if (quantum_info->format == FloatingPointQuantumFormat)
2301             {
2302               float
2303                 pixel;
2304
2305               for (x=0; x < (long) number_pixels; x++)
2306               {
2307                 p=PushFloatPixel(&quantum_state,p,&pixel);
2308                 q->red=RoundToQuantum(pixel);
2309                 p=PushFloatPixel(&quantum_state,p,&pixel);
2310                 q->green=RoundToQuantum(pixel);
2311                 p=PushFloatPixel(&quantum_state,p,&pixel);
2312                 q->blue=RoundToQuantum(pixel);
2313                 p=PushFloatPixel(&quantum_state,p,&pixel);
2314                 indexes[x]=(IndexPacket) RoundToQuantum(pixel);
2315                 p=PushFloatPixel(&quantum_state,p,&pixel);
2316                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
2317                 p+=quantum_info->pad;
2318                 q++;
2319               }
2320               break;
2321             }
2322           for (x=0; x < (long) number_pixels; x++)
2323           {
2324             p=PushLongPixel(endian,p,&pixel);
2325             q->red=ScaleLongToQuantum(pixel);
2326             p=PushLongPixel(endian,p,&pixel);
2327             q->green=ScaleLongToQuantum(pixel);
2328             p=PushLongPixel(endian,p,&pixel);
2329             q->blue=ScaleLongToQuantum(pixel);
2330             p=PushLongPixel(endian,p,&pixel);
2331             indexes[x]=ScaleLongToQuantum(pixel);
2332             p=PushLongPixel(endian,p,&pixel);
2333             q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
2334             p+=quantum_info->pad;
2335             q++;
2336           }
2337           break;
2338         }
2339         case 64:
2340         {
2341           if (quantum_info->format == FloatingPointQuantumFormat)
2342             {
2343               double
2344                 pixel;
2345
2346               for (x=0; x < (long) number_pixels; x++)
2347               {
2348                 p=PushDoublePixel(&quantum_state,p,&pixel);
2349                 q->red=RoundToQuantum(pixel);
2350                 p=PushDoublePixel(&quantum_state,p,&pixel);
2351                 q->green=RoundToQuantum(pixel);
2352                 p=PushDoublePixel(&quantum_state,p,&pixel);
2353                 q->blue=RoundToQuantum(pixel);
2354                 p=PushDoublePixel(&quantum_state,p,&pixel);
2355                 indexes[x]=(IndexPacket) RoundToQuantum(pixel);
2356                 p=PushDoublePixel(&quantum_state,p,&pixel);
2357                 q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
2358                 p=PushDoublePixel(&quantum_state,p,&pixel);
2359                 p+=quantum_info->pad;
2360                 q++;
2361               }
2362               break;
2363             }
2364         }
2365         default:
2366         {
2367           range=GetQuantumRange(image->depth);
2368           for (x=0; x < (long) number_pixels; x++)
2369           {
2370             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2371             q->red=ScaleAnyToQuantum(pixel,range);
2372             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2373             q->green=ScaleAnyToQuantum(pixel,range);
2374             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2375             q->blue=ScaleAnyToQuantum(pixel,range);
2376             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2377             indexes[x]=ScaleAnyToQuantum(pixel,range);
2378             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2379             q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
2380             q++;
2381           }
2382           break;
2383         }
2384       }
2385       break;
2386     }
2387     case CbYCrYQuantum:
2388     {
2389       switch (quantum_info->depth)
2390       {
2391         case 10:
2392         {
2393           Quantum
2394             cbcr[4];
2395
2396           pixel=0;
2397           if (quantum_info->pack == MagickFalse)
2398             {
2399               long
2400                 n;
2401
2402               register long
2403                 i;
2404
2405               unsigned long
2406                 quantum;
2407
2408               n=0;
2409               quantum=0;
2410               for (x=0; x < (long) number_pixels; x+=2)
2411               {
2412                 for (i=0; i < 4; i++)
2413                 {
2414                   switch (n % 3)
2415                   {
2416                     case 0:
2417                     {
2418                       p=PushLongPixel(endian,p,&pixel);
2419                       quantum=(unsigned long) (ScaleShortToQuantum(
2420                         (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
2421                       break;
2422                     }
2423                     case 1:
2424                     {
2425                       quantum=(unsigned long) (ScaleShortToQuantum(
2426                         (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
2427                       break;
2428                     }
2429                     case 2:
2430                     {
2431                       quantum=(unsigned long) (ScaleShortToQuantum(
2432                         (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
2433                       break;
2434                     }
2435                   }
2436                   cbcr[i]=(Quantum) (quantum);
2437                   n++;
2438                 }
2439                 p+=quantum_info->pad;
2440                 q->red=cbcr[1];
2441                 q->green=cbcr[0];
2442                 q->blue=cbcr[2];
2443                 q++;
2444                 q->red=cbcr[3];
2445                 q->green=cbcr[0];
2446                 q->blue=cbcr[2];
2447                 q++;
2448               }
2449               break;
2450             }
2451         }
2452         default:
2453         {
2454           range=GetQuantumRange(image->depth);
2455           for (x=0; x < (long) number_pixels; x++)
2456           {
2457             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2458             q->red=ScaleAnyToQuantum(pixel,range);
2459             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
2460             q->green=ScaleAnyToQuantum(pixel,range);
2461             q++;
2462           }
2463           break;
2464         }
2465       }
2466       break;
2467     }
2468     default:
2469       break;
2470   }
2471   if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
2472     {
2473       Quantum
2474         quantum;
2475
2476       register PixelPacket
2477         *__restrict q;
2478
2479       q=GetAuthenticPixelQueue(image);
2480       if (image_view != (CacheView *) NULL)
2481         q=GetCacheViewAuthenticPixelQueue(image_view);
2482       for (x=0; x < (long) number_pixels; x++)
2483       {
2484         quantum=q->red;
2485         q->red=q->green;
2486         q->green=quantum;
2487         q++;
2488       }
2489     }
2490   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
2491     {
2492       register PixelPacket
2493         *__restrict q;
2494
2495       q=GetAuthenticPixelQueue(image);
2496       if (image_view != (CacheView *) NULL)
2497         q=GetCacheViewAuthenticPixelQueue(image_view);
2498       for (x=0; x < (long) number_pixels; x++)
2499       {
2500         q->opacity=(Quantum) (QuantumRange-q->opacity);
2501         q++;
2502       }
2503     }
2504   if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
2505     {
2506       MagickRealType
2507         alpha;
2508
2509       register PixelPacket
2510         *__restrict q;
2511
2512       /*
2513         Disassociate alpha.
2514       */
2515       q=GetAuthenticPixelQueue(image);
2516       if (image_view != (CacheView *) NULL)
2517         q=GetCacheViewAuthenticPixelQueue(image_view);
2518       for (x=0; x < (long) number_pixels; x++)
2519       {
2520         alpha=QuantumScale*((MagickRealType) QuantumRange-q->opacity);
2521         alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
2522         q->red=RoundToQuantum(alpha*q->red);
2523         q->green=RoundToQuantum(alpha*q->green);
2524         q->blue=RoundToQuantum(alpha*q->blue);
2525         q++;
2526       }
2527     }
2528   return(extent);
2529 }