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 long DataType;
102 unsigned long ObjectSize;
103 unsigned long unknown1;
104 unsigned long unknown2;
105
106 unsigned short unknown5;
107 unsigned char StructureFlag;
108 unsigned char StructureClass;
109 unsigned long unknown3;
110 unsigned long unknown4;
111 unsigned long DimFlag;
112
113 unsigned long SizeX;
114 unsigned long SizeY;
115 unsigned short Flag1;
116 unsigned short NameFlag;
117 }
118 MATHeader;
119
120 static const char *MonthsTab[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
121 static const char *DayOfWTab[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
122 static const char *OsDesc=
123 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
124 "PCWIN";
125 #else
126 #ifdef __APPLE__
127 "MAC";
128 #else
129 "LNX86";
130 #endif
131 #endif
132
133 typedef enum
134 {
135 miINT8 = 1, /* 8 bit signed */
136 miUINT8, /* 8 bit unsigned */
137 miINT16, /* 16 bit signed */
138 miUINT16, /* 16 bit unsigned */
139 miINT32, /* 32 bit signed */
140 miUINT32, /* 32 bit unsigned */
141 miSINGLE, /* IEEE 754 single precision float */
142 miRESERVE1,
143 miDOUBLE, /* IEEE 754 double precision float */
144 miRESERVE2,
145 miRESERVE3,
146 miINT64, /* 64 bit signed */
147 miUINT64, /* 64 bit unsigned */
148 miMATRIX, /* MATLAB array */
149 miCOMPRESSED, /* Compressed Data */
150 miUTF8, /* Unicode UTF-8 Encoded Character Data */
151 miUTF16, /* Unicode UTF-16 Encoded Character Data */
152 miUTF32 /* Unicode UTF-32 Encoded Character Data */
153 } mat5_data_type;
154
155 typedef enum
156 {
157 mxCELL_CLASS=1, /* cell array */
158 mxSTRUCT_CLASS, /* structure */
159 mxOBJECT_CLASS, /* object */
160 mxCHAR_CLASS, /* character array */
161 mxSPARSE_CLASS, /* sparse array */
162 mxDOUBLE_CLASS, /* double precision array */
163 mxSINGLE_CLASS, /* single precision floating point */
164 mxINT8_CLASS, /* 8 bit signed integer */
165 mxUINT8_CLASS, /* 8 bit unsigned integer */
166 mxINT16_CLASS, /* 16 bit signed integer */
167 mxUINT16_CLASS, /* 16 bit unsigned integer */
168 mxINT32_CLASS, /* 32 bit signed integer */
169 mxUINT32_CLASS, /* 32 bit unsigned integer */
170 mxINT64_CLASS, /* 64 bit signed integer */
171 mxUINT64_CLASS, /* 64 bit unsigned integer */
172 mxFUNCTION_CLASS /* Function handle */
173 } arrayclasstype;
174
175 #define FLAG_COMPLEX 0x8
176 #define FLAG_GLOBAL 0x4
177 #define FLAG_LOGICAL 0x2
178
179 static const QuantumType z2qtype[4] = {GrayQuantum, BlueQuantum, GreenQuantum, RedQuantum};
180
181
InsertComplexDoubleRow(Image * image,double * p,int y,double MinVal,double MaxVal,ExceptionInfo * exception)182 static void InsertComplexDoubleRow(Image *image,double *p,int y,double MinVal,
183 double MaxVal,ExceptionInfo *exception)
184 {
185
186 double f;
187 int x;
188 register Quantum *q;
189
190 if (MinVal == 0)
191 MinVal = -1;
192 if (MaxVal == 0)
193 MaxVal = 1;
194
195 q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
196 if (q == (Quantum *) NULL)
197 return;
198 for (x = 0; x < (ssize_t) image->columns; x++)
199 {
200 if (*p > 0)
201 {
202 f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
203 if (f + GetPixelRed(image,q) > QuantumRange)
204 SetPixelRed(image,QuantumRange,q);
205 else
206 SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
207 if ((int) f / 2.0 > GetPixelGreen(image,q))
208 {
209 SetPixelGreen(image,0,q);
210 SetPixelBlue(image,0,q);
211 }
212 else
213 {
214 SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
215 SetPixelGreen(image,GetPixelBlue(image,q),q);
216 }
217 }
218 if (*p < 0)
219 {
220 f = (*p / MaxVal) * (QuantumRange-GetPixelBlue(image,q));
221 if (f+GetPixelBlue(image,q) > QuantumRange)
222 SetPixelBlue(image,QuantumRange,q);
223 else
224 SetPixelBlue(image,GetPixelBlue(image,q)+(int) f,q);
225 if ((int) f / 2.0 > GetPixelGreen(image,q))
226 {
227 SetPixelRed(image,0,q);
228 SetPixelGreen(image,0,q);
229 }
230 else
231 {
232 SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
233 SetPixelGreen(image,GetPixelRed(image,q),q);
234 }
235 }
236 p++;
237 q+=GetPixelChannels(image);
238 }
239 if (!SyncAuthenticPixels(image,exception))
240 return;
241 return;
242 }
243
244
InsertComplexFloatRow(Image * image,float * p,int y,double MinVal,double MaxVal,ExceptionInfo * exception)245 static void InsertComplexFloatRow(Image *image,float *p,int y,double MinVal,
246 double MaxVal,ExceptionInfo *exception)
247 {
248 double f;
249 int x;
250 register Quantum *q;
251
252 if (MinVal == 0)
253 MinVal = -1;
254 if (MaxVal == 0)
255 MaxVal = 1;
256
257 q = QueueAuthenticPixels(image, 0, y, image->columns, 1,exception);
258 if (q == (Quantum *) NULL)
259 return;
260 for (x = 0; x < (ssize_t) image->columns; x++)
261 {
262 if (*p > 0)
263 {
264 f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
265 if (f+GetPixelRed(image,q) > QuantumRange)
266 SetPixelRed(image,QuantumRange,q);
267 else
268 SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
269 if ((int) f / 2.0 > GetPixelGreen(image,q))
270 {
271 SetPixelGreen(image,0,q);
272 SetPixelBlue(image,0,q);
273 }
274 else
275 {
276 SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
277 SetPixelGreen(image,GetPixelBlue(image,q),q);
278 }
279 }
280 if (*p < 0)
281 {
282 f = (*p / MaxVal) * (QuantumRange - GetPixelBlue(image,q));
283 if (f + GetPixelBlue(image,q) > QuantumRange)
284 SetPixelBlue(image,QuantumRange,q);
285 else
286 SetPixelBlue(image,GetPixelBlue(image,q)+
287 (int) f,q);
288 if ((int) f / 2.0 > GetPixelGreen(image,q))
289 {
290 SetPixelGreen(image,0,q);
291 SetPixelRed(image,0,q);
292 }
293 else
294 {
295 SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
296 SetPixelGreen(image,GetPixelRed(image,q),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. */
DecompressBlock(Image * orig,MagickOffsetType Size,ImageInfo * clone_info,ExceptionInfo * exception)475 static Image *DecompressBlock(Image *orig, MagickOffsetType Size, ImageInfo *clone_info, ExceptionInfo *exception)
476 {
477
478 Image *image2;
479 void *CacheBlock, *DecompressBlock;
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
489 if(clone_info==NULL) return NULL;
490 if(clone_info->file) /* Close file opened from previous transaction. */
491 {
492 fclose(clone_info->file);
493 clone_info->file = NULL;
494 (void) remove_utf8(clone_info->filename);
495 }
496
497 CacheBlock = AcquireQuantumMemory((size_t)((Size<16384)?Size:16384),sizeof(unsigned char *));
498 if(CacheBlock==NULL) return NULL;
499 DecompressBlock = AcquireQuantumMemory((size_t)(4096),sizeof(unsigned char *));
500 if(DecompressBlock==NULL)
501 {
502 RelinquishMagickMemory(CacheBlock);
503 return NULL;
504 }
505
506 mat_file=0;
507 file = AcquireUniqueFileResource(clone_info->filename);
508 if (file != -1)
509 mat_file = fdopen(file,"w");
510 if(!mat_file)
511 {
512 RelinquishMagickMemory(CacheBlock);
513 RelinquishMagickMemory(DecompressBlock);
514 (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Cannot create file stream for decompressed image");
515 return NULL;
516 }
517
518 zip_info.zalloc=AcquireZIPMemory;
519 zip_info.zfree=RelinquishZIPMemory;
520 zip_info.opaque = (voidpf) NULL;
521 zip_status = inflateInit(&zip_info);
522 if (zip_status != Z_OK)
523 {
524 RelinquishMagickMemory(CacheBlock);
525 RelinquishMagickMemory(DecompressBlock);
526 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
527 "UnableToUncompressImage","`%s'",clone_info->filename);
528 (void) fclose(mat_file);
529 RelinquishUniqueFileResource(clone_info->filename);
530 return NULL;
531 }
532 /* zip_info.next_out = 8*4;*/
533
534 zip_info.avail_in = 0;
535 zip_info.total_out = 0;
536 while(Size>0 && !EOFBlob(orig))
537 {
538 magick_size = ReadBlob(orig, (Size<16384)?Size:16384, (unsigned char *) CacheBlock);
539 zip_info.next_in = (Bytef *) CacheBlock;
540 zip_info.avail_in = (uInt) magick_size;
541
542 while(zip_info.avail_in>0)
543 {
544 zip_info.avail_out = 4096;
545 zip_info.next_out = (Bytef *) DecompressBlock;
546 zip_status = inflate(&zip_info,Z_NO_FLUSH);
547 if ((zip_status != Z_OK) && (zip_status != Z_STREAM_END))
548 break;
549 extent=fwrite(DecompressBlock, 4096-zip_info.avail_out, 1, mat_file);
550 (void) extent;
551
552 if(zip_status == Z_STREAM_END) goto DblBreak;
553 }
554 if ((zip_status != Z_OK) && (zip_status != Z_STREAM_END))
555 break;
556
557 Size -= magick_size;
558 }
559 DblBreak:
560
561 inflateEnd(&zip_info);
562 (void)fclose(mat_file);
563 RelinquishMagickMemory(CacheBlock);
564 RelinquishMagickMemory(DecompressBlock);
565
566 if((clone_info->file=fopen(clone_info->filename,"rb"))==NULL) goto UnlinkFile;
567 if( (image2 = AcquireImage(clone_info,exception))==NULL ) goto EraseFile;
568 status = OpenBlob(clone_info,image2,ReadBinaryBlobMode,exception);
569 if (status == MagickFalse)
570 {
571 DeleteImageFromList(&image2);
572 EraseFile:
573 fclose(clone_info->file);
574 clone_info->file = NULL;
575 UnlinkFile:
576 RelinquishUniqueFileResource(clone_info->filename);
577 return NULL;
578 }
579
580 return image2;
581 }
582 #endif
583
ReadMATImageV4(const ImageInfo * image_info,Image * image,ExceptionInfo * exception)584 static Image *ReadMATImageV4(const ImageInfo *image_info,Image *image,
585 ExceptionInfo *exception)
586 {
587 typedef struct {
588 unsigned char Type[4];
589 unsigned int nRows;
590 unsigned int nCols;
591 unsigned int imagf;
592 unsigned int nameLen;
593 } MAT4_HDR;
594
595 long
596 ldblk;
597
598 EndianType
599 endian;
600
601 Image
602 *rotate_image;
603
604 MagickBooleanType
605 status;
606
607 MAT4_HDR
608 HDR;
609
610 QuantumInfo
611 *quantum_info;
612
613 QuantumFormatType
614 format_type;
615
616 register ssize_t
617 i;
618
619 ssize_t
620 count,
621 y;
622
623 unsigned char
624 *pixels;
625
626 unsigned int
627 depth;
628
629 (void) SeekBlob(image,0,SEEK_SET);
630 ldblk=ReadBlobLSBLong(image);
631 if ((ldblk > 9999) || (ldblk < 0))
632 return((Image *) NULL);
633 HDR.Type[3]=ldblk % 10; ldblk /= 10; /* T digit */
634 HDR.Type[2]=ldblk % 10; ldblk /= 10; /* P digit */
635 HDR.Type[1]=ldblk % 10; ldblk /= 10; /* O digit */
636 HDR.Type[0]=ldblk; /* M digit */
637 if (HDR.Type[3] != 0) return((Image *) NULL); /* Data format */
638 if (HDR.Type[2] != 0) return((Image *) NULL); /* Always 0 */
639 if (HDR.Type[0] == 0)
640 {
641 HDR.nRows=ReadBlobLSBLong(image);
642 HDR.nCols=ReadBlobLSBLong(image);
643 HDR.imagf=ReadBlobLSBLong(image);
644 HDR.nameLen=ReadBlobLSBLong(image);
645 endian=LSBEndian;
646 }
647 else
648 {
649 HDR.nRows=ReadBlobMSBLong(image);
650 HDR.nCols=ReadBlobMSBLong(image);
651 HDR.imagf=ReadBlobMSBLong(image);
652 HDR.nameLen=ReadBlobMSBLong(image);
653 endian=MSBEndian;
654 }
655 if (HDR.nameLen > 0xFFFF)
656 return((Image *) NULL);
657 for (i=0; i < (ssize_t) HDR.nameLen; i++)
658 {
659 int
660 byte;
661
662 /*
663 Skip matrix name.
664 */
665 byte=ReadBlobByte(image);
666 if (byte == EOF)
667 return((Image *) NULL);
668 }
669 image->columns=(size_t) HDR.nRows;
670 image->rows=(size_t) HDR.nCols;
671 SetImageColorspace(image,GRAYColorspace,exception);
672 if (image_info->ping != MagickFalse)
673 {
674 Swap(image->columns,image->rows);
675 return(image);
676 }
677 status=SetImageExtent(image,image->columns,image->rows,exception);
678 if (status == MagickFalse)
679 return((Image *) NULL);
680 quantum_info=AcquireQuantumInfo(image_info,image);
681 if (quantum_info == (QuantumInfo *) NULL)
682 return((Image *) NULL);
683 switch(HDR.Type[1])
684 {
685 case 0:
686 format_type=FloatingPointQuantumFormat;
687 depth=64;
688 break;
689 case 1:
690 format_type=FloatingPointQuantumFormat;
691 depth=32;
692 break;
693 case 2:
694 format_type=UnsignedQuantumFormat;
695 depth=16;
696 break;
697 case 3:
698 format_type=SignedQuantumFormat;
699 depth=16;
700 case 4:
701 format_type=UnsignedQuantumFormat;
702 depth=8;
703 break;
704 default:
705 format_type=UnsignedQuantumFormat;
706 depth=8;
707 break;
708 }
709 image->depth=depth;
710 if (HDR.Type[0] != 0)
711 SetQuantumEndian(image,quantum_info,MSBEndian);
712 status=SetQuantumFormat(image,quantum_info,format_type);
713 status=SetQuantumDepth(image,quantum_info,depth);
714 status=SetQuantumEndian(image,quantum_info,endian);
715 SetQuantumScale(quantum_info,1.0);
716 pixels=(unsigned char *) GetQuantumPixels(quantum_info);
717 for (y=0; y < (ssize_t) image->rows; y++)
718 {
719 int
720 status;
721
722 register Quantum
723 *magick_restrict q;
724
725 count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
726 if (count == -1)
727 break;
728 q=QueueAuthenticPixels(image,0,image->rows-y-1,image->columns,1,exception);
729 if (q == (Quantum *) NULL)
730 break;
731 (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
732 GrayQuantum,pixels,exception);
733 if ((HDR.Type[1] == 2) || (HDR.Type[1] == 3))
734 FixSignedValues(image,q,image->columns);
735 if (SyncAuthenticPixels(image,exception) == MagickFalse)
736 break;
737 if (image->previous == (Image *) NULL)
738 {
739 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
740 image->rows);
741 if (status == MagickFalse)
742 break;
743 }
744 }
745 if (HDR.imagf == 1)
746 for (y=0; y < (ssize_t) image->rows; y++)
747 {
748 /*
749 Read complex pixels.
750 */
751 count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
752 if (count == -1)
753 break;
754 if (HDR.Type[1] == 0)
755 InsertComplexDoubleRow(image,(double *) pixels,y,0,0,exception);
756 else
757 InsertComplexFloatRow(image,(float *) pixels,y,0,0,exception);
758 }
759 quantum_info=DestroyQuantumInfo(quantum_info);
760 rotate_image=RotateImage(image,90.0,exception);
761 if (rotate_image != (Image *) NULL)
762 {
763 image=DestroyImage(image);
764 image=rotate_image;
765 }
766 return(image);
767 }
768
769 /*
770 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
771 % %
772 % %
773 % %
774 % R e a d M A T L A B i m a g e %
775 % %
776 % %
777 % %
778 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
779 %
780 % ReadMATImage() reads an MAT X image file and returns it. It
781 % allocates the memory necessary for the new Image structure and returns a
782 % pointer to the new image.
783 %
784 % The format of the ReadMATImage method is:
785 %
786 % Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
787 %
788 % A description of each parameter follows:
789 %
790 % o image: Method ReadMATImage returns a pointer to the image after
791 % reading. A null image is returned if there is a memory shortage or if
792 % the image cannot be read.
793 %
794 % o image_info: Specifies a pointer to a ImageInfo structure.
795 %
796 % o exception: return any errors or warnings in this structure.
797 %
798 */
ReadMATImage(const ImageInfo * image_info,ExceptionInfo * exception)799 static Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
800 {
801 Image *image, *image2=NULL,
802 *rotated_image;
803 register Quantum *q;
804
805 unsigned int status;
806 MATHeader MATLAB_HDR;
807 size_t size;
808 size_t CellType;
809 QuantumInfo *quantum_info;
810 ImageInfo *clone_info;
811 int i;
812 ssize_t ldblk;
813 unsigned char *BImgBuff = NULL;
814 double MinVal, MaxVal;
815 unsigned z, z2;
816 unsigned Frames;
817 int logging;
818 int sample_size;
819 MagickOffsetType filepos=0x80;
820 BlobInfo *blob;
821 size_t one;
822
823 unsigned int (*ReadBlobXXXLong)(Image *image);
824 unsigned short (*ReadBlobXXXShort)(Image *image);
825 void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
826 void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
827
828
829 assert(image_info != (const ImageInfo *) NULL);
830 assert(image_info->signature == MagickCoreSignature);
831 assert(exception != (ExceptionInfo *) NULL);
832 assert(exception->signature == MagickCoreSignature);
833 logging = LogMagickEvent(CoderEvent,GetMagickModule(),"enter");
834
835 /*
836 Open image file.
837 */
838 image = AcquireImage(image_info,exception);
839
840 status = OpenBlob(image_info, image, ReadBinaryBlobMode, exception);
841 if (status == MagickFalse)
842 {
843 image=DestroyImageList(image);
844 return((Image *) NULL);
845 }
846 /*
847 Read MATLAB image.
848 */
849 clone_info=CloneImageInfo(image_info);
850 if (ReadBlob(image,124,(unsigned char *) &MATLAB_HDR.identific) != 124)
851 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
852 if (strncmp(MATLAB_HDR.identific,"MATLAB",6) != 0)
853 {
854 image2=ReadMATImageV4(image_info,image,exception);
855 if (image2 == NULL)
856 goto MATLAB_KO;
857 image=image2;
858 goto END_OF_READING;
859 }
860 MATLAB_HDR.Version = ReadBlobLSBShort(image);
861 if(ReadBlob(image,2,(unsigned char *) &MATLAB_HDR.EndianIndicator) != 2)
862 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
863
864 if (logging)
865 (void) LogMagickEvent(CoderEvent,GetMagickModule()," Endian %c%c",
866 MATLAB_HDR.EndianIndicator[0],MATLAB_HDR.EndianIndicator[1]);
867 if (!strncmp(MATLAB_HDR.EndianIndicator, "IM", 2))
868 {
869 ReadBlobXXXLong = ReadBlobLSBLong;
870 ReadBlobXXXShort = ReadBlobLSBShort;
871 ReadBlobDoublesXXX = ReadBlobDoublesLSB;
872 ReadBlobFloatsXXX = ReadBlobFloatsLSB;
873 image->endian = LSBEndian;
874 }
875 else if (!strncmp(MATLAB_HDR.EndianIndicator, "MI", 2))
876 {
877 ReadBlobXXXLong = ReadBlobMSBLong;
878 ReadBlobXXXShort = ReadBlobMSBShort;
879 ReadBlobDoublesXXX = ReadBlobDoublesMSB;
880 ReadBlobFloatsXXX = ReadBlobFloatsMSB;
881 image->endian = MSBEndian;
882 }
883 else
884 goto MATLAB_KO; /* unsupported endian */
885
886 if (strncmp(MATLAB_HDR.identific, "MATLAB", 6))
887 MATLAB_KO: ThrowReaderException(CorruptImageError,"ImproperImageHeader");
888
889 filepos = TellBlob(image);
890 while(!EOFBlob(image)) /* object parser loop */
891 {
892 Frames = 1;
893 (void) SeekBlob(image,filepos,SEEK_SET);
894 /* printf("pos=%X\n",TellBlob(image)); */
895
896 MATLAB_HDR.DataType = ReadBlobXXXLong(image);
897 if(EOFBlob(image)) break;
898 MATLAB_HDR.ObjectSize = ReadBlobXXXLong(image);
899 if(EOFBlob(image)) break;
900 filepos += MATLAB_HDR.ObjectSize + 4 + 4;
901
902 image2 = image;
903 #if defined(MAGICKCORE_ZLIB_DELEGATE)
904 if(MATLAB_HDR.DataType == miCOMPRESSED)
905 {
906 image2 = DecompressBlock(image,MATLAB_HDR.ObjectSize,clone_info,exception);
907 if(image2==NULL) continue;
908 MATLAB_HDR.DataType = ReadBlobXXXLong(image2); /* replace compressed object type. */
909 }
910 #endif
911
912 if(MATLAB_HDR.DataType!=miMATRIX) continue; /* skip another objects. */
913
914 MATLAB_HDR.unknown1 = ReadBlobXXXLong(image2);
915 MATLAB_HDR.unknown2 = ReadBlobXXXLong(image2);
916
917 MATLAB_HDR.unknown5 = ReadBlobXXXLong(image2);
918 MATLAB_HDR.StructureClass = MATLAB_HDR.unknown5 & 0xFF;
919 MATLAB_HDR.StructureFlag = (MATLAB_HDR.unknown5>>8) & 0xFF;
920
921 MATLAB_HDR.unknown3 = ReadBlobXXXLong(image2);
922 if(image!=image2)
923 MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2); /* ??? don't understand why ?? */
924 MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2);
925 MATLAB_HDR.DimFlag = ReadBlobXXXLong(image2);
926 MATLAB_HDR.SizeX = ReadBlobXXXLong(image2);
927 MATLAB_HDR.SizeY = ReadBlobXXXLong(image2);
928
929
930 switch(MATLAB_HDR.DimFlag)
931 {
932 case 8: z2=z=1; break; /* 2D matrix*/
933 case 12: z2=z = ReadBlobXXXLong(image2); /* 3D matrix RGB*/
934 (void) ReadBlobXXXLong(image2);
935 if(z!=3) ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
936 break;
937 case 16: z2=z = ReadBlobXXXLong(image2); /* 4D matrix animation */
938 if(z!=3 && z!=1)
939 ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
940 Frames = ReadBlobXXXLong(image2);
941 if (Frames == 0)
942 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
943 break;
944 default: ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
945 }
946
947 MATLAB_HDR.Flag1 = ReadBlobXXXShort(image2);
948 MATLAB_HDR.NameFlag = ReadBlobXXXShort(image2);
949
950 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
951 "MATLAB_HDR.StructureClass %d",MATLAB_HDR.StructureClass);
952 if (MATLAB_HDR.StructureClass != mxCHAR_CLASS &&
953 MATLAB_HDR.StructureClass != mxSINGLE_CLASS && /* float + complex float */
954 MATLAB_HDR.StructureClass != mxDOUBLE_CLASS && /* double + complex double */
955 MATLAB_HDR.StructureClass != mxINT8_CLASS &&
956 MATLAB_HDR.StructureClass != mxUINT8_CLASS && /* uint8 + uint8 3D */
957 MATLAB_HDR.StructureClass != mxINT16_CLASS &&
958 MATLAB_HDR.StructureClass != mxUINT16_CLASS && /* uint16 + uint16 3D */
959 MATLAB_HDR.StructureClass != mxINT32_CLASS &&
960 MATLAB_HDR.StructureClass != mxUINT32_CLASS && /* uint32 + uint32 3D */
961 MATLAB_HDR.StructureClass != mxINT64_CLASS &&
962 MATLAB_HDR.StructureClass != mxUINT64_CLASS) /* uint64 + uint64 3D */
963 ThrowReaderException(CoderError,"UnsupportedCellTypeInTheMatrix");
964
965 switch (MATLAB_HDR.NameFlag)
966 {
967 case 0:
968 size = ReadBlobXXXLong(image2); /* Object name string size */
969 size = 4 * (ssize_t) ((size + 3 + 1) / 4);
970 (void) SeekBlob(image2, size, SEEK_CUR);
971 break;
972 case 1:
973 case 2:
974 case 3:
975 case 4:
976 (void) ReadBlob(image2, 4, (unsigned char *) &size); /* Object name string */
977 break;
978 default:
979 goto MATLAB_KO;
980 }
981
982 CellType = ReadBlobXXXLong(image2); /* Additional object type */
983 if (logging)
984 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
985 "MATLAB_HDR.CellType: %.20g",(double) CellType);
986
987 (void) ReadBlob(image2, 4, (unsigned char *) &size); /* data size */
988
989 NEXT_FRAME:
990 switch (CellType)
991 {
992 case miINT8:
993 case miUINT8:
994 sample_size = 8;
995 if(MATLAB_HDR.StructureFlag & FLAG_LOGICAL)
996 image->depth = 1;
997 else
998 image->depth = 8; /* Byte type cell */
999 ldblk = (ssize_t) MATLAB_HDR.SizeX;
1000 break;
1001 case miINT16:
1002 case miUINT16:
1003 sample_size = 16;
1004 image->depth = 16; /* Word type cell */
1005 ldblk = (ssize_t) (2 * MATLAB_HDR.SizeX);
1006 break;
1007 case miINT32:
1008 case miUINT32:
1009 sample_size = 32;
1010 image->depth = 32; /* Dword type cell */
1011 ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1012 break;
1013 case miINT64:
1014 case miUINT64:
1015 sample_size = 64;
1016 image->depth = 64; /* Qword type cell */
1017 ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1018 break;
1019 case miSINGLE:
1020 sample_size = 32;
1021 image->depth = 32; /* double type cell */
1022 (void) SetImageOption(clone_info,"quantum:format","floating-point");
1023 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1024 { /* complex float type cell */
1025 }
1026 ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1027 break;
1028 case miDOUBLE:
1029 sample_size = 64;
1030 image->depth = 64; /* double type cell */
1031 (void) SetImageOption(clone_info,"quantum:format","floating-point");
1032 DisableMSCWarning(4127)
1033 if (sizeof(double) != 8)
1034 RestoreMSCWarning
1035 ThrowReaderException(CoderError, "IncompatibleSizeOfDouble");
1036 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1037 { /* complex double type cell */
1038 }
1039 ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1040 break;
1041 default:
1042 ThrowReaderException(CoderError, "UnsupportedCellTypeInTheMatrix");
1043 }
1044 (void) sample_size;
1045 image->columns = MATLAB_HDR.SizeX;
1046 image->rows = MATLAB_HDR.SizeY;
1047 quantum_info=AcquireQuantumInfo(clone_info,image);
1048 if (quantum_info == (QuantumInfo *) NULL)
1049 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1050 one=1;
1051 image->colors = one << image->depth;
1052 if (image->columns == 0 || image->rows == 0)
1053 goto MATLAB_KO;
1054 /* Image is gray when no complex flag is set and 2D Matrix */
1055 if ((MATLAB_HDR.DimFlag == 8) &&
1056 ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1057 {
1058 image->type=GrayscaleType;
1059 SetImageColorspace(image,GRAYColorspace,exception);
1060 }
1061
1062
1063 /*
1064 If ping is true, then only set image size and colors without
1065 reading any image data.
1066 */
1067 if (image_info->ping)
1068 {
1069 size_t temp = image->columns;
1070 image->columns = image->rows;
1071 image->rows = temp;
1072 goto done_reading; /* !!!!!! BAD !!!! */
1073 }
1074 status=SetImageExtent(image,image->columns,image->rows,exception);
1075 if (status == MagickFalse)
1076 return(DestroyImageList(image));
1077
1078 /* ----- Load raster data ----- */
1079 BImgBuff = (unsigned char *) AcquireQuantumMemory((size_t) (ldblk),sizeof(double)); /* Ldblk was set in the check phase */
1080 if (BImgBuff == NULL)
1081 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1082
1083 MinVal = 0;
1084 MaxVal = 0;
1085 if (CellType==miDOUBLE || CellType==miSINGLE) /* Find Min and Max Values for floats */
1086 {
1087 CalcMinMax(image2, image_info->endian, MATLAB_HDR.SizeX, MATLAB_HDR.SizeY, CellType, ldblk, BImgBuff, &quantum_info->minimum, &quantum_info->maximum);
1088 }
1089
1090 /* Main loop for reading all scanlines */
1091 if(z==1) z=0; /* read grey scanlines */
1092 /* else read color scanlines */
1093 do
1094 {
1095 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1096 {
1097 q=GetAuthenticPixels(image,0,MATLAB_HDR.SizeY-i-1,image->columns,1,exception);
1098 if (q == (Quantum *) NULL)
1099 {
1100 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1101 " MAT set image pixels returns unexpected NULL on a row %u.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1102 goto done_reading; /* Skip image rotation, when cannot set image pixels */
1103 }
1104 if(ReadBlob(image2,ldblk,(unsigned char *)BImgBuff) != (ssize_t) ldblk)
1105 {
1106 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1107 " MAT cannot read scanrow %u from a file.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1108 goto ExitLoop;
1109 }
1110 if((CellType==miINT8 || CellType==miUINT8) && (MATLAB_HDR.StructureFlag & FLAG_LOGICAL))
1111 {
1112 FixLogical((unsigned char *)BImgBuff,ldblk);
1113 if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1114 {
1115 ImportQuantumPixelsFailed:
1116 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1117 " MAT failed to ImportQuantumPixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1118 break;
1119 }
1120 }
1121 else
1122 {
1123 if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1124 goto ImportQuantumPixelsFailed;
1125
1126
1127 if (z<=1 && /* fix only during a last pass z==0 || z==1 */
1128 (CellType==miINT8 || CellType==miINT16 || CellType==miINT32 || CellType==miINT64))
1129 FixSignedValues(image,q,MATLAB_HDR.SizeX);
1130 }
1131
1132 if (!SyncAuthenticPixels(image,exception))
1133 {
1134 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1135 " MAT failed to sync image pixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1136 goto ExitLoop;
1137 }
1138 }
1139 } while(z-- >= 2);
1140 quantum_info=DestroyQuantumInfo(quantum_info);
1141 ExitLoop:
1142
1143
1144 /* Read complex part of numbers here */
1145 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1146 { /* Find Min and Max Values for complex parts of floats */
1147 CellType = ReadBlobXXXLong(image2); /* Additional object type */
1148 i = ReadBlobXXXLong(image2); /* size of a complex part - toss away*/
1149
1150 if (CellType==miDOUBLE || CellType==miSINGLE)
1151 {
1152 CalcMinMax(image2, image_info->endian, MATLAB_HDR.SizeX, MATLAB_HDR.SizeY, CellType, ldblk, BImgBuff, &MinVal, &MaxVal);
1153 }
1154
1155 if (CellType==miDOUBLE)
1156 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1157 {
1158 ReadBlobDoublesXXX(image2, ldblk, (double *)BImgBuff);
1159 InsertComplexDoubleRow(image, (double *)BImgBuff, i, MinVal, MaxVal,
1160 exception);
1161 }
1162
1163 if (CellType==miSINGLE)
1164 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1165 {
1166 ReadBlobFloatsXXX(image2, ldblk, (float *)BImgBuff);
1167 InsertComplexFloatRow(image,(float *)BImgBuff,i,MinVal,MaxVal,
1168 exception);
1169 }
1170 }
1171
1172 /* Image is gray when no complex flag is set and 2D Matrix AGAIN!!! */
1173 if ((MATLAB_HDR.DimFlag == 8) &&
1174 ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1175 image->type=GrayscaleType;
1176 if (image->depth == 1)
1177 image->type=BilevelType;
1178
1179 if(image2==image)
1180 image2 = NULL; /* Remove shadow copy to an image before rotation. */
1181
1182 /* Rotate image. */
1183 rotated_image = RotateImage(image, 90.0, exception);
1184 if (rotated_image != (Image *) NULL)
1185 {
1186 /* Remove page offsets added by RotateImage */
1187 rotated_image->page.x=0;
1188 rotated_image->page.y=0;
1189
1190 blob = rotated_image->blob;
1191 rotated_image->blob = image->blob;
1192 rotated_image->colors = image->colors;
1193 image->blob = blob;
1194 AppendImageToList(&image,rotated_image);
1195 DeleteImageFromList(&image);
1196 }
1197
1198 done_reading:
1199
1200 if(image2!=NULL)
1201 if(image2!=image)
1202 {
1203 DeleteImageFromList(&image2);
1204 if(clone_info)
1205 {
1206 if(clone_info->file)
1207 {
1208 fclose(clone_info->file);
1209 clone_info->file = NULL;
1210 (void) remove_utf8(clone_info->filename);
1211 }
1212 }
1213 }
1214
1215 /* Allocate next image structure. */
1216 AcquireNextImage(image_info,image,exception);
1217 if (image->next == (Image *) NULL) break;
1218 image=SyncNextImageInList(image);
1219 image->columns=image->rows=0;
1220 image->colors=0;
1221
1222 /* row scan buffer is no longer needed */
1223 RelinquishMagickMemory(BImgBuff);
1224 BImgBuff = NULL;
1225
1226 if(--Frames>0)
1227 {
1228 z = z2;
1229 if(image2==NULL) image2 = image;
1230 goto NEXT_FRAME;
1231 }
1232 if ((image2!=NULL) && (image2!=image)) /* Does shadow temporary decompressed image exist? */
1233 {
1234 /* CloseBlob(image2); */
1235 DeleteImageFromList(&image2);
1236 if(clone_info)
1237 {
1238 if(clone_info->file)
1239 {
1240 fclose(clone_info->file);
1241 clone_info->file = NULL;
1242 (void) remove_utf8(clone_info->filename);
1243 }
1244 }
1245 }
1246 }
1247
1248 RelinquishMagickMemory(BImgBuff);
1249 END_OF_READING:
1250 clone_info=DestroyImageInfo(clone_info);
1251 CloseBlob(image);
1252
1253
1254 {
1255 Image *p;
1256 ssize_t scene=0;
1257
1258 /*
1259 Rewind list, removing any empty images while rewinding.
1260 */
1261 p=image;
1262 image=NULL;
1263 while (p != (Image *) NULL)
1264 {
1265 Image *tmp=p;
1266 if ((p->rows == 0) || (p->columns == 0)) {
1267 p=p->previous;
1268 DeleteImageFromList(&tmp);
1269 } else {
1270 image=p;
1271 p=p->previous;
1272 }
1273 }
1274
1275 /*
1276 Fix scene numbers
1277 */
1278 for (p=image; p != (Image *) NULL; p=p->next)
1279 p->scene=scene++;
1280 }
1281
1282 if(clone_info != NULL) /* cleanup garbage file from compression */
1283 {
1284 if(clone_info->file)
1285 {
1286 fclose(clone_info->file);
1287 clone_info->file = NULL;
1288 (void) remove_utf8(clone_info->filename);
1289 }
1290 DestroyImageInfo(clone_info);
1291 clone_info = NULL;
1292 }
1293 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),"return");
1294 if(image==NULL)
1295 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
1296 return (image);
1297 }
1298
1299 /*
1300 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1301 % %
1302 % %
1303 % %
1304 % R e g i s t e r M A T I m a g e %
1305 % %
1306 % %
1307 % %
1308 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1309 %
1310 % Method RegisterMATImage adds attributes for the MAT image format to
1311 % the list of supported formats. The attributes include the image format
1312 % tag, a method to read and/or write the format, whether the format
1313 % supports the saving of more than one frame to the same file or blob,
1314 % whether the format supports native in-memory I/O, and a brief
1315 % description of the format.
1316 %
1317 % The format of the RegisterMATImage method is:
1318 %
1319 % size_t RegisterMATImage(void)
1320 %
1321 */
RegisterMATImage(void)1322 ModuleExport size_t RegisterMATImage(void)
1323 {
1324 MagickInfo
1325 *entry;
1326
1327 entry=AcquireMagickInfo("MAT","MAT","MATLAB level 5 image format");
1328 entry->decoder=(DecodeImageHandler *) ReadMATImage;
1329 entry->encoder=(EncodeImageHandler *) WriteMATImage;
1330 entry->flags^=CoderBlobSupportFlag;
1331 entry->flags|=CoderSeekableStreamFlag;
1332 (void) RegisterMagickInfo(entry);
1333 return(MagickImageCoderSignature);
1334 }
1335
1336 /*
1337 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1338 % %
1339 % %
1340 % %
1341 % U n r e g i s t e r M A T I m a g e %
1342 % %
1343 % %
1344 % %
1345 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1346 %
1347 % Method UnregisterMATImage removes format registrations made by the
1348 % MAT module from the list of supported formats.
1349 %
1350 % The format of the UnregisterMATImage method is:
1351 %
1352 % UnregisterMATImage(void)
1353 %
1354 */
UnregisterMATImage(void)1355 ModuleExport void UnregisterMATImage(void)
1356 {
1357 (void) UnregisterMagickInfo("MAT");
1358 }
1359
1360 /*
1361 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1362 % %
1363 % %
1364 % %
1365 % W r i t e M A T L A B I m a g e %
1366 % %
1367 % %
1368 % %
1369 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1370 %
1371 % Function WriteMATImage writes an Matlab matrix to a file.
1372 %
1373 % The format of the WriteMATImage method is:
1374 %
1375 % MagickBooleanType WriteMATImage(const ImageInfo *image_info,
1376 % Image *image,ExceptionInfo *exception)
1377 %
1378 % A description of each parameter follows.
1379 %
1380 % o image_info: Specifies a pointer to a ImageInfo structure.
1381 %
1382 % o image: A pointer to an Image structure.
1383 %
1384 % o exception: return any errors or warnings in this structure.
1385 %
1386 */
WriteMATImage(const ImageInfo * image_info,Image * image,ExceptionInfo * exception)1387 static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
1388 ExceptionInfo *exception)
1389 {
1390 ssize_t y;
1391 unsigned z;
1392 register const Quantum *p;
1393
1394 unsigned int status;
1395 int logging;
1396 size_t DataSize;
1397 char padding;
1398 char MATLAB_HDR[0x80];
1399 time_t current_time;
1400 struct tm local_time;
1401 unsigned char *pixels;
1402 int is_gray;
1403
1404 MagickOffsetType
1405 scene;
1406
1407 QuantumInfo
1408 *quantum_info;
1409
1410 /*
1411 Open output image file.
1412 */
1413 assert(image_info != (const ImageInfo *) NULL);
1414 assert(image_info->signature == MagickCoreSignature);
1415 assert(image != (Image *) NULL);
1416 assert(image->signature == MagickCoreSignature);
1417 logging=LogMagickEvent(CoderEvent,GetMagickModule(),"enter MAT");
1418 (void) logging;
1419 assert(exception != (ExceptionInfo *) NULL);
1420 assert(exception->signature == MagickCoreSignature);
1421 status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1422 if (status == MagickFalse)
1423 return(MagickFalse);
1424 image->depth=8;
1425
1426 current_time=time((time_t *) NULL);
1427 #if defined(MAGICKCORE_HAVE_LOCALTIME_R)
1428 (void) localtime_r(¤t_time,&local_time);
1429 #else
1430 (void) memcpy(&local_time,localtime(¤t_time),sizeof(local_time));
1431 #endif
1432 (void) memset(MATLAB_HDR,' ',MagickMin(sizeof(MATLAB_HDR),124));
1433 FormatLocaleString(MATLAB_HDR,sizeof(MATLAB_HDR),
1434 "MATLAB 5.0 MAT-file, Platform: %s, Created on: %s %s %2d %2d:%2d:%2d %d",
1435 OsDesc,DayOfWTab[local_time.tm_wday],MonthsTab[local_time.tm_mon],
1436 local_time.tm_mday,local_time.tm_hour,local_time.tm_min,
1437 local_time.tm_sec,local_time.tm_year+1900);
1438 MATLAB_HDR[0x7C]=0;
1439 MATLAB_HDR[0x7D]=1;
1440 MATLAB_HDR[0x7E]='I';
1441 MATLAB_HDR[0x7F]='M';
1442 (void) WriteBlob(image,sizeof(MATLAB_HDR),(unsigned char *) MATLAB_HDR);
1443 scene=0;
1444 do
1445 {
1446 (void) TransformImageColorspace(image,sRGBColorspace,exception);
1447 is_gray = SetImageGray(image,exception);
1448 z = is_gray ? 0 : 3;
1449
1450 /*
1451 Store MAT header.
1452 */
1453 DataSize = image->rows /*Y*/ * image->columns /*X*/;
1454 if(!is_gray) DataSize *= 3 /*Z*/;
1455 padding=((unsigned char)(DataSize-1) & 0x7) ^ 0x7;
1456
1457 (void) WriteBlobLSBLong(image, miMATRIX);
1458 (void) WriteBlobLSBLong(image, (unsigned int) DataSize+padding+(is_gray ? 48 : 56));
1459 (void) WriteBlobLSBLong(image, 0x6); /* 0x88 */
1460 (void) WriteBlobLSBLong(image, 0x8); /* 0x8C */
1461 (void) WriteBlobLSBLong(image, 0x6); /* 0x90 */
1462 (void) WriteBlobLSBLong(image, 0);
1463 (void) WriteBlobLSBLong(image, 0x5); /* 0x98 */
1464 (void) WriteBlobLSBLong(image, is_gray ? 0x8 : 0xC); /* 0x9C - DimFlag */
1465 (void) WriteBlobLSBLong(image, (unsigned int) image->rows); /* x: 0xA0 */
1466 (void) WriteBlobLSBLong(image, (unsigned int) image->columns); /* y: 0xA4 */
1467 if(!is_gray)
1468 {
1469 (void) WriteBlobLSBLong(image, 3); /* z: 0xA8 */
1470 (void) WriteBlobLSBLong(image, 0);
1471 }
1472 (void) WriteBlobLSBShort(image, 1); /* 0xB0 */
1473 (void) WriteBlobLSBShort(image, 1); /* 0xB2 */
1474 (void) WriteBlobLSBLong(image, 'M'); /* 0xB4 */
1475 (void) WriteBlobLSBLong(image, 0x2); /* 0xB8 */
1476 (void) WriteBlobLSBLong(image, (unsigned int) DataSize); /* 0xBC */
1477
1478 /*
1479 Store image data.
1480 */
1481 quantum_info=AcquireQuantumInfo(image_info,image);
1482 if (quantum_info == (QuantumInfo *) NULL)
1483 ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1484 pixels=(unsigned char *) GetQuantumPixels(quantum_info);
1485 do
1486 {
1487 for (y=0; y < (ssize_t)image->columns; y++)
1488 {
1489 p=GetVirtualPixels(image,y,0,1,image->rows,exception);
1490 if (p == (const Quantum *) NULL)
1491 break;
1492 (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1493 z2qtype[z],pixels,exception);
1494 (void) WriteBlob(image,image->rows,pixels);
1495 }
1496 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1497 break;
1498 } while(z-- >= 2);
1499 while(padding-->0) (void) WriteBlobByte(image,0);
1500 quantum_info=DestroyQuantumInfo(quantum_info);
1501 if (GetNextImageInList(image) == (Image *) NULL)
1502 break;
1503 image=SyncNextImageInList(image);
1504 status=SetImageProgress(image,SaveImagesTag,scene++,
1505 GetImageListLength(image));
1506 if (status == MagickFalse)
1507 break;
1508 } while (image_info->adjoin != MagickFalse);
1509 (void) CloseBlob(image);
1510 return(MagickTrue);
1511 }
1512