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