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(EOFBlob(image)) break;
644 if ((ldblk > 9999) || (ldblk < 0))
645 break;
646 HDR.Type[3]=ldblk % 10; ldblk /= 10; /* T digit */
647 HDR.Type[2]=ldblk % 10; ldblk /= 10; /* P digit */
648 HDR.Type[1]=ldblk % 10; ldblk /= 10; /* O digit */
649 HDR.Type[0]=ldblk; /* M digit */
650 if (HDR.Type[3] != 0)
651 break; /* Data format */
652 if (HDR.Type[2] != 0)
653 break; /* Always 0 */
654 if (HDR.Type[0] == 0)
655 {
656 HDR.nRows=ReadBlobLSBLong(image);
657 HDR.nCols=ReadBlobLSBLong(image);
658 HDR.imagf=ReadBlobLSBLong(image);
659 HDR.nameLen=ReadBlobLSBLong(image);
660 endian=LSBEndian;
661 }
662 else
663 {
664 HDR.nRows=ReadBlobMSBLong(image);
665 HDR.nCols=ReadBlobMSBLong(image);
666 HDR.imagf=ReadBlobMSBLong(image);
667 HDR.nameLen=ReadBlobMSBLong(image);
668 endian=MSBEndian;
669 }
670 if ((HDR.imagf != 0) && (HDR.imagf != 1))
671 break;
672 if (HDR.nameLen > 0xFFFF)
673 return(DestroyImageList(image));
674 for (i=0; i < (ssize_t) HDR.nameLen; i++)
675 {
676 int
677 byte;
678
679 /*
680 Skip matrix name.
681 */
682 byte=ReadBlobByte(image);
683 if (byte == EOF)
684 {
685 ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
686 image->filename);
687 break;
688 }
689 }
690 image->columns=(size_t) HDR.nRows;
691 image->rows=(size_t) HDR.nCols;
692 if ((image->columns == 0) || (image->rows == 0))
693 return(DestroyImageList(image));
694 if (image_info->ping != MagickFalse)
695 {
696 Swap(image->columns,image->rows);
697 if(HDR.imagf==1) ldblk *= 2;
698 SeekBlob(image, HDR.nCols*ldblk, SEEK_CUR);
699 if ((image->columns == 0) || (image->rows == 0))
700 return(image->previous == (Image *) NULL ? DestroyImageList(image)
701 : image);
702 goto skip_reading_current;
703 }
704 status=SetImageExtent(image,image->columns,image->rows,exception);
705 if (status == MagickFalse)
706 return(DestroyImageList(image));
707 (void) SetImageBackgroundColor(image,exception);
708 (void) SetImageColorspace(image,GRAYColorspace,exception);
709 quantum_info=AcquireQuantumInfo(image_info,image);
710 if (quantum_info == (QuantumInfo *) NULL)
711 return(DestroyImageList(image));
712 switch(HDR.Type[1])
713 {
714 case 0:
715 format_type=FloatingPointQuantumFormat;
716 depth=64;
717 break;
718 case 1:
719 format_type=FloatingPointQuantumFormat;
720 depth=32;
721 break;
722 case 2:
723 format_type=UnsignedQuantumFormat;
724 depth=16;
725 break;
726 case 3:
727 format_type=SignedQuantumFormat;
728 depth=16;
729 break;
730 case 4:
731 format_type=UnsignedQuantumFormat;
732 depth=8;
733 break;
734 default:
735 format_type=UnsignedQuantumFormat;
736 depth=8;
737 break;
738 }
739 image->depth=depth;
740 if (HDR.Type[0] != 0)
741 SetQuantumEndian(image,quantum_info,MSBEndian);
742 status=SetQuantumFormat(image,quantum_info,format_type);
743 status=SetQuantumDepth(image,quantum_info,depth);
744 status=SetQuantumEndian(image,quantum_info,endian);
745 SetQuantumScale(quantum_info,1.0);
746 pixels=(unsigned char *) GetQuantumPixels(quantum_info);
747 for (y=0; y < (ssize_t) image->rows; y++)
748 {
749 register Quantum
750 *magick_restrict q;
751
752 count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
753 if (count == -1)
754 break;
755 q=QueueAuthenticPixels(image,0,image->rows-y-1,image->columns,1,
756 exception);
757 if (q == (Quantum *) NULL)
758 break;
759 (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
760 GrayQuantum,pixels,exception);
761 if ((HDR.Type[1] == 2) || (HDR.Type[1] == 3))
762 FixSignedValues(image,q,(int) image->columns);
763 if (SyncAuthenticPixels(image,exception) == MagickFalse)
764 break;
765 if (image->previous == (Image *) NULL)
766 {
767 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
768 image->rows);
769 if (status == MagickFalse)
770 break;
771 }
772 }
773 if (HDR.imagf == 1)
774 for (y=0; y < (ssize_t) image->rows; y++)
775 {
776 /*
777 Read complex pixels.
778 */
779 count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
780 if (count == -1)
781 break;
782 if (HDR.Type[1] == 0)
783 InsertComplexDoubleRow(image,(double *) pixels,y,0,0,exception);
784 else
785 InsertComplexFloatRow(image,(float *) pixels,y,0,0,exception);
786 }
787 if (quantum_info != (QuantumInfo *) NULL)
788 quantum_info=DestroyQuantumInfo(quantum_info);
789 if (EOFBlob(image) != MagickFalse)
790 {
791 ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
792 image->filename);
793 break;
794 }
795 rotated_image=RotateImage(image,90.0,exception);
796 if (rotated_image != (Image *) NULL)
797 {
798 rotated_image->page.x=0;
799 rotated_image->page.y=0;
800 rotated_image->colors = image->colors;
801 DestroyBlob(rotated_image);
802 rotated_image->blob=ReferenceBlob(image->blob);
803 AppendImageToList(&image,rotated_image);
804 DeleteImageFromList(&image);
805 }
806 /*
807 Proceed to next image.
808 */
809 if (image_info->number_scenes != 0)
810 if (image->scene >= (image_info->scene+image_info->number_scenes-1))
811 break;
812 /*
813 Allocate next image structure.
814 */
815 skip_reading_current:
816 AcquireNextImage(image_info,image,exception);
817 if (GetNextImageInList(image) == (Image *) NULL)
818 {
819 status=MagickFalse;
820 break;
821 }
822 image=SyncNextImageInList(image);
823 status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
824 GetBlobSize(image));
825 if (status == MagickFalse)
826 break;
827 }
828 (void) CloseBlob(image);
829 if (status == MagickFalse)
830 return(DestroyImageList(image));
831 return(GetFirstImageInList(image));
832 }
833
834 /*
835 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
836 % %
837 % %
838 % %
839 % R e a d M A T L A B i m a g e %
840 % %
841 % %
842 % %
843 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
844 %
845 % ReadMATImage() reads an MAT X image file and returns it. It
846 % allocates the memory necessary for the new Image structure and returns a
847 % pointer to the new image.
848 %
849 % The format of the ReadMATImage method is:
850 %
851 % Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
852 %
853 % A description of each parameter follows:
854 %
855 % o image: Method ReadMATImage returns a pointer to the image after
856 % reading. A null image is returned if there is a memory shortage or if
857 % the image cannot be read.
858 %
859 % o image_info: Specifies a pointer to a ImageInfo structure.
860 %
861 % o exception: return any errors or warnings in this structure.
862 %
863 */
ReadMATImage(const ImageInfo * image_info,ExceptionInfo * exception)864 static Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
865 {
866 Image *image, *image2=NULL,
867 *rotated_image;
868 register Quantum *q;
869
870 unsigned int status;
871 MATHeader MATLAB_HDR;
872 size_t size;
873 size_t CellType;
874 QuantumInfo *quantum_info;
875 ImageInfo *clone_info;
876 int i;
877 ssize_t ldblk;
878 unsigned char *BImgBuff = NULL;
879 double MinVal, MaxVal;
880 unsigned z, z2;
881 unsigned Frames;
882 int logging;
883 int sample_size;
884 MagickOffsetType filepos=0x80;
885
886 unsigned int (*ReadBlobXXXLong)(Image *image);
887 unsigned short (*ReadBlobXXXShort)(Image *image);
888 void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
889 void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
890
891
892 assert(image_info != (const ImageInfo *) NULL);
893 assert(image_info->signature == MagickCoreSignature);
894 assert(exception != (ExceptionInfo *) NULL);
895 assert(exception->signature == MagickCoreSignature);
896 logging = LogMagickEvent(CoderEvent,GetMagickModule(),"enter");
897
898 /*
899 Open image file.
900 */
901 image = AcquireImage(image_info,exception);
902 image2 = (Image *) NULL;
903
904 status = OpenBlob(image_info, image, ReadBinaryBlobMode, exception);
905 if (status == MagickFalse)
906 {
907 image=DestroyImageList(image);
908 return((Image *) NULL);
909 }
910 /*
911 Read MATLAB image.
912 */
913 quantum_info=(QuantumInfo *) NULL;
914 clone_info=(ImageInfo *) NULL;
915 if (ReadBlob(image,124,(unsigned char *) &MATLAB_HDR.identific) != 124)
916 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
917 if (strncmp(MATLAB_HDR.identific,"MATLAB",6) != 0)
918 {
919 image=ReadMATImageV4(image_info,image,exception);
920 if (image == NULL)
921 {
922 if ((image != image2) && (image2 != (Image *) NULL))
923 image2=DestroyImage(image2);
924 if (clone_info != (ImageInfo *) NULL)
925 clone_info=DestroyImageInfo(clone_info);
926 return((Image *) NULL);
927 }
928 goto END_OF_READING;
929 }
930 MATLAB_HDR.Version = ReadBlobLSBShort(image);
931 if(ReadBlob(image,2,(unsigned char *) &MATLAB_HDR.EndianIndicator) != 2)
932 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
933
934 if (logging)
935 (void) LogMagickEvent(CoderEvent,GetMagickModule()," Endian %c%c",
936 MATLAB_HDR.EndianIndicator[0],MATLAB_HDR.EndianIndicator[1]);
937 if (!strncmp(MATLAB_HDR.EndianIndicator, "IM", 2))
938 {
939 ReadBlobXXXLong = ReadBlobLSBLong;
940 ReadBlobXXXShort = ReadBlobLSBShort;
941 ReadBlobDoublesXXX = ReadBlobDoublesLSB;
942 ReadBlobFloatsXXX = ReadBlobFloatsLSB;
943 image->endian = LSBEndian;
944 }
945 else if (!strncmp(MATLAB_HDR.EndianIndicator, "MI", 2))
946 {
947 ReadBlobXXXLong = ReadBlobMSBLong;
948 ReadBlobXXXShort = ReadBlobMSBShort;
949 ReadBlobDoublesXXX = ReadBlobDoublesMSB;
950 ReadBlobFloatsXXX = ReadBlobFloatsMSB;
951 image->endian = MSBEndian;
952 }
953 else
954 {
955 MATLAB_KO:
956 if ((image != image2) && (image2 != (Image *) NULL))
957 image2=DestroyImage(image2);
958 if (clone_info != (ImageInfo *) NULL)
959 clone_info=DestroyImageInfo(clone_info);
960 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
961 }
962
963 filepos = TellBlob(image);
964 while(filepos < GetBlobSize(image) && !EOFBlob(image)) /* object parser loop */
965 {
966 Frames = 1;
967 if(filepos > GetBlobSize(image) || filepos < 0)
968 break;
969 if(SeekBlob(image,filepos,SEEK_SET) != filepos) break;
970 /* printf("pos=%X\n",TellBlob(image)); */
971
972 MATLAB_HDR.DataType = ReadBlobXXXLong(image);
973 if(EOFBlob(image)) break;
974 MATLAB_HDR.ObjectSize = ReadBlobXXXLong(image);
975 if(EOFBlob(image)) break;
976 if((MagickSizeType) (MATLAB_HDR.ObjectSize+filepos) >= GetBlobSize(image))
977 goto MATLAB_KO;
978 filepos += (MagickOffsetType) MATLAB_HDR.ObjectSize + 4 + 4;
979
980 if (clone_info != (ImageInfo *) NULL)
981 clone_info=DestroyImageInfo(clone_info);
982 clone_info=CloneImageInfo(image_info);
983 if ((image != image2) && (image2 != (Image *) NULL))
984 image2=DestroyImage(image2);
985 image2 = image;
986 #if defined(MAGICKCORE_ZLIB_DELEGATE)
987 if(MATLAB_HDR.DataType == miCOMPRESSED)
988 {
989 image2 = decompress_block(image,&MATLAB_HDR.ObjectSize,clone_info,exception);
990 if(image2==NULL) continue;
991 MATLAB_HDR.DataType = ReadBlobXXXLong(image2); /* replace compressed object type. */
992 }
993 #endif
994
995 if (MATLAB_HDR.DataType != miMATRIX)
996 {
997 clone_info=DestroyImageInfo(clone_info);
998 #if defined(MAGICKCORE_ZLIB_DELEGATE)
999 if (image2 != image)
1000 DeleteImageFromList(&image2);
1001 #endif
1002 continue; /* skip another objects. */
1003 }
1004
1005 MATLAB_HDR.unknown1 = ReadBlobXXXLong(image2);
1006 MATLAB_HDR.unknown2 = ReadBlobXXXLong(image2);
1007
1008 MATLAB_HDR.unknown5 = ReadBlobXXXLong(image2);
1009 MATLAB_HDR.StructureClass = MATLAB_HDR.unknown5 & 0xFF;
1010 MATLAB_HDR.StructureFlag = (MATLAB_HDR.unknown5>>8) & 0xFF;
1011
1012 MATLAB_HDR.unknown3 = ReadBlobXXXLong(image2);
1013 if(image!=image2)
1014 MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2); /* ??? don't understand why ?? */
1015 MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2);
1016 MATLAB_HDR.DimFlag = ReadBlobXXXLong(image2);
1017 MATLAB_HDR.SizeX = ReadBlobXXXLong(image2);
1018 MATLAB_HDR.SizeY = ReadBlobXXXLong(image2);
1019
1020
1021 switch(MATLAB_HDR.DimFlag)
1022 {
1023 case 8: z2=z=1; break; /* 2D matrix*/
1024 case 12: z2=z = ReadBlobXXXLong(image2); /* 3D matrix RGB*/
1025 (void) ReadBlobXXXLong(image2);
1026 if(z!=3)
1027 {
1028 if (clone_info != (ImageInfo *) NULL)
1029 clone_info=DestroyImageInfo(clone_info);
1030 if ((image != image2) && (image2 != (Image *) NULL))
1031 image2=DestroyImage(image2);
1032 ThrowReaderException(CoderError,
1033 "MultidimensionalMatricesAreNotSupported");
1034 }
1035 break;
1036 case 16: z2=z = ReadBlobXXXLong(image2); /* 4D matrix animation */
1037 if(z!=3 && z!=1)
1038 {
1039 if (clone_info != (ImageInfo *) NULL)
1040 clone_info=DestroyImageInfo(clone_info);
1041 if ((image != image2) && (image2 != (Image *) NULL))
1042 image2=DestroyImage(image2);
1043 ThrowReaderException(CoderError,
1044 "MultidimensionalMatricesAreNotSupported");
1045 }
1046 Frames = ReadBlobXXXLong(image2);
1047 if (Frames == 0)
1048 {
1049 if (clone_info != (ImageInfo *) NULL)
1050 clone_info=DestroyImageInfo(clone_info);
1051 if ((image != image2) && (image2 != (Image *) NULL))
1052 image2=DestroyImage(image2);
1053 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
1054 }
1055 if (AcquireMagickResource(ListLengthResource,Frames) == MagickFalse)
1056 {
1057 if (clone_info != (ImageInfo *) NULL)
1058 clone_info=DestroyImageInfo(clone_info);
1059 if ((image != image2) && (image2 != (Image *) NULL))
1060 image2=DestroyImage(image2);
1061 ThrowReaderException(ResourceLimitError,"ListLengthExceedsLimit");
1062 }
1063 break;
1064 default:
1065 if (clone_info != (ImageInfo *) NULL)
1066 clone_info=DestroyImageInfo(clone_info);
1067 if ((image != image2) && (image2 != (Image *) NULL))
1068 image2=DestroyImage(image2);
1069 ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
1070 }
1071
1072 MATLAB_HDR.Flag1 = ReadBlobXXXShort(image2);
1073 MATLAB_HDR.NameFlag = ReadBlobXXXShort(image2);
1074
1075 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1076 "MATLAB_HDR.StructureClass %d",MATLAB_HDR.StructureClass);
1077 if (MATLAB_HDR.StructureClass != mxCHAR_CLASS &&
1078 MATLAB_HDR.StructureClass != mxSINGLE_CLASS && /* float + complex float */
1079 MATLAB_HDR.StructureClass != mxDOUBLE_CLASS && /* double + complex double */
1080 MATLAB_HDR.StructureClass != mxINT8_CLASS &&
1081 MATLAB_HDR.StructureClass != mxUINT8_CLASS && /* uint8 + uint8 3D */
1082 MATLAB_HDR.StructureClass != mxINT16_CLASS &&
1083 MATLAB_HDR.StructureClass != mxUINT16_CLASS && /* uint16 + uint16 3D */
1084 MATLAB_HDR.StructureClass != mxINT32_CLASS &&
1085 MATLAB_HDR.StructureClass != mxUINT32_CLASS && /* uint32 + uint32 3D */
1086 MATLAB_HDR.StructureClass != mxINT64_CLASS &&
1087 MATLAB_HDR.StructureClass != mxUINT64_CLASS) /* uint64 + uint64 3D */
1088 {
1089 if ((image2 != (Image*) NULL) && (image2 != image))
1090 {
1091 CloseBlob(image2);
1092 DeleteImageFromList(&image2);
1093 }
1094 if (clone_info != (ImageInfo *) NULL)
1095 clone_info=DestroyImageInfo(clone_info);
1096 ThrowReaderException(CoderError,"UnsupportedCellTypeInTheMatrix");
1097 }
1098
1099 switch (MATLAB_HDR.NameFlag)
1100 {
1101 case 0:
1102 size = ReadBlobXXXLong(image2); /* Object name string size */
1103 size = 4 * (((size_t) size + 3 + 1) / 4);
1104 (void) SeekBlob(image2, size, SEEK_CUR);
1105 break;
1106 case 1:
1107 case 2:
1108 case 3:
1109 case 4:
1110 (void) ReadBlob(image2, 4, (unsigned char *) &size); /* Object name string */
1111 break;
1112 default:
1113 goto MATLAB_KO;
1114 }
1115
1116 CellType = ReadBlobXXXLong(image2); /* Additional object type */
1117 if (logging)
1118 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
1119 "MATLAB_HDR.CellType: %.20g",(double) CellType);
1120
1121 /* data size */
1122 if (ReadBlob(image2, 4, (unsigned char *) &size) != 4)
1123 goto MATLAB_KO;
1124
1125 NEXT_FRAME:
1126 switch (CellType)
1127 {
1128 case miINT8:
1129 case miUINT8:
1130 sample_size = 8;
1131 if(MATLAB_HDR.StructureFlag & FLAG_LOGICAL)
1132 image->depth = 1;
1133 else
1134 image->depth = 8; /* Byte type cell */
1135 ldblk = (ssize_t) MATLAB_HDR.SizeX;
1136 break;
1137 case miINT16:
1138 case miUINT16:
1139 sample_size = 16;
1140 image->depth = 16; /* Word type cell */
1141 ldblk = (ssize_t) (2 * MATLAB_HDR.SizeX);
1142 break;
1143 case miINT32:
1144 case miUINT32:
1145 sample_size = 32;
1146 image->depth = 32; /* Dword type cell */
1147 ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1148 break;
1149 case miINT64:
1150 case miUINT64:
1151 sample_size = 64;
1152 image->depth = 64; /* Qword type cell */
1153 ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1154 break;
1155 case miSINGLE:
1156 sample_size = 32;
1157 image->depth = 32; /* double type cell */
1158 (void) SetImageOption(clone_info,"quantum:format","floating-point");
1159 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1160 { /* complex float type cell */
1161 }
1162 ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1163 break;
1164 case miDOUBLE:
1165 sample_size = 64;
1166 image->depth = 64; /* double type cell */
1167 (void) SetImageOption(clone_info,"quantum:format","floating-point");
1168 DisableMSCWarning(4127)
1169 if (sizeof(double) != 8)
1170 RestoreMSCWarning
1171 {
1172 if (clone_info != (ImageInfo *) NULL)
1173 clone_info=DestroyImageInfo(clone_info);
1174 if ((image != image2) && (image2 != (Image *) NULL))
1175 image2=DestroyImage(image2);
1176 ThrowReaderException(CoderError, "IncompatibleSizeOfDouble");
1177 }
1178 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1179 { /* complex double type cell */
1180 }
1181 ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1182 break;
1183 default:
1184 if ((image != image2) && (image2 != (Image *) NULL))
1185 image2=DestroyImage(image2);
1186 if (clone_info)
1187 clone_info=DestroyImageInfo(clone_info);
1188 ThrowReaderException(CoderError, "UnsupportedCellTypeInTheMatrix");
1189 }
1190 (void) sample_size;
1191 image->columns = MATLAB_HDR.SizeX;
1192 image->rows = MATLAB_HDR.SizeY;
1193 image->colors = GetQuantumRange(image->depth);
1194 if (image->columns == 0 || image->rows == 0)
1195 goto MATLAB_KO;
1196 if((unsigned int)ldblk*MATLAB_HDR.SizeY > MATLAB_HDR.ObjectSize)
1197 goto MATLAB_KO;
1198 /* Image is gray when no complex flag is set and 2D Matrix */
1199 if ((MATLAB_HDR.DimFlag == 8) &&
1200 ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1201 {
1202 image->type=GrayscaleType;
1203 SetImageColorspace(image,GRAYColorspace,exception);
1204 }
1205
1206
1207 /*
1208 If ping is true, then only set image size and colors without
1209 reading any image data.
1210 */
1211 if (image_info->ping)
1212 {
1213 size_t temp = image->columns;
1214 image->columns = image->rows;
1215 image->rows = temp;
1216 goto done_reading; /* !!!!!! BAD !!!! */
1217 }
1218 status=SetImageExtent(image,image->columns,image->rows,exception);
1219 if (status == MagickFalse)
1220 {
1221 if (clone_info != (ImageInfo *) NULL)
1222 clone_info=DestroyImageInfo(clone_info);
1223 if ((image != image2) && (image2 != (Image *) NULL))
1224 image2=DestroyImage(image2);
1225 return(DestroyImageList(image));
1226 }
1227 (void) SetImageBackgroundColor(image,exception);
1228 quantum_info=AcquireQuantumInfo(clone_info,image);
1229 if (quantum_info == (QuantumInfo *) NULL)
1230 {
1231 if (clone_info != (ImageInfo *) NULL)
1232 clone_info=DestroyImageInfo(clone_info);
1233 if ((image != image2) && (image2 != (Image *) NULL))
1234 image2=DestroyImage(image2);
1235 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1236 }
1237
1238 /* ----- Load raster data ----- */
1239 BImgBuff = (unsigned char *) AcquireQuantumMemory((size_t) (ldblk),sizeof(double)); /* Ldblk was set in the check phase */
1240 if (BImgBuff == NULL)
1241 {
1242 if (clone_info != (ImageInfo *) NULL)
1243 clone_info=DestroyImageInfo(clone_info);
1244 if ((image != image2) && (image2 != (Image *) NULL))
1245 image2=DestroyImage(image2);
1246 if (quantum_info != (QuantumInfo *) NULL)
1247 quantum_info=DestroyQuantumInfo(quantum_info);
1248 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1249 }
1250 (void) memset(BImgBuff,0,ldblk*sizeof(double));
1251
1252 MinVal = 0;
1253 MaxVal = 0;
1254 if (CellType==miDOUBLE || CellType==miSINGLE) /* Find Min and Max Values for floats */
1255 {
1256 CalcMinMax(image2,image_info->endian,MATLAB_HDR.SizeX,MATLAB_HDR.SizeY,
1257 CellType,ldblk,BImgBuff,&quantum_info->minimum,
1258 &quantum_info->maximum);
1259 }
1260
1261 /* Main loop for reading all scanlines */
1262 if(z==1) z=0; /* read grey scanlines */
1263 /* else read color scanlines */
1264 do
1265 {
1266 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1267 {
1268 q=GetAuthenticPixels(image,0,MATLAB_HDR.SizeY-i-1,image->columns,1,exception);
1269 if (q == (Quantum *) NULL)
1270 {
1271 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1272 " MAT set image pixels returns unexpected NULL on a row %u.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1273 goto done_reading; /* Skip image rotation, when cannot set image pixels */
1274 }
1275 if(ReadBlob(image2,ldblk,(unsigned char *)BImgBuff) != (ssize_t) ldblk)
1276 {
1277 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1278 " MAT cannot read scanrow %u from a file.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1279 ThrowReaderException(CorruptImageError,"UnexpectedEndOfFile");
1280 goto ExitLoop;
1281 }
1282 if((CellType==miINT8 || CellType==miUINT8) && (MATLAB_HDR.StructureFlag & FLAG_LOGICAL))
1283 {
1284 FixLogical((unsigned char *)BImgBuff,ldblk);
1285 if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1286 {
1287 ImportQuantumPixelsFailed:
1288 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1289 " MAT failed to ImportQuantumPixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1290 break;
1291 }
1292 }
1293 else
1294 {
1295 if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1296 goto ImportQuantumPixelsFailed;
1297
1298
1299 if (z<=1 && /* fix only during a last pass z==0 || z==1 */
1300 (CellType==miINT8 || CellType==miINT16 || CellType==miINT32 || CellType==miINT64))
1301 FixSignedValues(image,q,MATLAB_HDR.SizeX);
1302 }
1303
1304 if (!SyncAuthenticPixels(image,exception))
1305 {
1306 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1307 " MAT failed to sync image pixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1308 goto ExitLoop;
1309 }
1310 }
1311 } while(z-- >= 2);
1312 ExitLoop:
1313
1314
1315 /* Read complex part of numbers here */
1316 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1317 { /* Find Min and Max Values for complex parts of floats */
1318 CellType = ReadBlobXXXLong(image2); /* Additional object type */
1319 i = ReadBlobXXXLong(image2); /* size of a complex part - toss away*/
1320
1321 if (CellType==miDOUBLE || CellType==miSINGLE)
1322 {
1323 CalcMinMax(image2, image_info->endian, MATLAB_HDR.SizeX, MATLAB_HDR.SizeY, CellType, ldblk, BImgBuff, &MinVal, &MaxVal);
1324 }
1325
1326 if (CellType==miDOUBLE)
1327 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1328 {
1329 ReadBlobDoublesXXX(image2, ldblk, (double *)BImgBuff);
1330 InsertComplexDoubleRow(image, (double *)BImgBuff, i, MinVal, MaxVal,
1331 exception);
1332 }
1333
1334 if (CellType==miSINGLE)
1335 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1336 {
1337 ReadBlobFloatsXXX(image2, ldblk, (float *)BImgBuff);
1338 InsertComplexFloatRow(image,(float *)BImgBuff,i,MinVal,MaxVal,
1339 exception);
1340 }
1341 }
1342
1343 /* Image is gray when no complex flag is set and 2D Matrix AGAIN!!! */
1344 if ((MATLAB_HDR.DimFlag == 8) &&
1345 ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1346 image->type=GrayscaleType;
1347 if (image->depth == 1)
1348 image->type=BilevelType;
1349
1350 if(image2==image)
1351 image2 = NULL; /* Remove shadow copy to an image before rotation. */
1352
1353 /* Rotate image. */
1354 rotated_image = RotateImage(image, 90.0, exception);
1355 if (rotated_image != (Image *) NULL)
1356 {
1357 /* Remove page offsets added by RotateImage */
1358 rotated_image->page.x=0;
1359 rotated_image->page.y=0;
1360 rotated_image->colors = image->colors;
1361 DestroyBlob(rotated_image);
1362 rotated_image->blob=ReferenceBlob(image->blob);
1363 AppendImageToList(&image,rotated_image);
1364 DeleteImageFromList(&image);
1365 }
1366
1367 done_reading:
1368
1369 if(image2!=NULL)
1370 if(image2!=image)
1371 {
1372 DeleteImageFromList(&image2);
1373 if(clone_info)
1374 {
1375 if(clone_info->file)
1376 {
1377 fclose(clone_info->file);
1378 clone_info->file = NULL;
1379 (void) remove_utf8(clone_info->filename);
1380 }
1381 }
1382 }
1383 if (EOFBlob(image) != MagickFalse)
1384 break;
1385
1386 /* Allocate next image structure. */
1387 AcquireNextImage(image_info,image,exception);
1388 if (image->next == (Image *) NULL) break;
1389 image=SyncNextImageInList(image);
1390 image->columns=image->rows=0;
1391 image->colors=0;
1392
1393 /* row scan buffer is no longer needed */
1394 RelinquishMagickMemory(BImgBuff);
1395 BImgBuff = NULL;
1396 if (quantum_info != (QuantumInfo *) NULL)
1397 quantum_info=DestroyQuantumInfo(quantum_info);
1398
1399 if(--Frames>0)
1400 {
1401 z = z2;
1402 if(image2==NULL) image2 = image;
1403 if(!EOFBlob(image) && TellBlob(image)<filepos)
1404 goto NEXT_FRAME;
1405 }
1406 if ((image2!=NULL) && (image2!=image)) /* Does shadow temporary decompressed image exist? */
1407 {
1408 /* CloseBlob(image2); */
1409 DeleteImageFromList(&image2);
1410 if(clone_info)
1411 {
1412 if(clone_info->file)
1413 {
1414 fclose(clone_info->file);
1415 clone_info->file = NULL;
1416 (void) remove_utf8(clone_info->filename);
1417 }
1418 }
1419 }
1420
1421 if (clone_info)
1422 clone_info=DestroyImageInfo(clone_info);
1423 }
1424
1425 RelinquishMagickMemory(BImgBuff);
1426 if (quantum_info != (QuantumInfo *) NULL)
1427 quantum_info=DestroyQuantumInfo(quantum_info);
1428 END_OF_READING:
1429 CloseBlob(image);
1430
1431
1432 {
1433 Image *p;
1434 ssize_t scene=0;
1435
1436 /*
1437 Rewind list, removing any empty images while rewinding.
1438 */
1439 p=image;
1440 image=NULL;
1441 while (p != (Image *) NULL)
1442 {
1443 Image *tmp=p;
1444 if ((p->rows == 0) || (p->columns == 0)) {
1445 p=p->previous;
1446 if (tmp == image2)
1447 image2=(Image *) NULL;
1448 DeleteImageFromList(&tmp);
1449 } else {
1450 image=p;
1451 p=p->previous;
1452 }
1453 }
1454
1455 /*
1456 Fix scene numbers
1457 */
1458 for (p=image; p != (Image *) NULL; p=p->next)
1459 p->scene=scene++;
1460 }
1461
1462 if(clone_info != NULL) /* cleanup garbage file from compression */
1463 {
1464 if(clone_info->file)
1465 {
1466 fclose(clone_info->file);
1467 clone_info->file = NULL;
1468 (void) remove_utf8(clone_info->filename);
1469 }
1470 DestroyImageInfo(clone_info);
1471 clone_info = NULL;
1472 }
1473 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),"return");
1474 if ((image != image2) && (image2 != (Image *) NULL))
1475 image2=DestroyImage(image2);
1476 if (image == (Image *) NULL)
1477 ThrowReaderException(CorruptImageError,"ImproperImageHeader")
1478 return(image);
1479 }
1480
1481 /*
1482 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1483 % %
1484 % %
1485 % %
1486 % R e g i s t e r M A T I m a g e %
1487 % %
1488 % %
1489 % %
1490 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1491 %
1492 % Method RegisterMATImage adds attributes for the MAT image format to
1493 % the list of supported formats. The attributes include the image format
1494 % tag, a method to read and/or write the format, whether the format
1495 % supports the saving of more than one frame to the same file or blob,
1496 % whether the format supports native in-memory I/O, and a brief
1497 % description of the format.
1498 %
1499 % The format of the RegisterMATImage method is:
1500 %
1501 % size_t RegisterMATImage(void)
1502 %
1503 */
RegisterMATImage(void)1504 ModuleExport size_t RegisterMATImage(void)
1505 {
1506 MagickInfo
1507 *entry;
1508
1509 entry=AcquireMagickInfo("MAT","MAT","MATLAB level 5 image format");
1510 entry->decoder=(DecodeImageHandler *) ReadMATImage;
1511 entry->encoder=(EncodeImageHandler *) WriteMATImage;
1512 entry->flags^=CoderBlobSupportFlag;
1513 entry->flags|=CoderDecoderSeekableStreamFlag;
1514 (void) RegisterMagickInfo(entry);
1515 return(MagickImageCoderSignature);
1516 }
1517
1518 /*
1519 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1520 % %
1521 % %
1522 % %
1523 % U n r e g i s t e r M A T I m a g e %
1524 % %
1525 % %
1526 % %
1527 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1528 %
1529 % Method UnregisterMATImage removes format registrations made by the
1530 % MAT module from the list of supported formats.
1531 %
1532 % The format of the UnregisterMATImage method is:
1533 %
1534 % UnregisterMATImage(void)
1535 %
1536 */
UnregisterMATImage(void)1537 ModuleExport void UnregisterMATImage(void)
1538 {
1539 (void) UnregisterMagickInfo("MAT");
1540 }
1541
1542 /*
1543 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1544 % %
1545 % %
1546 % %
1547 % W r i t e M A T L A B I m a g e %
1548 % %
1549 % %
1550 % %
1551 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1552 %
1553 % Function WriteMATImage writes an Matlab matrix to a file.
1554 %
1555 % The format of the WriteMATImage method is:
1556 %
1557 % MagickBooleanType WriteMATImage(const ImageInfo *image_info,
1558 % Image *image,ExceptionInfo *exception)
1559 %
1560 % A description of each parameter follows.
1561 %
1562 % o image_info: Specifies a pointer to a ImageInfo structure.
1563 %
1564 % o image: A pointer to an Image structure.
1565 %
1566 % o exception: return any errors or warnings in this structure.
1567 %
1568 */
WriteMATImage(const ImageInfo * image_info,Image * image,ExceptionInfo * exception)1569 static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
1570 ExceptionInfo *exception)
1571 {
1572 char
1573 MATLAB_HDR[0x80];
1574
1575 MagickBooleanType
1576 status;
1577
1578 MagickOffsetType
1579 scene;
1580
1581 size_t
1582 imageListLength;
1583
1584 struct tm
1585 local_time;
1586
1587 time_t
1588 current_time;
1589
1590 /*
1591 Open output image file.
1592 */
1593 assert(image_info != (const ImageInfo *) NULL);
1594 assert(image_info->signature == MagickCoreSignature);
1595 assert(image != (Image *) NULL);
1596 assert(image->signature == MagickCoreSignature);
1597 (void) LogMagickEvent(CoderEvent,GetMagickModule(),"enter MAT");
1598 assert(exception != (ExceptionInfo *) NULL);
1599 assert(exception->signature == MagickCoreSignature);
1600 status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1601 if (status == MagickFalse)
1602 return(MagickFalse);
1603 image->depth=8;
1604
1605 current_time=time((time_t *) NULL);
1606 #if defined(MAGICKCORE_HAVE_LOCALTIME_R)
1607 (void) localtime_r(¤t_time,&local_time);
1608 #else
1609 (void) memcpy(&local_time,localtime(¤t_time),sizeof(local_time));
1610 #endif
1611 (void) memset(MATLAB_HDR,' ',MagickMin(sizeof(MATLAB_HDR),124));
1612 FormatLocaleString(MATLAB_HDR,sizeof(MATLAB_HDR),
1613 "MATLAB 5.0 MAT-file, Platform: %s, Created on: %s %s %2d %2d:%2d:%2d %d",
1614 OsDesc,DayOfWTab[local_time.tm_wday],MonthsTab[local_time.tm_mon],
1615 local_time.tm_mday,local_time.tm_hour,local_time.tm_min,
1616 local_time.tm_sec,local_time.tm_year+1900);
1617 MATLAB_HDR[0x7C]=0;
1618 MATLAB_HDR[0x7D]=1;
1619 MATLAB_HDR[0x7E]='I';
1620 MATLAB_HDR[0x7F]='M';
1621 (void) WriteBlob(image,sizeof(MATLAB_HDR),(unsigned char *) MATLAB_HDR);
1622 scene=0;
1623 imageListLength=GetImageListLength(image);
1624 do
1625 {
1626 char
1627 padding;
1628
1629 MagickBooleanType
1630 is_gray;
1631
1632 QuantumInfo
1633 *quantum_info;
1634
1635 size_t
1636 data_size;
1637
1638 unsigned char
1639 *pixels;
1640
1641 unsigned int
1642 z;
1643
1644 (void) TransformImageColorspace(image,sRGBColorspace,exception);
1645 is_gray=SetImageGray(image,exception);
1646 z=(is_gray != MagickFalse) ? 0 : 3;
1647
1648 /*
1649 Store MAT header.
1650 */
1651 data_size = image->rows * image->columns;
1652 if (is_gray == MagickFalse)
1653 data_size*=3;
1654 padding=((unsigned char)(data_size-1) & 0x7) ^ 0x7;
1655
1656 (void) WriteBlobLSBLong(image,miMATRIX);
1657 (void) WriteBlobLSBLong(image,(unsigned int) data_size+padding+
1658 ((is_gray != MagickFalse) ? 48 : 56));
1659 (void) WriteBlobLSBLong(image,0x6); /* 0x88 */
1660 (void) WriteBlobLSBLong(image,0x8); /* 0x8C */
1661 (void) WriteBlobLSBLong(image,0x6); /* 0x90 */
1662 (void) WriteBlobLSBLong(image,0);
1663 (void) WriteBlobLSBLong(image,0x5); /* 0x98 */
1664 (void) WriteBlobLSBLong(image,(is_gray != MagickFalse) ? 0x8 : 0xC); /* 0x9C - DimFlag */
1665 (void) WriteBlobLSBLong(image,(unsigned int) image->rows); /* x: 0xA0 */
1666 (void) WriteBlobLSBLong(image,(unsigned int) image->columns); /* y: 0xA4 */
1667 if (is_gray == MagickFalse)
1668 {
1669 (void) WriteBlobLSBLong(image,3); /* z: 0xA8 */
1670 (void) WriteBlobLSBLong(image,0);
1671 }
1672 (void) WriteBlobLSBShort(image,1); /* 0xB0 */
1673 (void) WriteBlobLSBShort(image,1); /* 0xB2 */
1674 (void) WriteBlobLSBLong(image,'M'); /* 0xB4 */
1675 (void) WriteBlobLSBLong(image,0x2); /* 0xB8 */
1676 (void) WriteBlobLSBLong(image,(unsigned int) data_size); /* 0xBC */
1677
1678 /*
1679 Store image data.
1680 */
1681 quantum_info=AcquireQuantumInfo(image_info,image);
1682 if (quantum_info == (QuantumInfo *) NULL)
1683 ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1684 pixels=(unsigned char *) GetQuantumPixels(quantum_info);
1685 do
1686 {
1687 const Quantum
1688 *p;
1689
1690 ssize_t
1691 y;
1692
1693 for (y=0; y < (ssize_t)image->columns; y++)
1694 {
1695 p=GetVirtualPixels(image,y,0,1,image->rows,exception);
1696 if (p == (const Quantum *) NULL)
1697 break;
1698 (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1699 z2qtype[z],pixels,exception);
1700 (void) WriteBlob(image,image->rows,pixels);
1701 }
1702 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1703 break;
1704 } while (z-- >= 2);
1705 while (padding-- > 0)
1706 (void) WriteBlobByte(image,0);
1707 quantum_info=DestroyQuantumInfo(quantum_info);
1708 if (GetNextImageInList(image) == (Image *) NULL)
1709 break;
1710 image=SyncNextImageInList(image);
1711 status=SetImageProgress(image,SaveImagesTag,scene++,imageListLength);
1712 if (status == MagickFalse)
1713 break;
1714 } while (image_info->adjoin != MagickFalse);
1715 (void) CloseBlob(image);
1716 return(status);
1717 }
1718