/*
Include declarations.
*/
-#include "magick/studio.h"
-#include "magick/blob.h"
-#include "magick/blob-private.h"
-#include "magick/cache.h"
-#include "magick/color-private.h"
-#include "magick/colormap.h"
-#include "magick/exception.h"
-#include "magick/exception-private.h"
-#include "magick/image.h"
-#include "magick/image-private.h"
-#include "magick/list.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/quantum-private.h"
-#include "magick/option.h"
-#include "magick/resource_.h"
-#include "magick/shear.h"
-#include "magick/static.h"
-#include "magick/string_.h"
-#include "magick/module.h"
-#include "magick/transform.h"
+#include "MagickCore/studio.h"
+#include "MagickCore/attribute.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/blob-private.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/colormap.h"
+#include "MagickCore/colorspace-private.h"
+#include "MagickCore/distort.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/exception-private.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/list.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/monitor-private.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/option.h"
+#include "MagickCore/pixel.h"
+#include "MagickCore/resource_.h"
+#include "MagickCore/static.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/module.h"
+#include "MagickCore/transform.h"
+#include "MagickCore/utility-private.h"
#if defined(MAGICKCORE_ZLIB_DELEGATE)
#include "zlib.h"
#endif
Forward declaration.
*/
static MagickBooleanType
- WriteMATImage(const ImageInfo *,Image *);
+ WriteMATImage(const ImageInfo *,Image *,ExceptionInfo *);
/* Auto coloring method, sorry this creates some artefact inside data
static const QuantumType z2qtype[4] = {GrayQuantum, BlueQuantum, GreenQuantum, RedQuantum};
-static void InsertComplexDoubleRow(double *p, int y, Image * image, double MinVal,
- double MaxVal)
+static void InsertComplexDoubleRow(Image *image,double *p,int y,double MinVal,
+ double MaxVal,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
double f;
int x;
- register PixelPacket *q;
+ register Quantum *q;
if (MinVal == 0)
MinVal = -1;
if (MaxVal == 0)
MaxVal = 1;
- exception=(&image->exception);
- q = QueueAuthenticPixels(image, 0, y, image->columns, 1,exception);
- if (q == (PixelPacket *) NULL)
+ q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
+ if (q == (Quantum *) NULL)
return;
for (x = 0; x < (ssize_t) image->columns; x++)
{
if (*p > 0)
{
- f = (*p / MaxVal) * (QuantumRange - q->red);
- if (f + q->red > QuantumRange)
- q->red = QuantumRange;
+ f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
+ if (f + GetPixelRed(image,q) > QuantumRange)
+ SetPixelRed(image,QuantumRange,q);
else
- q->red += (int) f;
- if ((int) f / 2.0 > q->green)
- q->green = q->blue = 0;
+ SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
+ if ((int) f / 2.0 > GetPixelGreen(image,q))
+ {
+ SetPixelGreen(image,0,q);
+ SetPixelBlue(image,0,q);
+ }
else
- q->green = q->blue -= (int) (f / 2.0);
+ {
+ SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
+ SetPixelGreen(image,GetPixelBlue(image,q),q);
+ }
}
if (*p < 0)
{
- f = (*p / MaxVal) * (QuantumRange - q->blue);
- if (f + q->blue > QuantumRange)
- q->blue = QuantumRange;
+ f = (*p / MaxVal) * (QuantumRange-GetPixelBlue(image,q));
+ if (f+GetPixelBlue(image,q) > QuantumRange)
+ SetPixelBlue(image,QuantumRange,q);
else
- q->blue += (int) f;
- if ((int) f / 2.0 > q->green)
- q->green = q->red = 0;
+ SetPixelBlue(image,GetPixelBlue(image,q)+(int) f,q);
+ if ((int) f / 2.0 > GetPixelGreen(image,q))
+ {
+ SetPixelRed(image,0,q);
+ SetPixelGreen(image,0,q);
+ }
else
- q->green = q->red -= (int) (f / 2.0);
+ {
+ SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
+ SetPixelGreen(image,GetPixelRed(image,q),q);
+ }
}
p++;
- q++;
+ q+=GetPixelChannels(image);
}
if (!SyncAuthenticPixels(image,exception))
return;
}
-static void InsertComplexFloatRow(float *p, int y, Image * image, double MinVal,
- double MaxVal)
+static void InsertComplexFloatRow(Image *image,float *p,int y,double MinVal,
+ double MaxVal,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
double f;
int x;
- register PixelPacket *q;
+ register Quantum *q;
if (MinVal == 0)
MinVal = -1;
if (MaxVal == 0)
MaxVal = 1;
- exception=(&image->exception);
q = QueueAuthenticPixels(image, 0, y, image->columns, 1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
return;
for (x = 0; x < (ssize_t) image->columns; x++)
{
if (*p > 0)
{
- f = (*p / MaxVal) * (QuantumRange - q->red);
- if (f + q->red > QuantumRange)
- q->red = QuantumRange;
+ f = (*p / MaxVal) * (QuantumRange-GetPixelRed(image,q));
+ if (f+GetPixelRed(image,q) > QuantumRange)
+ SetPixelRed(image,QuantumRange,q);
else
- q->red += (int) f;
- if ((int) f / 2.0 > q->green)
- q->green = q->blue = 0;
+ SetPixelRed(image,GetPixelRed(image,q)+(int) f,q);
+ if ((int) f / 2.0 > GetPixelGreen(image,q))
+ {
+ SetPixelGreen(image,0,q);
+ SetPixelBlue(image,0,q);
+ }
else
- q->green = q->blue -= (int) (f / 2.0);
+ {
+ SetPixelBlue(image,GetPixelBlue(image,q)-(int) (f/2.0),q);
+ SetPixelGreen(image,GetPixelBlue(image,q),q);
+ }
}
if (*p < 0)
{
- f = (*p / MaxVal) * (QuantumRange - q->blue);
- if (f + q->blue > QuantumRange)
- q->blue = QuantumRange;
+ f = (*p / MaxVal) * (QuantumRange - GetPixelBlue(image,q));
+ if (f + GetPixelBlue(image,q) > QuantumRange)
+ SetPixelBlue(image,QuantumRange,q);
else
- q->blue += (int) f;
- if ((int) f / 2.0 > q->green)
- q->green = q->red = 0;
+ SetPixelBlue(image,GetPixelBlue(image,q)+
+ (int) f,q);
+ if ((int) f / 2.0 > GetPixelGreen(image,q))
+ {
+ SetPixelGreen(image,0,q);
+ SetPixelRed(image,0,q);
+ }
else
- q->green = q->red -= (int) (f / 2.0);
+ {
+ SetPixelRed(image,GetPixelRed(image,q)-(int) (f/2.0),q);
+ SetPixelGreen(image,GetPixelRed(image,q),q);
+ }
}
p++;
q++;
}
-static void FixSignedValues(PixelPacket *q, int y)
+static void FixSignedValues(const Image *image,Quantum *q, int y)
{
while(y-->0)
{
/* Please note that negative values will overflow
Q=8; QuantumRange=255: <0;127> + 127+1 = <128; 255>
<-1;-128> + 127+1 = <0; 127> */
- q->red += QuantumRange/2 + 1;
- q->green += QuantumRange/ + 1;
- q->blue += QuantumRange/ + 1;
+ SetPixelRed(image,GetPixelRed(image,q)+QuantumRange/2+1,q);
+ SetPixelGreen(image,GetPixelGreen(image,q)+QuantumRange/2+1,q);
+ SetPixelBlue(image,GetPixelBlue(image,q)+QuantumRange/2+1,q);
q++;
}
}
}
#endif
+#if defined(MAGICKCORE_ZLIB_DELEGATE)
/** This procedure decompreses an image block for a new MATLAB format. */
static Image *DecompressBlock(Image *orig, MagickOffsetType Size, ImageInfo *clone_info, ExceptionInfo *exception)
{
-#if defined(MAGICKCORE_ZLIB_DELEGATE)
Image *image2;
void *CacheBlock, *DecompressBlock;
FILE *mat_file;
size_t magick_size;
size_t extent;
+int file;
int status;
{
fclose(clone_info->file);
clone_info->file = NULL;
- (void) unlink(clone_info->filename);
+ (void) remove_utf8(clone_info->filename);
}
CacheBlock = AcquireQuantumMemory((size_t)((Size<16384)?Size:16384),sizeof(unsigned char *));
return NULL;
}
- mat_file = fdopen(AcquireUniqueFileResource(clone_info->filename),"w");
+ mat_file=0;
+ file = AcquireUniqueFileResource(clone_info->filename);
+ if (file != -1)
+ mat_file = fdopen(file,"w");
if(!mat_file)
{
RelinquishMagickMemory(CacheBlock);
zip_info.next_out = (Bytef *) DecompressBlock;
status = inflate(&zip_info,Z_NO_FLUSH);
extent=fwrite(DecompressBlock, 4096-zip_info.avail_out, 1, mat_file);
+ (void) extent;
if(status == Z_STREAM_END) goto DblBreak;
}
RelinquishMagickMemory(DecompressBlock);
if((clone_info->file=fopen(clone_info->filename,"rb"))==NULL) goto UnlinkFile;
- if( (image2 = AcquireImage(clone_info))==NULL ) goto EraseFile;
+ if( (image2 = AcquireImage(clone_info,exception))==NULL ) goto EraseFile;
status = OpenBlob(clone_info,image2,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
fclose(clone_info->file);
clone_info->file = NULL;
UnlinkFile:
- (void) unlink(clone_info->filename);
+ (void) remove_utf8(clone_info->filename);
return NULL;
}
return image2;
-#else
- (void) orig;
- (void) Size;
- (void) clone_info;
- (void) exception;
- return NULL;
-#endif
}
+#endif
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
{
Image *image, *image2=NULL,
*rotated_image;
- PixelPacket *q;
+ register Quantum *q;
unsigned int status;
MATHeader MATLAB_HDR;
ssize_t ldblk;
unsigned char *BImgBuff = NULL;
double MinVal, MaxVal;
- size_t Unknown6;
- unsigned z;
+ unsigned z, z2;
+ unsigned Frames;
int logging;
int sample_size;
MagickOffsetType filepos=0x80;
/*
Open image file.
*/
- image = AcquireImage(image_info);
+ image = AcquireImage(image_info,exception);
status = OpenBlob(image_info, image, ReadBinaryBlobMode, exception);
if (status == MagickFalse)
filepos = TellBlob(image);
while(!EOFBlob(image)) /* object parser loop */
{
+ Frames = 1;
(void) SeekBlob(image,filepos,SEEK_SET);
/* printf("pos=%X\n",TellBlob(image)); */
switch(MATLAB_HDR.DimFlag)
{
- case 8: z=1; break; /* 2D matrix*/
- case 12: z = ReadBlobXXXLong(image2); /* 3D matrix RGB*/
- Unknown6 = ReadBlobXXXLong(image2);
+ case 8: z2=z=1; break; /* 2D matrix*/
+ case 12: z2=z = ReadBlobXXXLong(image2); /* 3D matrix RGB*/
+ (void) ReadBlobXXXLong(image2);
if(z!=3) ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
break;
+ case 16: z2=z = ReadBlobXXXLong(image2); /* 4D matrix animation */
+ if(z!=3 && z!=1)
+ ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
+ Frames = ReadBlobXXXLong(image2);
+ break;
default: ThrowReaderException(CoderError, "MultidimensionalMatricesAreNotSupported");
}
(void) ReadBlob(image2, 4, (unsigned char *) &size); /* data size */
- /* Image is gray when no complex flag is set and 2D Matrix */
- if ((MATLAB_HDR.DimFlag == 8) &&
- ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
- image->type=GrayscaleType;
-
+ NEXT_FRAME:
switch (CellType)
{
case miINT8:
sample_size = 64;
image->depth = 64; /* double type cell */
(void) SetImageOption(clone_info,"quantum:format","floating-point");
+DisableMSCWarning(4127)
if (sizeof(double) != 8)
+RestoreMSCWarning
ThrowReaderException(CoderError, "IncompatibleSizeOfDouble");
if (MATLAB_HDR.StructureFlag & FLAG_COMPLEX)
{ /* complex double type cell */
default:
ThrowReaderException(CoderError, "UnsupportedCellTypeInTheMatrix");
}
+ (void) sample_size;
image->columns = MATLAB_HDR.SizeX;
image->rows = MATLAB_HDR.SizeY;
quantum_info=AcquireQuantumInfo(clone_info,image);
image->colors = one << image->depth;
if (image->columns == 0 || image->rows == 0)
goto MATLAB_KO;
-
- /* ----- Create gray palette ----- */
-
- if (CellType==miUINT8 && z!=3)
- {
- if(image->colors>256) image->colors = 256;
-
- if (!AcquireImageColormap(image, image->colors))
+ /* Image is gray when no complex flag is set and 2D Matrix */
+ if ((MATLAB_HDR.DimFlag == 8) &&
+ ((MATLAB_HDR.StructureFlag & FLAG_COMPLEX) == 0))
{
- NoMemory:ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");}
- }
+ image->type=GrayscaleType;
+ SetImageColorspace(image,GRAYColorspace,exception);
+ }
+
/*
If ping is true, then only set image size and colors without
}
/* ----- Load raster data ----- */
- BImgBuff = (unsigned char *) AcquireQuantumMemory((size_t) (ldblk),sizeof(unsigned char *)); /* Ldblk was set in the check phase */
+ BImgBuff = (unsigned char *) AcquireQuantumMemory((size_t) (ldblk),sizeof(unsigned char)); /* Ldblk was set in the check phase */
if (BImgBuff == NULL)
- goto NoMemory;
+ ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
MinVal = 0;
MaxVal = 0;
{
for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
{
- q=QueueAuthenticPixels(image,0,MATLAB_HDR.SizeY-i-1,image->columns,1,exception);
- if (q == (PixelPacket *)NULL)
+ q=GetAuthenticPixels(image,0,MATLAB_HDR.SizeY-i-1,image->columns,1,exception);
+ if (q == (Quantum *)NULL)
{
if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
" MAT set image pixels returns unexpected NULL on a row %u.", (unsigned)(MATLAB_HDR.SizeY-i-1));
if (z<=1 && /* fix only during a last pass z==0 || z==1 */
(CellType==miINT8 || CellType==miINT16 || CellType==miINT32 || CellType==miINT64))
- FixSignedValues(q,MATLAB_HDR.SizeX);
+ FixSignedValues(image,q,MATLAB_HDR.SizeX);
}
if (!SyncAuthenticPixels(image,exception))
for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
{
ReadBlobDoublesXXX(image2, ldblk, (double *)BImgBuff);
- InsertComplexDoubleRow((double *)BImgBuff, i, image, MinVal, MaxVal);
+ InsertComplexDoubleRow(image, (double *)BImgBuff, i, MinVal, MaxVal,
+ exception);
}
if (CellType==miSINGLE)
for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
{
ReadBlobFloatsXXX(image2, ldblk, (float *)BImgBuff);
- InsertComplexFloatRow((float *)BImgBuff, i, image, MinVal, MaxVal);
+ InsertComplexFloatRow(image,(float *)BImgBuff,i,MinVal,MaxVal,
+ exception);
}
}
{
fclose(clone_info->file);
clone_info->file = NULL;
- (void) unlink(clone_info->filename);
+ (void) remove_utf8(clone_info->filename);
}
}
}
/* Allocate next image structure. */
- AcquireNextImage(image_info,image);
+ AcquireNextImage(image_info,image,exception);
if (image->next == (Image *) NULL) break;
image=SyncNextImageInList(image);
image->columns=image->rows=0;
/* row scan buffer is no longer needed */
RelinquishMagickMemory(BImgBuff);
BImgBuff = NULL;
+
+ if(--Frames>0)
+ {
+ z = z2;
+ if(image2==NULL) image2 = image;
+ goto NEXT_FRAME;
+ }
+ if ((image2!=NULL) && (image2!=image)) /* Does shadow temporary decompressed image exist? */
+ {
+/* CloseBlob(image2); */
+ DeleteImageFromList(&image2);
+ if(clone_info)
+ {
+ if(clone_info->file)
+ {
+ fclose(clone_info->file);
+ clone_info->file = NULL;
+ (void) remove_utf8(clone_info->filename);
+ }
+ }
+ }
}
- clone_info=DestroyImageInfo(clone_info);
+ clone_info=DestroyImageInfo(clone_info);
RelinquishMagickMemory(BImgBuff);
CloseBlob(image);
{
fclose(clone_info->file);
clone_info->file = NULL;
- (void) unlink(clone_info->filename);
+ (void) remove_utf8(clone_info->filename);
}
DestroyImageInfo(clone_info);
clone_info = NULL;
entry->encoder=(EncodeImageHandler *) WriteMATImage;
entry->blob_support=MagickFalse;
entry->seekable_stream=MagickTrue;
- entry->description=AcquireString("MATLAB image format");
+ entry->description=AcquireString("MATLAB level 5 image format");
entry->module=AcquireString("MAT");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
%
% The format of the WriteMATImage method is:
%
-% unsigned int WriteMATImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMATImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
-% o status: Function WriteMATImage return True if the image is written.
-% False is returned is there is a memory shortage or if the image file
-% fails to write.
-%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
ssize_t y;
unsigned z;
- const PixelPacket *p;
+ register const Quantum *p;
unsigned int status;
int logging;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
logging=LogMagickEvent(CoderEvent,GetMagickModule(),"enter MAT");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ (void) logging;
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(MagickFalse);
image->depth=8;
(void) memcpy(&local_time,localtime(¤t_time),sizeof(local_time));
#endif
(void) memset(MATLAB_HDR,' ',MagickMin(sizeof(MATLAB_HDR),124));
- FormatMagickString(MATLAB_HDR,MaxTextExtent,"MATLAB 5.0 MAT-file, Platform: %s, Created on: %s %s %2d %2d:%2d:%2d %d",
+ FormatLocaleString(MATLAB_HDR,sizeof(MATLAB_HDR),
+ "MATLAB 5.0 MAT-file, Platform: %s, Created on: %s %s %2d %2d:%2d:%2d %d",
OsDesc,DayOfWTab[local_time.tm_wday],MonthsTab[local_time.tm_mon],
local_time.tm_mday,local_time.tm_hour,local_time.tm_min,
local_time.tm_sec,local_time.tm_year+1900);
scene=0;
do
{
- if (image->colorspace != RGBColorspace)
- (void) TransformImageColorspace(image,RGBColorspace);
-
- is_gray = IsGrayImage(image,&image->exception);
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ is_gray = IsImageGray(image,exception);
z = is_gray ? 0 : 3;
/*
/*
Store image data.
*/
- exception=(&image->exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
{
for (y=0; y < (ssize_t)image->columns; y++)
{
- p=GetVirtualPixels(image,y,0,1,image->rows,&image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,y,0,1,image->rows,exception);
+ if (p == (const Quantum *) NULL)
break;
- (void) ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
+ (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
z2qtype[z],pixels,exception);
(void) WriteBlob(image,image->rows,pixels);
}
- if (!SyncAuthenticPixels(image,exception))
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
} while(z-- >= 2);
while(padding-->0) (void) WriteBlobByte(image,0);
projects / imagemagick / blobdiff