granicus.if.org Git - imagemagick/blob - coders/fpx.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            FFFFF  PPPP   X   X                              %
   7 %                            F      P   P   X X                               %
   8 %                            FFF    PPPP     X                                %
   9 %                            F      P       X X                               %
  10 %                            F      P      X   X                              %
  11 %                                                                             %
  12 %                                                                             %
  13 %                     Read/Write FlashPIX Image Format                        %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                   Cristy                                    %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/attribute.h"
  44 #include "MagickCore/property.h"
  45 #include "MagickCore/blob.h"
  46 #include "MagickCore/blob-private.h"
  47 #include "MagickCore/cache.h"
  48 #include "MagickCore/color.h"
  49 #include "MagickCore/color-private.h"
  50 #include "MagickCore/colormap.h"
  51 #include "MagickCore/colorspace.h"
  52 #include "MagickCore/colorspace-private.h"
  53 #include "MagickCore/constitute.h"
  54 #include "MagickCore/exception.h"
  55 #include "MagickCore/exception-private.h"
  56 #include "MagickCore/geometry.h"
  57 #include "MagickCore/image.h"
  58 #include "MagickCore/image-private.h"
  59 #include "MagickCore/list.h"
  60 #include "MagickCore/magick.h"
  61 #include "MagickCore/memory_.h"
  62 #include "MagickCore/monitor.h"
  63 #include "MagickCore/monitor-private.h"
  64 #include "MagickCore/pixel.h"
  65 #include "MagickCore/pixel-accessor.h"
  66 #include "MagickCore/property.h"
  67 #include "MagickCore/quantum-private.h"
  68 #include "MagickCore/static.h"
  69 #include "MagickCore/string_.h"
  70 #include "MagickCore/module.h"
  71 #if defined(MAGICKCORE_FPX_DELEGATE)
  72 #if !defined(vms) && !defined(macintosh) && !defined(MAGICKCORE_WINDOWS_SUPPORT)
  73 #include <fpxlib.h>
  74 #else
  75 #include "Fpxlib.h"
  76 #endif
  77 #endif
  78 \f
  79 #if defined(MAGICKCORE_FPX_DELEGATE)
  80 /*
  81   Forward declarations.
  82 */
  83 static MagickBooleanType
  84   WriteFPXImage(const ImageInfo *,Image *,ExceptionInfo *);
  85 #endif
  86 \f
  87 #if defined(MAGICKCORE_FPX_DELEGATE)
  88 /*
  89 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  90 %                                                                             %
  91 %                                                                             %
  92 %                                                                             %
  93 %   R e a d F P X I m a g e                                                   %
  94 %                                                                             %
  95 %                                                                             %
  96 %                                                                             %
  97 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  98 %
  99 %  ReadFPXImage() reads a FlashPix image file and returns it.  It
 100 %  allocates the memory necessary for the new Image structure and returns a
 101 %  pointer to the new image.  This method was contributed by BillR@corbis.com.
 102 %
 103 %  The format of the ReadFPXImage method is:
 104 %
 105 %      Image *ReadFPXImage(const ImageInfo *image_info,ExceptionInfo *exception)
 106 %
 107 %  A description of each parameter follows:
 108 %
 109 %    o image_info: the image info.
 110 %
 111 %    o exception: return any errors or warnings in this structure.
 112 %
 113 */
 114 static Image *ReadFPXImage(const ImageInfo *image_info,ExceptionInfo *exception)
 115 {
 116   FPXColorspace
 117     colorspace;
 118
 119   FPXImageComponentDesc
 120     *alpha_component,
 121     *blue_component,
 122     *green_component,
 123     *red_component;
 124
 125   FPXImageDesc
 126     fpx_info;
 127
 128   FPXImageHandle
 129     *flashpix;
 130
 131   FPXStatus
 132     fpx_status;
 133
 134   FPXSummaryInformation
 135     summary_info;
 136
 137   Image
 138     *image;
 139
 140   MagickBooleanType
 141     status;
 142
 143   Quantum
 144     index;
 145
 146   register ssize_t
 147     i,
 148     x;
 149
 150   register Quantum
 151     *q;
 152
 153   register unsigned char
 154     *a,
 155     *b,
 156     *g,
 157     *r;
 158
 159   size_t
 160     memory_limit;
 161
 162   ssize_t
 163     y;
 164
 165   unsigned char
 166     *pixels;
 167
 168   unsigned int
 169     height,
 170     tile_width,
 171     tile_height,
 172     width;
 173
 174   size_t
 175     scene;
 176
 177   /*
 178     Open image.
 179   */
 180   assert(image_info != (const ImageInfo *) NULL);
 181   assert(image_info->signature == MagickSignature);
 182   if (image_info->debug != MagickFalse)
 183     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 184       image_info->filename);
 185   assert(exception != (ExceptionInfo *) NULL);
 186   assert(exception->signature == MagickSignature);
 187   image=AcquireImage(image_info,exception);
 188   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 189   if (status == MagickFalse)
 190     {
 191       image=DestroyImageList(image);
 192       return((Image *) NULL);
 193     }
 194   (void) CloseBlob(image);
 195   /*
 196     Initialize FPX toolkit.
 197   */
 198   fpx_status=FPX_InitSystem();
 199   if (fpx_status != FPX_OK)
 200     ThrowReaderException(CoderError,"UnableToInitializeFPXLibrary");
 201   memory_limit=20000000;
 202   fpx_status=FPX_SetToolkitMemoryLimit(&memory_limit);
 203   if (fpx_status != FPX_OK)
 204     {
 205       FPX_ClearSystem();
 206       ThrowReaderException(CoderError,"UnableToInitializeFPXLibrary");
 207     }
 208   tile_width=64;
 209   tile_height=64;
 210   flashpix=(FPXImageHandle *) NULL;
 211   {
 212 #if defined(macintosh)
 213     FSSpec
 214       fsspec;
 215
 216     FilenameToFSSpec(image->filename,&fsspec);
 217     fpx_status=FPX_OpenImageByFilename((const FSSpec &) fsspec,(char *) NULL,
 218 #else
 219     fpx_status=FPX_OpenImageByFilename(image->filename,(char *) NULL,
 220 #endif
 221       &width,&height,&tile_width,&tile_height,&colorspace,&flashpix);
 222   }
 223   if (fpx_status == FPX_LOW_MEMORY_ERROR)
 224     {
 225       FPX_ClearSystem();
 226       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 227     }
 228   if (fpx_status != FPX_OK)
 229     {
 230       FPX_ClearSystem();
 231       ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
 232         image->filename);
 233       image=DestroyImageList(image);
 234       return((Image *) NULL);
 235     }
 236   if (colorspace.numberOfComponents == 0)
 237     {
 238       FPX_ClearSystem();
 239       ThrowReaderException(CorruptImageError,"ImageTypeNotSupported");
 240     }
 241   if (image_info->view == (char *) NULL)
 242     {
 243       float
 244         aspect_ratio;
 245
 246       /*
 247         Get the aspect ratio.
 248       */
 249       aspect_ratio=(float) width/height;
 250       fpx_status=FPX_GetImageResultAspectRatio(flashpix,&aspect_ratio);
 251       if (fpx_status != FPX_OK)
 252         ThrowReaderException(DelegateError,"UnableToReadAspectRatio");
 253       if (width != (size_t) floor((aspect_ratio*height)+0.5))
 254         Swap(width,height);
 255     }
 256   fpx_status=FPX_GetSummaryInformation(flashpix,&summary_info);
 257   if (fpx_status != FPX_OK)
 258     {
 259       FPX_ClearSystem();
 260       ThrowReaderException(DelegateError,"UnableToReadSummaryInfo");
 261     }
 262   if (summary_info.title_valid)
 263     if ((summary_info.title.length != 0) &&
 264         (summary_info.title.ptr != (unsigned char *) NULL))
 265       {
 266         char
 267           *label;
 268
 269         /*
 270           Note image label.
 271         */
 272         label=(char *) NULL;
 273         if (~summary_info.title.length >= (MagickPathExtent-1))
 274           label=(char *) AcquireQuantumMemory(summary_info.title.length+
 275             MagickPathExtent,sizeof(*label));
 276         if (label == (char *) NULL)
 277           {
 278             FPX_ClearSystem();
 279             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 280           }
 281         (void) CopyMagickString(label,(char *) summary_info.title.ptr,
 282           summary_info.title.length+1);
 283         (void) SetImageProperty(image,"label",label,exception);
 284         label=DestroyString(label);
 285       }
 286   if (summary_info.comments_valid)
 287     if ((summary_info.comments.length != 0) &&
 288         (summary_info.comments.ptr != (unsigned char *) NULL))
 289       {
 290         char
 291           *comments;
 292
 293         /*
 294           Note image comment.
 295         */
 296         comments=(char *) NULL;
 297         if (~summary_info.comments.length >= (MagickPathExtent-1))
 298           comments=(char *) AcquireQuantumMemory(summary_info.comments.length+
 299             MagickPathExtent,sizeof(*comments));
 300         if (comments == (char *) NULL)
 301           {
 302             FPX_ClearSystem();
 303             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 304           }
 305         (void) CopyMagickString(comments,(char *) summary_info.comments.ptr,
 306           summary_info.comments.length+1);
 307         (void) SetImageProperty(image,"comment",comments,exception);
 308         comments=DestroyString(comments);
 309       }
 310   /*
 311     Determine resolution by scene specification.
 312   */
 313   for (i=1; ; i++)
 314     if (((width >> i) < tile_width) || ((height >> i) < tile_height))
 315       break;
 316   scene=i;
 317   if (image_info->number_scenes != 0)
 318     while (scene > image_info->scene)
 319     {
 320       width>>=1;
 321       height>>=1;
 322       scene--;
 323     }
 324   if (image_info->size != (char *) NULL)
 325     while ((width > image->columns) || (height > image->rows))
 326     {
 327       width>>=1;
 328       height>>=1;
 329       scene--;
 330     }
 331   image->depth=8;
 332   image->columns=width;
 333   image->rows=height;
 334   if ((colorspace.numberOfComponents % 2) == 0)
 335     image->alpha_trait=BlendPixelTrait;
 336   if (colorspace.numberOfComponents == 1)
 337     {
 338       /*
 339         Create linear colormap.
 340       */
 341       if (AcquireImageColormap(image,MaxColormapSize,exception) == MagickFalse)
 342         {
 343           FPX_ClearSystem();
 344           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 345         }
 346     }
 347   if (image_info->ping != MagickFalse)
 348     {
 349       (void) FPX_CloseImage(flashpix);
 350       FPX_ClearSystem();
 351       return(GetFirstImageInList(image));
 352     }
 353   status=SetImageExtent(image,image->columns,image->rows,exception);
 354   if (status == MagickFalse)
 355     return(DestroyImageList(image));
 356   /*
 357     Allocate memory for the image and pixel buffer.
 358   */
 359   pixels=(unsigned char *) AcquireQuantumMemory(image->columns,(tile_height+
 360     1UL)*colorspace.numberOfComponents*sizeof(*pixels));
 361   if (pixels == (unsigned char *) NULL)
 362     {
 363       FPX_ClearSystem();
 364       (void) FPX_CloseImage(flashpix);
 365       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 366     }
 367   /*
 368     Initialize FlashPix image description.
 369   */
 370   fpx_info.numberOfComponents=colorspace.numberOfComponents;
 371   for (i=0; i < 4; i++)
 372   {
 373     fpx_info.components[i].myColorType.myDataType=DATA_TYPE_UNSIGNED_BYTE;
 374     fpx_info.components[i].horzSubSampFactor=1;
 375     fpx_info.components[i].vertSubSampFactor=1;
 376     fpx_info.components[i].columnStride=fpx_info.numberOfComponents;
 377     fpx_info.components[i].lineStride=image->columns*
 378       fpx_info.components[i].columnStride;
 379     fpx_info.components[i].theData=pixels+i;
 380   }
 381   fpx_info.components[0].myColorType.myColor=fpx_info.numberOfComponents > 2 ?
 382     NIFRGB_R : MONOCHROME;
 383   red_component=(&fpx_info.components[0]);
 384   fpx_info.components[1].myColorType.myColor=fpx_info.numberOfComponents > 2 ?
 385     NIFRGB_G : ALPHA;
 386   green_component=(&fpx_info.components[1]);
 387   fpx_info.components[2].myColorType.myColor=NIFRGB_B;
 388   blue_component=(&fpx_info.components[2]);
 389   fpx_info.components[3].myColorType.myColor=ALPHA;
 390   alpha_component=(&fpx_info.components[fpx_info.numberOfComponents-1]);
 391   FPX_SetResampleMethod(FPX_LINEAR_INTERPOLATION);
 392   /*
 393     Initialize image pixels.
 394   */
 395   for (y=0; y < (ssize_t) image->rows; y++)
 396   {
 397     q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 398     if (q == (Quantum *) NULL)
 399       break;
 400     if ((y % tile_height) == 0)
 401       {
 402         /*
 403           Read FPX image tile (with or without viewing affine)..
 404         */
 405         if (image_info->view != (char *) NULL)
 406           fpx_status=FPX_ReadImageRectangle(flashpix,0,y,image->columns,y+
 407             tile_height-1,scene,&fpx_info);
 408         else
 409           fpx_status=FPX_ReadImageTransformRectangle(flashpix,0.0F,
 410             (float) y/image->rows,(float) image->columns/image->rows,
 411             (float) (y+tile_height-1)/image->rows,(ssize_t) image->columns,
 412             (ssize_t) tile_height,&fpx_info);
 413         if (fpx_status == FPX_LOW_MEMORY_ERROR)
 414           {
 415             pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 416             (void) FPX_CloseImage(flashpix);
 417             FPX_ClearSystem();
 418             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 419           }
 420       }
 421     /*
 422       Transfer a FPX pixels.
 423     */
 424     r=red_component->theData+(y % tile_height)*red_component->lineStride;
 425     g=green_component->theData+(y % tile_height)*green_component->lineStride;
 426     b=blue_component->theData+(y % tile_height)*blue_component->lineStride;
 427     a=alpha_component->theData+(y % tile_height)*alpha_component->lineStride;
 428     for (x=0; x < (ssize_t) image->columns; x++)
 429     {
 430       if (fpx_info.numberOfComponents > 2)
 431         {
 432           SetPixelRed(image,ScaleCharToQuantum(*r),q);
 433           SetPixelGreen(image,ScaleCharToQuantum(*g),q);
 434           SetPixelBlue(image,ScaleCharToQuantum(*b),q);
 435         }
 436       else
 437         {
 438           index=ScaleCharToQuantum(*r);
 439           SetPixelBlack(image,index,q);
 440           SetPixelRed(image,index,q);
 441           SetPixelGreen(image,index,q);
 442           SetPixelBlue(image,index,q);
 443         }
 444       SetPixelAlpha(image,OpaqueAlpha,q);
 445       if (image->alpha_trait != UndefinedPixelTrait)
 446         SetPixelAlpha(image,ScaleCharToQuantum(*a),q);
 447       q+=GetPixelChannels(image);
 448       r+=red_component->columnStride;
 449       g+=green_component->columnStride;
 450       b+=blue_component->columnStride;
 451       a+=alpha_component->columnStride;
 452     }
 453     if (SyncAuthenticPixels(image,exception) == MagickFalse)
 454       break;
 455     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 456       image->rows);
 457     if (status == MagickFalse)
 458       break;
 459   }
 460   pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 461   (void) FPX_CloseImage(flashpix);
 462   FPX_ClearSystem();
 463   return(GetFirstImageInList(image));
 464 }
 465 #endif
 466 \f
 467 /*
 468 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 469 %                                                                             %
 470 %                                                                             %
 471 %                                                                             %
 472 %   R e g i s t e r F P X I m a g e                                           %
 473 %                                                                             %
 474 %                                                                             %
 475 %                                                                             %
 476 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 477 %
 478 %  RegisterFPXImage() adds attributes for the FPX image format to
 479 %  the list of supported formats.  The attributes include the image format
 480 %  tag, a method to read and/or write the format, whether the format
 481 %  supports the saving of more than one frame to the same file or blob,
 482 %  whether the format supports native in-memory I/O, and a brief
 483 %  description of the format.
 484 %
 485 %  The format of the RegisterFPXImage method is:
 486 %
 487 %      size_t RegisterFPXImage(void)
 488 %
 489 */
 490 ModuleExport size_t RegisterFPXImage(void)
 491 {
 492   MagickInfo
 493     *entry;
 494
 495   entry=AcquireMagickInfo("FPX","FPX","FlashPix Format");
 496 #if defined(MAGICKCORE_FPX_DELEGATE)
 497   entry->decoder=(DecodeImageHandler *) ReadFPXImage;
 498   entry->encoder=(EncodeImageHandler *) WriteFPXImage;
 499 #endif
 500   entry->flags^=CoderAdjoinFlag;
 501   entry->flags|=CoderSeekableStreamFlag;
 502   entry->flags^=CoderBlobSupportFlag;
 503   (void) RegisterMagickInfo(entry);
 504   return(MagickImageCoderSignature);
 505 }
 506 \f
 507 /*
 508 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 509 %                                                                             %
 510 %                                                                             %
 511 %                                                                             %
 512 %   U n r e g i s t e r F P X I m a g e                                       %
 513 %                                                                             %
 514 %                                                                             %
 515 %                                                                             %
 516 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 517 %
 518 %  UnregisterFPXImage() removes format registrations made by the
 519 %  FPX module from the list of supported formats.
 520 %
 521 %  The format of the UnregisterFPXImage method is:
 522 %
 523 %      UnregisterFPXImage(void)
 524 %
 525 */
 526 ModuleExport void UnregisterFPXImage(void)
 527 {
 528   (void) UnregisterMagickInfo("FPX");
 529 }
 530 \f
 531 #if defined(MAGICKCORE_FPX_DELEGATE)
 532 /*
 533 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 534 %                                                                             %
 535 %                                                                             %
 536 %                                                                             %
 537 %   W r i t e F P X I m a g e                                                 %
 538 %                                                                             %
 539 %                                                                             %
 540 %                                                                             %
 541 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 542 %
 543 %  WriteFPXImage() writes an image in the FlashPix image format.  This
 544 %  method was contributed by BillR@corbis.com.
 545 %
 546 %  The format of the WriteFPXImage method is:
 547 %
 548 %      MagickBooleanType WriteFPXImage(const ImageInfo *image_info,
 549 %        Image *image,ExceptionInfo *exception)
 550 %
 551 %  A description of each parameter follows.
 552 %
 553 %    o image_info: the image info.
 554 %
 555 %    o image:  The image.
 556 %
 557 %    o exception: return any errors or warnings in this structure.
 558 %
 559 */
 560
 561 static void ColorTwistMultiply(FPXColorTwistMatrix first,
 562   FPXColorTwistMatrix second,FPXColorTwistMatrix *color_twist)
 563 {
 564   /*
 565     Matrix multiply.
 566   */
 567   assert(color_twist != (FPXColorTwistMatrix *) NULL);
 568   color_twist->byy=(first.byy*second.byy)+(first.byc1*second.bc1y)+
 569     (first.byc2*second.bc2y)+(first.dummy1_zero*second.dummy4_zero);
 570   color_twist->byc1=(first.byy*second.byc1)+(first.byc1*second.bc1c1)+
 571     (first.byc2*second.bc2c1)+(first.dummy1_zero*second.dummy5_zero);
 572   color_twist->byc2=(first.byy*second.byc2)+(first.byc1*second.bc1c2)+
 573     (first.byc2*second.bc2c2)+(first.dummy1_zero*second.dummy6_zero);
 574   color_twist->dummy1_zero=(first.byy*second.dummy1_zero)+
 575     (first.byc1*second.dummy2_zero)+(first.byc2*second.dummy3_zero)+
 576     (first.dummy1_zero*second.dummy7_one);
 577   color_twist->bc1y=(first.bc1y*second.byy)+(first.bc1c1*second.bc1y)+
 578     (first.bc1c2*second.bc2y)+(first.dummy2_zero*second.dummy4_zero);
 579   color_twist->bc1c1=(first.bc1y*second.byc1)+(first.bc1c1*second.bc1c1)+
 580     (first.bc1c2*second.bc2c1)+(first.dummy2_zero*second.dummy5_zero);
 581   color_twist->bc1c2=(first.bc1y*second.byc2)+(first.bc1c1*second.bc1c2)+
 582     (first.bc1c2*second.bc2c2)+(first.dummy2_zero*second.dummy6_zero);
 583   color_twist->dummy2_zero=(first.bc1y*second.dummy1_zero)+
 584     (first.bc1c1*second.dummy2_zero)+(first.bc1c2*second.dummy3_zero)+
 585     (first.dummy2_zero*second.dummy7_one);
 586   color_twist->bc2y=(first.bc2y*second.byy)+(first.bc2c1*second.bc1y)+
 587     (first.bc2c2*second.bc2y)+(first.dummy3_zero*second.dummy4_zero);
 588   color_twist->bc2c1=(first.bc2y*second.byc1)+(first.bc2c1*second.bc1c1)+
 589     (first.bc2c2*second.bc2c1)+(first.dummy3_zero*second.dummy5_zero);
 590   color_twist->bc2c2=(first.bc2y*second.byc2)+(first.bc2c1*second.bc1c2)+
 591     (first.bc2c2*second.bc2c2)+(first.dummy3_zero*second.dummy6_zero);
 592   color_twist->dummy3_zero=(first.bc2y*second.dummy1_zero)+
 593     (first.bc2c1*second.dummy2_zero)+(first.bc2c2*second.dummy3_zero)+
 594     (first.dummy3_zero*second.dummy7_one);
 595   color_twist->dummy4_zero=(first.dummy4_zero*second.byy)+
 596     (first.dummy5_zero*second.bc1y)+(first.dummy6_zero*second.bc2y)+
 597     (first.dummy7_one*second.dummy4_zero);
 598   color_twist->dummy5_zero=(first.dummy4_zero*second.byc1)+
 599     (first.dummy5_zero*second.bc1c1)+(first.dummy6_zero*second.bc2c1)+
 600     (first.dummy7_one*second.dummy5_zero);
 601   color_twist->dummy6_zero=(first.dummy4_zero*second.byc2)+
 602     (first.dummy5_zero*second.bc1c2)+(first.dummy6_zero*second.bc2c2)+
 603     (first.dummy7_one*second.dummy6_zero);
 604   color_twist->dummy7_one=(first.dummy4_zero*second.dummy1_zero)+
 605     (first.dummy5_zero*second.dummy2_zero)+
 606     (first.dummy6_zero*second.dummy3_zero)+(first.dummy7_one*second.dummy7_one);
 607 }
 608
 609 static void SetBrightness(double brightness,FPXColorTwistMatrix *color_twist)
 610 {
 611   FPXColorTwistMatrix
 612     effect,
 613     result;
 614
 615   /*
 616     Set image brightness in color twist matrix.
 617   */
 618   assert(color_twist != (FPXColorTwistMatrix *) NULL);
 619   brightness=sqrt((double) brightness);
 620   effect.byy=brightness;
 621   effect.byc1=0.0;
 622   effect.byc2=0.0;
 623   effect.dummy1_zero=0.0;
 624   effect.bc1y=0.0;
 625   effect.bc1c1=brightness;
 626   effect.bc1c2=0.0;
 627   effect.dummy2_zero=0.0;
 628   effect.bc2y=0.0;
 629   effect.bc2c1=0.0;
 630   effect.bc2c2=brightness;
 631   effect.dummy3_zero=0.0;
 632   effect.dummy4_zero=0.0;
 633   effect.dummy5_zero=0.0;
 634   effect.dummy6_zero=0.0;
 635   effect.dummy7_one=1.0;
 636   ColorTwistMultiply(*color_twist,effect,&result);
 637   *color_twist=result;
 638 }
 639
 640 static void SetColorBalance(double red,double green,double blue,
 641   FPXColorTwistMatrix *color_twist)
 642 {
 643   FPXColorTwistMatrix
 644     blue_effect,
 645     green_effect,
 646     result,
 647     rgb_effect,
 648     rg_effect,
 649     red_effect;
 650
 651   /*
 652     Set image color balance in color twist matrix.
 653   */
 654   assert(color_twist != (FPXColorTwistMatrix *) NULL);
 655   red=sqrt((double) red)-1.0;
 656   green=sqrt((double) green)-1.0;
 657   blue=sqrt((double) blue)-1.0;
 658   red_effect.byy=1.0;
 659   red_effect.byc1=0.0;
 660   red_effect.byc2=0.299*red;
 661   red_effect.dummy1_zero=0.0;
 662   red_effect.bc1y=(-0.299)*red;
 663   red_effect.bc1c1=1.0-0.299*red;
 664   red_effect.bc1c2=(-0.299)*red;
 665   red_effect.dummy2_zero=0.0;
 666   red_effect.bc2y=0.701*red;
 667   red_effect.bc2c1=0.0;
 668   red_effect.bc2c2=1.0+0.402*red;
 669   red_effect.dummy3_zero=0.0;
 670   red_effect.dummy4_zero=0.0;
 671   red_effect.dummy5_zero=0.0;
 672   red_effect.dummy6_zero=0.0;
 673   red_effect.dummy7_one=1.0;
 674   green_effect.byy=1.0;
 675   green_effect.byc1=(-0.114)*green;
 676   green_effect.byc2=(-0.299)*green;
 677   green_effect.dummy1_zero=0.0;
 678   green_effect.bc1y=(-0.587)*green;
 679   green_effect.bc1c1=1.0-0.473*green;
 680   green_effect.bc1c2=0.299*green;
 681   green_effect.dummy2_zero=0.0;
 682   green_effect.bc2y=(-0.587)*green;
 683   green_effect.bc2c1=0.114*green;
 684   green_effect.bc2c2=1.0-0.288*green;
 685   green_effect.dummy3_zero=0.0;
 686   green_effect.dummy4_zero=0.0;
 687   green_effect.dummy5_zero=0.0;
 688   green_effect.dummy6_zero=0.0;
 689   green_effect.dummy7_one=1.0;
 690   blue_effect.byy=1.0;
 691   blue_effect.byc1=0.114*blue;
 692   blue_effect.byc2=0.0;
 693   blue_effect.dummy1_zero=0.0;
 694   blue_effect.bc1y=0.886*blue;
 695   blue_effect.bc1c1=1.0+0.772*blue;
 696   blue_effect.bc1c2=0.0;
 697   blue_effect.dummy2_zero=0.0;
 698   blue_effect.bc2y=(-0.114)*blue;
 699   blue_effect.bc2c1=(-0.114)*blue;
 700   blue_effect.bc2c2=1.0-0.114*blue;
 701   blue_effect.dummy3_zero=0.0;
 702   blue_effect.dummy4_zero=0.0;
 703   blue_effect.dummy5_zero=0.0;
 704   blue_effect.dummy6_zero=0.0;
 705   blue_effect.dummy7_one=1.0;
 706   ColorTwistMultiply(red_effect,green_effect,&rg_effect);
 707   ColorTwistMultiply(rg_effect,blue_effect,&rgb_effect);
 708   ColorTwistMultiply(*color_twist,rgb_effect,&result);
 709   *color_twist=result;
 710 }
 711
 712 static void SetSaturation(double saturation,FPXColorTwistMatrix *color_twist)
 713 {
 714   FPXColorTwistMatrix
 715     effect,
 716     result;
 717
 718   /*
 719     Set image saturation in color twist matrix.
 720   */
 721   assert(color_twist != (FPXColorTwistMatrix *) NULL);
 722   effect.byy=1.0;
 723   effect.byc1=0.0;
 724   effect.byc2=0.0;
 725   effect.dummy1_zero=0.0;
 726   effect.bc1y=0.0;
 727   effect.bc1c1=saturation;
 728   effect.bc1c2=0.0;
 729   effect.dummy2_zero=0.0;
 730   effect.bc2y=0.0;
 731   effect.bc2c1=0.0;
 732   effect.bc2c2=saturation;
 733   effect.dummy3_zero=0.0;
 734   effect.dummy4_zero=0.0;
 735   effect.dummy5_zero=0.0;
 736   effect.dummy6_zero=0.0;
 737   effect.dummy7_one=1.0;
 738   ColorTwistMultiply(*color_twist,effect,&result);
 739   *color_twist=result;
 740 }
 741
 742 static MagickBooleanType WriteFPXImage(const ImageInfo *image_info,Image *image,
 743   ExceptionInfo *exception)
 744 {
 745   FPXBackground
 746     background_color;
 747
 748   FPXColorspace
 749     colorspace =
 750     {
 751       TRUE, 4,
 752       {
 753         { NIFRGB_R, DATA_TYPE_UNSIGNED_BYTE },
 754         { NIFRGB_G, DATA_TYPE_UNSIGNED_BYTE },
 755         { NIFRGB_B, DATA_TYPE_UNSIGNED_BYTE },
 756         { ALPHA, DATA_TYPE_UNSIGNED_BYTE }
 757       }
 758     };
 759
 760   const char
 761     *comment,
 762     *label;
 763
 764   FPXCompressionOption
 765     compression;
 766
 767   FPXImageDesc
 768     fpx_info;
 769
 770   FPXImageHandle
 771     *flashpix;
 772
 773   FPXStatus
 774     fpx_status;
 775
 776   FPXSummaryInformation
 777     summary_info;
 778
 779   MagickBooleanType
 780     status;
 781
 782   QuantumInfo
 783     *quantum_info;
 784
 785   QuantumType
 786     quantum_type;
 787
 788   register const Quantum
 789     *p;
 790
 791   register ssize_t
 792     i;
 793
 794   size_t
 795     length,
 796     memory_limit;
 797
 798   ssize_t
 799     y;
 800
 801   unsigned char
 802     *pixels;
 803
 804   unsigned int
 805     tile_height,
 806     tile_width;
 807
 808   /*
 809     Open input file.
 810   */
 811   assert(image_info != (const ImageInfo *) NULL);
 812   assert(image_info->signature == MagickSignature);
 813   assert(image != (Image *) NULL);
 814   assert(image->signature == MagickSignature);
 815   if (image->debug != MagickFalse)
 816     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 817   assert(exception != (ExceptionInfo *) NULL);
 818   assert(exception->signature == MagickSignature);
 819   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
 820   if (status == MagickFalse)
 821     return(status);
 822   (void) TransformImageColorspace(image,sRGBColorspace,exception);
 823   (void) CloseBlob(image);
 824   /*
 825     Initialize FPX toolkit.
 826   */
 827   image->depth=8;
 828   memory_limit=20000000;
 829   fpx_status=FPX_SetToolkitMemoryLimit(&memory_limit);
 830   if (fpx_status != FPX_OK)
 831     ThrowWriterException(DelegateError,"UnableToInitializeFPXLibrary");
 832   tile_width=64;
 833   tile_height=64;
 834   colorspace.numberOfComponents=3;
 835   if (image->alpha_trait != UndefinedPixelTrait)
 836     colorspace.numberOfComponents=4;
 837   if ((image_info->type != TrueColorType) &&
 838       (SetImageGray(image,exception) != MagickFalse))
 839     {
 840       colorspace.numberOfComponents=1;
 841       colorspace.theComponents[0].myColor=MONOCHROME;
 842     }
 843   background_color.color1_value=0;
 844   background_color.color2_value=0;
 845   background_color.color3_value=0;
 846   background_color.color4_value=0;
 847   compression=NONE;
 848   if (image->compression == JPEGCompression)
 849     compression=JPEG_UNSPECIFIED;
 850   if (image_info->compression == JPEGCompression)
 851     compression=JPEG_UNSPECIFIED;
 852   {
 853 #if defined(macintosh)
 854     FSSpec
 855       fsspec;
 856
 857     FilenameToFSSpec(filename,&fsspec);
 858     fpx_status=FPX_CreateImageByFilename((const FSSpec &) fsspec,image->columns,
 859 #else
 860     fpx_status=FPX_CreateImageByFilename(image->filename,image->columns,
 861 #endif
 862       image->rows,tile_width,tile_height,colorspace,background_color,
 863       compression,&flashpix);
 864   }
 865   if (fpx_status != FPX_OK)
 866     return(status);
 867   if (compression == JPEG_UNSPECIFIED)
 868     {
 869       /*
 870         Initialize the compression by quality for the entire image.
 871       */
 872       fpx_status=FPX_SetJPEGCompression(flashpix,(unsigned short)
 873         image->quality == UndefinedCompressionQuality ? 75 : image->quality);
 874       if (fpx_status != FPX_OK)
 875         ThrowWriterException(DelegateError,"UnableToSetJPEGLevel");
 876     }
 877   /*
 878     Set image summary info.
 879   */
 880   summary_info.title_valid=MagickFalse;
 881   summary_info.subject_valid=MagickFalse;
 882   summary_info.author_valid=MagickFalse;
 883   summary_info.comments_valid=MagickFalse;
 884   summary_info.keywords_valid=MagickFalse;
 885   summary_info.OLEtemplate_valid=MagickFalse;
 886   summary_info.last_author_valid=MagickFalse;
 887   summary_info.rev_number_valid=MagickFalse;
 888   summary_info.edit_time_valid=MagickFalse;
 889   summary_info.last_printed_valid=MagickFalse;
 890   summary_info.create_dtm_valid=MagickFalse;
 891   summary_info.last_save_dtm_valid=MagickFalse;
 892   summary_info.page_count_valid=MagickFalse;
 893   summary_info.word_count_valid=MagickFalse;
 894   summary_info.char_count_valid=MagickFalse;
 895   summary_info.thumbnail_valid=MagickFalse;
 896   summary_info.appname_valid=MagickFalse;
 897   summary_info.security_valid=MagickFalse;
 898   summary_info.title.ptr=(unsigned char *) NULL;
 899   label=GetImageProperty(image,"label",exception);
 900   if (label != (const char *) NULL)
 901     {
 902       /*
 903         Note image label.
 904       */
 905       summary_info.title_valid=MagickTrue;
 906       length=strlen(label);
 907       summary_info.title.length=length;
 908       if (~length >= (MagickPathExtent-1))
 909         summary_info.title.ptr=(unsigned char *) AcquireQuantumMemory(
 910           length+MagickPathExtent,sizeof(*summary_info.title.ptr));
 911       if (summary_info.title.ptr == (unsigned char *) NULL)
 912         ThrowWriterException(DelegateError,"UnableToSetImageTitle");
 913       (void) CopyMagickString((char *) summary_info.title.ptr,label,
 914         MagickPathExtent);
 915     }
 916   comment=GetImageProperty(image,"comment",exception);
 917   if (comment != (const char *) NULL)
 918     {
 919       /*
 920         Note image comment.
 921       */
 922       summary_info.comments_valid=MagickTrue;
 923       summary_info.comments.ptr=(unsigned char *) AcquireString(comment);
 924       summary_info.comments.length=strlen(comment);
 925     }
 926   fpx_status=FPX_SetSummaryInformation(flashpix,&summary_info);
 927   if (fpx_status != FPX_OK)
 928     ThrowWriterException(DelegateError,"UnableToSetSummaryInfo");
 929   /*
 930     Initialize FlashPix image description.
 931   */
 932   quantum_info=AcquireQuantumInfo(image_info,image);
 933   if (quantum_info == (QuantumInfo *) NULL)
 934     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 935   pixels=GetQuantumPixels(quantum_info);
 936   fpx_info.numberOfComponents=colorspace.numberOfComponents;
 937   for (i=0; i < (ssize_t) fpx_info.numberOfComponents; i++)
 938   {
 939     fpx_info.components[i].myColorType.myDataType=DATA_TYPE_UNSIGNED_BYTE;
 940     fpx_info.components[i].horzSubSampFactor=1;
 941     fpx_info.components[i].vertSubSampFactor=1;
 942     fpx_info.components[i].columnStride=fpx_info.numberOfComponents;
 943     fpx_info.components[i].lineStride=
 944       image->columns*fpx_info.components[i].columnStride;
 945     fpx_info.components[i].theData=pixels+i;
 946   }
 947   fpx_info.components[0].myColorType.myColor=fpx_info.numberOfComponents != 1 ?
 948     NIFRGB_R : MONOCHROME;
 949   fpx_info.components[1].myColorType.myColor=NIFRGB_G;
 950   fpx_info.components[2].myColorType.myColor=NIFRGB_B;
 951   fpx_info.components[3].myColorType.myColor=ALPHA;
 952   /*
 953     Write image pixels.
 954   */
 955   quantum_type=RGBQuantum;
 956   if (image->alpha_trait != UndefinedPixelTrait)
 957     quantum_type=RGBAQuantum;
 958   if (fpx_info.numberOfComponents == 1)
 959     quantum_type=GrayQuantum;
 960   for (y=0; y < (ssize_t) image->rows; y++)
 961   {
 962     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 963     if (p == (const Quantum *) NULL)
 964       break;
 965     length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
 966       quantum_type,pixels,exception);
 967     fpx_status=FPX_WriteImageLine(flashpix,&fpx_info);
 968     if (fpx_status != FPX_OK)
 969       break;
 970     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 971       image->rows);
 972     if (status == MagickFalse)
 973       break;
 974   }
 975   quantum_info=DestroyQuantumInfo(quantum_info);
 976   if (image_info->view != (char *) NULL)
 977     {
 978       FPXAffineMatrix
 979         affine;
 980
 981       FPXColorTwistMatrix
 982         color_twist;
 983
 984       FPXContrastAdjustment
 985         contrast;
 986
 987       FPXFilteringValue
 988         sharpen;
 989
 990       FPXResultAspectRatio
 991         aspect_ratio;
 992
 993       FPXROI
 994         view_rect;
 995
 996       MagickBooleanType
 997         affine_valid,
 998         aspect_ratio_valid,
 999         color_twist_valid,
1000         contrast_valid,
1001         sharpen_valid,
1002         view_rect_valid;
1003
1004       /*
1005         Initialize default viewing parameters.
1006       */
1007       contrast=1.0;
1008       contrast_valid=MagickTrue;
1009       color_twist.byy=1.0;
1010       color_twist.byc1=0.0;
1011       color_twist.byc2=0.0;
1012       color_twist.dummy1_zero=0.0;
1013       color_twist.bc1y=0.0;
1014       color_twist.bc1c1=1.0;
1015       color_twist.bc1c2=0.0;
1016       color_twist.dummy2_zero=0.0;
1017       color_twist.bc2y=0.0;
1018       color_twist.bc2c1=0.0;
1019       color_twist.bc2c2=1.0;
1020       color_twist.dummy3_zero=0.0;
1021       color_twist.dummy4_zero=0.0;
1022       color_twist.dummy5_zero=0.0;
1023       color_twist.dummy6_zero=0.0;
1024       color_twist.dummy7_one=1.0;
1025       color_twist_valid=MagickTrue;
1026       sharpen=0.0;
1027       sharpen_valid=MagickTrue;
1028       aspect_ratio=(double) image->columns/image->rows;
1029       aspect_ratio_valid=MagickTrue;
1030       view_rect.left=(float) 0.1;
1031       view_rect.width=aspect_ratio-0.2;
1032       view_rect.top=(float) 0.1;
1033       view_rect.height=(float) 0.8; /* 1.0-0.2 */
1034       view_rect_valid=MagickTrue;
1035       affine.a11=1.0;
1036       affine.a12=0.0;
1037       affine.a13=0.0;
1038       affine.a14=0.0;
1039       affine.a21=0.0;
1040       affine.a22=1.0;
1041       affine.a23=0.0;
1042       affine.a24=0.0;
1043       affine.a31=0.0;
1044       affine.a32=0.0;
1045       affine.a33=1.0;
1046       affine.a34=0.0;
1047       affine.a41=0.0;
1048       affine.a42=0.0;
1049       affine.a43=0.0;
1050       affine.a44=1.0;
1051       affine_valid=MagickTrue;
1052       if (0)
1053         {
1054           /*
1055             Color color twist.
1056           */
1057           SetBrightness(0.5,&color_twist);
1058           SetSaturation(0.5,&color_twist);
1059           SetColorBalance(0.5,1.0,1.0,&color_twist);
1060           color_twist_valid=MagickTrue;
1061         }
1062       if (affine_valid != MagickFalse)
1063         {
1064           fpx_status=FPX_SetImageAffineMatrix(flashpix,&affine);
1065           if (fpx_status != FPX_OK)
1066             ThrowWriterException(DelegateError,"UnableToSetAffineMatrix");
1067         }
1068       if (aspect_ratio_valid != MagickFalse)
1069         {
1070           fpx_status=FPX_SetImageResultAspectRatio(flashpix,&aspect_ratio);
1071           if (fpx_status != FPX_OK)
1072             ThrowWriterException(DelegateError,"UnableToSetAspectRatio");
1073         }
1074       if (color_twist_valid != MagickFalse)
1075         {
1076           fpx_status=FPX_SetImageColorTwistMatrix(flashpix,&color_twist);
1077           if (fpx_status != FPX_OK)
1078             ThrowWriterException(DelegateError,"UnableToSetColorTwist");
1079         }
1080       if (contrast_valid != MagickFalse)
1081         {
1082           fpx_status=FPX_SetImageContrastAdjustment(flashpix,&contrast);
1083           if (fpx_status != FPX_OK)
1084             ThrowWriterException(DelegateError,"UnableToSetContrast");
1085         }
1086       if (sharpen_valid != MagickFalse)
1087         {
1088           fpx_status=FPX_SetImageFilteringValue(flashpix,&sharpen);
1089           if (fpx_status != FPX_OK)
1090             ThrowWriterException(DelegateError,"UnableToSetFilteringValue");
1091         }
1092       if (view_rect_valid != MagickFalse)
1093         {
1094           fpx_status=FPX_SetImageROI(flashpix,&view_rect);
1095           if (fpx_status != FPX_OK)
1096             ThrowWriterException(DelegateError,"UnableToSetRegionOfInterest");
1097         }
1098     }
1099   (void) FPX_CloseImage(flashpix);
1100   FPX_ClearSystem();
1101   return(MagickTrue);
1102 }
1103 #endif