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

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