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   return(quantum_info);
 135 }
 136 \f
 137 /*
 138 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 139 %                                                                             %
 140 %                                                                             %
 141 %                                                                             %
 142 +   A c q u i r e Q u a n t u m P i x e l s                                   %
 143 %                                                                             %
 144 %                                                                             %
 145 %                                                                             %
 146 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 147 %
 148 %  AcquireQuantumPixels() allocates the unsigned char structure.
 149 %
 150 %  The format of the AcquireQuantumPixels method is:
 151 %
 152 %      MagickBooleanType AcquireQuantumPixels(QuantumInfo *quantum_info,
 153 %        const size_t extent)
 154 %
 155 %  A description of each parameter follows:
 156 %
 157 %    o quantum_info: the quantum info.
 158 %
 159 %    o extent: the quantum info.
 160 %
 161 */
 162 static MagickBooleanType AcquireQuantumPixels(QuantumInfo *quantum_info,
 163   const size_t extent)
 164 {
 165   register ssize_t
 166     i;
 167
 168   assert(quantum_info != (QuantumInfo *) NULL);
 169   assert(quantum_info->signature == MagickSignature);
 170   quantum_info->number_threads=GetOpenMPMaximumThreads();
 171   quantum_info->pixels=(unsigned char **) AcquireQuantumMemory(
 172     quantum_info->number_threads,sizeof(*quantum_info->pixels));
 173   if (quantum_info->pixels == (unsigned char **) NULL)
 174     return(MagickFalse);
 175   quantum_info->extent=extent;
 176   (void) ResetMagickMemory(quantum_info->pixels,0,
 177     quantum_info->number_threads*sizeof(*quantum_info->pixels));
 178   for (i=0; i < (ssize_t) quantum_info->number_threads; i++)
 179   {
 180     quantum_info->pixels[i]=(unsigned char *) AcquireQuantumMemory(extent+1,
 181       sizeof(**quantum_info->pixels));
 182     if (quantum_info->pixels[i] == (unsigned char *) NULL)
 183       return(MagickFalse);
 184     (void) ResetMagickMemory(quantum_info->pixels[i],0,(extent+1)*
 185       sizeof(**quantum_info->pixels));
 186     quantum_info->pixels[i][extent]=QuantumSignature;
 187   }
 188   return(MagickTrue);
 189 }
 190 \f
 191 /*
 192 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 193 %                                                                             %
 194 %                                                                             %
 195 %                                                                             %
 196 %   D e s t r o y Q u a n t u m I n f o                                       %
 197 %                                                                             %
 198 %                                                                             %
 199 %                                                                             %
 200 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 201 %
 202 %  DestroyQuantumInfo() deallocates memory associated with the QuantumInfo
 203 %  structure.
 204 %
 205 %  The format of the DestroyQuantumInfo method is:
 206 %
 207 %      QuantumInfo *DestroyQuantumInfo(QuantumInfo *quantum_info)
 208 %
 209 %  A description of each parameter follows:
 210 %
 211 %    o quantum_info: the quantum info.
 212 %
 213 */
 214 MagickExport QuantumInfo *DestroyQuantumInfo(QuantumInfo *quantum_info)
 215 {
 216   assert(quantum_info != (QuantumInfo *) NULL);
 217   assert(quantum_info->signature == MagickSignature);
 218   if (quantum_info->pixels != (unsigned char **) NULL)
 219     DestroyQuantumPixels(quantum_info);
 220   if (quantum_info->semaphore != (SemaphoreInfo *) NULL)
 221     DestroySemaphoreInfo(&quantum_info->semaphore);
 222   quantum_info->signature=(~MagickSignature);
 223   quantum_info=(QuantumInfo *) RelinquishMagickMemory(quantum_info);
 224   return(quantum_info);
 225 }
 226 \f
 227 /*
 228 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 229 %                                                                             %
 230 %                                                                             %
 231 %                                                                             %
 232 +   D e s t r o y Q u a n t u m P i x e l s                                   %
 233 %                                                                             %
 234 %                                                                             %
 235 %                                                                             %
 236 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 237 %
 238 %  DestroyQuantumPixels() destroys the quantum pixels.
 239 %
 240 %  The format of the DestroyQuantumPixels() method is:
 241 %
 242 %      void DestroyQuantumPixels(QuantumInfo *quantum_info)
 243 %
 244 %  A description of each parameter follows:
 245 %
 246 %    o quantum_info: the quantum info.
 247 %
 248 */
 249 static void DestroyQuantumPixels(QuantumInfo *quantum_info)
 250 {
 251   register ssize_t
 252     i;
 253
 254   ssize_t
 255     extent;
 256
 257   assert(quantum_info != (QuantumInfo *) NULL);
 258   assert(quantum_info->signature == MagickSignature);
 259   assert(quantum_info->pixels != (unsigned char **) NULL);
 260   extent=(ssize_t) quantum_info->extent;
 261   for (i=0; i < (ssize_t) quantum_info->number_threads; i++)
 262     if (quantum_info->pixels[i] != (unsigned char *) NULL)
 263       {
 264         /*
 265           Did we overrun our quantum buffer?
 266         */
 267         assert(quantum_info->pixels[i][extent] == QuantumSignature);
 268         quantum_info->pixels[i]=(unsigned char *) RelinquishMagickMemory(
 269           quantum_info->pixels[i]);
 270       }
 271   quantum_info->pixels=(unsigned char **) RelinquishMagickMemory(
 272     quantum_info->pixels);
 273 }
 274 \f
 275 /*
 276 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 277 %                                                                             %
 278 %                                                                             %
 279 %                                                                             %
 280 %   G e t Q u a n t u m E x t e n t                                           %
 281 %                                                                             %
 282 %                                                                             %
 283 %                                                                             %
 284 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 285 %
 286 %  GetQuantumExtent() returns the quantum pixel buffer extent.
 287 %
 288 %  The format of the GetQuantumExtent method is:
 289 %
 290 %      size_t GetQuantumExtent(Image *image,const QuantumInfo *quantum_info,
 291 %        const QuantumType quantum_type)
 292 %
 293 %  A description of each parameter follows:
 294 %
 295 %    o image: the image.
 296 %
 297 %    o quantum_info: the quantum info.
 298 %
 299 %    o quantum_type: Declare which pixel components to transfer (red, green,
 300 %      blue, opacity, RGB, or RGBA).
 301 %
 302 */
 303 MagickExport size_t GetQuantumExtent(const Image *image,
 304   const QuantumInfo *quantum_info,const QuantumType quantum_type)
 305 {
 306   size_t
 307     packet_size;
 308
 309   assert(quantum_info != (QuantumInfo *) NULL);
 310   assert(quantum_info->signature == MagickSignature);
 311   packet_size=1;
 312   switch (quantum_type)
 313   {
 314     case GrayAlphaQuantum: packet_size=2; break;
 315     case IndexAlphaQuantum: packet_size=2; break;
 316     case RGBQuantum: packet_size=3; break;
 317     case BGRQuantum: packet_size=3; break;
 318     case RGBAQuantum: packet_size=4; break;
 319     case RGBOQuantum: packet_size=4; break;
 320     case BGRAQuantum: packet_size=4; break;
 321     case CMYKQuantum: packet_size=4; break;
 322     case CMYKAQuantum: packet_size=5; break;
 323     default: break;
 324   }
 325   if (quantum_info->pack == MagickFalse)
 326     return((size_t) (packet_size*image->columns*((quantum_info->depth+7)/8)));
 327   return((size_t) ((packet_size*image->columns*quantum_info->depth+7)/8));
 328 }
 329 \f
 330 /*
 331 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 332 %                                                                             %
 333 %                                                                             %
 334 %                                                                             %
 335 %   G e t Q u a n t u m F o r m a t                                           %
 336 %                                                                             %
 337 %                                                                             %
 338 %                                                                             %
 339 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 340 %
 341 %  GetQuantumFormat() returns the quantum format of the image.
 342 %
 343 %  The format of the GetQuantumFormat method is:
 344 %
 345 %      QuantumFormatType GetQuantumFormat(const QuantumInfo *quantum_info)
 346 %
 347 %  A description of each parameter follows:
 348 %
 349 %    o quantum_info: the quantum info.
 350 %
 351 */
 352 MagickExport QuantumFormatType GetQuantumFormat(const QuantumInfo *quantum_info)
 353 {
 354   assert(quantum_info != (QuantumInfo *) NULL);
 355   assert(quantum_info->signature == MagickSignature);
 356   return(quantum_info->format);
 357 }
 358 \f
 359 /*
 360 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 361 %                                                                             %
 362 %                                                                             %
 363 %                                                                             %
 364 %   G e t Q u a n t u m I n f o                                               %
 365 %                                                                             %
 366 %                                                                             %
 367 %                                                                             %
 368 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 369 %
 370 %  GetQuantumInfo() initializes the QuantumInfo structure to default values.
 371 %
 372 %  The format of the GetQuantumInfo method is:
 373 %
 374 %      GetQuantumInfo(const ImageInfo *image_info,QuantumInfo *quantum_info)
 375 %
 376 %  A description of each parameter follows:
 377 %
 378 %    o image_info: the image info.
 379 %
 380 %    o quantum_info: the quantum info.
 381 %
 382 */
 383 MagickExport void GetQuantumInfo(const ImageInfo *image_info,
 384   QuantumInfo *quantum_info)
 385 {
 386   const char
 387     *option;
 388
 389   assert(quantum_info != (QuantumInfo *) NULL);
 390   (void) ResetMagickMemory(quantum_info,0,sizeof(*quantum_info));
 391   quantum_info->quantum=8;
 392   quantum_info->maximum=1.0;
 393   quantum_info->scale=QuantumRange;
 394   quantum_info->pack=MagickTrue;
 395   quantum_info->semaphore=AllocateSemaphoreInfo();
 396   quantum_info->signature=MagickSignature;
 397   if (image_info == (const ImageInfo *) NULL)
 398     return;
 399   option=GetImageOption(image_info,"quantum:format");
 400   if (option != (char *) NULL)
 401     quantum_info->format=(QuantumFormatType) ParseCommandOption(
 402       MagickQuantumFormatOptions,MagickFalse,option);
 403   option=GetImageOption(image_info,"quantum:minimum");
 404   if (option != (char *) NULL)
 405     quantum_info->minimum=StringToDouble(option,(char **) NULL);
 406   option=GetImageOption(image_info,"quantum:maximum");
 407   if (option != (char *) NULL)
 408     quantum_info->maximum=StringToDouble(option,(char **) NULL);
 409   if ((quantum_info->minimum == 0.0) && (quantum_info->maximum == 0.0))
 410     quantum_info->scale=0.0;
 411   else
 412     if (quantum_info->minimum == quantum_info->maximum)
 413       {
 414         quantum_info->scale=(MagickRealType) QuantumRange/quantum_info->minimum;
 415         quantum_info->minimum=0.0;
 416       }
 417     else
 418       quantum_info->scale=(MagickRealType) QuantumRange/(quantum_info->maximum-
 419         quantum_info->minimum);
 420   option=GetImageOption(image_info,"quantum:scale");
 421   if (option != (char *) NULL)
 422     quantum_info->scale=StringToDouble(option,(char **) NULL);
 423   option=GetImageOption(image_info,"quantum:polarity");
 424   if (option != (char *) NULL)
 425     quantum_info->min_is_white=LocaleCompare(option,"min-is-white") == 0 ?
 426       MagickTrue : MagickFalse;
 427 }
 428 \f
 429 /*
 430 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 431 %                                                                             %
 432 %                                                                             %
 433 %                                                                             %
 434 %   G e t Q u a n t u m P i x e l s                                           %
 435 %                                                                             %
 436 %                                                                             %
 437 %                                                                             %
 438 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 439 %
 440 %  GetQuantumPixels() returns the quantum pixels.
 441 %
 442 %  The format of the GetQuantumPixels method is:
 443 %
 444 %      unsigned char *QuantumPixels GetQuantumPixels(
 445 %        const QuantumInfo *quantum_info)
 446 %
 447 %  A description of each parameter follows:
 448 %
 449 %    o image: the image.
 450 %
 451 */
 452 MagickExport unsigned char *GetQuantumPixels(const QuantumInfo *quantum_info)
 453 {
 454   const int
 455     id = GetOpenMPThreadId();
 456
 457   assert(quantum_info != (QuantumInfo *) NULL);
 458   assert(quantum_info->signature == MagickSignature);
 459   return(quantum_info->pixels[id]);
 460 }
 461 \f
 462 /*
 463 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 464 %                                                                             %
 465 %                                                                             %
 466 %                                                                             %
 467 %   G e t Q u a n t u m T y p e                                               %
 468 %                                                                             %
 469 %                                                                             %
 470 %                                                                             %
 471 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 472 %
 473 %  GetQuantumType() returns the quantum type of the image.
 474 %
 475 %  The format of the GetQuantumType method is:
 476 %
 477 %      QuantumType GetQuantumType(Image *image,ExceptionInfo *exception)
 478 %
 479 %  A description of each parameter follows:
 480 %
 481 %    o image: the image.
 482 %
 483 */
 484 MagickExport QuantumType GetQuantumType(Image *image,ExceptionInfo *exception)
 485 {
 486   QuantumType
 487     quantum_type;
 488
 489   assert(image != (Image *) NULL);
 490   assert(image->signature == MagickSignature);
 491   if (image->debug != MagickFalse)
 492     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 493   quantum_type=RGBQuantum;
 494   if (image->matte != MagickFalse)
 495     quantum_type=RGBAQuantum;
 496   if (image->colorspace == CMYKColorspace)
 497     {
 498       quantum_type=CMYKQuantum;
 499       if (image->matte != MagickFalse)
 500         quantum_type=CMYKAQuantum;
 501     }
 502   if (IsImageGray(image,exception) != MagickFalse)
 503     {
 504       quantum_type=GrayQuantum;
 505       if (image->matte != MagickFalse)
 506         quantum_type=GrayAlphaQuantum;
 507     }
 508   else
 509     if (image->storage_class == PseudoClass)
 510       {
 511         quantum_type=IndexQuantum;
 512         if (image->matte != MagickFalse)
 513           quantum_type=IndexAlphaQuantum;
 514       }
 515   return(quantum_type);
 516 }
 517 \f
 518 /*
 519 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 520 %                                                                             %
 521 %                                                                             %
 522 %                                                                             %
 523 %   S e t Q u a n t u m F o r m a t                                           %
 524 %                                                                             %
 525 %                                                                             %
 526 %                                                                             %
 527 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 528 %
 529 %  SetQuantumAlphaType() sets the quantum format.
 530 %
 531 %  The format of the SetQuantumAlphaType method is:
 532 %
 533 %      void SetQuantumAlphaType(QuantumInfo *quantum_info,
 534 %        const QuantumAlphaType type)
 535 %
 536 %  A description of each parameter follows:
 537 %
 538 %    o quantum_info: the quantum info.
 539 %
 540 %    o type: the alpha type (e.g. associate).
 541 %
 542 */
 543 MagickExport void SetQuantumAlphaType(QuantumInfo *quantum_info,
 544   const QuantumAlphaType type)
 545 {
 546   assert(quantum_info != (QuantumInfo *) NULL);
 547   assert(quantum_info->signature == MagickSignature);
 548   quantum_info->alpha_type=type;
 549 }
 550 \f
 551 /*
 552 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 553 %                                                                             %
 554 %                                                                             %
 555 %                                                                             %
 556 %   S e t Q u a n t u m D e p t h                                             %
 557 %                                                                             %
 558 %                                                                             %
 559 %                                                                             %
 560 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 561 %
 562 %  SetQuantumDepth() sets the quantum depth.
 563 %
 564 %  The format of the SetQuantumDepth method is:
 565 %
 566 %      MagickBooleanType SetQuantumDepth(const Image *image,
 567 %        QuantumInfo *quantum_info,const size_t depth)
 568 %
 569 %  A description of each parameter follows:
 570 %
 571 %    o image: the image.
 572 %
 573 %    o quantum_info: the quantum info.
 574 %
 575 %    o depth: the quantum depth.
 576 %
 577 */
 578 MagickExport MagickBooleanType SetQuantumDepth(const Image *image,
 579   QuantumInfo *quantum_info,const size_t depth)
 580 {
 581   MagickBooleanType
 582     status;
 583
 584   /*
 585     Allocate the quantum pixel buffer.
 586   */
 587   assert(image != (Image *) NULL);
 588   assert(image->signature == MagickSignature);
 589   if (image->debug != MagickFalse)
 590     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 591   assert(quantum_info != (QuantumInfo *) NULL);
 592   assert(quantum_info->signature == MagickSignature);
 593   quantum_info->depth=depth;
 594   if (quantum_info->format == FloatingPointQuantumFormat)
 595     {
 596       if (quantum_info->depth > 32)
 597         quantum_info->depth=64;
 598       else
 599         if (quantum_info->depth > 16)
 600           quantum_info->depth=32;
 601         else
 602           quantum_info->depth=16;
 603     }
 604   if (quantum_info->pixels != (unsigned char **) NULL)
 605     DestroyQuantumPixels(quantum_info);
 606   status=AcquireQuantumPixels(quantum_info,(6+quantum_info->pad)*image->columns*
 607     ((quantum_info->depth+7)/8));  /* allow for CMYKA + RLE byte + pad */
 608   return(status);
 609 }
 610 \f
 611 /*
 612 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 613 %                                                                             %
 614 %                                                                             %
 615 %                                                                             %
 616 %   S e t Q u a n t u m F o r m a t                                           %
 617 %                                                                             %
 618 %                                                                             %
 619 %                                                                             %
 620 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 621 %
 622 %  SetQuantumFormat() sets the quantum format.
 623 %
 624 %  The format of the SetQuantumFormat method is:
 625 %
 626 %      MagickBooleanType SetQuantumFormat(const Image *image,
 627 %        QuantumInfo *quantum_info,const QuantumFormatType format)
 628 %
 629 %  A description of each parameter follows:
 630 %
 631 %    o image: the image.
 632 %
 633 %    o quantum_info: the quantum info.
 634 %
 635 %    o format: the quantum format.
 636 %
 637 */
 638 MagickExport MagickBooleanType SetQuantumFormat(const Image *image,
 639   QuantumInfo *quantum_info,const QuantumFormatType format)
 640 {
 641   assert(image != (Image *) NULL);
 642   assert(image->signature == MagickSignature);
 643   if (image->debug != MagickFalse)
 644     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 645   assert(quantum_info != (QuantumInfo *) NULL);
 646   assert(quantum_info->signature == MagickSignature);
 647   quantum_info->format=format;
 648   return(SetQuantumDepth(image,quantum_info,quantum_info->depth));
 649 }
 650 \f
 651 /*
 652 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 653 %                                                                             %
 654 %                                                                             %
 655 %                                                                             %
 656 %   S e t Q u a n t u m I m a g e T y p e                                     %
 657 %                                                                             %
 658 %                                                                             %
 659 %                                                                             %
 660 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 661 %
 662 %  SetQuantumImageType() sets the image type based on the quantum type.
 663 %
 664 %  The format of the SetQuantumImageType method is:
 665 %
 666 %      void ImageType SetQuantumImageType(Image *image,
 667 %        const QuantumType quantum_type)
 668 %
 669 %  A description of each parameter follows:
 670 %
 671 %    o image: the image.
 672 %
 673 %    o quantum_type: Declare which pixel components to transfer (red, green,
 674 %      blue, opacity, RGB, or RGBA).
 675 %
 676 */
 677 MagickExport void SetQuantumImageType(Image *image,
 678   const QuantumType quantum_type)
 679 {
 680   assert(image != (Image *) NULL);
 681   assert(image->signature == MagickSignature);
 682   if (image->debug != MagickFalse)
 683     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 684   switch (quantum_type)
 685   {
 686     case IndexQuantum:
 687     case IndexAlphaQuantum:
 688     {
 689       image->type=PaletteType;
 690       break;
 691     }
 692     case GrayQuantum:
 693     case GrayAlphaQuantum:
 694     {
 695       image->type=GrayscaleType;
 696       if (image->depth == 1)
 697         image->type=BilevelType;
 698       break;
 699     }
 700     case CyanQuantum:
 701     case MagentaQuantum:
 702     case YellowQuantum:
 703     case BlackQuantum:
 704     case CMYKQuantum:
 705     case CMYKAQuantum:
 706     {
 707       image->type=ColorSeparationType;
 708       break;
 709     }
 710     default:
 711     {
 712       image->type=TrueColorType;
 713       break;
 714     }
 715   }
 716 }
 717 \f
 718 /*
 719 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 720 %                                                                             %
 721 %                                                                             %
 722 %                                                                             %
 723 %   S e t Q u a n t u m P a c k                                               %
 724 %                                                                             %
 725 %                                                                             %
 726 %                                                                             %
 727 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 728 %
 729 %  SetQuantumPack() sets the quantum pack flag.
 730 %
 731 %  The format of the SetQuantumPack method is:
 732 %
 733 %      void SetQuantumPack(QuantumInfo *quantum_info,
 734 %        const MagickBooleanType pack)
 735 %
 736 %  A description of each parameter follows:
 737 %
 738 %    o quantum_info: the quantum info.
 739 %
 740 %    o pack: the pack flag.
 741 %
 742 */
 743 MagickExport void SetQuantumPack(QuantumInfo *quantum_info,
 744   const MagickBooleanType pack)
 745 {
 746   assert(quantum_info != (QuantumInfo *) NULL);
 747   assert(quantum_info->signature == MagickSignature);
 748   quantum_info->pack=pack;
 749 }
 750 \f
 751 \f
 752 /*
 753 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 754 %                                                                             %
 755 %                                                                             %
 756 %                                                                             %
 757 %   S e t Q u a n t u m P a d                                                 %
 758 %                                                                             %
 759 %                                                                             %
 760 %                                                                             %
 761 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 762 %
 763 %  SetQuantumPad() sets the quantum pad.
 764 %
 765 %  The format of the SetQuantumPad method is:
 766 %
 767 %      MagickBooleanType SetQuantumPad(const Image *image,
 768 %        QuantumInfo *quantum_info,const size_t pad)
 769 %
 770 %  A description of each parameter follows:
 771 %
 772 %    o image: the image.
 773 %
 774 %    o quantum_info: the quantum info.
 775 %
 776 %    o pad: the quantum pad.
 777 %
 778 */
 779 MagickExport MagickBooleanType SetQuantumPad(const Image *image,
 780   QuantumInfo *quantum_info,const size_t pad)
 781 {
 782   assert(image != (Image *) NULL);
 783   assert(image->signature == MagickSignature);
 784   if (image->debug != MagickFalse)
 785     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 786   assert(quantum_info != (QuantumInfo *) NULL);
 787   assert(quantum_info->signature == MagickSignature);
 788   quantum_info->pad=pad;
 789   return(SetQuantumDepth(image,quantum_info,quantum_info->depth));
 790 }
 791 \f
 792 /*
 793 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 794 %                                                                             %
 795 %                                                                             %
 796 %                                                                             %
 797 %   S e t Q u a n t u m M i n I s W h i t e                                   %
 798 %                                                                             %
 799 %                                                                             %
 800 %                                                                             %
 801 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 802 %
 803 %  SetQuantumMinIsWhite() sets the quantum min-is-white flag.
 804 %
 805 %  The format of the SetQuantumMinIsWhite method is:
 806 %
 807 %      void SetQuantumMinIsWhite(QuantumInfo *quantum_info,
 808 %        const MagickBooleanType min_is_white)
 809 %
 810 %  A description of each parameter follows:
 811 %
 812 %    o quantum_info: the quantum info.
 813 %
 814 %    o min_is_white: the min-is-white flag.
 815 %
 816 */
 817 MagickExport void SetQuantumMinIsWhite(QuantumInfo *quantum_info,
 818   const MagickBooleanType min_is_white)
 819 {
 820   assert(quantum_info != (QuantumInfo *) NULL);
 821   assert(quantum_info->signature == MagickSignature);
 822   quantum_info->min_is_white=min_is_white;
 823 }
 824 \f
 825 /*
 826 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 827 %                                                                             %
 828 %                                                                             %
 829 %                                                                             %
 830 %   S e t Q u a n t u m Q u a n t u m                                         %
 831 %                                                                             %
 832 %                                                                             %
 833 %                                                                             %
 834 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 835 %
 836 %  SetQuantumQuantum() sets the quantum quantum.
 837 %
 838 %  The format of the SetQuantumQuantum method is:
 839 %
 840 %      void SetQuantumQuantum(QuantumInfo *quantum_info,
 841 %        const size_t quantum)
 842 %
 843 %  A description of each parameter follows:
 844 %
 845 %    o quantum_info: the quantum info.
 846 %
 847 %    o quantum: the quantum quantum.
 848 %
 849 */
 850 MagickExport void SetQuantumQuantum(QuantumInfo *quantum_info,
 851   const size_t quantum)
 852 {
 853   assert(quantum_info != (QuantumInfo *) NULL);
 854   assert(quantum_info->signature == MagickSignature);
 855   quantum_info->quantum=quantum;
 856 }
 857 \f
 858 /*
 859 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 860 %                                                                             %
 861 %                                                                             %
 862 %                                                                             %
 863 %   S e t Q u a n t u m S c a l e                                             %
 864 %                                                                             %
 865 %                                                                             %
 866 %                                                                             %
 867 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 868 %
 869 %  SetQuantumScale() sets the quantum scale.
 870 %
 871 %  The format of the SetQuantumScale method is:
 872 %
 873 %      void SetQuantumScale(QuantumInfo *quantum_info,const double scale)
 874 %
 875 %  A description of each parameter follows:
 876 %
 877 %    o quantum_info: the quantum info.
 878 %
 879 %    o scale: the quantum scale.
 880 %
 881 */
 882 MagickExport void SetQuantumScale(QuantumInfo *quantum_info,const double scale)
 883 {
 884   assert(quantum_info != (QuantumInfo *) NULL);
 885   assert(quantum_info->signature == MagickSignature);
 886   quantum_info->scale=scale;
 887 }