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.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 \f
  83 /*
  84   Forward declaration.
  85 */
  86 static MagickBooleanType
  87   WriteMATImage(const ImageInfo *,Image *,ExceptionInfo *);
  88
  89
  90 /* Auto coloring method, sorry this creates some artefact inside data
  91 MinReal+j*MaxComplex = red  MaxReal+j*MaxComplex = black
  92 MinReal+j*0 = white          MaxReal+j*0 = black
  93 MinReal+j*MinComplex = blue  MaxReal+j*MinComplex = black
  94 */
  95
  96 typedef struct
  97 {
  98   char identific[124];
  99   unsigned short Version;
 100   char EndianIndicator[2];
 101   unsigned int DataType;
 102   unsigned int ObjectSize;
 103   unsigned int unknown1;
 104   unsigned int unknown2;
 105
 106   unsigned short unknown5;
 107   unsigned char StructureFlag;
 108   unsigned char StructureClass;
 109   unsigned int unknown3;
 110   unsigned int unknown4;
 111   unsigned int DimFlag;
 112
 113   unsigned int SizeX;
 114   unsigned int SizeY;
 115   unsigned short Flag1;
 116   unsigned short NameFlag;
 117 }
 118 MATHeader;
 119
 120 static const char *MonthsTab[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
 121 static const char *DayOfWTab[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
 122 static 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
 133 typedef 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
 155 typedef 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
 179 static const QuantumType z2qtype[4] = {GrayQuantum, BlueQuantum, GreenQuantum, RedQuantum};
 180
 181
 182 static 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)+ClampToQuantum(f),q);
 207       f = GetPixelGreen(image,q)-f/2.0;
 208       if (f <= 0.0)
 209         {
 210           SetPixelGreen(image,0,q);
 211           SetPixelBlue(image,0,q);
 212         }
 213       else
 214         {
 215           SetPixelBlue(image,ClampToQuantum(f),q);
 216           SetPixelGreen(image,ClampToQuantum(f),q);
 217         }
 218     }
 219     if (*p < 0)
 220     {
 221       f = (*p / MinVal) * (QuantumRange-GetPixelBlue(image,q));
 222       if (f+GetPixelBlue(image,q) > QuantumRange)
 223         SetPixelBlue(image,QuantumRange,q);
 224       else
 225         SetPixelBlue(image,GetPixelBlue(image,q)+ClampToQuantum(f),q);
 226       f = GetPixelGreen(image,q)-f/2.0;
 227       if (f <= 0.0)
 228         {
 229           SetPixelRed(image,0,q);
 230           SetPixelGreen(image,0,q);
 231         }
 232       else
 233         {
 234           SetPixelRed(image,ClampToQuantum(f),q);
 235           SetPixelGreen(image,ClampToQuantum(f),q);
 236         }
 237     }
 238     p++;
 239     q+=GetPixelChannels(image);
 240   }
 241   if (!SyncAuthenticPixels(image,exception))
 242     return;
 243   return;
 244 }
 245
 246
 247 static void InsertComplexFloatRow(Image *image,float *p,int y,double MinVal,
 248   double MaxVal,ExceptionInfo *exception)
 249 {
 250   double f;
 251   int x;
 252   register Quantum *q;
 253
 254   if (MinVal == 0)
 255     MinVal = -1;
 256   if (MaxVal == 0)
 257     MaxVal = 1;
 258
 259   q = QueueAuthenticPixels(image, 0, y, image->columns, 1,exception);
 260   if (q == (Quantum *) NULL)
 261     return;
 262   for (x = 0; x < (ssize_t) image->columns; x++)
 263   {
 264     if (*p > 0)
 265     {
 266       f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
 267       if (f+GetPixelRed(image,q) > QuantumRange)
 268         SetPixelRed(image,QuantumRange,q);
 269       else
 270         SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
 271       if ((int) f / 2.0 > GetPixelGreen(image,q))
 272         {
 273           SetPixelGreen(image,0,q);
 274           SetPixelBlue(image,0,q);
 275         }
 276       else
 277         {
 278           SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
 279           SetPixelGreen(image,GetPixelBlue(image,q),q);
 280         }
 281     }
 282     if (*p < 0)
 283     {
 284       f = (*p / MaxVal) * (QuantumRange - GetPixelBlue(image,q));
 285       if (f + GetPixelBlue(image,q) > QuantumRange)
 286         SetPixelBlue(image,QuantumRange,q);
 287       else
 288         SetPixelBlue(image,GetPixelBlue(image,q)+
 289           (int) f,q);
 290       if ((int) f / 2.0 > GetPixelGreen(image,q))
 291         {
 292           SetPixelGreen(image,0,q);
 293           SetPixelRed(image,0,q);
 294         }
 295       else
 296         {
 297           SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
 298           SetPixelGreen(image,GetPixelRed(image,q),q);
 299         }
 300     }
 301     p++;
 302     q++;
 303   }
 304   if (!SyncAuthenticPixels(image,exception))
 305     return;
 306   return;
 307 }
 308
 309
 310 /************** READERS ******************/
 311
 312 /* This function reads one block of floats*/
 313 static void ReadBlobFloatsLSB(Image * image, size_t len, float *data)
 314 {
 315   while (len >= 4)
 316   {
 317     *data++ = ReadBlobFloat(image);
 318     len -= sizeof(float);
 319   }
 320   if (len > 0)
 321     (void) SeekBlob(image, len, SEEK_CUR);
 322 }
 323
 324 static void ReadBlobFloatsMSB(Image * image, size_t len, float *data)
 325 {
 326   while (len >= 4)
 327   {
 328     *data++ = ReadBlobFloat(image);
 329     len -= sizeof(float);
 330   }
 331   if (len > 0)
 332     (void) SeekBlob(image, len, SEEK_CUR);
 333 }
 334
 335 /* This function reads one block of doubles*/
 336 static void ReadBlobDoublesLSB(Image * image, size_t len, double *data)
 337 {
 338   while (len >= 8)
 339   {
 340     *data++ = ReadBlobDouble(image);
 341     len -= sizeof(double);
 342   }
 343   if (len > 0)
 344     (void) SeekBlob(image, len, SEEK_CUR);
 345 }
 346
 347 static void ReadBlobDoublesMSB(Image * image, size_t len, double *data)
 348 {
 349   while (len >= 8)
 350   {
 351     *data++ = ReadBlobDouble(image);
 352     len -= sizeof(double);
 353   }
 354   if (len > 0)
 355     (void) SeekBlob(image, len, SEEK_CUR);
 356 }
 357
 358 /* Calculate minimum and maximum from a given block of data */
 359 static void CalcMinMax(Image *image, int endian_indicator, int SizeX, int SizeY, size_t CellType, unsigned ldblk, void *BImgBuff, double *Min, double *Max)
 360 {
 361 MagickOffsetType filepos;
 362 int i, x;
 363 void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
 364 void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
 365 double *dblrow;
 366 float *fltrow;
 367
 368   if (endian_indicator == LSBEndian)
 369   {
 370     ReadBlobDoublesXXX = ReadBlobDoublesLSB;
 371     ReadBlobFloatsXXX = ReadBlobFloatsLSB;
 372   }
 373   else    /* MI */
 374   {
 375     ReadBlobDoublesXXX = ReadBlobDoublesMSB;
 376     ReadBlobFloatsXXX = ReadBlobFloatsMSB;
 377   }
 378
 379   filepos = TellBlob(image);     /* Please note that file seeking occurs only in the case of doubles */
 380   for (i = 0; i < SizeY; i++)
 381   {
 382     if (CellType==miDOUBLE)
 383     {
 384       ReadBlobDoublesXXX(image, ldblk, (double *)BImgBuff);
 385       dblrow = (double *)BImgBuff;
 386       if (i == 0)
 387       {
 388         *Min = *Max = *dblrow;
 389       }
 390       for (x = 0; x < SizeX; x++)
 391       {
 392         if (*Min > *dblrow)
 393           *Min = *dblrow;
 394         if (*Max < *dblrow)
 395           *Max = *dblrow;
 396         dblrow++;
 397       }
 398     }
 399     if (CellType==miSINGLE)
 400     {
 401       ReadBlobFloatsXXX(image, ldblk, (float *)BImgBuff);
 402       fltrow = (float *)BImgBuff;
 403       if (i == 0)
 404       {
 405         *Min = *Max = *fltrow;
 406       }
 407     for (x = 0; x < (ssize_t) SizeX; x++)
 408       {
 409         if (*Min > *fltrow)
 410           *Min = *fltrow;
 411         if (*Max < *fltrow)
 412           *Max = *fltrow;
 413         fltrow++;
 414       }
 415     }
 416   }
 417   (void) SeekBlob(image, filepos, SEEK_SET);
 418 }
 419
 420
 421 static void FixSignedValues(const Image *image,Quantum *q, int y)
 422 {
 423   while(y-->0)
 424   {
 425      /* Please note that negative values will overflow
 426         Q=8; QuantumRange=255: <0;127> + 127+1 = <128; 255>
 427            <-1;-128> + 127+1 = <0; 127> */
 428     SetPixelRed(image,GetPixelRed(image,q)+QuantumRange/2+1,q);
 429     SetPixelGreen(image,GetPixelGreen(image,q)+QuantumRange/2+1,q);
 430     SetPixelBlue(image,GetPixelBlue(image,q)+QuantumRange/2+1,q);
 431     q++;
 432   }
 433 }
 434
 435
 436 /** Fix whole row of logical/binary data. It means pack it. */
 437 static void FixLogical(unsigned char *Buff,int ldblk)
 438 {
 439 unsigned char mask=128;
 440 unsigned char *BuffL = Buff;
 441 unsigned char val = 0;
 442
 443   while(ldblk-->0)
 444   {
 445     if(*Buff++ != 0)
 446       val |= mask;
 447
 448     mask >>= 1;
 449     if(mask==0)
 450     {
 451       *BuffL++ = val;
 452       val = 0;
 453       mask = 128;
 454     }
 455
 456   }
 457   *BuffL = val;
 458 }
 459
 460 #if defined(MAGICKCORE_ZLIB_DELEGATE)
 461 static voidpf AcquireZIPMemory(voidpf context,unsigned int items,
 462   unsigned int size)
 463 {
 464   (void) context;
 465   return((voidpf) AcquireQuantumMemory(items,size));
 466 }
 467
 468 static void RelinquishZIPMemory(voidpf context,voidpf memory)
 469 {
 470   (void) context;
 471   memory=RelinquishMagickMemory(memory);
 472 }
 473 #endif
 474
 475 #if defined(MAGICKCORE_ZLIB_DELEGATE)
 476 /** This procedure decompreses an image block for a new MATLAB format. */
 477 static Image *decompress_block(Image *orig, unsigned int *Size, ImageInfo *clone_info, ExceptionInfo *exception)
 478 {
 479
 480 Image *image2;
 481 void *cache_block, *decompress_block;
 482 z_stream zip_info;
 483 FILE *mat_file;
 484 size_t magick_size;
 485 size_t extent;
 486 int file;
 487
 488 int status;
 489 int zip_status;
 490 ssize_t TotalSize = 0;
 491
 492   if(clone_info==NULL) return NULL;
 493   if(clone_info->file)    /* Close file opened from previous transaction. */
 494   {
 495     fclose(clone_info->file);
 496     clone_info->file = NULL;
 497     (void) remove_utf8(clone_info->filename);
 498   }
 499
 500   cache_block = AcquireQuantumMemory((size_t)(*Size < 16384) ? *Size: 16384,sizeof(unsigned char *));
 501   if(cache_block==NULL) return NULL;
 502   decompress_block = AcquireQuantumMemory((size_t)(4096),sizeof(unsigned char *));
 503   if(decompress_block==NULL)
 504   {
 505     RelinquishMagickMemory(cache_block);
 506     return NULL;
 507   }
 508
 509   mat_file=0;
 510   file = AcquireUniqueFileResource(clone_info->filename);
 511   if (file != -1)
 512     mat_file = fdopen(file,"w");
 513   if(!mat_file)
 514   {
 515     RelinquishMagickMemory(cache_block);
 516     RelinquishMagickMemory(decompress_block);
 517     (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Cannot create file stream for decompressed image");
 518     return NULL;
 519   }
 520
 521   zip_info.zalloc=AcquireZIPMemory;
 522   zip_info.zfree=RelinquishZIPMemory;
 523   zip_info.opaque = (voidpf) NULL;
 524   zip_status = inflateInit(&zip_info);
 525   if (zip_status != Z_OK)
 526     {
 527       RelinquishMagickMemory(cache_block);
 528       RelinquishMagickMemory(decompress_block);
 529       (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
 530         "UnableToUncompressImage","`%s'",clone_info->filename);
 531       (void) fclose(mat_file);
 532       RelinquishUniqueFileResource(clone_info->filename);
 533       return NULL;
 534     }
 535   /* zip_info.next_out = 8*4;*/
 536
 537   zip_info.avail_in = 0;
 538   zip_info.total_out = 0;
 539   while(*Size>0 && !EOFBlob(orig))
 540   {
 541     magick_size = ReadBlob(orig, (*Size < 16384) ? *Size : 16384, (unsigned char *) cache_block);
 542     if (magick_size == 0)
 543       break;
 544     zip_info.next_in = (Bytef *) cache_block;
 545     zip_info.avail_in = (uInt) magick_size;
 546
 547     while(zip_info.avail_in>0)
 548     {
 549       zip_info.avail_out = 4096;
 550       zip_info.next_out = (Bytef *) decompress_block;
 551       zip_status = inflate(&zip_info,Z_NO_FLUSH);
 552       if ((zip_status != Z_OK) && (zip_status != Z_STREAM_END))
 553         break;
 554       extent=fwrite(decompress_block, 4096-zip_info.avail_out, 1, mat_file);
 555       (void) extent;
 556       TotalSize += 4096-zip_info.avail_out;
 557
 558       if(zip_status == Z_STREAM_END) goto DblBreak;
 559     }
 560     if ((zip_status != Z_OK) && (zip_status != Z_STREAM_END))
 561       break;
 562
 563     *Size -= (unsigned int) magick_size;
 564   }
 565 DblBreak:
 566
 567   inflateEnd(&zip_info);
 568   (void)fclose(mat_file);
 569   RelinquishMagickMemory(cache_block);
 570   RelinquishMagickMemory(decompress_block);
 571   *Size = TotalSize;
 572
 573   if((clone_info->file=fopen(clone_info->filename,"rb"))==NULL) goto UnlinkFile;
 574   if( (image2 = AcquireImage(clone_info,exception))==NULL ) goto EraseFile;
 575   status = OpenBlob(clone_info,image2,ReadBinaryBlobMode,exception);
 576   if (status == MagickFalse)
 577   {
 578     DeleteImageFromList(&image2);
 579 EraseFile:
 580     fclose(clone_info->file);
 581     clone_info->file = NULL;
 582 UnlinkFile:
 583     RelinquishUniqueFileResource(clone_info->filename);
 584     return NULL;
 585   }
 586
 587   return image2;
 588 }
 589 #endif
 590
 591 static Image *ReadMATImageV4(const ImageInfo *image_info,Image *image,
 592   ExceptionInfo *exception)
 593 {
 594   typedef struct {
 595     unsigned char Type[4];
 596     unsigned int nRows;
 597     unsigned int nCols;
 598     unsigned int imagf;
 599     unsigned int nameLen;
 600   } MAT4_HDR;
 601
 602   long
 603     ldblk;
 604
 605   EndianType
 606     endian;
 607
 608   Image
 609     *rotated_image;
 610
 611   MagickBooleanType
 612     status;
 613
 614   MAT4_HDR
 615     HDR;
 616
 617   QuantumInfo
 618     *quantum_info;
 619
 620   QuantumFormatType
 621     format_type;
 622
 623   register ssize_t
 624     i;
 625
 626   ssize_t
 627     count,
 628     y;
 629
 630   unsigned char
 631     *pixels;
 632
 633   unsigned int
 634     depth;
 635
 636   quantum_info=(QuantumInfo *) NULL;
 637   (void) SeekBlob(image,0,SEEK_SET);
 638   status=MagickTrue;
 639   while (EOFBlob(image) == MagickFalse)
 640   {
 641     /*
 642      Object parser loop.
 643     */
 644     ldblk=ReadBlobLSBLong(image);
 645     if ((ldblk > 9999) || (ldblk < 0))
 646       break;
 647     HDR.Type[3]=ldblk % 10; ldblk /= 10;  /* T digit */
 648     HDR.Type[2]=ldblk % 10; ldblk /= 10;  /* P digit */
 649     HDR.Type[1]=ldblk % 10; ldblk /= 10;  /* O digit */
 650     HDR.Type[0]=ldblk;        /* M digit */
 651     if (HDR.Type[3] != 0)
 652       break;  /* Data format */
 653     if (HDR.Type[2] != 0)
 654       break;  /* Always 0 */
 655     if (HDR.Type[0] == 0)
 656       {
 657         HDR.nRows=ReadBlobLSBLong(image);
 658         HDR.nCols=ReadBlobLSBLong(image);
 659         HDR.imagf=ReadBlobLSBLong(image);
 660         HDR.nameLen=ReadBlobLSBLong(image);
 661         endian=LSBEndian;
 662       }
 663     else
 664       {
 665         HDR.nRows=ReadBlobMSBLong(image);
 666         HDR.nCols=ReadBlobMSBLong(image);
 667         HDR.imagf=ReadBlobMSBLong(image);
 668         HDR.nameLen=ReadBlobMSBLong(image);
 669         endian=MSBEndian;
 670       }
 671     if ((HDR.imagf != 0) && (HDR.imagf != 1))
 672       break;
 673     if (HDR.nameLen > 0xFFFF)
 674       return(DestroyImageList(image));
 675     for (i=0; i < (ssize_t) HDR.nameLen; i++)
 676     {
 677       int
 678         byte;
 679
 680       /*
 681         Skip matrix name.
 682       */
 683       byte=ReadBlobByte(image);
 684       if (byte == EOF)
 685         {
 686           ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 687             image->filename);
 688           break;
 689         }
 690     }
 691     image->columns=(size_t) HDR.nRows;
 692     image->rows=(size_t) HDR.nCols;
 693     if ((image->columns == 0) || (image->rows == 0))
 694       return(DestroyImageList(image));
 695     if (image_info->ping != MagickFalse)
 696       {
 697         Swap(image->columns,image->rows);
 698         if(HDR.imagf==1) ldblk *= 2;
 699         SeekBlob(image, HDR.nCols*ldblk, SEEK_CUR);
 700         if ((image->columns == 0) || (image->rows == 0))
 701           return(image->previous == (Image *) NULL ? DestroyImageList(image)
 702             : image);
 703         goto skip_reading_current;
 704       }
 705     status=SetImageExtent(image,image->columns,image->rows,exception);
 706     if (status == MagickFalse)
 707       return(DestroyImageList(image));
 708     (void) SetImageBackgroundColor(image,exception);
 709     (void) SetImageColorspace(image,GRAYColorspace,exception);
 710     quantum_info=AcquireQuantumInfo(image_info,image);
 711     if (quantum_info == (QuantumInfo *) NULL)
 712       return(DestroyImageList(image));
 713     switch(HDR.Type[1])
 714     {
 715       case 0:
 716         format_type=FloatingPointQuantumFormat;
 717         depth=64;
 718         break;
 719       case 1:
 720         format_type=FloatingPointQuantumFormat;
 721         depth=32;
 722         break;
 723       case 2:
 724         format_type=UnsignedQuantumFormat;
 725         depth=16;
 726         break;
 727       case 3:
 728         format_type=SignedQuantumFormat;
 729         depth=16;
 730         break;
 731       case 4:
 732         format_type=UnsignedQuantumFormat;
 733         depth=8;
 734         break;
 735       default:
 736         format_type=UnsignedQuantumFormat;
 737         depth=8;
 738         break;
 739     }
 740     image->depth=depth;
 741     if (HDR.Type[0] != 0)
 742       SetQuantumEndian(image,quantum_info,MSBEndian);
 743     status=SetQuantumFormat(image,quantum_info,format_type);
 744     status=SetQuantumDepth(image,quantum_info,depth);
 745     status=SetQuantumEndian(image,quantum_info,endian);
 746     SetQuantumScale(quantum_info,1.0);
 747     pixels=(unsigned char *) GetQuantumPixels(quantum_info);
 748     for (y=0; y < (ssize_t) image->rows; y++)
 749     {
 750       register Quantum
 751         *magick_restrict q;
 752
 753       count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
 754       if (count == -1)
 755         break;
 756       q=QueueAuthenticPixels(image,0,image->rows-y-1,image->columns,1,
 757         exception);
 758       if (q == (Quantum *) NULL)
 759         break;
 760       (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
 761         GrayQuantum,pixels,exception);
 762       if ((HDR.Type[1] == 2) || (HDR.Type[1] == 3))
 763         FixSignedValues(image,q,(int) image->columns);
 764       if (SyncAuthenticPixels(image,exception) == MagickFalse)
 765         break;
 766       if (image->previous == (Image *) NULL)
 767         {
 768           status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 769             image->rows);
 770           if (status == MagickFalse)
 771             break;
 772         }
 773     }
 774     if (HDR.imagf == 1)
 775       for (y=0; y < (ssize_t) image->rows; y++)
 776       {
 777         /*
 778           Read complex pixels.
 779         */
 780         count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
 781         if (count == -1)
 782           break;
 783         if (HDR.Type[1] == 0)
 784           InsertComplexDoubleRow(image,(double *) pixels,y,0,0,exception);
 785         else
 786           InsertComplexFloatRow(image,(float *) pixels,y,0,0,exception);
 787       }
 788     if (quantum_info != (QuantumInfo *) NULL)
 789       quantum_info=DestroyQuantumInfo(quantum_info);
 790     if (EOFBlob(image) != MagickFalse)
 791       {
 792         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 793           image->filename);
 794         break;
 795       }
 796     rotated_image=RotateImage(image,90.0,exception);
 797     if (rotated_image != (Image *) NULL)
 798       {
 799         rotated_image->page.x=0;
 800         rotated_image->page.y=0;
 801         rotated_image->colors = image->colors;
 802         DestroyBlob(rotated_image);
 803         rotated_image->blob=ReferenceBlob(image->blob);
 804         AppendImageToList(&image,rotated_image);
 805         DeleteImageFromList(&image);
 806       }
 807     /*
 808       Proceed to next image.
 809     */
 810     if (image_info->number_scenes != 0)
 811       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 812         break;
 813     /*
 814       Allocate next image structure.
 815     */
 816 skip_reading_current:
 817     AcquireNextImage(image_info,image,exception);
 818     if (GetNextImageInList(image) == (Image *) NULL)
 819       {
 820         status=MagickFalse;
 821         break;
 822       }
 823     image=SyncNextImageInList(image);
 824     status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
 825       GetBlobSize(image));
 826     if (status == MagickFalse)
 827       break;
 828   }
 829   (void) CloseBlob(image);
 830   if (status == MagickFalse)
 831     return(DestroyImageList(image));
 832   return(GetFirstImageInList(image));
 833 }
 834 \f
 835 /*
 836 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 837 %                                                                             %
 838 %                                                                             %
 839 %                                                                             %
 840 %   R e a d M A T L A B i m a g e                                             %
 841 %                                                                             %
 842 %                                                                             %
 843 %                                                                             %
 844 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 845 %
 846 %  ReadMATImage() reads an MAT X image file and returns it.  It
 847 %  allocates the memory necessary for the new Image structure and returns a
 848 %  pointer to the new image.
 849 %
 850 %  The format of the ReadMATImage method is:
 851 %
 852 %      Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
 853 %
 854 %  A description of each parameter follows:
 855 %
 856 %    o image:  Method ReadMATImage returns a pointer to the image after
 857 %      reading. A null image is returned if there is a memory shortage or if
 858 %      the image cannot be read.
 859 %
 860 %    o image_info: Specifies a pointer to a ImageInfo structure.
 861 %
 862 %    o exception: return any errors or warnings in this structure.
 863 %
 864 */
 865 static Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
 866 {
 867   Image *image, *image2=NULL,
 868    *rotated_image;
 869   register Quantum *q;
 870
 871   unsigned int status;
 872   MATHeader MATLAB_HDR;
 873   size_t size;
 874   size_t CellType;
 875   QuantumInfo *quantum_info;
 876   ImageInfo *clone_info;
 877   int i;
 878   ssize_t ldblk;
 879   unsigned char *BImgBuff = NULL;
 880   double MinVal, MaxVal;
 881   unsigned z, z2;
 882   unsigned Frames;
 883   int logging;
 884   int sample_size;
 885   MagickOffsetType filepos=0x80;
 886
 887   unsigned int (*ReadBlobXXXLong)(Image *image);
 888   unsigned short (*ReadBlobXXXShort)(Image *image);
 889   void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
 890   void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
 891
 892
 893   assert(image_info != (const ImageInfo *) NULL);
 894   assert(image_info->signature == MagickCoreSignature);
 895   assert(exception != (ExceptionInfo *) NULL);
 896   assert(exception->signature == MagickCoreSignature);
 897   logging = LogMagickEvent(CoderEvent,GetMagickModule(),"enter");
 898
 899   /*
 900      Open image file.
 901    */
 902   image = AcquireImage(image_info,exception);
 903   image2 = (Image *) NULL;
 904
 905   status = OpenBlob(image_info, image, ReadBinaryBlobMode, exception);
 906   if (status == MagickFalse)
 907     {
 908       image=DestroyImageList(image);
 909       return((Image *) NULL);
 910     }
 911   /*
 912      Read MATLAB image.
 913    */
 914   quantum_info=(QuantumInfo *) NULL;
 915   clone_info=(ImageInfo *) NULL;
 916   if (ReadBlob(image,124,(unsigned char *) &MATLAB_HDR.identific) != 124)
 917     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 918   if (strncmp(MATLAB_HDR.identific,"MATLAB",6) != 0)
 919     {
 920       image=ReadMATImageV4(image_info,image,exception);
 921       if (image == NULL)
 922         {
 923           if ((image != image2) && (image2 != (Image *) NULL))
 924             image2=DestroyImage(image2);
 925           if (clone_info != (ImageInfo *) NULL)
 926             clone_info=DestroyImageInfo(clone_info);
 927           return((Image *) NULL);
 928         }
 929       goto END_OF_READING;
 930     }
 931   MATLAB_HDR.Version = ReadBlobLSBShort(image);
 932   if(ReadBlob(image,2,(unsigned char *) &MATLAB_HDR.EndianIndicator) != 2)
 933     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 934
 935   if (logging)
 936     (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  Endian %c%c",
 937       MATLAB_HDR.EndianIndicator[0],MATLAB_HDR.EndianIndicator[1]);
 938   if (!strncmp(MATLAB_HDR.EndianIndicator, "IM", 2))
 939   {
 940     ReadBlobXXXLong = ReadBlobLSBLong;
 941     ReadBlobXXXShort = ReadBlobLSBShort;
 942     ReadBlobDoublesXXX = ReadBlobDoublesLSB;
 943     ReadBlobFloatsXXX = ReadBlobFloatsLSB;
 944     image->endian = LSBEndian;
 945   }
 946   else if (!strncmp(MATLAB_HDR.EndianIndicator, "MI", 2))
 947   {
 948     ReadBlobXXXLong = ReadBlobMSBLong;
 949     ReadBlobXXXShort = ReadBlobMSBShort;
 950     ReadBlobDoublesXXX = ReadBlobDoublesMSB;
 951     ReadBlobFloatsXXX = ReadBlobFloatsMSB;
 952     image->endian = MSBEndian;
 953   }
 954   else
 955     {
 956 MATLAB_KO:
 957       if ((image != image2) && (image2 != (Image *) NULL))
 958         image2=DestroyImage(image2);
 959       if (clone_info != (ImageInfo *) NULL)
 960         clone_info=DestroyImageInfo(clone_info);
 961       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 962     }
 963
 964   filepos = TellBlob(image);
 965   while(!EOFBlob(image)) /* object parser loop */
 966   {
 967     Frames = 1;
 968     if (filepos != (unsigned int) filepos)
 969       break;
 970     if(SeekBlob(image,filepos,SEEK_SET) != filepos) break;
 971     /* printf("pos=%X\n",TellBlob(image)); */
 972
 973     MATLAB_HDR.DataType = ReadBlobXXXLong(image);
 974     if(EOFBlob(image)) break;
 975     MATLAB_HDR.ObjectSize = ReadBlobXXXLong(image);
 976     if(EOFBlob(image)) break;
 977     if((MagickSizeType) (MATLAB_HDR.ObjectSize+filepos) > GetBlobSize(image))
 978       goto MATLAB_KO;
 979     filepos += (MagickOffsetType) MATLAB_HDR.ObjectSize + 4 + 4;
 980
 981     if (clone_info != (ImageInfo *) NULL)
 982       clone_info=DestroyImageInfo(clone_info);
 983     clone_info=CloneImageInfo(image_info);
 984     if ((image != image2) && (image2 != (Image *) NULL))
 985       image2=DestroyImage(image2);
 986     image2 = image;
 987 #if defined(MAGICKCORE_ZLIB_DELEGATE)
 988     if(MATLAB_HDR.DataType == miCOMPRESSED)
 989     {
 990       image2 = decompress_block(image,&MATLAB_HDR.ObjectSize,clone_info,exception);
 991       if(image2==NULL) continue;
 992       MATLAB_HDR.DataType = ReadBlobXXXLong(image2); /* replace compressed object type. */
 993     }
 994 #endif
 995
 996     if (MATLAB_HDR.DataType != miMATRIX)
 997       {
 998         clone_info=DestroyImageInfo(clone_info);
 999 #if defined(MAGICKCORE_ZLIB_DELEGATE)
1000         if (image2 != image)
1001           DeleteImageFromList(&image2);
1002 #endif
1003         continue;  /* skip another objects. */
1004       }
1005
1006     MATLAB_HDR.unknown1 = ReadBlobXXXLong(image2);
1007     MATLAB_HDR.unknown2 = ReadBlobXXXLong(image2);
1008
1009     MATLAB_HDR.unknown5 = ReadBlobXXXLong(image2);
1010     MATLAB_HDR.StructureClass = MATLAB_HDR.unknown5 & 0xFF;
1011     MATLAB_HDR.StructureFlag = (MATLAB_HDR.unknown5>>8) & 0xFF;
1012
1013     MATLAB_HDR.unknown3 = ReadBlobXXXLong(image2);
1014     if(image!=image2)
1015       MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2);  /* ??? don't understand why ?? */
1016     MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2);
1017     MATLAB_HDR.DimFlag = ReadBlobXXXLong(image2);
1018     MATLAB_HDR.SizeX = ReadBlobXXXLong(image2);
1019     MATLAB_HDR.SizeY = ReadBlobXXXLong(image2);
1020
1021
1022     switch(MATLAB_HDR.DimFlag)
1023     {
1024       case  8: z2=z=1; break;      /* 2D matrix*/
1025       case 12: z2=z = ReadBlobXXXLong(image2);  /* 3D matrix RGB*/
1026            (void) ReadBlobXXXLong(image2);
1027          if(z!=3)
1028            {
1029              if (clone_info != (ImageInfo *) NULL)
1030                clone_info=DestroyImageInfo(clone_info);
1031              if ((image != image2) && (image2 != (Image *) NULL))
1032                image2=DestroyImage(image2);
1033              ThrowReaderException(CoderError,
1034                "MultidimensionalMatricesAreNotSupported");
1035            }
1036          break;
1037       case 16: z2=z = ReadBlobXXXLong(image2);  /* 4D matrix animation */
1038          if(z!=3 && z!=1)
1039            {
1040              if (clone_info != (ImageInfo *) NULL)
1041                clone_info=DestroyImageInfo(clone_info);
1042              if ((image != image2) && (image2 != (Image *) NULL))
1043                image2=DestroyImage(image2);
1044              ThrowReaderException(CoderError,
1045                "MultidimensionalMatricesAreNotSupported");
1046            }
1047           Frames = ReadBlobXXXLong(image2);
1048           if (Frames == 0)
1049             {
1050               if (clone_info != (ImageInfo *) NULL)
1051                 clone_info=DestroyImageInfo(clone_info);
1052               if ((image != image2) && (image2 != (Image *) NULL))
1053                 image2=DestroyImage(image2);
1054               ThrowReaderException(CorruptImageError,"ImproperImageHeader");
1055             }
1056           if (AcquireMagickResource(ListLengthResource,Frames) == MagickFalse)
1057             {
1058               if (clone_info != (ImageInfo *) NULL)
1059                 clone_info=DestroyImageInfo(clone_info);
1060               if ((image != image2) && (image2 != (Image *) NULL))
1061                 image2=DestroyImage(image2);
1062               ThrowReaderException(ResourceLimitError,"ListLengthExceedsLimit");
1063             }
1064          break;
1065       default:
1066         if (clone_info != (ImageInfo *) NULL)
1067           clone_info=DestroyImageInfo(clone_info);
1068         if ((image != image2) && (image2 != (Image *) NULL))
1069           image2=DestroyImage(image2);
1070         ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
1071     }
1072
1073     MATLAB_HDR.Flag1 = ReadBlobXXXShort(image2);
1074     MATLAB_HDR.NameFlag = ReadBlobXXXShort(image2);
1075
1076     if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1077           "MATLAB_HDR.StructureClass %d",MATLAB_HDR.StructureClass);
1078     if (MATLAB_HDR.StructureClass != mxCHAR_CLASS &&
1079         MATLAB_HDR.StructureClass != mxSINGLE_CLASS &&    /* float + complex float */
1080         MATLAB_HDR.StructureClass != mxDOUBLE_CLASS &&    /* double + complex double */
1081         MATLAB_HDR.StructureClass != mxINT8_CLASS &&
1082         MATLAB_HDR.StructureClass != mxUINT8_CLASS &&    /* uint8 + uint8 3D */
1083         MATLAB_HDR.StructureClass != mxINT16_CLASS &&
1084         MATLAB_HDR.StructureClass != mxUINT16_CLASS &&    /* uint16 + uint16 3D */
1085         MATLAB_HDR.StructureClass != mxINT32_CLASS &&
1086         MATLAB_HDR.StructureClass != mxUINT32_CLASS &&    /* uint32 + uint32 3D */
1087         MATLAB_HDR.StructureClass != mxINT64_CLASS &&
1088         MATLAB_HDR.StructureClass != mxUINT64_CLASS)    /* uint64 + uint64 3D */
1089       {
1090         if ((image2 != (Image*) NULL) && (image2 != image))
1091           {
1092             CloseBlob(image2);
1093             DeleteImageFromList(&image2);
1094           }
1095         if (clone_info != (ImageInfo *) NULL)
1096           clone_info=DestroyImageInfo(clone_info);
1097         ThrowReaderException(CoderError,"UnsupportedCellTypeInTheMatrix");
1098       }
1099
1100     switch (MATLAB_HDR.NameFlag)
1101     {
1102       case 0:
1103         size = ReadBlobXXXLong(image2);  /* Object name string size */
1104         size = 4 * (((size_t) size + 3 + 1) / 4);
1105         (void) SeekBlob(image2, size, SEEK_CUR);
1106         break;
1107       case 1:
1108       case 2:
1109       case 3:
1110       case 4:
1111         (void) ReadBlob(image2, 4, (unsigned char *) &size); /* Object name string */
1112         break;
1113       default:
1114         goto MATLAB_KO;
1115     }
1116
1117     CellType = ReadBlobXXXLong(image2);    /* Additional object type */
1118     if (logging)
1119       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
1120         "MATLAB_HDR.CellType: %.20g",(double) CellType);
1121
1122     (void) ReadBlob(image2, 4, (unsigned char *) &size);     /* data size */
1123
1124     NEXT_FRAME:
1125     switch (CellType)
1126     {
1127       case miINT8:
1128       case miUINT8:
1129         sample_size = 8;
1130         if(MATLAB_HDR.StructureFlag & FLAG_LOGICAL)
1131           image->depth = 1;
1132         else
1133           image->depth = 8;         /* Byte type cell */
1134         ldblk = (ssize_t) MATLAB_HDR.SizeX;
1135         break;
1136       case miINT16:
1137       case miUINT16:
1138         sample_size = 16;
1139         image->depth = 16;        /* Word type cell */
1140         ldblk = (ssize_t) (2 * MATLAB_HDR.SizeX);
1141         break;
1142       case miINT32:
1143       case miUINT32:
1144         sample_size = 32;
1145         image->depth = 32;        /* Dword type cell */
1146         ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1147         break;
1148       case miINT64:
1149       case miUINT64:
1150         sample_size = 64;
1151         image->depth = 64;        /* Qword type cell */
1152         ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1153         break;
1154       case miSINGLE:
1155         sample_size = 32;
1156         image->depth = 32;        /* double type cell */
1157         (void) SetImageOption(clone_info,"quantum:format","floating-point");
1158         if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1159           {              /* complex float type cell */
1160           }
1161         ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1162         break;
1163       case miDOUBLE:
1164         sample_size = 64;
1165         image->depth = 64;        /* double type cell */
1166         (void) SetImageOption(clone_info,"quantum:format","floating-point");
1167 DisableMSCWarning(4127)
1168         if (sizeof(double) != 8)
1169 RestoreMSCWarning
1170           {
1171             if (clone_info != (ImageInfo *) NULL)
1172               clone_info=DestroyImageInfo(clone_info);
1173             if ((image != image2) && (image2 != (Image *) NULL))
1174               image2=DestroyImage(image2);
1175             ThrowReaderException(CoderError, "IncompatibleSizeOfDouble");
1176           }
1177         if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1178           {                         /* complex double type cell */
1179           }
1180         ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1181         break;
1182       default:
1183         if ((image != image2) && (image2 != (Image *) NULL))
1184           image2=DestroyImage(image2);
1185         if (clone_info)
1186           clone_info=DestroyImageInfo(clone_info);
1187         ThrowReaderException(CoderError, "UnsupportedCellTypeInTheMatrix");
1188     }
1189     (void) sample_size;
1190     image->columns = MATLAB_HDR.SizeX;
1191     image->rows = MATLAB_HDR.SizeY;
1192     image->colors = GetQuantumRange(image->depth);
1193     if (image->columns == 0 || image->rows == 0)
1194       goto MATLAB_KO;
1195     if((unsigned int)ldblk*MATLAB_HDR.SizeY > MATLAB_HDR.ObjectSize)
1196       goto MATLAB_KO;
1197     /* Image is gray when no complex flag is set and 2D Matrix */
1198     if ((MATLAB_HDR.DimFlag == 8) &&
1199         ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1200       {
1201         image->type=GrayscaleType;
1202         SetImageColorspace(image,GRAYColorspace,exception);
1203       }
1204
1205
1206     /*
1207       If ping is true, then only set image size and colors without
1208       reading any image data.
1209     */
1210     if (image_info->ping)
1211     {
1212       size_t temp = image->columns;
1213       image->columns = image->rows;
1214       image->rows = temp;
1215       goto done_reading; /* !!!!!! BAD  !!!! */
1216     }
1217     status=SetImageExtent(image,image->columns,image->rows,exception);
1218     if (status == MagickFalse)
1219       {
1220         if (clone_info != (ImageInfo *) NULL)
1221           clone_info=DestroyImageInfo(clone_info);
1222         if ((image != image2) && (image2 != (Image *) NULL))
1223           image2=DestroyImage(image2);
1224         return(DestroyImageList(image));
1225       }
1226     (void) SetImageBackgroundColor(image,exception);
1227     quantum_info=AcquireQuantumInfo(clone_info,image);
1228     if (quantum_info == (QuantumInfo *) NULL)
1229       {
1230         if (clone_info != (ImageInfo *) NULL)
1231           clone_info=DestroyImageInfo(clone_info);
1232         if ((image != image2) && (image2 != (Image *) NULL))
1233           image2=DestroyImage(image2);
1234         ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1235       }
1236
1237   /* ----- Load raster data ----- */
1238     BImgBuff = (unsigned char *) AcquireQuantumMemory((size_t) (ldblk),sizeof(double));    /* Ldblk was set in the check phase */
1239     if (BImgBuff == NULL)
1240       {
1241         if (clone_info != (ImageInfo *) NULL)
1242           clone_info=DestroyImageInfo(clone_info);
1243         if ((image != image2) && (image2 != (Image *) NULL))
1244           image2=DestroyImage(image2);
1245         if (quantum_info != (QuantumInfo *) NULL)
1246           quantum_info=DestroyQuantumInfo(quantum_info);
1247         ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1248       }
1249     (void) memset(BImgBuff,0,ldblk*sizeof(double));
1250
1251     MinVal = 0;
1252     MaxVal = 0;
1253     if (CellType==miDOUBLE || CellType==miSINGLE)        /* Find Min and Max Values for floats */
1254       {
1255         CalcMinMax(image2,image_info->endian,MATLAB_HDR.SizeX,MATLAB_HDR.SizeY,
1256           CellType,ldblk,BImgBuff,&quantum_info->minimum,
1257           &quantum_info->maximum);
1258       }
1259
1260     /* Main loop for reading all scanlines */
1261     if(z==1) z=0; /* read grey scanlines */
1262     /* else read color scanlines */
1263     do
1264     {
1265       for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1266       {
1267         q=GetAuthenticPixels(image,0,MATLAB_HDR.SizeY-i-1,image->columns,1,exception);
1268         if (q == (Quantum *) NULL)
1269           {
1270             if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1271               "  MAT set image pixels returns unexpected NULL on a row %u.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1272             goto done_reading;    /* Skip image rotation, when cannot set image pixels    */
1273           }
1274         if(ReadBlob(image2,ldblk,(unsigned char *)BImgBuff) != (ssize_t) ldblk)
1275           {
1276             if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1277               "  MAT cannot read scanrow %u from a file.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1278             goto ExitLoop;
1279           }
1280         if((CellType==miINT8 || CellType==miUINT8) && (MATLAB_HDR.StructureFlag & FLAG_LOGICAL))
1281         {
1282           FixLogical((unsigned char *)BImgBuff,ldblk);
1283           if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1284             {
1285 ImportQuantumPixelsFailed:
1286               if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1287                 "  MAT failed to ImportQuantumPixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1288               break;
1289             }
1290         }
1291         else
1292         {
1293           if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1294             goto ImportQuantumPixelsFailed;
1295
1296
1297           if (z<=1 &&       /* fix only during a last pass z==0 || z==1 */
1298              (CellType==miINT8 || CellType==miINT16 || CellType==miINT32 || CellType==miINT64))
1299             FixSignedValues(image,q,MATLAB_HDR.SizeX);
1300         }
1301
1302         if (!SyncAuthenticPixels(image,exception))
1303           {
1304             if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1305               "  MAT failed to sync image pixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1306             goto ExitLoop;
1307           }
1308       }
1309     } while(z-- >= 2);
1310 ExitLoop:
1311
1312
1313     /* Read complex part of numbers here */
1314     if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1315     {        /* Find Min and Max Values for complex parts of floats */
1316       CellType = ReadBlobXXXLong(image2);    /* Additional object type */
1317       i = ReadBlobXXXLong(image2);           /* size of a complex part - toss away*/
1318
1319       if (CellType==miDOUBLE || CellType==miSINGLE)
1320       {
1321         CalcMinMax(image2,  image_info->endian, MATLAB_HDR.SizeX, MATLAB_HDR.SizeY, CellType, ldblk, BImgBuff, &MinVal, &MaxVal);
1322       }
1323
1324       if (CellType==miDOUBLE)
1325         for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1326         {
1327           ReadBlobDoublesXXX(image2, ldblk, (double *)BImgBuff);
1328           InsertComplexDoubleRow(image, (double *)BImgBuff, i, MinVal, MaxVal,
1329             exception);
1330         }
1331
1332       if (CellType==miSINGLE)
1333         for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1334         {
1335           ReadBlobFloatsXXX(image2, ldblk, (float *)BImgBuff);
1336           InsertComplexFloatRow(image,(float *)BImgBuff,i,MinVal,MaxVal,
1337             exception);
1338         }
1339     }
1340
1341       /* Image is gray when no complex flag is set and 2D Matrix AGAIN!!! */
1342     if ((MATLAB_HDR.DimFlag == 8) &&
1343         ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1344       image->type=GrayscaleType;
1345     if (image->depth == 1)
1346       image->type=BilevelType;
1347
1348     if(image2==image)
1349         image2 = NULL;    /* Remove shadow copy to an image before rotation. */
1350
1351       /*  Rotate image. */
1352     rotated_image = RotateImage(image, 90.0, exception);
1353     if (rotated_image != (Image *) NULL)
1354     {
1355         /* Remove page offsets added by RotateImage */
1356       rotated_image->page.x=0;
1357       rotated_image->page.y=0;
1358       rotated_image->colors = image->colors;
1359       DestroyBlob(rotated_image);
1360       rotated_image->blob=ReferenceBlob(image->blob);
1361       AppendImageToList(&image,rotated_image);
1362       DeleteImageFromList(&image);
1363     }
1364
1365 done_reading:
1366
1367     if(image2!=NULL)
1368       if(image2!=image)
1369       {
1370         DeleteImageFromList(&image2);
1371         if(clone_info)
1372         {
1373           if(clone_info->file)
1374           {
1375             fclose(clone_info->file);
1376             clone_info->file = NULL;
1377             (void) remove_utf8(clone_info->filename);
1378           }
1379         }
1380       }
1381     if (EOFBlob(image) != MagickFalse)
1382       break;
1383
1384       /* Allocate next image structure. */
1385     AcquireNextImage(image_info,image,exception);
1386     if (image->next == (Image *) NULL) break;
1387     image=SyncNextImageInList(image);
1388     image->columns=image->rows=0;
1389     image->colors=0;
1390
1391       /* row scan buffer is no longer needed */
1392     RelinquishMagickMemory(BImgBuff);
1393     BImgBuff = NULL;
1394     if (quantum_info != (QuantumInfo *) NULL)
1395       quantum_info=DestroyQuantumInfo(quantum_info);
1396
1397     if(--Frames>0)
1398     {
1399       z = z2;
1400       if(image2==NULL) image2 = image;
1401       if(!EOFBlob(image) && TellBlob(image)<filepos)
1402         goto NEXT_FRAME;
1403     }
1404     if ((image2!=NULL) && (image2!=image))   /* Does shadow temporary decompressed image exist? */
1405       {
1406 /*  CloseBlob(image2); */
1407         DeleteImageFromList(&image2);
1408         if(clone_info)
1409         {
1410           if(clone_info->file)
1411           {
1412             fclose(clone_info->file);
1413             clone_info->file = NULL;
1414             (void) remove_utf8(clone_info->filename);
1415           }
1416         }
1417       }
1418
1419     if (clone_info)
1420       clone_info=DestroyImageInfo(clone_info);
1421   }
1422
1423   RelinquishMagickMemory(BImgBuff);
1424   if (quantum_info != (QuantumInfo *) NULL)
1425     quantum_info=DestroyQuantumInfo(quantum_info);
1426 END_OF_READING:
1427   CloseBlob(image);
1428
1429
1430   {
1431     Image *p;
1432     ssize_t scene=0;
1433
1434     /*
1435       Rewind list, removing any empty images while rewinding.
1436     */
1437     p=image;
1438     image=NULL;
1439     while (p != (Image *) NULL)
1440       {
1441         Image *tmp=p;
1442         if ((p->rows == 0) || (p->columns == 0)) {
1443           p=p->previous;
1444           if (tmp == image2)
1445             image2=(Image *) NULL;
1446           DeleteImageFromList(&tmp);
1447         } else {
1448           image=p;
1449           p=p->previous;
1450         }
1451       }
1452
1453     /*
1454       Fix scene numbers
1455     */
1456     for (p=image; p != (Image *) NULL; p=p->next)
1457       p->scene=scene++;
1458   }
1459
1460   if(clone_info != NULL)  /* cleanup garbage file from compression */
1461   {
1462     if(clone_info->file)
1463     {
1464       fclose(clone_info->file);
1465       clone_info->file = NULL;
1466       (void) remove_utf8(clone_info->filename);
1467     }
1468     DestroyImageInfo(clone_info);
1469     clone_info = NULL;
1470   }
1471   if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),"return");
1472   if ((image != image2) && (image2 != (Image *) NULL))
1473     image2=DestroyImage(image2);
1474   if (image == (Image *) NULL)
1475     ThrowReaderException(CorruptImageError,"ImproperImageHeader")
1476   return(image);
1477 }
1478 \f
1479 /*
1480 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1481 %                                                                             %
1482 %                                                                             %
1483 %                                                                             %
1484 %   R e g i s t e r M A T I m a g e                                           %
1485 %                                                                             %
1486 %                                                                             %
1487 %                                                                             %
1488 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1489 %
1490 %  Method RegisterMATImage adds attributes for the MAT image format to
1491 %  the list of supported formats.  The attributes include the image format
1492 %  tag, a method to read and/or write the format, whether the format
1493 %  supports the saving of more than one frame to the same file or blob,
1494 %  whether the format supports native in-memory I/O, and a brief
1495 %  description of the format.
1496 %
1497 %  The format of the RegisterMATImage method is:
1498 %
1499 %      size_t RegisterMATImage(void)
1500 %
1501 */
1502 ModuleExport size_t RegisterMATImage(void)
1503 {
1504   MagickInfo
1505     *entry;
1506
1507   entry=AcquireMagickInfo("MAT","MAT","MATLAB level 5 image format");
1508   entry->decoder=(DecodeImageHandler *) ReadMATImage;
1509   entry->encoder=(EncodeImageHandler *) WriteMATImage;
1510   entry->flags^=CoderBlobSupportFlag;
1511   entry->flags|=CoderDecoderSeekableStreamFlag;
1512   (void) RegisterMagickInfo(entry);
1513   return(MagickImageCoderSignature);
1514 }
1515 \f
1516 /*
1517 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1518 %                                                                             %
1519 %                                                                             %
1520 %                                                                             %
1521 %   U n r e g i s t e r M A T I m a g e                                       %
1522 %                                                                             %
1523 %                                                                             %
1524 %                                                                             %
1525 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1526 %
1527 %  Method UnregisterMATImage removes format registrations made by the
1528 %  MAT module from the list of supported formats.
1529 %
1530 %  The format of the UnregisterMATImage method is:
1531 %
1532 %      UnregisterMATImage(void)
1533 %
1534 */
1535 ModuleExport void UnregisterMATImage(void)
1536 {
1537   (void) UnregisterMagickInfo("MAT");
1538 }
1539 \f
1540 /*
1541 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1542 %                                                                             %
1543 %                                                                             %
1544 %                                                                             %
1545 %   W r i t e M A T L A B I m a g e                                           %
1546 %                                                                             %
1547 %                                                                             %
1548 %                                                                             %
1549 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1550 %
1551 %  Function WriteMATImage writes an Matlab matrix to a file.
1552 %
1553 %  The format of the WriteMATImage method is:
1554 %
1555 %      MagickBooleanType WriteMATImage(const ImageInfo *image_info,
1556 %        Image *image,ExceptionInfo *exception)
1557 %
1558 %  A description of each parameter follows.
1559 %
1560 %    o image_info: Specifies a pointer to a ImageInfo structure.
1561 %
1562 %    o image:  A pointer to an Image structure.
1563 %
1564 %    o exception: return any errors or warnings in this structure.
1565 %
1566 */
1567 static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
1568   ExceptionInfo *exception)
1569 {
1570   char
1571     MATLAB_HDR[0x80];
1572
1573   MagickBooleanType
1574     status;
1575
1576   MagickOffsetType
1577     scene;
1578
1579   size_t
1580     imageListLength;
1581
1582   struct tm
1583     local_time;
1584
1585   time_t
1586     current_time;
1587
1588   /*
1589     Open output image file.
1590   */
1591   assert(image_info != (const ImageInfo *) NULL);
1592   assert(image_info->signature == MagickCoreSignature);
1593   assert(image != (Image *) NULL);
1594   assert(image->signature == MagickCoreSignature);
1595   (void) LogMagickEvent(CoderEvent,GetMagickModule(),"enter MAT");
1596   assert(exception != (ExceptionInfo *) NULL);
1597   assert(exception->signature == MagickCoreSignature);
1598   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1599   if (status == MagickFalse)
1600     return(MagickFalse);
1601   image->depth=8;
1602
1603   current_time=time((time_t *) NULL);
1604 #if defined(MAGICKCORE_HAVE_LOCALTIME_R)
1605   (void) localtime_r(&current_time,&local_time);
1606 #else
1607   (void) memcpy(&local_time,localtime(&current_time),sizeof(local_time));
1608 #endif
1609   (void) memset(MATLAB_HDR,' ',MagickMin(sizeof(MATLAB_HDR),124));
1610   FormatLocaleString(MATLAB_HDR,sizeof(MATLAB_HDR),
1611     "MATLAB 5.0 MAT-file, Platform: %s, Created on: %s %s %2d %2d:%2d:%2d %d",
1612     OsDesc,DayOfWTab[local_time.tm_wday],MonthsTab[local_time.tm_mon],
1613     local_time.tm_mday,local_time.tm_hour,local_time.tm_min,
1614     local_time.tm_sec,local_time.tm_year+1900);
1615   MATLAB_HDR[0x7C]=0;
1616   MATLAB_HDR[0x7D]=1;
1617   MATLAB_HDR[0x7E]='I';
1618   MATLAB_HDR[0x7F]='M';
1619   (void) WriteBlob(image,sizeof(MATLAB_HDR),(unsigned char *) MATLAB_HDR);
1620   scene=0;
1621   imageListLength=GetImageListLength(image);
1622   do
1623   {
1624     char
1625       padding;
1626
1627     MagickBooleanType
1628       is_gray;
1629
1630     QuantumInfo
1631       *quantum_info;
1632
1633     size_t
1634       data_size;
1635
1636     unsigned char
1637       *pixels;
1638
1639     unsigned int
1640       z;
1641
1642     (void) TransformImageColorspace(image,sRGBColorspace,exception);
1643     is_gray=SetImageGray(image,exception);
1644     z=(is_gray != MagickFalse) ? 0 : 3;
1645
1646     /*
1647       Store MAT header.
1648     */
1649     data_size = image->rows * image->columns;
1650     if (is_gray == MagickFalse)
1651       data_size*=3;
1652     padding=((unsigned char)(data_size-1) & 0x7) ^ 0x7;
1653
1654     (void) WriteBlobLSBLong(image,miMATRIX);
1655     (void) WriteBlobLSBLong(image,(unsigned int) data_size+padding+
1656       ((is_gray != MagickFalse) ? 48 : 56));
1657     (void) WriteBlobLSBLong(image,0x6); /* 0x88 */
1658     (void) WriteBlobLSBLong(image,0x8); /* 0x8C */
1659     (void) WriteBlobLSBLong(image,0x6); /* 0x90 */
1660     (void) WriteBlobLSBLong(image,0);
1661     (void) WriteBlobLSBLong(image,0x5); /* 0x98 */
1662     (void) WriteBlobLSBLong(image,(is_gray != MagickFalse) ? 0x8 : 0xC); /* 0x9C - DimFlag */
1663     (void) WriteBlobLSBLong(image,(unsigned int) image->rows);    /* x: 0xA0 */
1664     (void) WriteBlobLSBLong(image,(unsigned int) image->columns); /* y: 0xA4 */
1665     if (is_gray == MagickFalse)
1666       {
1667         (void) WriteBlobLSBLong(image,3); /* z: 0xA8 */
1668         (void) WriteBlobLSBLong(image,0);
1669       }
1670     (void) WriteBlobLSBShort(image,1);  /* 0xB0 */
1671     (void) WriteBlobLSBShort(image,1);  /* 0xB2 */
1672     (void) WriteBlobLSBLong(image,'M'); /* 0xB4 */
1673     (void) WriteBlobLSBLong(image,0x2); /* 0xB8 */
1674     (void) WriteBlobLSBLong(image,(unsigned int) data_size); /* 0xBC */
1675
1676     /*
1677       Store image data.
1678     */
1679     quantum_info=AcquireQuantumInfo(image_info,image);
1680     if (quantum_info == (QuantumInfo *) NULL)
1681       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1682     pixels=(unsigned char *) GetQuantumPixels(quantum_info);
1683     do
1684     {
1685       const Quantum
1686         *p;
1687
1688       ssize_t
1689         y;
1690
1691       for (y=0; y < (ssize_t)image->columns; y++)
1692       {
1693         p=GetVirtualPixels(image,y,0,1,image->rows,exception);
1694         if (p == (const Quantum *) NULL)
1695           break;
1696         (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1697           z2qtype[z],pixels,exception);
1698         (void) WriteBlob(image,image->rows,pixels);
1699       }
1700       if (SyncAuthenticPixels(image,exception) == MagickFalse)
1701         break;
1702     } while (z-- >= 2);
1703     while (padding-- > 0)
1704       (void) WriteBlobByte(image,0);
1705     quantum_info=DestroyQuantumInfo(quantum_info);
1706     if (GetNextImageInList(image) == (Image *) NULL)
1707       break;
1708     image=SyncNextImageInList(image);
1709     status=SetImageProgress(image,SaveImagesTag,scene++,imageListLength);
1710     if (status == MagickFalse)
1711       break;
1712   } while (image_info->adjoin != MagickFalse);
1713   (void) CloseBlob(image);
1714   return(status);
1715 }