granicus.if.org Git - imagemagick/blob - MagickCore/quantum.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 %             MagicCore Methods to Acquire / Destroy Quantum Pixels           %
  13 %                                                                             %
  14 %                             Software Design                                 %
  15 %                               John Cristy                                   %
  16 %                               October 1998                                  %
  17 %                                                                             %
  18 %                                                                             %
  19 %  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
  20 %  dedicated to making software imaging solutions freely available.           %
  21 %                                                                             %
  22 %  You may not use this file except in compliance with the License.  You may  %
  23 %  obtain a copy of the License at                                            %
  24 %                                                                             %
  25 %    http://www.imagemagick.org/script/license.php                            %
  26 %                                                                             %
  27 %  Unless required by applicable law or agreed to in writing, software        %
  28 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  29 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  30 %  See the License for the specific language governing permissions and        %
  31 %  limitations under the License.                                             %
  32 %                                                                             %
  33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  34 %
  35 %
  36 */
  37 \f
  38 /*
  39   Include declarations.
  40 */
  41 #include "MagickCore/studio.h"
  42 #include "MagickCore/attribute.h"
  43 #include "MagickCore/blob.h"
  44 #include "MagickCore/blob-private.h"
  45 #include "MagickCore/color-private.h"
  46 #include "MagickCore/exception.h"
  47 #include "MagickCore/exception-private.h"
  48 #include "MagickCore/cache.h"
  49 #include "MagickCore/constitute.h"
  50 #include "MagickCore/delegate.h"
  51 #include "MagickCore/geometry.h"
  52 #include "MagickCore/list.h"
  53 #include "MagickCore/magick.h"
  54 #include "MagickCore/memory_.h"
  55 #include "MagickCore/monitor.h"
  56 #include "MagickCore/option.h"
  57 #include "MagickCore/pixel.h"
  58 #include "MagickCore/pixel-accessor.h"
  59 #include "MagickCore/property.h"
  60 #include "MagickCore/quantum.h"
  61 #include "MagickCore/quantum-private.h"
  62 #include "MagickCore/resource_.h"
  63 #include "MagickCore/semaphore.h"
  64 #include "MagickCore/statistic.h"
  65 #include "MagickCore/stream.h"
  66 #include "MagickCore/string_.h"
  67 #include "MagickCore/string-private.h"
  68 #include "MagickCore/thread-private.h"
  69 #include "MagickCore/utility.h"
  70 \f
  71 /*
  72   Define declarations.
  73 */
  74 #define QuantumSignature  0xab
  75 \f
  76 /*
  77   Forward declarations.
  78 */
  79 static void
  80   DestroyQuantumPixels(QuantumInfo *);
  81 \f
  82 /*
  83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  84 %                                                                             %
  85 %                                                                             %
  86 %                                                                             %
  87 %   A c q u i r e Q u a n t u m I n f o                                       %
  88 %                                                                             %
  89 %                                                                             %
  90 %                                                                             %
  91 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  92 %
  93 %  AcquireQuantumInfo() allocates the QuantumInfo structure.
  94 %
  95 %  The format of the AcquireQuantumInfo method is:
  96 %
  97 %      QuantumInfo *AcquireQuantumInfo(const ImageInfo *image_info,Image *image)
  98 %
  99 %  A description of each parameter follows:
 100 %
 101 %    o image_info: the image info.
 102 %
 103 %    o image: the image.
 104 %
 105 */
 106
 107 static inline size_t MagickMax(const size_t x,
 108   const size_t y)
 109 {
 110   if (x > y)
 111     return(x);
 112   return(y);
 113 }
 114
 115 MagickExport QuantumInfo *AcquireQuantumInfo(const ImageInfo *image_info,
 116   Image *image)
 117 {
 118   MagickBooleanType
 119     status;
 120
 121   QuantumInfo
 122     *quantum_info;
 123
 124   quantum_info=(QuantumInfo *) AcquireMagickMemory(sizeof(*quantum_info));
 125   if (quantum_info == (QuantumInfo *) NULL)
 126     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 127   quantum_info->signature=MagickSignature;
 128   GetQuantumInfo(image_info,quantum_info);
 129   if (image == (const Image *) NULL)
 130     return(quantum_info);
 131   status=SetQuantumDepth(image,quantum_info,image->depth);
 132   if (status == MagickFalse)
 133     quantum_info=DestroyQuantumInfo(quantum_info);
 134   quantum_info->endian=image->endian;
 135   return(quantum_info);
 136 }
 137 \f
 138 /*
 139 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 140 %                                                                             %
 141 %                                                                             %
 142 %                                                                             %
 143 +   A c q u i r e Q u a n t u m P i x e l s                                   %
 144 %                                                                             %
 145 %                                                                             %
 146 %                                                                             %
 147 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 148 %
 149 %  AcquireQuantumPixels() allocates the unsigned char structure.
 150 %
 151 %  The format of the AcquireQuantumPixels method is:
 152 %
 153 %      MagickBooleanType AcquireQuantumPixels(QuantumInfo *quantum_info,
 154 %        const size_t extent)
 155 %
 156 %  A description of each parameter follows:
 157 %
 158 %    o quantum_info: the quantum info.
 159 %
 160 %    o extent: the quantum info.
 161 %
 162 */
 163 static MagickBooleanType AcquireQuantumPixels(QuantumInfo *quantum_info,
 164   const size_t extent)
 165 {
 166   register ssize_t
 167     i;
 168
 169   assert(quantum_info != (QuantumInfo *) NULL);
 170   assert(quantum_info->signature == MagickSignature);
 171   quantum_info->number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
 172   quantum_info->pixels=(unsigned char **) AcquireQuantumMemory(
 173     quantum_info->number_threads,sizeof(*quantum_info->pixels));
 174   if (quantum_info->pixels == (unsigned char **) NULL)
 175     return(MagickFalse);
 176   quantum_info->extent=extent;
 177   (void) ResetMagickMemory(quantum_info->pixels,0,quantum_info->number_threads*
 178     sizeof(*quantum_info->pixels));
 179   for (i=0; i < (ssize_t) quantum_info->number_threads; i++)
 180   {
 181     quantum_info->pixels[i]=(unsigned char *) AcquireQuantumMemory(extent+1,
 182       sizeof(**quantum_info->pixels));
 183     if (quantum_info->pixels[i] == (unsigned char *) NULL)
 184       return(MagickFalse);
 185     (void) ResetMagickMemory(quantum_info->pixels[i],0,(extent+1)*
 186       sizeof(**quantum_info->pixels));
 187     quantum_info->pixels[i][extent]=QuantumSignature;
 188   }
 189   return(MagickTrue);
 190 }
 191 \f
 192 /*
 193 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 194 %                                                                             %
 195 %                                                                             %
 196 %                                                                             %
 197 %   D e s t r o y Q u a n t u m I n f o                                       %
 198 %                                                                             %
 199 %                                                                             %
 200 %                                                                             %
 201 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 202 %
 203 %  DestroyQuantumInfo() deallocates memory associated with the QuantumInfo
 204 %  structure.
 205 %
 206 %  The format of the DestroyQuantumInfo method is:
 207 %
 208 %      QuantumInfo *DestroyQuantumInfo(QuantumInfo *quantum_info)
 209 %
 210 %  A description of each parameter follows:
 211 %
 212 %    o quantum_info: the quantum info.
 213 %
 214 */
 215 MagickExport QuantumInfo *DestroyQuantumInfo(QuantumInfo *quantum_info)
 216 {
 217   assert(quantum_info != (QuantumInfo *) NULL);
 218   assert(quantum_info->signature == MagickSignature);
 219   if (quantum_info->pixels != (unsigned char **) NULL)
 220     DestroyQuantumPixels(quantum_info);
 221   if (quantum_info->semaphore != (SemaphoreInfo *) NULL)
 222     DestroySemaphoreInfo(&quantum_info->semaphore);
 223   quantum_info->signature=(~MagickSignature);
 224   quantum_info=(QuantumInfo *) RelinquishMagickMemory(quantum_info);
 225   return(quantum_info);
 226 }
 227 \f
 228 /*
 229 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 230 %                                                                             %
 231 %                                                                             %
 232 %                                                                             %
 233 +   D e s t r o y Q u a n t u m P i x e l s                                   %
 234 %                                                                             %
 235 %                                                                             %
 236 %                                                                             %
 237 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 238 %
 239 %  DestroyQuantumPixels() destroys the quantum pixels.
 240 %
 241 %  The format of the DestroyQuantumPixels() method is:
 242 %
 243 %      void DestroyQuantumPixels(QuantumInfo *quantum_info)
 244 %
 245 %  A description of each parameter follows:
 246 %
 247 %    o quantum_info: the quantum info.
 248 %
 249 */
 250 static void DestroyQuantumPixels(QuantumInfo *quantum_info)
 251 {
 252   register ssize_t
 253     i;
 254
 255   ssize_t
 256     extent;
 257
 258   assert(quantum_info != (QuantumInfo *) NULL);
 259   assert(quantum_info->signature == MagickSignature);
 260   assert(quantum_info->pixels != (unsigned char **) NULL);
 261   extent=(ssize_t) quantum_info->extent;
 262   for (i=0; i < (ssize_t) quantum_info->number_threads; i++)
 263     if (quantum_info->pixels[i] != (unsigned char *) NULL)
 264       {
 265         /*
 266           Did we overrun our quantum buffer?
 267         */
 268         assert(quantum_info->pixels[i][extent] == QuantumSignature);
 269         quantum_info->pixels[i]=(unsigned char *) RelinquishMagickMemory(
 270           quantum_info->pixels[i]);
 271       }
 272   quantum_info->pixels=(unsigned char **) RelinquishMagickMemory(
 273     quantum_info->pixels);
 274 }
 275 \f
 276 /*
 277 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 278 %                                                                             %
 279 %                                                                             %
 280 %                                                                             %
 281 %   G e t Q u a n t u m E x t e n t                                           %
 282 %                                                                             %
 283 %                                                                             %
 284 %                                                                             %
 285 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 286 %
 287 %  GetQuantumExtent() returns the quantum pixel buffer extent.
 288 %
 289 %  The format of the GetQuantumExtent method is:
 290 %
 291 %      size_t GetQuantumExtent(Image *image,const QuantumInfo *quantum_info,
 292 %        const QuantumType quantum_type)
 293 %
 294 %  A description of each parameter follows:
 295 %
 296 %    o image: the image.
 297 %
 298 %    o quantum_info: the quantum info.
 299 %
 300 %    o quantum_type: Declare which pixel components to transfer (red, green,
 301 %      blue, opacity, RGB, or RGBA).
 302 %
 303 */
 304 MagickExport size_t GetQuantumExtent(const Image *image,
 305   const QuantumInfo *quantum_info,const QuantumType quantum_type)
 306 {
 307   size_t
 308     packet_size;
 309
 310   assert(quantum_info != (QuantumInfo *) NULL);
 311   assert(quantum_info->signature == MagickSignature);
 312   packet_size=1;
 313   switch (quantum_type)
 314   {
 315     case GrayAlphaQuantum: packet_size=2; break;
 316     case IndexAlphaQuantum: packet_size=2; break;
 317     case RGBQuantum: packet_size=3; break;
 318     case BGRQuantum: packet_size=3; break;
 319     case RGBAQuantum: packet_size=4; break;
 320     case RGBOQuantum: packet_size=4; break;
 321     case BGRAQuantum: packet_size=4; break;
 322     case CMYKQuantum: packet_size=4; break;
 323     case CMYKAQuantum: packet_size=5; break;
 324     default: break;
 325   }
 326   if (quantum_info->pack == MagickFalse)
 327     return((size_t) (packet_size*image->columns*((quantum_info->depth+7)/8)));
 328   return((size_t) ((packet_size*image->columns*quantum_info->depth+7)/8));
 329 }
 330 \f
 331 /*
 332 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 333 %                                                                             %
 334 %                                                                             %
 335 %                                                                             %
 336 %   G e t Q u a n t u m F o r m a t                                           %
 337 %                                                                             %
 338 %                                                                             %
 339 %                                                                             %
 340 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 341 %
 342 %  GetQuantumFormat() returns the quantum format of the image.
 343 %
 344 %  The format of the GetQuantumFormat method is:
 345 %
 346 %      QuantumFormatType GetQuantumFormat(const QuantumInfo *quantum_info)
 347 %
 348 %  A description of each parameter follows:
 349 %
 350 %    o quantum_info: the quantum info.
 351 %
 352 */
 353 MagickExport QuantumFormatType GetQuantumFormat(const QuantumInfo *quantum_info)
 354 {
 355   assert(quantum_info != (QuantumInfo *) NULL);
 356   assert(quantum_info->signature == MagickSignature);
 357   return(quantum_info->format);
 358 }
 359 \f
 360 /*
 361 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 362 %                                                                             %
 363 %                                                                             %
 364 %                                                                             %
 365 %   G e t Q u a n t u m I n f o                                               %
 366 %                                                                             %
 367 %                                                                             %
 368 %                                                                             %
 369 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 370 %
 371 %  GetQuantumInfo() initializes the QuantumInfo structure to default values.
 372 %
 373 %  The format of the GetQuantumInfo method is:
 374 %
 375 %      GetQuantumInfo(const ImageInfo *image_info,QuantumInfo *quantum_info)
 376 %
 377 %  A description of each parameter follows:
 378 %
 379 %    o image_info: the image info.
 380 %
 381 %    o quantum_info: the quantum info.
 382 %
 383 */
 384 MagickExport void GetQuantumInfo(const ImageInfo *image_info,
 385   QuantumInfo *quantum_info)
 386 {
 387   const char
 388     *option;
 389
 390   assert(quantum_info != (QuantumInfo *) NULL);
 391   (void) ResetMagickMemory(quantum_info,0,sizeof(*quantum_info));
 392   quantum_info->quantum=8;
 393   quantum_info->maximum=1.0;
 394   quantum_info->scale=QuantumRange;
 395   quantum_info->pack=MagickTrue;
 396   quantum_info->semaphore=AllocateSemaphoreInfo();
 397   quantum_info->signature=MagickSignature;
 398   if (image_info == (const ImageInfo *) NULL)
 399     return;
 400   option=GetImageOption(image_info,"quantum:format");
 401   if (option != (char *) NULL)
 402     quantum_info->format=(QuantumFormatType) ParseCommandOption(
 403       MagickQuantumFormatOptions,MagickFalse,option);
 404   option=GetImageOption(image_info,"quantum:minimum");
 405   if (option != (char *) NULL)
 406     quantum_info->minimum=StringToDouble(option,(char **) NULL);
 407   option=GetImageOption(image_info,"quantum:maximum");
 408   if (option != (char *) NULL)
 409     quantum_info->maximum=StringToDouble(option,(char **) NULL);
 410   if ((quantum_info->minimum == 0.0) && (quantum_info->maximum == 0.0))
 411     quantum_info->scale=0.0;
 412   else
 413     if (quantum_info->minimum == quantum_info->maximum)
 414       {
 415         quantum_info->scale=(double) QuantumRange/quantum_info->minimum;
 416         quantum_info->minimum=0.0;
 417       }
 418     else
 419       quantum_info->scale=(double) QuantumRange/(quantum_info->maximum-
 420         quantum_info->minimum);
 421   option=GetImageOption(image_info,"quantum:scale");
 422   if (option != (char *) NULL)
 423     quantum_info->scale=StringToDouble(option,(char **) NULL);
 424   option=GetImageOption(image_info,"quantum:polarity");
 425   if (option != (char *) NULL)
 426     quantum_info->min_is_white=LocaleCompare(option,"min-is-white") == 0 ?
 427       MagickTrue : MagickFalse;
 428   quantum_info->endian=image_info->endian;
 429   ResetQuantumState(quantum_info);
 430 }
 431 \f
 432 /*
 433 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 434 %                                                                             %
 435 %                                                                             %
 436 %                                                                             %
 437 %   G e t Q u a n t u m P i x e l s                                           %
 438 %                                                                             %
 439 %                                                                             %
 440 %                                                                             %
 441 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 442 %
 443 %  GetQuantumPixels() returns the quantum pixels.
 444 %
 445 %  The format of the GetQuantumPixels method is:
 446 %
 447 %      unsigned char *QuantumPixels GetQuantumPixels(
 448 %        const QuantumInfo *quantum_info)
 449 %
 450 %  A description of each parameter follows:
 451 %
 452 %    o image: the image.
 453 %
 454 */
 455 MagickExport unsigned char *GetQuantumPixels(const QuantumInfo *quantum_info)
 456 {
 457   const int
 458     id = GetOpenMPThreadId();
 459
 460   assert(quantum_info != (QuantumInfo *) NULL);
 461   assert(quantum_info->signature == MagickSignature);
 462   return(quantum_info->pixels[id]);
 463 }
 464 \f
 465 /*
 466 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 467 %                                                                             %
 468 %                                                                             %
 469 %                                                                             %
 470 %   G e t Q u a n t u m T y p e                                               %
 471 %                                                                             %
 472 %                                                                             %
 473 %                                                                             %
 474 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 475 %
 476 %  GetQuantumType() returns the quantum type of the image.
 477 %
 478 %  The format of the GetQuantumType method is:
 479 %
 480 %      QuantumType GetQuantumType(Image *image,ExceptionInfo *exception)
 481 %
 482 %  A description of each parameter follows:
 483 %
 484 %    o image: the image.
 485 %
 486 */
 487 MagickExport QuantumType GetQuantumType(Image *image,ExceptionInfo *exception)
 488 {
 489   QuantumType
 490     quantum_type;
 491
 492   assert(image != (Image *) NULL);
 493   assert(image->signature == MagickSignature);
 494   if (image->debug != MagickFalse)
 495     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 496   quantum_type=RGBQuantum;
 497   if (image->alpha_trait == BlendPixelTrait)
 498     quantum_type=RGBAQuantum;
 499   if (image->colorspace == CMYKColorspace)
 500     {
 501       quantum_type=CMYKQuantum;
 502       if (image->alpha_trait == BlendPixelTrait)
 503         quantum_type=CMYKAQuantum;
 504     }
 505   if (IsImageGray(image,exception) != MagickFalse)
 506     {
 507       quantum_type=GrayQuantum;
 508       if (image->alpha_trait == BlendPixelTrait)
 509         quantum_type=GrayAlphaQuantum;
 510     }
 511   if (image->storage_class == PseudoClass)
 512     {
 513       quantum_type=IndexQuantum;
 514       if (image->alpha_trait == BlendPixelTrait)
 515         quantum_type=IndexAlphaQuantum;
 516     }
 517   return(quantum_type);
 518 }
 519 \f
 520 /*
 521 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 522 %                                                                             %
 523 %                                                                             %
 524 %                                                                             %
 525 +   R e s e t Q u a n t u m S t a t e                                         %
 526 %                                                                             %
 527 %                                                                             %
 528 %                                                                             %
 529 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 530 %
 531 %  ResetQuantumState() resets the quantum state.
 532 %
 533 %  The format of the ResetQuantumState method is:
 534 %
 535 %      void ResetQuantumState(QuantumInfo *quantum_info)
 536 %
 537 %  A description of each parameter follows:
 538 %
 539 %    o quantum_info: the quantum info.
 540 %
 541 */
 542 MagickPrivate void ResetQuantumState(QuantumInfo *quantum_info)
 543 {
 544   static const unsigned int mask[32] =
 545   {
 546     0x00000000U, 0x00000001U, 0x00000003U, 0x00000007U, 0x0000000fU,
 547     0x0000001fU, 0x0000003fU, 0x0000007fU, 0x000000ffU, 0x000001ffU,
 548     0x000003ffU, 0x000007ffU, 0x00000fffU, 0x00001fffU, 0x00003fffU,
 549     0x00007fffU, 0x0000ffffU, 0x0001ffffU, 0x0003ffffU, 0x0007ffffU,
 550     0x000fffffU, 0x001fffffU, 0x003fffffU, 0x007fffffU, 0x00ffffffU,
 551     0x01ffffffU, 0x03ffffffU, 0x07ffffffU, 0x0fffffffU, 0x1fffffffU,
 552     0x3fffffffU, 0x7fffffffU
 553   };
 554
 555   assert(quantum_info != (QuantumInfo *) NULL);
 556   assert(quantum_info->signature == MagickSignature);
 557   quantum_info->state.inverse_scale=1.0;
 558   if (fabs(quantum_info->scale) >= MagickEpsilon)
 559     quantum_info->state.inverse_scale/=quantum_info->scale;
 560   quantum_info->state.pixel=0U;
 561   quantum_info->state.bits=0U;
 562   quantum_info->state.mask=mask;
 563 }
 564 \f
 565 /*
 566 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 567 %                                                                             %
 568 %                                                                             %
 569 %                                                                             %
 570 %   S e t Q u a n t u m F o r m a t                                           %
 571 %                                                                             %
 572 %                                                                             %
 573 %                                                                             %
 574 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 575 %
 576 %  SetQuantumAlphaType() sets the quantum format.
 577 %
 578 %  The format of the SetQuantumAlphaType method is:
 579 %
 580 %      void SetQuantumAlphaType(QuantumInfo *quantum_info,
 581 %        const QuantumAlphaType type)
 582 %
 583 %  A description of each parameter follows:
 584 %
 585 %    o quantum_info: the quantum info.
 586 %
 587 %    o type: the alpha type (e.g. associate).
 588 %
 589 */
 590 MagickExport void SetQuantumAlphaType(QuantumInfo *quantum_info,
 591   const QuantumAlphaType type)
 592 {
 593   assert(quantum_info != (QuantumInfo *) NULL);
 594   assert(quantum_info->signature == MagickSignature);
 595   quantum_info->alpha_type=type;
 596 }
 597 \f
 598 /*
 599 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 600 %                                                                             %
 601 %                                                                             %
 602 %                                                                             %
 603 %   S e t Q u a n t u m D e p t h                                             %
 604 %                                                                             %
 605 %                                                                             %
 606 %                                                                             %
 607 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 608 %
 609 %  SetQuantumDepth() sets the quantum depth.
 610 %
 611 %  The format of the SetQuantumDepth method is:
 612 %
 613 %      MagickBooleanType SetQuantumDepth(const Image *image,
 614 %        QuantumInfo *quantum_info,const size_t depth)
 615 %
 616 %  A description of each parameter follows:
 617 %
 618 %    o image: the image.
 619 %
 620 %    o quantum_info: the quantum info.
 621 %
 622 %    o depth: the quantum depth.
 623 %
 624 */
 625 MagickExport MagickBooleanType SetQuantumDepth(const Image *image,
 626   QuantumInfo *quantum_info,const size_t depth)
 627 {
 628   MagickBooleanType
 629     status;
 630
 631   /*
 632     Allocate the quantum pixel buffer.
 633   */
 634   assert(image != (Image *) NULL);
 635   assert(image->signature == MagickSignature);
 636   if (image->debug != MagickFalse)
 637     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 638   assert(quantum_info != (QuantumInfo *) NULL);
 639   assert(quantum_info->signature == MagickSignature);
 640   quantum_info->depth=depth;
 641   if (quantum_info->format == FloatingPointQuantumFormat)
 642     {
 643       if (quantum_info->depth > 32)
 644         quantum_info->depth=64;
 645       else
 646         if (quantum_info->depth > 16)
 647           quantum_info->depth=32;
 648         else
 649           quantum_info->depth=16;
 650     }
 651   if (quantum_info->pixels != (unsigned char **) NULL)
 652     DestroyQuantumPixels(quantum_info);
 653   status=AcquireQuantumPixels(quantum_info,(6+quantum_info->pad)*image->columns*
 654     ((quantum_info->depth+7)/8));  /* allow for CMYKA + RLE byte + pad */
 655   return(status);
 656 }
 657 \f
 658 /*
 659 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 660 %                                                                             %
 661 %                                                                             %
 662 %                                                                             %
 663 %   S e t Q u a n t u m F o r m a t                                           %
 664 %                                                                             %
 665 %                                                                             %
 666 %                                                                             %
 667 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 668 %
 669 %  SetQuantumFormat() sets the quantum format.
 670 %
 671 %  The format of the SetQuantumFormat method is:
 672 %
 673 %      MagickBooleanType SetQuantumFormat(const Image *image,
 674 %        QuantumInfo *quantum_info,const QuantumFormatType format)
 675 %
 676 %  A description of each parameter follows:
 677 %
 678 %    o image: the image.
 679 %
 680 %    o quantum_info: the quantum info.
 681 %
 682 %    o format: the quantum format.
 683 %
 684 */
 685 MagickExport MagickBooleanType SetQuantumFormat(const Image *image,
 686   QuantumInfo *quantum_info,const QuantumFormatType format)
 687 {
 688   assert(image != (Image *) NULL);
 689   assert(image->signature == MagickSignature);
 690   if (image->debug != MagickFalse)
 691     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 692   assert(quantum_info != (QuantumInfo *) NULL);
 693   assert(quantum_info->signature == MagickSignature);
 694   quantum_info->format=format;
 695   return(SetQuantumDepth(image,quantum_info,quantum_info->depth));
 696 }
 697 \f
 698 /*
 699 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 700 %                                                                             %
 701 %                                                                             %
 702 %                                                                             %
 703 %   S e t Q u a n t u m I m a g e T y p e                                     %
 704 %                                                                             %
 705 %                                                                             %
 706 %                                                                             %
 707 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 708 %
 709 %  SetQuantumImageType() sets the image type based on the quantum type.
 710 %
 711 %  The format of the SetQuantumImageType method is:
 712 %
 713 %      void ImageType SetQuantumImageType(Image *image,
 714 %        const QuantumType quantum_type)
 715 %
 716 %  A description of each parameter follows:
 717 %
 718 %    o image: the image.
 719 %
 720 %    o quantum_type: Declare which pixel components to transfer (red, green,
 721 %      blue, opacity, RGB, or RGBA).
 722 %
 723 */
 724 MagickExport void SetQuantumImageType(Image *image,
 725   const QuantumType quantum_type)
 726 {
 727   assert(image != (Image *) NULL);
 728   assert(image->signature == MagickSignature);
 729   if (image->debug != MagickFalse)
 730     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 731   switch (quantum_type)
 732   {
 733     case IndexQuantum:
 734     case IndexAlphaQuantum:
 735     {
 736       image->type=PaletteType;
 737       break;
 738     }
 739     case GrayQuantum:
 740     case GrayAlphaQuantum:
 741     {
 742       image->type=GrayscaleType;
 743       if (image->depth == 1)
 744         image->type=BilevelType;
 745       break;
 746     }
 747     case CyanQuantum:
 748     case MagentaQuantum:
 749     case YellowQuantum:
 750     case BlackQuantum:
 751     case CMYKQuantum:
 752     case CMYKAQuantum:
 753     {
 754       image->type=ColorSeparationType;
 755       break;
 756     }
 757     default:
 758     {
 759       image->type=TrueColorType;
 760       break;
 761     }
 762   }
 763 }
 764 \f
 765 /*
 766 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 767 %                                                                             %
 768 %                                                                             %
 769 %                                                                             %
 770 %   S e t Q u a n t u m P a c k                                               %
 771 %                                                                             %
 772 %                                                                             %
 773 %                                                                             %
 774 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 775 %
 776 %  SetQuantumPack() sets the quantum pack flag.
 777 %
 778 %  The format of the SetQuantumPack method is:
 779 %
 780 %      void SetQuantumPack(QuantumInfo *quantum_info,
 781 %        const MagickBooleanType pack)
 782 %
 783 %  A description of each parameter follows:
 784 %
 785 %    o quantum_info: the quantum info.
 786 %
 787 %    o pack: the pack flag.
 788 %
 789 */
 790 MagickExport void SetQuantumPack(QuantumInfo *quantum_info,
 791   const MagickBooleanType pack)
 792 {
 793   assert(quantum_info != (QuantumInfo *) NULL);
 794   assert(quantum_info->signature == MagickSignature);
 795   quantum_info->pack=pack;
 796 }
 797 \f
 798 \f
 799 /*
 800 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 801 %                                                                             %
 802 %                                                                             %
 803 %                                                                             %
 804 %   S e t Q u a n t u m P a d                                                 %
 805 %                                                                             %
 806 %                                                                             %
 807 %                                                                             %
 808 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 809 %
 810 %  SetQuantumPad() sets the quantum pad.
 811 %
 812 %  The format of the SetQuantumPad method is:
 813 %
 814 %      MagickBooleanType SetQuantumPad(const Image *image,
 815 %        QuantumInfo *quantum_info,const size_t pad)
 816 %
 817 %  A description of each parameter follows:
 818 %
 819 %    o image: the image.
 820 %
 821 %    o quantum_info: the quantum info.
 822 %
 823 %    o pad: the quantum pad.
 824 %
 825 */
 826 MagickExport MagickBooleanType SetQuantumPad(const Image *image,
 827   QuantumInfo *quantum_info,const size_t pad)
 828 {
 829   assert(image != (Image *) NULL);
 830   assert(image->signature == MagickSignature);
 831   if (image->debug != MagickFalse)
 832     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 833   assert(quantum_info != (QuantumInfo *) NULL);
 834   assert(quantum_info->signature == MagickSignature);
 835   quantum_info->pad=pad;
 836   return(SetQuantumDepth(image,quantum_info,quantum_info->depth));
 837 }
 838 \f
 839 /*
 840 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 841 %                                                                             %
 842 %                                                                             %
 843 %                                                                             %
 844 %   S e t Q u a n t u m M i n I s W h i t e                                   %
 845 %                                                                             %
 846 %                                                                             %
 847 %                                                                             %
 848 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 849 %
 850 %  SetQuantumMinIsWhite() sets the quantum min-is-white flag.
 851 %
 852 %  The format of the SetQuantumMinIsWhite method is:
 853 %
 854 %      void SetQuantumMinIsWhite(QuantumInfo *quantum_info,
 855 %        const MagickBooleanType min_is_white)
 856 %
 857 %  A description of each parameter follows:
 858 %
 859 %    o quantum_info: the quantum info.
 860 %
 861 %    o min_is_white: the min-is-white flag.
 862 %
 863 */
 864 MagickExport void SetQuantumMinIsWhite(QuantumInfo *quantum_info,
 865   const MagickBooleanType min_is_white)
 866 {
 867   assert(quantum_info != (QuantumInfo *) NULL);
 868   assert(quantum_info->signature == MagickSignature);
 869   quantum_info->min_is_white=min_is_white;
 870 }
 871 \f
 872 /*
 873 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 874 %                                                                             %
 875 %                                                                             %
 876 %                                                                             %
 877 %   S e t Q u a n t u m Q u a n t u m                                         %
 878 %                                                                             %
 879 %                                                                             %
 880 %                                                                             %
 881 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 882 %
 883 %  SetQuantumQuantum() sets the quantum quantum.
 884 %
 885 %  The format of the SetQuantumQuantum method is:
 886 %
 887 %      void SetQuantumQuantum(QuantumInfo *quantum_info,
 888 %        const size_t quantum)
 889 %
 890 %  A description of each parameter follows:
 891 %
 892 %    o quantum_info: the quantum info.
 893 %
 894 %    o quantum: the quantum quantum.
 895 %
 896 */
 897 MagickExport void SetQuantumQuantum(QuantumInfo *quantum_info,
 898   const size_t quantum)
 899 {
 900   assert(quantum_info != (QuantumInfo *) NULL);
 901   assert(quantum_info->signature == MagickSignature);
 902   quantum_info->quantum=quantum;
 903 }
 904 \f
 905 /*
 906 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 907 %                                                                             %
 908 %                                                                             %
 909 %                                                                             %
 910 %   S e t Q u a n t u m S c a l e                                             %
 911 %                                                                             %
 912 %                                                                             %
 913 %                                                                             %
 914 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 915 %
 916 %  SetQuantumScale() sets the quantum scale.
 917 %
 918 %  The format of the SetQuantumScale method is:
 919 %
 920 %      void SetQuantumScale(QuantumInfo *quantum_info,const double scale)
 921 %
 922 %  A description of each parameter follows:
 923 %
 924 %    o quantum_info: the quantum info.
 925 %
 926 %    o scale: the quantum scale.
 927 %
 928 */
 929 MagickExport void SetQuantumScale(QuantumInfo *quantum_info,const double scale)
 930 {
 931   assert(quantum_info != (QuantumInfo *) NULL);
 932   assert(quantum_info->signature == MagickSignature);
 933   quantum_info->scale=scale;
 934 }