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