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