1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % M M AAA TTTTT L AAA BBBB %
6 % MM MM A A T L A A B B %
7 % M M M AAAAA T L AAAAA BBBB %
8 % M M A A T L A A B B %
9 % M M A A T LLLLL A A BBBB %
10 % %
11 % %
12 % Read MATLAB Image Format %
13 % %
14 % Software Design %
15 % Jaroslav Fojtik %
16 % 2001-2008 %
17 % %
18 % %
19 % Permission is hereby granted, free of charge, to any person obtaining a %
20 % copy of this software and associated documentation files ("ImageMagick"), %
21 % to deal in ImageMagick without restriction, including without limitation %
22 % the rights to use, copy, modify, merge, publish, distribute, sublicense, %
23 % and/or sell copies of ImageMagick, and to permit persons to whom the %
24 % ImageMagick is furnished to do so, subject to the following conditions: %
25 % %
26 % The above copyright notice and this permission notice shall be included in %
27 % all copies or substantial portions of ImageMagick. %
28 % %
29 % The software is provided "as is", without warranty of any kind, express or %
30 % implied, including but not limited to the warranties of merchantability, %
31 % fitness for a particular purpose and noninfringement. In no event shall %
32 % ImageMagick Studio be liable for any claim, damages or other liability, %
33 % whether in an action of contract, tort or otherwise, arising from, out of %
34 % or in connection with ImageMagick or the use or other dealings in %
35 % ImageMagick. %
36 % %
37 % Except as contained in this notice, the name of the ImageMagick Studio %
38 % shall not be used in advertising or otherwise to promote the sale, use or %
39 % other dealings in ImageMagick without prior written authorization from the %
40 % ImageMagick Studio. %
41 % %
42 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
43 %
44 %
45 */
46
47 /*
48 Include declarations.
49 */
50 #include "MagickCore/studio.h"
51 #include "MagickCore/attribute.h"
52 #include "MagickCore/blob.h"
53 #include "MagickCore/blob-private.h"
54 #include "MagickCore/cache.h"
55 #include "MagickCore/color-private.h"
56 #include "MagickCore/colormap.h"
57 #include "MagickCore/colorspace-private.h"
58 #include "MagickCore/distort.h"
59 #include "MagickCore/exception.h"
60 #include "MagickCore/exception-private.h"
61 #include "MagickCore/image.h"
62 #include "MagickCore/image-private.h"
63 #include "MagickCore/list.h"
64 #include "MagickCore/magick.h"
65 #include "MagickCore/memory_.h"
66 #include "MagickCore/monitor.h"
67 #include "MagickCore/monitor-private.h"
68 #include "MagickCore/pixel-accessor.h"
69 #include "MagickCore/quantum.h"
70 #include "MagickCore/quantum-private.h"
71 #include "MagickCore/option.h"
72 #include "MagickCore/pixel.h"
73 #include "MagickCore/resource_.h"
74 #include "MagickCore/static.h"
75 #include "MagickCore/string_.h"
76 #include "MagickCore/module.h"
77 #include "MagickCore/transform.h"
78 #include "MagickCore/utility-private.h"
79 #if defined(MAGICKCORE_ZLIB_DELEGATE)
80 #include "zlib.h"
81 #endif
82
83 /*
84 Forward declaration.
85 */
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
InsertComplexDoubleRow(Image * image,double * p,int y,double MinVal,double MaxVal,ExceptionInfo * exception)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
InsertComplexFloatRow(Image * image,float * p,int y,double MinVal,double MaxVal,ExceptionInfo * exception)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+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*/
ReadBlobFloatsLSB(Image * image,size_t len,float * data)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
ReadBlobFloatsMSB(Image * image,size_t len,float * data)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*/
ReadBlobDoublesLSB(Image * image,size_t len,double * data)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
ReadBlobDoublesMSB(Image * image,size_t len,double * data)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 */
CalcMinMax(Image * image,int endian_indicator,int SizeX,int SizeY,size_t CellType,unsigned ldblk,void * BImgBuff,double * Min,double * Max)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
FixSignedValues(const Image * image,Quantum * q,int y)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. */
FixLogical(unsigned char * Buff,int ldblk)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)
AcquireZIPMemory(voidpf context,unsigned int items,unsigned int size)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
RelinquishZIPMemory(voidpf context,voidpf memory)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. */
decompress_block(Image * orig,unsigned int * Size,ImageInfo * clone_info,ExceptionInfo * exception)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
ReadMATImageV4(const ImageInfo * image_info,Image * image,ExceptionInfo * exception)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
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 */
ReadMATImage(const ImageInfo * image_info,ExceptionInfo * exception)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 /* data size */
1121 if (ReadBlob(image2, 4, (unsigned char *) &size) != 4)
1122 goto MATLAB_KO;
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
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 */
RegisterMATImage(void)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
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 */
UnregisterMATImage(void)1535 ModuleExport void UnregisterMATImage(void)
1536 {
1537 (void) UnregisterMagickInfo("MAT");
1538 }
1539
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 */
WriteMATImage(const ImageInfo * image_info,Image * image,ExceptionInfo * exception)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(¤t_time,&local_time);
1606 #else
1607 (void) memcpy(&local_time,localtime(¤t_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 }
1716