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