2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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 %
12 % Read MATLAB Image Format %
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: %
26 % The above copyright notice and this permission notice shall be included in %
27 % all copies or substantial portions of ImageMagick. %
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 %
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. %
42 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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)
86 static MagickBooleanType
87 WriteMATImage(const ImageInfo *,Image *,ExceptionInfo *);
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
99 unsigned short Version;
100 char EndianIndicator[2];
101 unsigned int DataType;
102 unsigned int ObjectSize;
103 unsigned int unknown1;
104 unsigned int unknown2;
106 unsigned short unknown5;
107 unsigned char StructureFlag;
108 unsigned char StructureClass;
109 unsigned int unknown3;
110 unsigned int unknown4;
111 unsigned int DimFlag;
115 unsigned short Flag1;
116 unsigned short NameFlag;
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)
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 */
143 miDOUBLE, /* IEEE 754 double precision float */
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 */
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 */
175 #define FLAG_COMPLEX 0x8
176 #define FLAG_GLOBAL 0x4
177 #define FLAG_LOGICAL 0x2
179 static const QuantumType z2qtype[4] = {GrayQuantum, BlueQuantum, GreenQuantum, RedQuantum};
182 static void InsertComplexDoubleRow(Image *image,double *p,int y,double MinVal,
183 double MaxVal,ExceptionInfo *exception)
195 q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
196 if (q == (Quantum *) NULL)
198 for (x = 0; x < (ssize_t) image->columns; x++)
202 f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
203 if (f + GetPixelRed(image,q) > QuantumRange)
204 SetPixelRed(image,QuantumRange,q);
206 SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
207 if ((int) f / 2.0 > GetPixelGreen(image,q))
209 SetPixelGreen(image,0,q);
210 SetPixelBlue(image,0,q);
214 SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
215 SetPixelGreen(image,GetPixelBlue(image,q),q);
220 f = (*p / MinVal) * (QuantumRange-GetPixelBlue(image,q));
221 if (f+GetPixelBlue(image,q) > QuantumRange)
222 SetPixelBlue(image,QuantumRange,q);
224 SetPixelBlue(image,GetPixelBlue(image,q)+(int) f,q);
225 if ((int) f / 2.0 > GetPixelGreen(image,q))
227 SetPixelRed(image,0,q);
228 SetPixelGreen(image,0,q);
232 SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
233 SetPixelGreen(image,GetPixelRed(image,q),q);
237 q+=GetPixelChannels(image);
239 if (!SyncAuthenticPixels(image,exception))
245 static void InsertComplexFloatRow(Image *image,float *p,int y,double MinVal,
246 double MaxVal,ExceptionInfo *exception)
257 q = QueueAuthenticPixels(image, 0, y, image->columns, 1,exception);
258 if (q == (Quantum *) NULL)
260 for (x = 0; x < (ssize_t) image->columns; x++)
264 f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
265 if (f+GetPixelRed(image,q) > QuantumRange)
266 SetPixelRed(image,QuantumRange,q);
268 SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
269 if ((int) f / 2.0 > GetPixelGreen(image,q))
271 SetPixelGreen(image,0,q);
272 SetPixelBlue(image,0,q);
276 SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
277 SetPixelGreen(image,GetPixelBlue(image,q),q);
282 f = (*p / MaxVal) * (QuantumRange - GetPixelBlue(image,q));
283 if (f + GetPixelBlue(image,q) > QuantumRange)
284 SetPixelBlue(image,QuantumRange,q);
286 SetPixelBlue(image,GetPixelBlue(image,q)+
288 if ((int) f / 2.0 > GetPixelGreen(image,q))
290 SetPixelGreen(image,0,q);
291 SetPixelRed(image,0,q);
295 SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
296 SetPixelGreen(image,GetPixelRed(image,q),q);
302 if (!SyncAuthenticPixels(image,exception))
308 /************** READERS ******************/
310 /* This function reads one block of floats*/
311 static void ReadBlobFloatsLSB(Image * image, size_t len, float *data)
315 *data++ = ReadBlobFloat(image);
316 len -= sizeof(float);
319 (void) SeekBlob(image, len, SEEK_CUR);
322 static void ReadBlobFloatsMSB(Image * image, size_t len, float *data)
326 *data++ = ReadBlobFloat(image);
327 len -= sizeof(float);
330 (void) SeekBlob(image, len, SEEK_CUR);
333 /* This function reads one block of doubles*/
334 static void ReadBlobDoublesLSB(Image * image, size_t len, double *data)
338 *data++ = ReadBlobDouble(image);
339 len -= sizeof(double);
342 (void) SeekBlob(image, len, SEEK_CUR);
345 static void ReadBlobDoublesMSB(Image * image, size_t len, double *data)
349 *data++ = ReadBlobDouble(image);
350 len -= sizeof(double);
353 (void) SeekBlob(image, len, SEEK_CUR);
356 /* Calculate minimum and maximum from a given block of data */
357 static void CalcMinMax(Image *image, int endian_indicator, int SizeX, int SizeY, size_t CellType, unsigned ldblk, void *BImgBuff, double *Min, double *Max)
359 MagickOffsetType filepos;
361 void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
362 void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
366 if (endian_indicator == LSBEndian)
368 ReadBlobDoublesXXX = ReadBlobDoublesLSB;
369 ReadBlobFloatsXXX = ReadBlobFloatsLSB;
373 ReadBlobDoublesXXX = ReadBlobDoublesMSB;
374 ReadBlobFloatsXXX = ReadBlobFloatsMSB;
377 filepos = TellBlob(image); /* Please note that file seeking occurs only in the case of doubles */
378 for (i = 0; i < SizeY; i++)
380 if (CellType==miDOUBLE)
382 ReadBlobDoublesXXX(image, ldblk, (double *)BImgBuff);
383 dblrow = (double *)BImgBuff;
386 *Min = *Max = *dblrow;
388 for (x = 0; x < SizeX; x++)
397 if (CellType==miSINGLE)
399 ReadBlobFloatsXXX(image, ldblk, (float *)BImgBuff);
400 fltrow = (float *)BImgBuff;
403 *Min = *Max = *fltrow;
405 for (x = 0; x < (ssize_t) SizeX; x++)
415 (void) SeekBlob(image, filepos, SEEK_SET);
419 static void FixSignedValues(const Image *image,Quantum *q, int y)
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);
434 /** Fix whole row of logical/binary data. It means pack it. */
435 static void FixLogical(unsigned char *Buff,int ldblk)
437 unsigned char mask=128;
438 unsigned char *BuffL = Buff;
439 unsigned char val = 0;
458 #if defined(MAGICKCORE_ZLIB_DELEGATE)
459 static voidpf AcquireZIPMemory(voidpf context,unsigned int items,
463 return((voidpf) AcquireQuantumMemory(items,size));
466 static void RelinquishZIPMemory(voidpf context,voidpf memory)
469 memory=RelinquishMagickMemory(memory);
473 #if defined(MAGICKCORE_ZLIB_DELEGATE)
474 /** This procedure decompreses an image block for a new MATLAB format. */
475 static Image *decompress_block(Image *orig, unsigned int *Size, ImageInfo *clone_info, ExceptionInfo *exception)
479 void *cache_block, *decompress_block;
488 ssize_t TotalSize = 0;
490 if(clone_info==NULL) return NULL;
491 if(clone_info->file) /* Close file opened from previous transaction. */
493 fclose(clone_info->file);
494 clone_info->file = NULL;
495 (void) remove_utf8(clone_info->filename);
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)
503 RelinquishMagickMemory(cache_block);
508 file = AcquireUniqueFileResource(clone_info->filename);
510 mat_file = fdopen(file,"w");
513 RelinquishMagickMemory(cache_block);
514 RelinquishMagickMemory(decompress_block);
515 (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Cannot create file stream for decompressed image");
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)
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);
533 /* zip_info.next_out = 8*4;*/
535 zip_info.avail_in = 0;
536 zip_info.total_out = 0;
537 while(*Size>0 && !EOFBlob(orig))
539 magick_size = ReadBlob(orig, (*Size < 16384) ? *Size : 16384, (unsigned char *) cache_block);
540 if (magick_size == 0)
542 zip_info.next_in = (Bytef *) cache_block;
543 zip_info.avail_in = (uInt) magick_size;
545 while(zip_info.avail_in>0)
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))
552 extent=fwrite(decompress_block, 4096-zip_info.avail_out, 1, mat_file);
554 TotalSize += 4096-zip_info.avail_out;
556 if(zip_status == Z_STREAM_END) goto DblBreak;
558 if ((zip_status != Z_OK) && (zip_status != Z_STREAM_END))
561 *Size -= (unsigned int) magick_size;
565 inflateEnd(&zip_info);
566 (void)fclose(mat_file);
567 RelinquishMagickMemory(cache_block);
568 RelinquishMagickMemory(decompress_block);
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)
576 DeleteImageFromList(&image2);
578 fclose(clone_info->file);
579 clone_info->file = NULL;
581 RelinquishUniqueFileResource(clone_info->filename);
589 static Image *ReadMATImageV4(const ImageInfo *image_info,Image *image,
590 ExceptionInfo *exception)
593 unsigned char Type[4];
597 unsigned int nameLen;
635 quantum_info=(QuantumInfo *) NULL;
636 (void) SeekBlob(image,0,SEEK_SET);
637 while (EOFBlob(image) == MagickFalse)
642 ldblk=ReadBlobLSBLong(image);
643 if ((ldblk > 9999) || (ldblk < 0))
645 HDR.Type[3]=ldblk % 10; ldblk /= 10; /* T digit */
646 HDR.Type[2]=ldblk % 10; ldblk /= 10; /* P digit */
647 HDR.Type[1]=ldblk % 10; ldblk /= 10; /* O digit */
648 HDR.Type[0]=ldblk; /* M digit */
649 if (HDR.Type[3] != 0)
650 break; /* Data format */
651 if (HDR.Type[2] != 0)
652 break; /* Always 0 */
653 if (HDR.Type[0] == 0)
655 HDR.nRows=ReadBlobLSBLong(image);
656 HDR.nCols=ReadBlobLSBLong(image);
657 HDR.imagf=ReadBlobLSBLong(image);
658 HDR.nameLen=ReadBlobLSBLong(image);
663 HDR.nRows=ReadBlobMSBLong(image);
664 HDR.nCols=ReadBlobMSBLong(image);
665 HDR.imagf=ReadBlobMSBLong(image);
666 HDR.nameLen=ReadBlobMSBLong(image);
669 if ((HDR.imagf != 0) && (HDR.imagf != 1))
671 if (HDR.nameLen > 0xFFFF)
672 return(DestroyImageList(image));
673 for (i=0; i < (ssize_t) HDR.nameLen; i++)
681 byte=ReadBlobByte(image);
684 ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
689 image->columns=(size_t) HDR.nRows;
690 image->rows=(size_t) HDR.nCols;
691 if ((image->columns == 0) || (image->rows == 0))
692 return(DestroyImageList(image));
693 if (image_info->ping != MagickFalse)
695 Swap(image->columns,image->rows);
696 if(HDR.imagf==1) ldblk *= 2;
697 SeekBlob(image, HDR.nCols*ldblk, SEEK_CUR);
698 if ((image->columns == 0) || (image->rows == 0))
699 return(image->previous == (Image *) NULL ? DestroyImageList(image)
701 goto skip_reading_current;
703 status=SetImageExtent(image,image->columns,image->rows,exception);
704 if (status == MagickFalse)
705 return(DestroyImageList(image));
706 (void) SetImageBackgroundColor(image,exception);
707 (void) SetImageColorspace(image,GRAYColorspace,exception);
708 quantum_info=AcquireQuantumInfo(image_info,image);
709 if (quantum_info == (QuantumInfo *) NULL)
710 return(DestroyImageList(image));
714 format_type=FloatingPointQuantumFormat;
718 format_type=FloatingPointQuantumFormat;
722 format_type=UnsignedQuantumFormat;
726 format_type=SignedQuantumFormat;
730 format_type=UnsignedQuantumFormat;
734 format_type=UnsignedQuantumFormat;
739 if (HDR.Type[0] != 0)
740 SetQuantumEndian(image,quantum_info,MSBEndian);
741 status=SetQuantumFormat(image,quantum_info,format_type);
742 status=SetQuantumDepth(image,quantum_info,depth);
743 status=SetQuantumEndian(image,quantum_info,endian);
744 SetQuantumScale(quantum_info,1.0);
745 pixels=(unsigned char *) GetQuantumPixels(quantum_info);
746 for (y=0; y < (ssize_t) image->rows; y++)
751 count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
754 q=QueueAuthenticPixels(image,0,image->rows-y-1,image->columns,1,
756 if (q == (Quantum *) NULL)
758 (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
759 GrayQuantum,pixels,exception);
760 if ((HDR.Type[1] == 2) || (HDR.Type[1] == 3))
761 FixSignedValues(image,q,(int) image->columns);
762 if (SyncAuthenticPixels(image,exception) == MagickFalse)
764 if (image->previous == (Image *) NULL)
766 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
768 if (status == MagickFalse)
773 for (y=0; y < (ssize_t) image->rows; y++)
778 count=ReadBlob(image,depth/8*image->columns,(char *) pixels);
781 if (HDR.Type[1] == 0)
782 InsertComplexDoubleRow(image,(double *) pixels,y,0,0,exception);
784 InsertComplexFloatRow(image,(float *) pixels,y,0,0,exception);
786 if (quantum_info != (QuantumInfo *) NULL)
787 quantum_info=DestroyQuantumInfo(quantum_info);
788 if (EOFBlob(image) != MagickFalse)
790 ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
794 rotated_image=RotateImage(image,90.0,exception);
795 if (rotated_image != (Image *) NULL)
797 rotated_image->page.x=0;
798 rotated_image->page.y=0;
799 rotated_image->colors = image->colors;
800 DestroyBlob(rotated_image);
801 rotated_image->blob=ReferenceBlob(image->blob);
802 AppendImageToList(&image,rotated_image);
803 DeleteImageFromList(&image);
806 Proceed to next image.
808 if (image_info->number_scenes != 0)
809 if (image->scene >= (image_info->scene+image_info->number_scenes-1))
812 Allocate next image structure.
814 skip_reading_current:
815 AcquireNextImage(image_info,image,exception);
816 if (GetNextImageInList(image) == (Image *) NULL)
817 return(DestroyImageList(image));
818 image=SyncNextImageInList(image);
819 status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
821 if (status == MagickFalse)
824 (void) CloseBlob(image);
825 return(GetFirstImageInList(image));
829 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
833 % R e a d M A T L A B i m a g e %
837 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
839 % ReadMATImage() reads an MAT X image file and returns it. It
840 % allocates the memory necessary for the new Image structure and returns a
841 % pointer to the new image.
843 % The format of the ReadMATImage method is:
845 % Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
847 % A description of each parameter follows:
849 % o image: Method ReadMATImage returns a pointer to the image after
850 % reading. A null image is returned if there is a memory shortage or if
851 % the image cannot be read.
853 % o image_info: Specifies a pointer to a ImageInfo structure.
855 % o exception: return any errors or warnings in this structure.
858 static Image *ReadMATImage(const ImageInfo *image_info,ExceptionInfo *exception)
860 Image *image, *image2=NULL,
865 MATHeader MATLAB_HDR;
868 QuantumInfo *quantum_info;
869 ImageInfo *clone_info;
872 unsigned char *BImgBuff = NULL;
873 double MinVal, MaxVal;
878 MagickOffsetType filepos=0x80;
880 unsigned int (*ReadBlobXXXLong)(Image *image);
881 unsigned short (*ReadBlobXXXShort)(Image *image);
882 void (*ReadBlobDoublesXXX)(Image * image, size_t len, double *data);
883 void (*ReadBlobFloatsXXX)(Image * image, size_t len, float *data);
886 assert(image_info != (const ImageInfo *) NULL);
887 assert(image_info->signature == MagickCoreSignature);
888 assert(exception != (ExceptionInfo *) NULL);
889 assert(exception->signature == MagickCoreSignature);
890 logging = LogMagickEvent(CoderEvent,GetMagickModule(),"enter");
895 image = AcquireImage(image_info,exception);
896 image2 = (Image *) NULL;
898 status = OpenBlob(image_info, image, ReadBinaryBlobMode, exception);
899 if (status == MagickFalse)
901 image=DestroyImageList(image);
902 return((Image *) NULL);
907 quantum_info=(QuantumInfo *) NULL;
908 clone_info=(ImageInfo *) NULL;
909 if (ReadBlob(image,124,(unsigned char *) &MATLAB_HDR.identific) != 124)
910 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
911 if (strncmp(MATLAB_HDR.identific,"MATLAB",6) != 0)
913 image=ReadMATImageV4(image_info,image,exception);
916 if ((image != image2) && (image2 != (Image *) NULL))
917 image2=DestroyImage(image2);
918 if (clone_info != (ImageInfo *) NULL)
919 clone_info=DestroyImageInfo(clone_info);
920 return((Image *) NULL);
924 MATLAB_HDR.Version = ReadBlobLSBShort(image);
925 if(ReadBlob(image,2,(unsigned char *) &MATLAB_HDR.EndianIndicator) != 2)
926 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
929 (void) LogMagickEvent(CoderEvent,GetMagickModule()," Endian %c%c",
930 MATLAB_HDR.EndianIndicator[0],MATLAB_HDR.EndianIndicator[1]);
931 if (!strncmp(MATLAB_HDR.EndianIndicator, "IM", 2))
933 ReadBlobXXXLong = ReadBlobLSBLong;
934 ReadBlobXXXShort = ReadBlobLSBShort;
935 ReadBlobDoublesXXX = ReadBlobDoublesLSB;
936 ReadBlobFloatsXXX = ReadBlobFloatsLSB;
937 image->endian = LSBEndian;
939 else if (!strncmp(MATLAB_HDR.EndianIndicator, "MI", 2))
941 ReadBlobXXXLong = ReadBlobMSBLong;
942 ReadBlobXXXShort = ReadBlobMSBShort;
943 ReadBlobDoublesXXX = ReadBlobDoublesMSB;
944 ReadBlobFloatsXXX = ReadBlobFloatsMSB;
945 image->endian = MSBEndian;
950 if ((image != image2) && (image2 != (Image *) NULL))
951 image2=DestroyImage(image2);
952 if (clone_info != (ImageInfo *) NULL)
953 clone_info=DestroyImageInfo(clone_info);
954 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
957 filepos = TellBlob(image);
958 while(!EOFBlob(image)) /* object parser loop */
961 if (filepos != (unsigned int) filepos)
963 if(SeekBlob(image,filepos,SEEK_SET) != filepos) break;
964 /* printf("pos=%X\n",TellBlob(image)); */
966 MATLAB_HDR.DataType = ReadBlobXXXLong(image);
967 if(EOFBlob(image)) break;
968 MATLAB_HDR.ObjectSize = ReadBlobXXXLong(image);
969 if(EOFBlob(image)) break;
970 if((MagickSizeType) (MATLAB_HDR.ObjectSize+filepos) > GetBlobSize(image))
972 filepos += (MagickOffsetType) MATLAB_HDR.ObjectSize + 4 + 4;
974 if (clone_info != (ImageInfo *) NULL)
975 clone_info=DestroyImageInfo(clone_info);
976 clone_info=CloneImageInfo(image_info);
977 if ((image != image2) && (image2 != (Image *) NULL))
978 image2=DestroyImage(image2);
980 #if defined(MAGICKCORE_ZLIB_DELEGATE)
981 if(MATLAB_HDR.DataType == miCOMPRESSED)
983 image2 = decompress_block(image,&MATLAB_HDR.ObjectSize,clone_info,exception);
984 if(image2==NULL) continue;
985 MATLAB_HDR.DataType = ReadBlobXXXLong(image2); /* replace compressed object type. */
989 if (MATLAB_HDR.DataType != miMATRIX)
991 clone_info=DestroyImageInfo(clone_info);
992 #if defined(MAGICKCORE_ZLIB_DELEGATE)
994 DeleteImageFromList(&image2);
996 continue; /* skip another objects. */
999 MATLAB_HDR.unknown1 = ReadBlobXXXLong(image2);
1000 MATLAB_HDR.unknown2 = ReadBlobXXXLong(image2);
1002 MATLAB_HDR.unknown5 = ReadBlobXXXLong(image2);
1003 MATLAB_HDR.StructureClass = MATLAB_HDR.unknown5 & 0xFF;
1004 MATLAB_HDR.StructureFlag = (MATLAB_HDR.unknown5>>8) & 0xFF;
1006 MATLAB_HDR.unknown3 = ReadBlobXXXLong(image2);
1008 MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2); /* ??? don't understand why ?? */
1009 MATLAB_HDR.unknown4 = ReadBlobXXXLong(image2);
1010 MATLAB_HDR.DimFlag = ReadBlobXXXLong(image2);
1011 MATLAB_HDR.SizeX = ReadBlobXXXLong(image2);
1012 MATLAB_HDR.SizeY = ReadBlobXXXLong(image2);
1015 switch(MATLAB_HDR.DimFlag)
1017 case 8: z2=z=1; break; /* 2D matrix*/
1018 case 12: z2=z = ReadBlobXXXLong(image2); /* 3D matrix RGB*/
1019 (void) ReadBlobXXXLong(image2);
1022 if (clone_info != (ImageInfo *) NULL)
1023 clone_info=DestroyImageInfo(clone_info);
1024 if ((image != image2) && (image2 != (Image *) NULL))
1025 image2=DestroyImage(image2);
1026 ThrowReaderException(CoderError,
1027 "MultidimensionalMatricesAreNotSupported");
1030 case 16: z2=z = ReadBlobXXXLong(image2); /* 4D matrix animation */
1033 if (clone_info != (ImageInfo *) NULL)
1034 clone_info=DestroyImageInfo(clone_info);
1035 if ((image != image2) && (image2 != (Image *) NULL))
1036 image2=DestroyImage(image2);
1037 ThrowReaderException(CoderError,
1038 "MultidimensionalMatricesAreNotSupported");
1040 Frames = ReadBlobXXXLong(image2);
1043 if (clone_info != (ImageInfo *) NULL)
1044 clone_info=DestroyImageInfo(clone_info);
1045 if ((image != image2) && (image2 != (Image *) NULL))
1046 image2=DestroyImage(image2);
1047 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
1049 if (AcquireMagickResource(ListLengthResource,Frames) == MagickFalse)
1051 if (clone_info != (ImageInfo *) NULL)
1052 clone_info=DestroyImageInfo(clone_info);
1053 if ((image != image2) && (image2 != (Image *) NULL))
1054 image2=DestroyImage(image2);
1055 ThrowReaderException(ResourceLimitError,"ListLengthExceedsLimit");
1059 if (clone_info != (ImageInfo *) NULL)
1060 clone_info=DestroyImageInfo(clone_info);
1061 if ((image != image2) && (image2 != (Image *) NULL))
1062 image2=DestroyImage(image2);
1063 ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
1066 MATLAB_HDR.Flag1 = ReadBlobXXXShort(image2);
1067 MATLAB_HDR.NameFlag = ReadBlobXXXShort(image2);
1069 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1070 "MATLAB_HDR.StructureClass %d",MATLAB_HDR.StructureClass);
1071 if (MATLAB_HDR.StructureClass != mxCHAR_CLASS &&
1072 MATLAB_HDR.StructureClass != mxSINGLE_CLASS && /* float + complex float */
1073 MATLAB_HDR.StructureClass != mxDOUBLE_CLASS && /* double + complex double */
1074 MATLAB_HDR.StructureClass != mxINT8_CLASS &&
1075 MATLAB_HDR.StructureClass != mxUINT8_CLASS && /* uint8 + uint8 3D */
1076 MATLAB_HDR.StructureClass != mxINT16_CLASS &&
1077 MATLAB_HDR.StructureClass != mxUINT16_CLASS && /* uint16 + uint16 3D */
1078 MATLAB_HDR.StructureClass != mxINT32_CLASS &&
1079 MATLAB_HDR.StructureClass != mxUINT32_CLASS && /* uint32 + uint32 3D */
1080 MATLAB_HDR.StructureClass != mxINT64_CLASS &&
1081 MATLAB_HDR.StructureClass != mxUINT64_CLASS) /* uint64 + uint64 3D */
1083 if (image2 != (Image*) NULL)
1086 DeleteImageFromList(&image2);
1088 if (clone_info != (ImageInfo *) NULL)
1089 clone_info=DestroyImageInfo(clone_info);
1090 ThrowReaderException(CoderError,"UnsupportedCellTypeInTheMatrix");
1093 switch (MATLAB_HDR.NameFlag)
1096 size = ReadBlobXXXLong(image2); /* Object name string size */
1097 size = 4 * (((size_t) size + 3 + 1) / 4);
1098 (void) SeekBlob(image2, size, SEEK_CUR);
1104 (void) ReadBlob(image2, 4, (unsigned char *) &size); /* Object name string */
1110 CellType = ReadBlobXXXLong(image2); /* Additional object type */
1112 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
1113 "MATLAB_HDR.CellType: %.20g",(double) CellType);
1115 (void) ReadBlob(image2, 4, (unsigned char *) &size); /* data size */
1123 if(MATLAB_HDR.StructureFlag & FLAG_LOGICAL)
1126 image->depth = 8; /* Byte type cell */
1127 ldblk = (ssize_t) MATLAB_HDR.SizeX;
1132 image->depth = 16; /* Word type cell */
1133 ldblk = (ssize_t) (2 * MATLAB_HDR.SizeX);
1138 image->depth = 32; /* Dword type cell */
1139 ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1144 image->depth = 64; /* Qword type cell */
1145 ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1149 image->depth = 32; /* double type cell */
1150 (void) SetImageOption(clone_info,"quantum:format","floating-point");
1151 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1152 { /* complex float type cell */
1154 ldblk = (ssize_t) (4 * MATLAB_HDR.SizeX);
1158 image->depth = 64; /* double type cell */
1159 (void) SetImageOption(clone_info,"quantum:format","floating-point");
1160 DisableMSCWarning(4127)
1161 if (sizeof(double) != 8)
1164 if (clone_info != (ImageInfo *) NULL)
1165 clone_info=DestroyImageInfo(clone_info);
1166 if ((image != image2) && (image2 != (Image *) NULL))
1167 image2=DestroyImage(image2);
1168 ThrowReaderException(CoderError, "IncompatibleSizeOfDouble");
1170 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1171 { /* complex double type cell */
1173 ldblk = (ssize_t) (8 * MATLAB_HDR.SizeX);
1176 if ((image != image2) && (image2 != (Image *) NULL))
1177 image2=DestroyImage(image2);
1179 clone_info=DestroyImageInfo(clone_info);
1180 ThrowReaderException(CoderError, "UnsupportedCellTypeInTheMatrix");
1183 image->columns = MATLAB_HDR.SizeX;
1184 image->rows = MATLAB_HDR.SizeY;
1185 image->colors = GetQuantumRange(image->depth);
1186 if (image->columns == 0 || image->rows == 0)
1188 if((unsigned int)ldblk*MATLAB_HDR.SizeY > MATLAB_HDR.ObjectSize)
1190 /* Image is gray when no complex flag is set and 2D Matrix */
1191 if ((MATLAB_HDR.DimFlag == 8) &&
1192 ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1194 image->type=GrayscaleType;
1195 SetImageColorspace(image,GRAYColorspace,exception);
1200 If ping is true, then only set image size and colors without
1201 reading any image data.
1203 if (image_info->ping)
1205 size_t temp = image->columns;
1206 image->columns = image->rows;
1208 goto done_reading; /* !!!!!! BAD !!!! */
1210 status=SetImageExtent(image,image->columns,image->rows,exception);
1211 if (status == MagickFalse)
1213 if (clone_info != (ImageInfo *) NULL)
1214 clone_info=DestroyImageInfo(clone_info);
1215 if ((image != image2) && (image2 != (Image *) NULL))
1216 image2=DestroyImage(image2);
1217 return(DestroyImageList(image));
1219 (void) SetImageBackgroundColor(image,exception);
1220 quantum_info=AcquireQuantumInfo(clone_info,image);
1221 if (quantum_info == (QuantumInfo *) NULL)
1223 if (clone_info != (ImageInfo *) NULL)
1224 clone_info=DestroyImageInfo(clone_info);
1225 if ((image != image2) && (image2 != (Image *) NULL))
1226 image2=DestroyImage(image2);
1227 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1230 /* ----- Load raster data ----- */
1231 BImgBuff = (unsigned char *) AcquireQuantumMemory((size_t) (ldblk),sizeof(double)); /* Ldblk was set in the check phase */
1232 if (BImgBuff == NULL)
1234 if (clone_info != (ImageInfo *) NULL)
1235 clone_info=DestroyImageInfo(clone_info);
1236 if ((image != image2) && (image2 != (Image *) NULL))
1237 image2=DestroyImage(image2);
1238 if (quantum_info != (QuantumInfo *) NULL)
1239 quantum_info=DestroyQuantumInfo(quantum_info);
1240 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1242 (void) memset(BImgBuff,0,ldblk*sizeof(double));
1246 if (CellType==miDOUBLE || CellType==miSINGLE) /* Find Min and Max Values for floats */
1248 CalcMinMax(image2,image_info->endian,MATLAB_HDR.SizeX,MATLAB_HDR.SizeY,
1249 CellType,ldblk,BImgBuff,&quantum_info->minimum,
1250 &quantum_info->maximum);
1253 /* Main loop for reading all scanlines */
1254 if(z==1) z=0; /* read grey scanlines */
1255 /* else read color scanlines */
1258 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1260 q=GetAuthenticPixels(image,0,MATLAB_HDR.SizeY-i-1,image->columns,1,exception);
1261 if (q == (Quantum *) NULL)
1263 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1264 " MAT set image pixels returns unexpected NULL on a row %u.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1265 goto done_reading; /* Skip image rotation, when cannot set image pixels */
1267 if(ReadBlob(image2,ldblk,(unsigned char *)BImgBuff) != (ssize_t) ldblk)
1269 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1270 " MAT cannot read scanrow %u from a file.", (unsigned)(MATLAB_HDR.SizeY-i-1));
1273 if((CellType==miINT8 || CellType==miUINT8) && (MATLAB_HDR.StructureFlag & FLAG_LOGICAL))
1275 FixLogical((unsigned char *)BImgBuff,ldblk);
1276 if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1278 ImportQuantumPixelsFailed:
1279 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1280 " MAT failed to ImportQuantumPixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1286 if(ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,z2qtype[z],BImgBuff,exception) <= 0)
1287 goto ImportQuantumPixelsFailed;
1290 if (z<=1 && /* fix only during a last pass z==0 || z==1 */
1291 (CellType==miINT8 || CellType==miINT16 || CellType==miINT32 || CellType==miINT64))
1292 FixSignedValues(image,q,MATLAB_HDR.SizeX);
1295 if (!SyncAuthenticPixels(image,exception))
1297 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
1298 " MAT failed to sync image pixels for a row %u", (unsigned)(MATLAB_HDR.SizeY-i-1));
1306 /* Read complex part of numbers here */
1307 if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
1308 { /* Find Min and Max Values for complex parts of floats */
1309 CellType = ReadBlobXXXLong(image2); /* Additional object type */
1310 i = ReadBlobXXXLong(image2); /* size of a complex part - toss away*/
1312 if (CellType==miDOUBLE || CellType==miSINGLE)
1314 CalcMinMax(image2, image_info->endian, MATLAB_HDR.SizeX, MATLAB_HDR.SizeY, CellType, ldblk, BImgBuff, &MinVal, &MaxVal);
1317 if (CellType==miDOUBLE)
1318 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1320 ReadBlobDoublesXXX(image2, ldblk, (double *)BImgBuff);
1321 InsertComplexDoubleRow(image, (double *)BImgBuff, i, MinVal, MaxVal,
1325 if (CellType==miSINGLE)
1326 for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
1328 ReadBlobFloatsXXX(image2, ldblk, (float *)BImgBuff);
1329 InsertComplexFloatRow(image,(float *)BImgBuff,i,MinVal,MaxVal,
1334 /* Image is gray when no complex flag is set and 2D Matrix AGAIN!!! */
1335 if ((MATLAB_HDR.DimFlag == 8) &&
1336 ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
1337 image->type=GrayscaleType;
1338 if (image->depth == 1)
1339 image->type=BilevelType;
1342 image2 = NULL; /* Remove shadow copy to an image before rotation. */
1345 rotated_image = RotateImage(image, 90.0, exception);
1346 if (rotated_image != (Image *) NULL)
1348 /* Remove page offsets added by RotateImage */
1349 rotated_image->page.x=0;
1350 rotated_image->page.y=0;
1351 rotated_image->colors = image->colors;
1352 DestroyBlob(rotated_image);
1353 rotated_image->blob=ReferenceBlob(image->blob);
1354 AppendImageToList(&image,rotated_image);
1355 DeleteImageFromList(&image);
1363 DeleteImageFromList(&image2);
1366 if(clone_info->file)
1368 fclose(clone_info->file);
1369 clone_info->file = NULL;
1370 (void) remove_utf8(clone_info->filename);
1374 if (EOFBlob(image) != MagickFalse)
1377 /* Allocate next image structure. */
1378 AcquireNextImage(image_info,image,exception);
1379 if (image->next == (Image *) NULL) break;
1380 image=SyncNextImageInList(image);
1381 image->columns=image->rows=0;
1384 /* row scan buffer is no longer needed */
1385 RelinquishMagickMemory(BImgBuff);
1387 if (quantum_info != (QuantumInfo *) NULL)
1388 quantum_info=DestroyQuantumInfo(quantum_info);
1393 if(image2==NULL) image2 = image;
1394 if(!EOFBlob(image) && TellBlob(image)<filepos)
1397 if ((image2!=NULL) && (image2!=image)) /* Does shadow temporary decompressed image exist? */
1399 /* CloseBlob(image2); */
1400 DeleteImageFromList(&image2);
1403 if(clone_info->file)
1405 fclose(clone_info->file);
1406 clone_info->file = NULL;
1407 (void) remove_utf8(clone_info->filename);
1413 clone_info=DestroyImageInfo(clone_info);
1416 RelinquishMagickMemory(BImgBuff);
1417 if (quantum_info != (QuantumInfo *) NULL)
1418 quantum_info=DestroyQuantumInfo(quantum_info);
1428 Rewind list, removing any empty images while rewinding.
1432 while (p != (Image *) NULL)
1435 if ((p->rows == 0) || (p->columns == 0)) {
1438 image2=(Image *) NULL;
1439 DeleteImageFromList(&tmp);
1449 for (p=image; p != (Image *) NULL; p=p->next)
1453 if(clone_info != NULL) /* cleanup garbage file from compression */
1455 if(clone_info->file)
1457 fclose(clone_info->file);
1458 clone_info->file = NULL;
1459 (void) remove_utf8(clone_info->filename);
1461 DestroyImageInfo(clone_info);
1464 if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),"return");
1465 if ((image != image2) && (image2 != (Image *) NULL))
1466 image2=DestroyImage(image2);
1467 if (image == (Image *) NULL)
1468 ThrowReaderException(CorruptImageError,"ImproperImageHeader")
1473 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1477 % R e g i s t e r M A T I m a g e %
1481 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1483 % Method RegisterMATImage adds attributes for the MAT image format to
1484 % the list of supported formats. The attributes include the image format
1485 % tag, a method to read and/or write the format, whether the format
1486 % supports the saving of more than one frame to the same file or blob,
1487 % whether the format supports native in-memory I/O, and a brief
1488 % description of the format.
1490 % The format of the RegisterMATImage method is:
1492 % size_t RegisterMATImage(void)
1495 ModuleExport size_t RegisterMATImage(void)
1500 entry=AcquireMagickInfo("MAT","MAT","MATLAB level 5 image format");
1501 entry->decoder=(DecodeImageHandler *) ReadMATImage;
1502 entry->encoder=(EncodeImageHandler *) WriteMATImage;
1503 entry->flags^=CoderBlobSupportFlag;
1504 entry->flags|=CoderDecoderSeekableStreamFlag;
1505 (void) RegisterMagickInfo(entry);
1506 return(MagickImageCoderSignature);
1510 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1514 % U n r e g i s t e r M A T I m a g e %
1518 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1520 % Method UnregisterMATImage removes format registrations made by the
1521 % MAT module from the list of supported formats.
1523 % The format of the UnregisterMATImage method is:
1525 % UnregisterMATImage(void)
1528 ModuleExport void UnregisterMATImage(void)
1530 (void) UnregisterMagickInfo("MAT");
1534 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1538 % W r i t e M A T L A B I m a g e %
1542 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1544 % Function WriteMATImage writes an Matlab matrix to a file.
1546 % The format of the WriteMATImage method is:
1548 % MagickBooleanType WriteMATImage(const ImageInfo *image_info,
1549 % Image *image,ExceptionInfo *exception)
1551 % A description of each parameter follows.
1553 % o image_info: Specifies a pointer to a ImageInfo structure.
1555 % o image: A pointer to an Image structure.
1557 % o exception: return any errors or warnings in this structure.
1560 static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
1561 ExceptionInfo *exception)
1582 Open output image file.
1584 assert(image_info != (const ImageInfo *) NULL);
1585 assert(image_info->signature == MagickCoreSignature);
1586 assert(image != (Image *) NULL);
1587 assert(image->signature == MagickCoreSignature);
1588 (void) LogMagickEvent(CoderEvent,GetMagickModule(),"enter MAT");
1589 assert(exception != (ExceptionInfo *) NULL);
1590 assert(exception->signature == MagickCoreSignature);
1591 status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1592 if (status == MagickFalse)
1593 return(MagickFalse);
1596 current_time=time((time_t *) NULL);
1597 #if defined(MAGICKCORE_HAVE_LOCALTIME_R)
1598 (void) localtime_r(¤t_time,&local_time);
1600 (void) memcpy(&local_time,localtime(¤t_time),sizeof(local_time));
1602 (void) memset(MATLAB_HDR,' ',MagickMin(sizeof(MATLAB_HDR),124));
1603 FormatLocaleString(MATLAB_HDR,sizeof(MATLAB_HDR),
1604 "MATLAB 5.0 MAT-file, Platform: %s, Created on: %s %s %2d %2d:%2d:%2d %d",
1605 OsDesc,DayOfWTab[local_time.tm_wday],MonthsTab[local_time.tm_mon],
1606 local_time.tm_mday,local_time.tm_hour,local_time.tm_min,
1607 local_time.tm_sec,local_time.tm_year+1900);
1610 MATLAB_HDR[0x7E]='I';
1611 MATLAB_HDR[0x7F]='M';
1612 (void) WriteBlob(image,sizeof(MATLAB_HDR),(unsigned char *) MATLAB_HDR);
1614 imageListLength=GetImageListLength(image);
1635 (void) TransformImageColorspace(image,sRGBColorspace,exception);
1636 is_gray=SetImageGray(image,exception);
1637 z=(is_gray != MagickFalse) ? 0 : 3;
1642 data_size = image->rows * image->columns;
1643 if (is_gray == MagickFalse)
1645 padding=((unsigned char)(data_size-1) & 0x7) ^ 0x7;
1647 (void) WriteBlobLSBLong(image,miMATRIX);
1648 (void) WriteBlobLSBLong(image,(unsigned int) data_size+padding+
1649 ((is_gray != MagickFalse) ? 48 : 56));
1650 (void) WriteBlobLSBLong(image,0x6); /* 0x88 */
1651 (void) WriteBlobLSBLong(image,0x8); /* 0x8C */
1652 (void) WriteBlobLSBLong(image,0x6); /* 0x90 */
1653 (void) WriteBlobLSBLong(image,0);
1654 (void) WriteBlobLSBLong(image,0x5); /* 0x98 */
1655 (void) WriteBlobLSBLong(image,(is_gray != MagickFalse) ? 0x8 : 0xC); /* 0x9C - DimFlag */
1656 (void) WriteBlobLSBLong(image,(unsigned int) image->rows); /* x: 0xA0 */
1657 (void) WriteBlobLSBLong(image,(unsigned int) image->columns); /* y: 0xA4 */
1658 if (is_gray == MagickFalse)
1660 (void) WriteBlobLSBLong(image,3); /* z: 0xA8 */
1661 (void) WriteBlobLSBLong(image,0);
1663 (void) WriteBlobLSBShort(image,1); /* 0xB0 */
1664 (void) WriteBlobLSBShort(image,1); /* 0xB2 */
1665 (void) WriteBlobLSBLong(image,'M'); /* 0xB4 */
1666 (void) WriteBlobLSBLong(image,0x2); /* 0xB8 */
1667 (void) WriteBlobLSBLong(image,(unsigned int) data_size); /* 0xBC */
1672 quantum_info=AcquireQuantumInfo(image_info,image);
1673 if (quantum_info == (QuantumInfo *) NULL)
1674 ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1675 pixels=(unsigned char *) GetQuantumPixels(quantum_info);
1684 for (y=0; y < (ssize_t)image->columns; y++)
1686 p=GetVirtualPixels(image,y,0,1,image->rows,exception);
1687 if (p == (const Quantum *) NULL)
1689 (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1690 z2qtype[z],pixels,exception);
1691 (void) WriteBlob(image,image->rows,pixels);
1693 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1696 while (padding-- > 0)
1697 (void) WriteBlobByte(image,0);
1698 quantum_info=DestroyQuantumInfo(quantum_info);
1699 if (GetNextImageInList(image) == (Image *) NULL)
1701 image=SyncNextImageInList(image);
1702 status=SetImageProgress(image,SaveImagesTag,scene++,imageListLength);
1703 if (status == MagickFalse)
1705 } while (image_info->adjoin != MagickFalse);
1706 (void) CloseBlob(image);