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