1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3%                                                                             %
4%                                                                             %
5%                  M   M   AAA   TTTTT  L       AAA   BBBB                    %
6%                  MM MM  A   A    T    L      A   A  B   B                   %
7%                  M M M  AAAAA    T    L      AAAAA  BBBB                    %
8%                  M   M  A   A    T    L      A   A  B   B                   %
9%                  M   M  A   A    T    LLLLL  A   A  BBBB                    %
10%                                                                             %
11%                                                                             %
12%                        Read MATLAB Image Format                             %
13%                                                                             %
14%                              Software Design                                %
15%                              Jaroslav Fojtik                                %
16%                                2001-2008                                    %
17%                                                                             %
18%                                                                             %
19%  Permission is hereby granted, free of charge, to any person obtaining a    %
20%  copy of this software and associated documentation files ("ImageMagick"),  %
21%  to deal in ImageMagick without restriction, including without limitation   %
22%  the rights to use, copy, modify, merge, publish, distribute, sublicense,   %
23%  and/or sell copies of ImageMagick, and to permit persons to whom the       %
24%  ImageMagick is furnished to do so, subject to the following conditions:    %
25%                                                                             %
26%  The above copyright notice and this permission notice shall be included in %
27%  all copies or substantial portions of ImageMagick.                         %
28%                                                                             %
29%  The software is provided "as is", without warranty of any kind, express or %
30%  implied, including but not limited to the warranties of merchantability,   %
31%  fitness for a particular purpose and noninfringement.  In no event shall   %
32%  ImageMagick Studio be liable for any claim, damages or other liability,    %
33%  whether in an action of contract, tort or otherwise, arising from, out of  %
34%  or in connection with ImageMagick or the use or other dealings in          %
35%  ImageMagick.                                                               %
36%                                                                             %
37%  Except as contained in this notice, the name of the ImageMagick Studio     %
38%  shall not be used in advertising or otherwise to promote the sale, use or  %
39%  other dealings in ImageMagick without prior written authorization from the %
40%  ImageMagick Studio.                                                        %
41%                                                                             %
42%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
43%
44%
45*/
46
47/*
48  Include declarations.
49*/
50#include "MagickCore/studio.h"
51#include "MagickCore/attribute.h"
52#include "MagickCore/blob.h"
53#include "MagickCore/blob-private.h"
54#include "MagickCore/cache.h"
55#include "MagickCore/color-private.h"
56#include "MagickCore/colormap.h"
57#include "MagickCore/colorspace-private.h"
58#include "MagickCore/distort.h"
59#include "MagickCore/exception.h"
60#include "MagickCore/exception-private.h"
61#include "MagickCore/image.h"
62#include "MagickCore/image-private.h"
63#include "MagickCore/list.h"
64#include "MagickCore/magick.h"
65#include "MagickCore/memory_.h"
66#include "MagickCore/monitor.h"
67#include "MagickCore/monitor-private.h"
68#include "MagickCore/pixel-accessor.h"
69#include "MagickCore/quantum.h"
70#include "MagickCore/quantum-private.h"
71#include "MagickCore/option.h"
72#include "MagickCore/pixel.h"
73#include "MagickCore/resource_.h"
74#include "MagickCore/static.h"
75#include "MagickCore/string_.h"
76#include "MagickCore/module.h"
77#include "MagickCore/transform.h"
78#include "MagickCore/utility-private.h"
79#if defined(MAGICKCORE_ZLIB_DELEGATE)
80 #include "zlib.h"
81#endif
82
83/*
84  Forward declaration.
85*/
86static MagickBooleanType
87  WriteMATImage(const ImageInfo *,Image *,ExceptionInfo *);
88
89
90/* Auto coloring method, sorry this creates some artefact inside data
91MinReal+j*MaxComplex = red  MaxReal+j*MaxComplex = black
92MinReal+j*0 = white          MaxReal+j*0 = black
93MinReal+j*MinComplex = blue  MaxReal+j*MinComplex = black
94*/
95
96typedef struct
97{
98  char identific[124];
99  unsigned short Version;
100  char EndianIndicator[2];
101  unsigned long DataType;
102  unsigned long ObjectSize;
103  unsigned long unknown1;
104  unsigned long unknown2;
105
106  unsigned short unknown5;
107  unsigned char StructureFlag;
108  unsigned char StructureClass;
109  unsigned long unknown3;
110  unsigned long unknown4;
111  unsigned long DimFlag;
112
113  unsigned long SizeX;
114  unsigned long SizeY;
115  unsigned short Flag1;
116  unsigned short NameFlag;
117}
118MATHeader;
119
120static const char *MonthsTab[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
121static const char *DayOfWTab[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
122static const char *OsDesc=
123#if defined(MAGICKCORE_WINDOWS_SUPPORT)
124    "PCWIN";
125#else
126 #ifdef __APPLE__
127    "MAC";
128 #else
129    "LNX86";
130 #endif
131#endif
132
133typedef enum
134  {
135    miINT8 = 1,      /* 8 bit signed */
136    miUINT8,      /* 8 bit unsigned */
137    miINT16,      /* 16 bit signed */
138    miUINT16,      /* 16 bit unsigned */
139    miINT32,      /* 32 bit signed */
140    miUINT32,      /* 32 bit unsigned */
141    miSINGLE,      /* IEEE 754 single precision float */
142    miRESERVE1,
143    miDOUBLE,      /* IEEE 754 double precision float */
144    miRESERVE2,
145    miRESERVE3,
146    miINT64,      /* 64 bit signed */
147    miUINT64,      /* 64 bit unsigned */
148    miMATRIX,            /* MATLAB array */
149    miCOMPRESSED,          /* Compressed Data */
150    miUTF8,            /* Unicode UTF-8 Encoded Character Data */
151    miUTF16,            /* Unicode UTF-16 Encoded Character Data */
152    miUTF32      /* Unicode UTF-32 Encoded Character Data */
153  } mat5_data_type;
154
155typedef enum
156  {
157    mxCELL_CLASS=1,    /* cell array */
158    mxSTRUCT_CLASS,    /* structure */
159    mxOBJECT_CLASS,    /* object */
160    mxCHAR_CLASS,    /* character array */
161    mxSPARSE_CLASS,    /* sparse array */
162    mxDOUBLE_CLASS,    /* double precision array */
163    mxSINGLE_CLASS,    /* single precision floating point */
164    mxINT8_CLASS,    /* 8 bit signed integer */
165    mxUINT8_CLASS,    /* 8 bit unsigned integer */
166    mxINT16_CLASS,    /* 16 bit signed integer */
167    mxUINT16_CLASS,    /* 16 bit unsigned integer */
168    mxINT32_CLASS,    /* 32 bit signed integer */
169    mxUINT32_CLASS,    /* 32 bit unsigned integer */
170    mxINT64_CLASS,    /* 64 bit signed integer */
171    mxUINT64_CLASS,    /* 64 bit unsigned integer */
172    mxFUNCTION_CLASS            /* Function handle */
173  } arrayclasstype;
174
175#define FLAG_COMPLEX 0x8
176#define FLAG_GLOBAL  0x4
177#define FLAG_LOGICAL 0x2
178
179static const QuantumType z2qtype[4] = {GrayQuantum, BlueQuantum, GreenQuantum, RedQuantum};
180
181
182static void InsertComplexDoubleRow(Image *image,double *p,int y,double MinVal,
183  double MaxVal,ExceptionInfo *exception)
184{
185
186  double f;
187  int x;
188  register Quantum *q;
189
190  if (MinVal == 0)
191    MinVal = -1;
192  if (MaxVal == 0)
193    MaxVal = 1;
194
195  q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
196  if (q == (Quantum *) NULL)
197    return;
198  for (x = 0; x < (ssize_t) image->columns; x++)
199  {
200    if (*p > 0)
201    {
202      f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
203      if (f + GetPixelRed(image,q) > QuantumRange)
204        SetPixelRed(image,QuantumRange,q);
205      else
206        SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
207      if ((int) f / 2.0 > GetPixelGreen(image,q))
208        {
209          SetPixelGreen(image,0,q);
210          SetPixelBlue(image,0,q);
211        }
212      else
213        {
214          SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
215          SetPixelGreen(image,GetPixelBlue(image,q),q);
216        }
217    }
218    if (*p < 0)
219    {
220      f = (*p / MaxVal) * (QuantumRange-GetPixelBlue(image,q));
221      if (f+GetPixelBlue(image,q) > QuantumRange)
222        SetPixelBlue(image,QuantumRange,q);
223      else
224        SetPixelBlue(image,GetPixelBlue(image,q)+(int) f,q);
225      if ((int) f / 2.0 > GetPixelGreen(image,q))
226        {
227          SetPixelRed(image,0,q);
228          SetPixelGreen(image,0,q);
229        }
230      else
231        {
232          SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
233          SetPixelGreen(image,GetPixelRed(image,q),q);
234        }
235    }
236    p++;
237    q+=GetPixelChannels(image);
238  }
239  if (!SyncAuthenticPixels(image,exception))
240    return;
241  return;
242}
243
244
245static void InsertComplexFloatRow(Image *image,float *p,int y,double MinVal,
246  double MaxVal,ExceptionInfo *exception)
247{
248  double f;
249  int x;
250  register Quantum *q;
251
252  if (MinVal == 0)
253    MinVal = -1;
254  if (MaxVal == 0)
255    MaxVal = 1;
256
257  q = QueueAuthenticPixels(image, 0, y, image->columns, 1,exception);
258  if (q == (Quantum *) NULL)
259    return;
260  for (x = 0; x < (ssize_t) image->columns; x++)
261  {
262    if (*p > 0)
263    {
264      f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
265      if (f+GetPixelRed(image,q) > QuantumRange)
266        SetPixelRed(image,QuantumRange,q);
267      else
268        SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
269      if ((int) f / 2.0 > GetPixelGreen(image,q))
270        {
271          SetPixelGreen(image,0,q);
272          SetPixelBlue(image,0,q);
273        }
274      else
275        {
276          SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
277          SetPixelGreen(image,GetPixelBlue(image,q),q);
278        }
279    }
280    if (*p < 0)
281    {
282      f = (*p / MaxVal) * (QuantumRange - GetPixelBlue(image,q));
283      if (f + GetPixelBlue(image,q) > QuantumRange)
284        SetPixelBlue(image,QuantumRange,q);
285      else
286        SetPixelBlue(image,GetPixelBlue(image,q)+
287          (int) f,q);
288      if ((int) f / 2.0 > GetPixelGreen(image,q))
289        {
290          SetPixelGreen(image,0,q);
291          SetPixelRed(image,0,q);
292        }
293      else
294        {
295          SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
296          SetPixelGreen(image,GetPixelRed(image,q),q);
297        }
298    }
299    p++;
300    q++;
301  }
302  if (!SyncAuthenticPixels(image,exception))
303    return;
304  return;
305}
306
307
308/************** READERS ******************/
309
310/* This function reads one block of floats*/
311static void ReadBlobFloatsLSB(Image * image, size_t len, float *data)
312{
313  while (len >= 4)
314  {
315    *data++ = ReadBlobFloat(image);
316    len -= sizeof(float);
317  }
318  if (len > 0)
319    (void) SeekBlob(image, len, SEEK_CUR);
320}
321
322static void ReadBlobFloatsMSB(Image * image, size_t len, float *data)
323{
324  while (len >= 4)
325  {
326    *data++ = ReadBlobFloat(image);
327    len -= sizeof(float);
328  }
329  if (len > 0)
330    (void) SeekBlob(image, len, SEEK_CUR);
331}
332
333/* This function reads one block of doubles*/
334static void ReadBlobDoublesLSB(Image * image, size_t len, double *data)
335{
336  while (len >= 8)
337  {
338    *data++ = ReadBlobDouble(image);
339    len -= sizeof(double);
340  }
341  if (len > 0)
342    (void) SeekBlob(image, len, SEEK_CUR);
343}
344
345static void ReadBlobDoublesMSB(Image * image, size_t len, double *data)
346{
347  while (len >= 8)
348  {
349    *data++ = ReadBlobDouble(image);
350    len -= sizeof(double);
351  }
352  if (len > 0)
353    (void) SeekBlob(image, len, SEEK_CUR);
354}
355
356/* Calculate minimum and maximum from a given block of data */
357static void CalcMinMax(Image *image, int endian_indicator, int SizeX, int SizeY, size_t CellType, unsigned ldblk, void *BImgBuff, double *Min, double *Max)
358{
359MagickOffsetType filepos;
360int i, x;
361void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
362void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
363double *dblrow;
364float *fltrow;
365
366  if (endian_indicator == LSBEndian)
367  {
368    ReadBlobDoublesXXX = ReadBlobDoublesLSB;
369    ReadBlobFloatsXXX = ReadBlobFloatsLSB;
370  }
371  else    /* MI */
372  {
373    ReadBlobDoublesXXX = ReadBlobDoublesMSB;
374    ReadBlobFloatsXXX = ReadBlobFloatsMSB;
375  }
376
377  filepos = TellBlob(image);     /* Please note that file seeking occurs only in the case of doubles */
378  for (i = 0; i < SizeY; i++)
379  {
380    if (CellType==miDOUBLE)
381    {
382      ReadBlobDoublesXXX(image, ldblk, (double *)BImgBuff);
383      dblrow = (double *)BImgBuff;
384      if (i == 0)
385      {
386        *Min = *Max = *dblrow;
387      }
388      for (x = 0; x < SizeX; x++)
389      {
390        if (*Min > *dblrow)
391          *Min = *dblrow;
392        if (*Max < *dblrow)
393          *Max = *dblrow;
394        dblrow++;
395      }
396    }
397    if (CellType==miSINGLE)
398    {
399      ReadBlobFloatsXXX(image, ldblk, (float *)BImgBuff);
400      fltrow = (float *)BImgBuff;
401      if (i == 0)
402      {
403        *Min = *Max = *fltrow;
404      }
405    for (x = 0; x < (ssize_t) SizeX; x++)
406      {
407        if (*Min > *fltrow)
408          *Min = *fltrow;
409        if (*Max < *fltrow)
410          *Max = *fltrow;
411        fltrow++;
412      }
413    }
414  }
415  (void) SeekBlob(image, filepos, SEEK_SET);
416}
417
418
419static void FixSignedValues(const Image *image,Quantum *q, int y)
420{
421  while(y-->0)
422  {
423     /* Please note that negative values will overflow
424        Q=8; QuantumRange=255: <0;127> + 127+1 = <128; 255>
425           <-1;-128> + 127+1 = <0; 127> */
426    SetPixelRed(image,GetPixelRed(image,q)+QuantumRange/2+1,q);
427    SetPixelGreen(image,GetPixelGreen(image,q)+QuantumRange/2+1,q);
428    SetPixelBlue(image,GetPixelBlue(image,q)+QuantumRange/2+1,q);
429    q++;
430  }
431}
432
433
434/** Fix whole row of logical/binary data. It means pack it. */
435static void FixLogical(unsigned char *Buff,int ldblk)
436{
437unsigned char mask=128;
438unsigned char *BuffL = Buff;
439unsigned char val = 0;
440
441  while(ldblk-->0)
442  {
443    if(*Buff++ != 0)
444      val |= mask;
445
446    mask >>= 1;
447    if(mask==0)
448    {
449      *BuffL++ = val;
450      val = 0;
451      mask = 128;
452    }
453
454  }
455  *BuffL = val;
456}
457
458#if defined(MAGICKCORE_ZLIB_DELEGATE)
459static voidpf AcquireZIPMemory(voidpf context,unsigned int items,
460  unsigned int size)
461{
462  (void) context;
463  return((voidpf) AcquireQuantumMemory(items,size));
464}
465
466static void RelinquishZIPMemory(voidpf context,voidpf memory)
467{
468  (void) context;
469  memory=RelinquishMagickMemory(memory);
470}
471#endif
472
473#if defined(MAGICKCORE_ZLIB_DELEGATE)
474/** This procedure decompreses an image block for a new MATLAB format. */
475static Image *DecompressBlock(Image *orig, MagickOffsetType Size, ImageInfo *clone_info, ExceptionInfo *exception)
476{
477
478Image *image2;
479void *CacheBlock, *DecompressBlock;
480z_stream zip_info;
481FILE *mat_file;
482size_t magick_size;
483size_t extent;
484int file;
485
486int status;
487int zip_status;
488
489  if(clone_info==NULL) return NULL;
490  if(clone_info->file)    /* Close file opened from previous transaction. */
491  {
492    fclose(clone_info->file);
493    clone_info->file = NULL;
494    (void) remove_utf8(clone_info->filename);
495  }
496
497  CacheBlock = AcquireQuantumMemory((size_t)((Size<16384)?Size:16384),sizeof(unsigned char *));
498  if(CacheBlock==NULL) return NULL;
499  DecompressBlock = AcquireQuantumMemory((size_t)(4096),sizeof(unsigned char *));
500  if(DecompressBlock==NULL)
501  {
502    RelinquishMagickMemory(CacheBlock);
503    return NULL;
504  }
505
506  mat_file=0;
507  file = AcquireUniqueFileResource(clone_info->filename);
508  if (file != -1)
509    mat_file = fdopen(file,"w");
510  if(!mat_file)
511  {
512    RelinquishMagickMemory(CacheBlock);
513    RelinquishMagickMemory(DecompressBlock);
514    (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Cannot create file stream for decompressed image");
515    return NULL;
516  }
517
518  zip_info.zalloc=AcquireZIPMemory;
519  zip_info.zfree=RelinquishZIPMemory;
520  zip_info.opaque = (voidpf) NULL;
521  zip_status = inflateInit(&zip_info);
522  if (zip_status != Z_OK)
523    {
524      RelinquishMagickMemory(CacheBlock);
525      RelinquishMagickMemory(DecompressBlock);
526      (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
527        "UnableToUncompressImage","`%s'",clone_info->filename);
528      (void) fclose(mat_file);
529      RelinquishUniqueFileResource(clone_info->filename);
530      return NULL;
531    }
532  /* zip_info.next_out = 8*4;*/
533
534  zip_info.avail_in = 0;
535  zip_info.total_out = 0;
536  while(Size>0 && !EOFBlob(orig))
537  {
538    magick_size = ReadBlob(orig, (Size<16384)?Size:16384, (unsigned char *) CacheBlock);
539    zip_info.next_in = (Bytef *) CacheBlock;
540    zip_info.avail_in = (uInt) magick_size;
541
542    while(zip_info.avail_in>0)
543    {
544      zip_info.avail_out = 4096;
545      zip_info.next_out = (Bytef *) DecompressBlock;
546      zip_status = inflate(&zip_info,Z_NO_FLUSH);
547      if ((zip_status != Z_OK) && (zip_status != Z_STREAM_END))
548        break;
549      extent=fwrite(DecompressBlock, 4096-zip_info.avail_out, 1, mat_file);
550      (void) extent;
551
552      if(zip_status == Z_STREAM_END) goto DblBreak;
553    }
554    if ((zip_status != Z_OK) && (zip_status != Z_STREAM_END))
555      break;
556
557    Size -= magick_size;
558  }
559DblBreak:
560
561  inflateEnd(&zip_info);
562  (void)fclose(mat_file);
563  RelinquishMagickMemory(CacheBlock);
564  RelinquishMagickMemory(DecompressBlock);
565
566  if((clone_info->file=fopen(clone_info->filename,"rb"))==NULL) goto UnlinkFile;
567  if( (image2 = AcquireImage(clone_info,exception))==NULL ) goto EraseFile;
568  status = OpenBlob(clone_info,image2,ReadBinaryBlobMode,exception);
569  if (status == MagickFalse)
570  {
571    DeleteImageFromList(&image2);
572EraseFile:
573    fclose(clone_info->file);
574    clone_info->file = NULL;
575UnlinkFile:
576    RelinquishUniqueFileResource(clone_info->filename);
577    return NULL;
578  }
579
580  return image2;
581}
582#endif
583
584static Image *ReadMATImageV4(const ImageInfo *image_info,Image *image,
585  ExceptionInfo *exception)
586{
587  typedef struct {
588    unsigned char Type[4];
589    unsigned int nRows;
590    unsigned int nCols;
591    unsigned int imagf;
592    unsigned int nameLen;
593  } MAT4_HDR;
594
595  long
596    ldblk;
597
598  EndianType
599    endian;
600
601  Image
602    *rotate_image;
603
604  MagickBooleanType
605    status;
606
607  MAT4_HDR
608    HDR;
609
610  QuantumInfo
611    *quantum_info;
612
613  QuantumFormatType
614    format_type;
615
616  register ssize_t
617    i;
618
619  ssize_t
620    count,
621    y;
622
623  unsigned char
624    *pixels;
625
626  unsigned int
627    depth;
628
629  (void) SeekBlob(image,0,SEEK_SET);
630  ldblk=ReadBlobLSBLong(image);
631  if ((ldblk > 9999) || (ldblk < 0))
632    return((Image *) NULL);
633  HDR.Type[3]=ldblk % 10; ldblk /= 10;  /* T digit */
634  HDR.Type[2]=ldblk % 10; ldblk /= 10;  /* P digit */
635  HDR.Type[1]=ldblk % 10; ldblk /= 10;  /* O digit */
636  HDR.Type[0]=ldblk;        /* M digit */
637  if (HDR.Type[3] != 0) return((Image *) NULL);    /* Data format */
638  if (HDR.Type[2] != 0) return((Image *) NULL);    /* Always 0 */
639  if (HDR.Type[0] == 0)
640    {
641      HDR.nRows=ReadBlobLSBLong(image);
642      HDR.nCols=ReadBlobLSBLong(image);
643      HDR.imagf=ReadBlobLSBLong(image);
644      HDR.nameLen=ReadBlobLSBLong(image);
645      endian=LSBEndian;
646    }
647  else
648    {
649      HDR.nRows=ReadBlobMSBLong(image);
650      HDR.nCols=ReadBlobMSBLong(image);
651      HDR.imagf=ReadBlobMSBLong(image);
652      HDR.nameLen=ReadBlobMSBLong(image);
653      endian=MSBEndian;
654    }
655  if (HDR.nameLen > 0xFFFF)
656    return((Image *) NULL);
657  for (i=0; i < (ssize_t) HDR.nameLen; i++)
658  {
659    int
660      byte;
661
662    /*
663      Skip matrix name.
664    */
665    byte=ReadBlobByte(image);
666    if (byte == EOF)
667      return((Image *) NULL);
668  }
669  image->columns=(size_t) HDR.nRows;
670  image->rows=(size_t) HDR.nCols;
671  SetImageColorspace(image,GRAYColorspace,exception);
672  if (image_info->ping != MagickFalse)
673    {
674      Swap(image->columns,image->rows);
675      return(image);
676    }
677  status=SetImageExtent(image,image->columns,image->rows,exception);
678  if (status == MagickFalse)
679    return((Image *) NULL);
680  quantum_info=AcquireQuantumInfo(image_info,image);
681  if (quantum_info == (QuantumInfo *) NULL)
682    return((Image *) NULL);
683  switch(HDR.Type[1])
684  {
685    case 0:
686      format_type=FloatingPointQuantumFormat;
687      depth=64;
688      break;
689    case 1:
690      format_type=FloatingPointQuantumFormat;
691      depth=32;
692      break;
693    case 2:
694      format_type=UnsignedQuantumFormat;
695      depth=16;
696      break;
697    case 3:
698      format_type=SignedQuantumFormat;
699      depth=16;
700    case 4:
701      format_type=UnsignedQuantumFormat;
702      depth=8;
703      break;
704    default:
705      format_type=UnsignedQuantumFormat;
706      depth=8;
707      break;
708  }
709  image->depth=depth;
710  if (HDR.Type[0] != 0)
711    SetQuantumEndian(image,quantum_info,MSBEndian);
712  status=SetQuantumFormat(image,quantum_info,format_type);
713  status=SetQuantumDepth(image,quantum_info,depth);
714  status=SetQuantumEndian(image,quantum_info,endian);
715  SetQuantumScale(quantum_info,1.0);
716  pixels=(unsigned char *) GetQuantumPixels(quantum_info);
717  for (y=0; y < (ssize_t) image->rows; y++)
718  {
719    int
720      status;
721
722    register Quantum
723      *magick_restrict q;
724
725    count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
726    if (count == -1)
727      break;
728    q=QueueAuthenticPixels(image,0,image->rows-y-1,image->columns,1,exception);
729    if (q == (Quantum *) NULL)
730      break;
731    (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
732      GrayQuantum,pixels,exception);
733    if ((HDR.Type[1] == 2) || (HDR.Type[1] == 3))
734      FixSignedValues(image,q,image->columns);
735    if (SyncAuthenticPixels(image,exception) == MagickFalse)
736      break;
737    if (image->previous == (Image *) NULL)
738      {
739        status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
740          image->rows);
741        if (status == MagickFalse)
742          break;
743      }
744  }
745  if (HDR.imagf == 1)
746    for (y=0; y < (ssize_t) image->rows; y++)
747    {
748      /*
749        Read complex pixels.
750      */
751      count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
752      if (count == -1)
753        break;
754      if (HDR.Type[1] == 0)
755        InsertComplexDoubleRow(image,(double *) pixels,y,0,0,exception);
756      else
757        InsertComplexFloatRow(image,(float *) pixels,y,0,0,exception);
758    }
759  quantum_info=DestroyQuantumInfo(quantum_info);
760  rotate_image=RotateImage(image,90.0,exception);
761  if (rotate_image != (Image *) NULL)
762    {
763      image=DestroyImage(image);
764      image=rotate_image;
765    }
766  return(image);
767}
768
769/*
770%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
771%                                                                             %
772%                                                                             %
773%                                                                             %
774%   R e a d M A T L A B i m a g e                                             %
775%                                                                             %
776%                                                                             %
777%                                                                             %
778%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
779%
780%  ReadMATImage() reads an MAT X image file and returns it.  It
781%  allocates the memory necessary for the new Image structure and returns a
782%  pointer to the new image.
783%
784%  The format of the ReadMATImage method is:
785%
786%      Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
787%
788%  A description of each parameter follows:
789%
790%    o image:  Method ReadMATImage returns a pointer to the image after
791%      reading. A null image is returned if there is a memory shortage or if
792%      the image cannot be read.
793%
794%    o image_info: Specifies a pointer to a ImageInfo structure.
795%
796%    o exception: return any errors or warnings in this structure.
797%
798*/
799static Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
800{
801  Image *image, *image2=NULL,
802   *rotated_image;
803  register Quantum *q;
804
805  unsigned int status;
806  MATHeader MATLAB_HDR;
807  size_t size;
808  size_t CellType;
809  QuantumInfo *quantum_info;
810  ImageInfo *clone_info;
811  int i;
812  ssize_t ldblk;
813  unsigned char *BImgBuff = NULL;
814  double MinVal, MaxVal;
815  unsigned z, z2;
816  unsigned Frames;
817  int logging;
818  int sample_size;
819  MagickOffsetType filepos=0x80;
820  BlobInfo *blob;
821  size_t one;
822
823  unsigned int (*ReadBlobXXXLong)(Image *image);
824  unsigned short (*ReadBlobXXXShort)(Image *image);
825  void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
826  void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
827
828
829  assert(image_info != (const ImageInfo *) NULL);
830  assert(image_info->signature == MagickCoreSignature);
831  assert(exception != (ExceptionInfo *) NULL);
832  assert(exception->signature == MagickCoreSignature);
833  logging = LogMagickEvent(CoderEvent,GetMagickModule(),"enter");
834
835  /*
836     Open image file.
837   */
838  image = AcquireImage(image_info,exception);
839
840  status = OpenBlob(image_info, image, ReadBinaryBlobMode, exception);
841  if (status == MagickFalse)
842    {
843      image=DestroyImageList(image);
844      return((Image *) NULL);
845    }
846  /*
847     Read MATLAB image.
848   */
849  clone_info=CloneImageInfo(image_info);
850  if (ReadBlob(image,124,(unsigned char *) &MATLAB_HDR.identific) != 124)
851    ThrowReaderException(CorruptImageError,"ImproperImageHeader");
852  if (strncmp(MATLAB_HDR.identific,"MATLAB",6) != 0)
853    {
854      image2=ReadMATImageV4(image_info,image,exception);
855      if (image2  == NULL)
856        goto MATLAB_KO;
857      image=image2;
858      goto END_OF_READING;
859    }
860  MATLAB_HDR.Version = ReadBlobLSBShort(image);
861  if(ReadBlob(image,2,(unsigned char *) &MATLAB_HDR.EndianIndicator) != 2)
862    ThrowReaderException(CorruptImageError,"ImproperImageHeader");
863
864  if (logging)
865    (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  Endian %c%c",
866      MATLAB_HDR.EndianIndicator[0],MATLAB_HDR.EndianIndicator[1]);
867  if (!strncmp(MATLAB_HDR.EndianIndicator, "IM", 2))
868  {
869    ReadBlobXXXLong = ReadBlobLSBLong;
870    ReadBlobXXXShort = ReadBlobLSBShort;
871    ReadBlobDoublesXXX = ReadBlobDoublesLSB;
872    ReadBlobFloatsXXX = ReadBlobFloatsLSB;
873    image->endian = LSBEndian;
874  }
875  else if (!strncmp(MATLAB_HDR.EndianIndicator, "MI", 2))
876  {
877    ReadBlobXXXLong = ReadBlobMSBLong;
878    ReadBlobXXXShort = ReadBlobMSBShort;
879    ReadBlobDoublesXXX = ReadBlobDoublesMSB;
880    ReadBlobFloatsXXX = ReadBlobFloatsMSB;
881    image->endian = MSBEndian;
882  }
883  else
884    goto MATLAB_KO;    /* unsupported endian */
885
886  if (strncmp(MATLAB_HDR.identific, "MATLAB", 6))
887MATLAB_KO: ThrowReaderException(CorruptImageError,"ImproperImageHeader");
888
889  filepos = TellBlob(image);
890  while(!EOFBlob(image)) /* object parser loop */
891  {
892    Frames = 1;
893    (void) SeekBlob(image,filepos,SEEK_SET);
894    /* printf("pos=%X\n",TellBlob(image)); */
895
896    MATLAB_HDR.DataType = ReadBlobXXXLong(image);
897    if(EOFBlob(image)) break;
898    MATLAB_HDR.ObjectSize = ReadBlobXXXLong(image);
899    if(EOFBlob(image)) break;
900    filepos += MATLAB_HDR.ObjectSize + 4 + 4;
901
902    image2 = image;
903#if defined(MAGICKCORE_ZLIB_DELEGATE)
904    if(MATLAB_HDR.DataType == miCOMPRESSED)
905    {
906      image2 = DecompressBlock(image,MATLAB_HDR.ObjectSize,clone_info,exception);
907      if(image2==NULL) continue;
908      MATLAB_HDR.DataType = ReadBlobXXXLong(image2); /* replace compressed object type. */
909    }
910#endif
911
912    if(MATLAB_HDR.DataType!=miMATRIX) continue;  /* skip another objects. */
913
914    MATLAB_HDR.unknown1 = ReadBlobXXXLong(image2);
915    MATLAB_HDR.unknown2 = ReadBlobXXXLong(image2);
916
917    MATLAB_HDR.unknown5 = ReadBlobXXXLong(image2);
918    MATLAB_HDR.StructureClass = MATLAB_HDR.unknown5 & 0xFF;
919    MATLAB_HDR.StructureFlag = (MATLAB_HDR.unknown5>>8) & 0xFF;
920
921    MATLAB_HDR.unknown3 = ReadBlobXXXLong(image2);
922    if(image!=image2)
923      MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2);  /* ??? don't understand why ?? */
924    MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2);
925    MATLAB_HDR.DimFlag = ReadBlobXXXLong(image2);
926    MATLAB_HDR.SizeX = ReadBlobXXXLong(image2);
927    MATLAB_HDR.SizeY = ReadBlobXXXLong(image2);
928
929
930    switch(MATLAB_HDR.DimFlag)
931    {
932      case  8: z2=z=1; break;      /* 2D matrix*/
933      case 12: z2=z = ReadBlobXXXLong(image2);  /* 3D matrix RGB*/
934           (void) ReadBlobXXXLong(image2);
935         if(z!=3) ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
936         break;
937      case 16: z2=z = ReadBlobXXXLong(image2);  /* 4D matrix animation */
938         if(z!=3 && z!=1)
939            ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
940         Frames = ReadBlobXXXLong(image2);
941         if (Frames == 0)
942           ThrowReaderException(CorruptImageError,"ImproperImageHeader");
943         break;
944      default: ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
945    }
946
947    MATLAB_HDR.Flag1 = ReadBlobXXXShort(image2);
948    MATLAB_HDR.NameFlag = ReadBlobXXXShort(image2);
949
950    if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
951          "MATLAB_HDR.StructureClass %d",MATLAB_HDR.StructureClass);
952    if (MATLAB_HDR.StructureClass != mxCHAR_CLASS &&
953        MATLAB_HDR.StructureClass != mxSINGLE_CLASS &&    /* float + complex float */
954        MATLAB_HDR.StructureClass != mxDOUBLE_CLASS &&    /* double + complex double */
955        MATLAB_HDR.StructureClass != mxINT8_CLASS &&
956        MATLAB_HDR.StructureClass != mxUINT8_CLASS &&    /* uint8 + uint8 3D */
957        MATLAB_HDR.StructureClass != mxINT16_CLASS &&
958        MATLAB_HDR.StructureClass != mxUINT16_CLASS &&    /* uint16 + uint16 3D */
959        MATLAB_HDR.StructureClass != mxINT32_CLASS &&
960        MATLAB_HDR.StructureClass != mxUINT32_CLASS &&    /* uint32 + uint32 3D */
961        MATLAB_HDR.StructureClass != mxINT64_CLASS &&
962        MATLAB_HDR.StructureClass != mxUINT64_CLASS)    /* uint64 + uint64 3D */
963      ThrowReaderException(CoderError,"UnsupportedCellTypeInTheMatrix");
964
965    switch (MATLAB_HDR.NameFlag)
966    {
967      case 0:
968        size = ReadBlobXXXLong(image2);  /* Object name string size */
969        size = 4 * (ssize_t) ((size + 3 + 1) / 4);
970        (void) SeekBlob(image2, size, SEEK_CUR);
971        break;
972      case 1:
973      case 2:
974      case 3:
975      case 4:
976        (void) ReadBlob(image2, 4, (unsigned char *) &size); /* Object name string */
977        break;
978      default:
979        goto MATLAB_KO;
980    }
981
982    CellType = ReadBlobXXXLong(image2);    /* Additional object type */
983    if (logging)
984      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
985        "MATLAB_HDR.CellType: %.20g",(double) CellType);
986
987    (void) ReadBlob(image2, 4, (unsigned char *) &size);     /* data size */
988
989    NEXT_FRAME:
990    switch (CellType)
991    {
992      case miINT8:
993      case miUINT8:
994        sample_size = 8;
995        if(MATLAB_HDR.StructureFlag & FLAG_LOGICAL)
996          image->depth = 1;
997        else
998          image->depth = 8;         /* Byte type cell */
999        ldblk = (ssize_t) MATLAB_HDR.SizeX;
1000        break;
1001      case miINT16:
1002      case miUINT16:
1003        sample_size = 16;
1004        image->depth = 16;        /* Word type cell */
1005        ldblk = (ssize_t) (2 * MATLAB_HDR.SizeX);
1006        break;
1007      case miINT32:
1008      case miUINT32:
1009        sample_size = 32;
1010        image->depth = 32;        /* Dword type cell */
1011        ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1012        break;
1013      case miINT64:
1014      case miUINT64:
1015        sample_size = 64;
1016        image->depth = 64;        /* Qword type cell */
1017        ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1018        break;
1019      case miSINGLE:
1020        sample_size = 32;
1021        image->depth = 32;        /* double type cell */
1022        (void) SetImageOption(clone_info,"quantum:format","floating-point");
1023        if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1024  {              /* complex float type cell */
1025  }
1026        ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1027        break;
1028      case miDOUBLE:
1029        sample_size = 64;
1030        image->depth = 64;        /* double type cell */
1031        (void) SetImageOption(clone_info,"quantum:format","floating-point");
1032DisableMSCWarning(4127)
1033        if (sizeof(double) != 8)
1034RestoreMSCWarning
1035          ThrowReaderException(CoderError, "IncompatibleSizeOfDouble");
1036        if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1037  {                         /* complex double type cell */
1038  }
1039        ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1040        break;
1041      default:
1042        ThrowReaderException(CoderError, "UnsupportedCellTypeInTheMatrix");
1043    }
1044    (void) sample_size;
1045    image->columns = MATLAB_HDR.SizeX;
1046    image->rows = MATLAB_HDR.SizeY;
1047    quantum_info=AcquireQuantumInfo(clone_info,image);
1048    if (quantum_info == (QuantumInfo *) NULL)
1049      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1050    one=1;
1051    image->colors = one << image->depth;
1052    if (image->columns == 0 || image->rows == 0)
1053      goto MATLAB_KO;
1054    /* Image is gray when no complex flag is set and 2D Matrix */
1055    if ((MATLAB_HDR.DimFlag == 8) &&
1056        ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1057      {
1058        image->type=GrayscaleType;
1059        SetImageColorspace(image,GRAYColorspace,exception);
1060      }
1061
1062
1063    /*
1064      If ping is true, then only set image size and colors without
1065      reading any image data.
1066    */
1067    if (image_info->ping)
1068    {
1069      size_t temp = image->columns;
1070      image->columns = image->rows;
1071      image->rows = temp;
1072      goto done_reading; /* !!!!!! BAD  !!!! */
1073    }
1074    status=SetImageExtent(image,image->columns,image->rows,exception);
1075    if (status == MagickFalse)
1076      return(DestroyImageList(image));
1077
1078  /* ----- Load raster data ----- */
1079    BImgBuff = (unsigned char *) AcquireQuantumMemory((size_t) (ldblk),sizeof(double));    /* Ldblk was set in the check phase */
1080    if (BImgBuff == NULL)
1081      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1082
1083    MinVal = 0;
1084    MaxVal = 0;
1085    if (CellType==miDOUBLE || CellType==miSINGLE)        /* Find Min and Max Values for floats */
1086    {
1087      CalcMinMax(image2, image_info->endian,  MATLAB_HDR.SizeX, MATLAB_HDR.SizeY, CellType, ldblk, BImgBuff, &quantum_info->minimum, &quantum_info->maximum);
1088    }
1089
1090    /* Main loop for reading all scanlines */
1091    if(z==1) z=0; /* read grey scanlines */
1092    /* else read color scanlines */
1093    do
1094    {
1095      for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1096      {
1097        q=GetAuthenticPixels(image,0,MATLAB_HDR.SizeY-i-1,image->columns,1,exception);
1098        if (q == (Quantum *) NULL)
1099  {
1100    if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1101              "  MAT set image pixels returns unexpected NULL on a row %u.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1102    goto done_reading;    /* Skip image rotation, when cannot set image pixels    */
1103  }
1104        if(ReadBlob(image2,ldblk,(unsigned char *)BImgBuff) != (ssize_t) ldblk)
1105  {
1106    if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1107             "  MAT cannot read scanrow %u from a file.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1108    goto ExitLoop;
1109  }
1110        if((CellType==miINT8 || CellType==miUINT8) && (MATLAB_HDR.StructureFlag & FLAG_LOGICAL))
1111        {
1112          FixLogical((unsigned char *)BImgBuff,ldblk);
1113          if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1114    {
1115ImportQuantumPixelsFailed:
1116      if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1117              "  MAT failed to ImportQuantumPixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1118      break;
1119    }
1120        }
1121        else
1122        {
1123          if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1124      goto ImportQuantumPixelsFailed;
1125
1126
1127          if (z<=1 &&       /* fix only during a last pass z==0 || z==1 */
1128          (CellType==miINT8 || CellType==miINT16 || CellType==miINT32 || CellType==miINT64))
1129      FixSignedValues(image,q,MATLAB_HDR.SizeX);
1130        }
1131
1132        if (!SyncAuthenticPixels(image,exception))
1133  {
1134    if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1135            "  MAT failed to sync image pixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1136    goto ExitLoop;
1137  }
1138      }
1139    } while(z-- >= 2);
1140    quantum_info=DestroyQuantumInfo(quantum_info);
1141ExitLoop:
1142
1143
1144    /* Read complex part of numbers here */
1145    if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1146    {        /* Find Min and Max Values for complex parts of floats */
1147      CellType = ReadBlobXXXLong(image2);    /* Additional object type */
1148      i = ReadBlobXXXLong(image2);           /* size of a complex part - toss away*/
1149
1150      if (CellType==miDOUBLE || CellType==miSINGLE)
1151      {
1152        CalcMinMax(image2,  image_info->endian, MATLAB_HDR.SizeX, MATLAB_HDR.SizeY, CellType, ldblk, BImgBuff, &MinVal, &MaxVal);
1153      }
1154
1155      if (CellType==miDOUBLE)
1156        for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1157  {
1158          ReadBlobDoublesXXX(image2, ldblk, (double *)BImgBuff);
1159          InsertComplexDoubleRow(image, (double *)BImgBuff, i, MinVal, MaxVal,
1160            exception);
1161  }
1162
1163      if (CellType==miSINGLE)
1164        for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1165  {
1166          ReadBlobFloatsXXX(image2, ldblk, (float *)BImgBuff);
1167          InsertComplexFloatRow(image,(float *)BImgBuff,i,MinVal,MaxVal,
1168            exception);
1169  }
1170    }
1171
1172      /* Image is gray when no complex flag is set and 2D Matrix AGAIN!!! */
1173    if ((MATLAB_HDR.DimFlag == 8) &&
1174        ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1175      image->type=GrayscaleType;
1176    if (image->depth == 1)
1177      image->type=BilevelType;
1178
1179    if(image2==image)
1180        image2 = NULL;    /* Remove shadow copy to an image before rotation. */
1181
1182      /*  Rotate image. */
1183    rotated_image = RotateImage(image, 90.0, exception);
1184    if (rotated_image != (Image *) NULL)
1185    {
1186        /* Remove page offsets added by RotateImage */
1187      rotated_image->page.x=0;
1188      rotated_image->page.y=0;
1189
1190      blob = rotated_image->blob;
1191      rotated_image->blob = image->blob;
1192      rotated_image->colors = image->colors;
1193      image->blob = blob;
1194      AppendImageToList(&image,rotated_image);
1195      DeleteImageFromList(&image);
1196    }
1197
1198done_reading:
1199
1200    if(image2!=NULL)
1201      if(image2!=image)
1202      {
1203        DeleteImageFromList(&image2);
1204  if(clone_info)
1205  {
1206          if(clone_info->file)
1207    {
1208            fclose(clone_info->file);
1209            clone_info->file = NULL;
1210            (void) remove_utf8(clone_info->filename);
1211    }
1212        }
1213      }
1214
1215      /* Allocate next image structure. */
1216    AcquireNextImage(image_info,image,exception);
1217    if (image->next == (Image *) NULL) break;
1218    image=SyncNextImageInList(image);
1219    image->columns=image->rows=0;
1220    image->colors=0;
1221
1222      /* row scan buffer is no longer needed */
1223    RelinquishMagickMemory(BImgBuff);
1224    BImgBuff = NULL;
1225
1226    if(--Frames>0)
1227    {
1228      z = z2;
1229      if(image2==NULL) image2 = image;
1230      goto NEXT_FRAME;
1231    }
1232    if ((image2!=NULL) && (image2!=image))   /* Does shadow temporary decompressed image exist? */
1233      {
1234/*  CloseBlob(image2); */
1235        DeleteImageFromList(&image2);
1236        if(clone_info)
1237        {
1238          if(clone_info->file)
1239          {
1240            fclose(clone_info->file);
1241            clone_info->file = NULL;
1242            (void) remove_utf8(clone_info->filename);
1243          }
1244        }
1245        }
1246  }
1247
1248  RelinquishMagickMemory(BImgBuff);
1249END_OF_READING:
1250  clone_info=DestroyImageInfo(clone_info);
1251  CloseBlob(image);
1252
1253
1254  {
1255    Image *p;
1256    ssize_t scene=0;
1257
1258    /*
1259      Rewind list, removing any empty images while rewinding.
1260    */
1261    p=image;
1262    image=NULL;
1263    while (p != (Image *) NULL)
1264      {
1265        Image *tmp=p;
1266        if ((p->rows == 0) || (p->columns == 0)) {
1267          p=p->previous;
1268          DeleteImageFromList(&tmp);
1269        } else {
1270          image=p;
1271          p=p->previous;
1272        }
1273      }
1274
1275    /*
1276      Fix scene numbers
1277    */
1278    for (p=image; p != (Image *) NULL; p=p->next)
1279      p->scene=scene++;
1280  }
1281
1282  if(clone_info != NULL)  /* cleanup garbage file from compression */
1283  {
1284    if(clone_info->file)
1285    {
1286      fclose(clone_info->file);
1287      clone_info->file = NULL;
1288      (void) remove_utf8(clone_info->filename);
1289    }
1290    DestroyImageInfo(clone_info);
1291    clone_info = NULL;
1292  }
1293  if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),"return");
1294  if(image==NULL)
1295    ThrowReaderException(CorruptImageError,"ImproperImageHeader");
1296  return (image);
1297}
1298
1299/*
1300%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1301%                                                                             %
1302%                                                                             %
1303%                                                                             %
1304%   R e g i s t e r M A T I m a g e                                           %
1305%                                                                             %
1306%                                                                             %
1307%                                                                             %
1308%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1309%
1310%  Method RegisterMATImage adds attributes for the MAT image format to
1311%  the list of supported formats.  The attributes include the image format
1312%  tag, a method to read and/or write the format, whether the format
1313%  supports the saving of more than one frame to the same file or blob,
1314%  whether the format supports native in-memory I/O, and a brief
1315%  description of the format.
1316%
1317%  The format of the RegisterMATImage method is:
1318%
1319%      size_t RegisterMATImage(void)
1320%
1321*/
1322ModuleExport size_t RegisterMATImage(void)
1323{
1324  MagickInfo
1325    *entry;
1326
1327  entry=AcquireMagickInfo("MAT","MAT","MATLAB level 5 image format");
1328  entry->decoder=(DecodeImageHandler *) ReadMATImage;
1329  entry->encoder=(EncodeImageHandler *) WriteMATImage;
1330  entry->flags^=CoderBlobSupportFlag;
1331  entry->flags|=CoderSeekableStreamFlag;
1332  (void) RegisterMagickInfo(entry);
1333  return(MagickImageCoderSignature);
1334}
1335
1336/*
1337%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1338%                                                                             %
1339%                                                                             %
1340%                                                                             %
1341%   U n r e g i s t e r M A T I m a g e                                       %
1342%                                                                             %
1343%                                                                             %
1344%                                                                             %
1345%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1346%
1347%  Method UnregisterMATImage removes format registrations made by the
1348%  MAT module from the list of supported formats.
1349%
1350%  The format of the UnregisterMATImage method is:
1351%
1352%      UnregisterMATImage(void)
1353%
1354*/
1355ModuleExport void UnregisterMATImage(void)
1356{
1357  (void) UnregisterMagickInfo("MAT");
1358}
1359
1360/*
1361%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1362%                                                                             %
1363%                                                                             %
1364%                                                                             %
1365%   W r i t e M A T L A B I m a g e                                           %
1366%                                                                             %
1367%                                                                             %
1368%                                                                             %
1369%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1370%
1371%  Function WriteMATImage writes an Matlab matrix to a file.
1372%
1373%  The format of the WriteMATImage method is:
1374%
1375%      MagickBooleanType WriteMATImage(const ImageInfo *image_info,
1376%        Image *image,ExceptionInfo *exception)
1377%
1378%  A description of each parameter follows.
1379%
1380%    o image_info: Specifies a pointer to a ImageInfo structure.
1381%
1382%    o image:  A pointer to an Image structure.
1383%
1384%    o exception: return any errors or warnings in this structure.
1385%
1386*/
1387static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
1388  ExceptionInfo *exception)
1389{
1390  ssize_t y;
1391  unsigned z;
1392  register const Quantum *p;
1393
1394  unsigned int status;
1395  int logging;
1396  size_t DataSize;
1397  char padding;
1398  char MATLAB_HDR[0x80];
1399  time_t current_time;
1400  struct tm local_time;
1401  unsigned char *pixels;
1402  int is_gray;
1403
1404  MagickOffsetType
1405    scene;
1406
1407  QuantumInfo
1408    *quantum_info;
1409
1410  /*
1411    Open output image file.
1412  */
1413  assert(image_info != (const ImageInfo *) NULL);
1414  assert(image_info->signature == MagickCoreSignature);
1415  assert(image != (Image *) NULL);
1416  assert(image->signature == MagickCoreSignature);
1417  logging=LogMagickEvent(CoderEvent,GetMagickModule(),"enter MAT");
1418  (void) logging;
1419  assert(exception != (ExceptionInfo *) NULL);
1420  assert(exception->signature == MagickCoreSignature);
1421  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1422  if (status == MagickFalse)
1423    return(MagickFalse);
1424  image->depth=8;
1425
1426  current_time=time((time_t *) NULL);
1427#if defined(MAGICKCORE_HAVE_LOCALTIME_R)
1428  (void) localtime_r(&current_time,&local_time);
1429#else
1430  (void) memcpy(&local_time,localtime(&current_time),sizeof(local_time));
1431#endif
1432  (void) memset(MATLAB_HDR,' ',MagickMin(sizeof(MATLAB_HDR),124));
1433  FormatLocaleString(MATLAB_HDR,sizeof(MATLAB_HDR),
1434    "MATLAB 5.0 MAT-file, Platform: %s, Created on: %s %s %2d %2d:%2d:%2d %d",
1435    OsDesc,DayOfWTab[local_time.tm_wday],MonthsTab[local_time.tm_mon],
1436    local_time.tm_mday,local_time.tm_hour,local_time.tm_min,
1437    local_time.tm_sec,local_time.tm_year+1900);
1438  MATLAB_HDR[0x7C]=0;
1439  MATLAB_HDR[0x7D]=1;
1440  MATLAB_HDR[0x7E]='I';
1441  MATLAB_HDR[0x7F]='M';
1442  (void) WriteBlob(image,sizeof(MATLAB_HDR),(unsigned char *) MATLAB_HDR);
1443  scene=0;
1444  do
1445  {
1446    (void) TransformImageColorspace(image,sRGBColorspace,exception);
1447    is_gray = SetImageGray(image,exception);
1448    z = is_gray ? 0 : 3;
1449
1450    /*
1451      Store MAT header.
1452    */
1453    DataSize = image->rows /*Y*/ * image->columns /*X*/;
1454    if(!is_gray) DataSize *= 3 /*Z*/;
1455    padding=((unsigned char)(DataSize-1) & 0x7) ^ 0x7;
1456
1457    (void) WriteBlobLSBLong(image, miMATRIX);
1458    (void) WriteBlobLSBLong(image, (unsigned int) DataSize+padding+(is_gray ? 48 : 56));
1459    (void) WriteBlobLSBLong(image, 0x6); /* 0x88 */
1460    (void) WriteBlobLSBLong(image, 0x8); /* 0x8C */
1461    (void) WriteBlobLSBLong(image, 0x6); /* 0x90 */
1462    (void) WriteBlobLSBLong(image, 0);
1463    (void) WriteBlobLSBLong(image, 0x5); /* 0x98 */
1464    (void) WriteBlobLSBLong(image, is_gray ? 0x8 : 0xC); /* 0x9C - DimFlag */
1465    (void) WriteBlobLSBLong(image, (unsigned int) image->rows);    /* x: 0xA0 */
1466    (void) WriteBlobLSBLong(image, (unsigned int) image->columns); /* y: 0xA4 */
1467    if(!is_gray)
1468    {
1469      (void) WriteBlobLSBLong(image, 3); /* z: 0xA8 */
1470      (void) WriteBlobLSBLong(image, 0);
1471    }
1472    (void) WriteBlobLSBShort(image, 1);  /* 0xB0 */
1473    (void) WriteBlobLSBShort(image, 1);  /* 0xB2 */
1474    (void) WriteBlobLSBLong(image, 'M'); /* 0xB4 */
1475    (void) WriteBlobLSBLong(image, 0x2); /* 0xB8 */
1476    (void) WriteBlobLSBLong(image, (unsigned int) DataSize); /* 0xBC */
1477
1478    /*
1479      Store image data.
1480    */
1481    quantum_info=AcquireQuantumInfo(image_info,image);
1482    if (quantum_info == (QuantumInfo *) NULL)
1483      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1484    pixels=(unsigned char *) GetQuantumPixels(quantum_info);
1485    do
1486    {
1487      for (y=0; y < (ssize_t)image->columns; y++)
1488      {
1489        p=GetVirtualPixels(image,y,0,1,image->rows,exception);
1490        if (p == (const Quantum *) NULL)
1491          break;
1492        (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1493          z2qtype[z],pixels,exception);
1494        (void) WriteBlob(image,image->rows,pixels);
1495      }
1496      if (SyncAuthenticPixels(image,exception) == MagickFalse)
1497        break;
1498    } while(z-- >= 2);
1499    while(padding-->0) (void) WriteBlobByte(image,0);
1500    quantum_info=DestroyQuantumInfo(quantum_info);
1501    if (GetNextImageInList(image) == (Image *) NULL)
1502      break;
1503    image=SyncNextImageInList(image);
1504    status=SetImageProgress(image,SaveImagesTag,scene++,
1505      GetImageListLength(image));
1506    if (status == MagickFalse)
1507      break;
1508  } while (image_info->adjoin != MagickFalse);
1509  (void) CloseBlob(image);
1510  return(MagickTrue);
1511}
1512