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