X-Git-Url: https://granicus.if.org/sourcecode?a=blobdiff_plain;f=coders%2Fcin.c;h=df281f69e1caf8e03331feaefa9fb28cbe7573b9;hb=7beda643d8713ff62ffc17b57e4b1f0d3fc9c523;hp=559439349c3093689edf40ceb7751528233d6198;hpb=f2f2727f17ecbb23d902f70bb98f81faabc92dbd;p=imagemagick diff --git a/coders/cin.c b/coders/cin.c index 559439349..df281f69e 100644 --- a/coders/cin.c +++ b/coders/cin.c @@ -15,12 +15,12 @@ % % % % % Software Design % -% John Cristy % +% Cristy % % Kelly Bergougnoux % % October 2003 % % % % % -% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization % +% Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization % % dedicated to making software imaging solutions freely available. % % % % You may not use this file except in compliance with the License. You may % @@ -46,29 +46,30 @@ /* Include declarations. */ -#include "magick/studio.h" -#include "magick/blob.h" -#include "magick/blob-private.h" -#include "magick/cache.h" -#include "magick/colorspace.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/option.h" -#include "magick/profile.h" -#include "magick/property.h" -#include "magick/quantum-private.h" -#include "magick/quantum-private.h" -#include "magick/static.h" -#include "magick/string_.h" -#include "magick/string-private.h" -#include "magick/module.h" +#include "MagickCore/studio.h" +#include "MagickCore/artifact.h" +#include "MagickCore/blob.h" +#include "MagickCore/blob-private.h" +#include "MagickCore/cache.h" +#include "MagickCore/colorspace.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/option.h" +#include "MagickCore/profile.h" +#include "MagickCore/property.h" +#include "MagickCore/quantum-private.h" +#include "MagickCore/quantum-private.h" +#include "MagickCore/static.h" +#include "MagickCore/string_.h" +#include "MagickCore/string-private.h" +#include "MagickCore/module.h" /* Typedef declaration. @@ -81,7 +82,7 @@ typedef struct _CINDataFormatInfo sign, sense; - unsigned long + size_t line_pad, channel_pad; @@ -91,7 +92,7 @@ typedef struct _CINDataFormatInfo typedef struct _CINFileInfo { - unsigned long + size_t magic, image_offset, generic_length, @@ -115,14 +116,14 @@ typedef struct _CINFilmInfo offset, reserve1; - unsigned long + size_t prefix, count; char format[32]; - unsigned long + size_t frame_position; float @@ -141,7 +142,7 @@ typedef struct _CINImageChannel bits_per_pixel, reserve; - unsigned long + size_t pixels_per_line, lines_per_image; @@ -175,7 +176,7 @@ typedef struct _CINImageInfo typedef struct _CINOriginationInfo { - long + ssize_t x_offset, y_offset; @@ -227,7 +228,7 @@ typedef struct CINInfo Forward declaractions. */ static MagickBooleanType - WriteCINImage(const ImageInfo *,Image *); + WriteCINImage(const ImageInfo *,Image *,ExceptionInfo *); /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -291,8 +292,8 @@ static MagickBooleanType IsCIN(const unsigned char *magick,const size_t length) % */ -static size_t GetBytesPerRow(unsigned long columns, - unsigned long samples_per_pixel,unsigned long bits_per_pixel, +static size_t GetBytesPerRow(size_t columns, + size_t samples_per_pixel,size_t bits_per_pixel, MagickBooleanType pad) { size_t @@ -361,38 +362,37 @@ static inline MagickBooleanType IsFloatDefined(const float value) { union { - unsigned long + unsigned int unsigned_value; double float_value; } quantum; - quantum.unsigned_value=0UL; + quantum.unsigned_value=0U; quantum.float_value=value; - if (quantum.unsigned_value == 0UL) + if (quantum.unsigned_value == 0U) return(MagickFalse); return(MagickTrue); } -static Image *ReadCINImage(const ImageInfo *image_info, - ExceptionInfo *exception) +static Image *ReadCINImage(const ImageInfo *image_info,ExceptionInfo *exception) { #define MonoColorType 1 #define RGBColorType 3 char - magick[4]; + property[MagickPathExtent]; CINInfo cin; + const unsigned char + *pixels; + Image *image; - long - y; - MagickBooleanType status; @@ -405,23 +405,21 @@ static Image *ReadCINImage(const ImageInfo *image_info, QuantumType quantum_type; - register long + register ssize_t i; - register PixelPacket + register Quantum *q; size_t length; ssize_t - count; + count, + y; unsigned char - *pixels; - - unsigned long - lsb_first; + magick[4]; /* Open image file. @@ -433,7 +431,7 @@ static Image *ReadCINImage(const ImageInfo *image_info, image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); - image=AcquireImage(image_info); + image=AcquireImage(image_info,exception); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { @@ -444,15 +442,13 @@ static Image *ReadCINImage(const ImageInfo *image_info, File information. */ offset=0; - count=ReadBlob(image,4,(unsigned char *) magick); + count=ReadBlob(image,4,magick); offset+=count; if ((count != 4) || ((LocaleNCompare((char *) magick,"\200\052\137\327",4) != 0))) ThrowReaderException(CorruptImageError,"ImproperImageHeader"); - image->endian=LSBEndian; - lsb_first=1; - if ((int) (*(char *) &lsb_first) != 0) - image->endian=MSBEndian; + image->endian=(magick[0] == 0x80) && (magick[1] == 0x2a) && + (magick[2] == 0x5f) && (magick[3] == 0xd7) ? MSBEndian : LSBEndian; cin.file.image_offset=ReadBlobLong(image); offset+=4; cin.file.generic_length=ReadBlobLong(image); @@ -465,16 +461,22 @@ static Image *ReadCINImage(const ImageInfo *image_info, offset+=4; offset+=ReadBlob(image,sizeof(cin.file.version),(unsigned char *) cin.file.version); - (void) SetImageProperty(image,"cin:file.version",cin.file.version); + (void) CopyMagickString(property,cin.file.version,sizeof(cin.file.version)); + (void) SetImageProperty(image,"dpx:file.version",property,exception); offset+=ReadBlob(image,sizeof(cin.file.filename),(unsigned char *) cin.file.filename); - (void) SetImageProperty(image,"cin:file.filename",cin.file.filename); + (void) CopyMagickString(property,cin.file.filename,sizeof(cin.file.filename)); + (void) SetImageProperty(image,"dpx:file.filename",property,exception); offset+=ReadBlob(image,sizeof(cin.file.create_date),(unsigned char *) cin.file.create_date); - (void) SetImageProperty(image,"cin:file.create_date",cin.file.create_date); + (void) CopyMagickString(property,cin.file.create_date, + sizeof(cin.file.create_date)); + (void) SetImageProperty(image,"dpx:file.create_date",property,exception); offset+=ReadBlob(image,sizeof(cin.file.create_time),(unsigned char *) cin.file.create_time); - (void) SetImageProperty(image,"cin:file.create_time",cin.file.create_time); + (void) CopyMagickString(property,cin.file.create_time, + sizeof(cin.file.create_time)); + (void) SetImageProperty(image,"dpx:file.create_time",property,exception); offset+=ReadBlob(image,sizeof(cin.file.reserve),(unsigned char *) cin.file.reserve); /* @@ -482,20 +484,20 @@ static Image *ReadCINImage(const ImageInfo *image_info, */ cin.image.orientation=(unsigned char) ReadBlobByte(image); offset++; - if (cin.image.orientation != (unsigned char) (~0U)) - (void) FormatImageProperty(image,"cin:image.orientation","%d", + if (cin.image.orientation != (unsigned char) (~0)) + (void) FormatImageProperty(image,"dpx:image.orientation","%d", cin.image.orientation); switch (cin.image.orientation) { default: - case 0: image->orientation=TopLeftOrientation; break; - case 1: image->orientation=TopRightOrientation; break; - case 2: image->orientation=BottomLeftOrientation; break; - case 3: image->orientation=BottomRightOrientation; break; - case 4: image->orientation=LeftTopOrientation; break; - case 5: image->orientation=RightTopOrientation; break; - case 6: image->orientation=LeftBottomOrientation; break; - case 7: image->orientation=RightBottomOrientation; break; + case 0: image->orientation=TopLeftOrientation; break; + case 1: image->orientation=TopRightOrientation; break; + case 2: image->orientation=BottomLeftOrientation; break; + case 3: image->orientation=BottomRightOrientation; break; + case 4: image->orientation=LeftTopOrientation; break; + case 5: image->orientation=RightTopOrientation; break; + case 6: image->orientation=LeftBottomOrientation; break; + case 7: image->orientation=RightBottomOrientation; break; } cin.image.number_channels=(unsigned char) ReadBlobByte(image); offset++; @@ -558,7 +560,8 @@ static Image *ReadCINImage(const ImageInfo *image_info, image->chromaticity.blue_primary.y=cin.image.blue_primary_chromaticity[1]; offset+=ReadBlob(image,sizeof(cin.image.label),(unsigned char *) cin.image.label); - (void) SetImageProperty(image,"cin:image.label",cin.image.label); + (void) CopyMagickString(property,cin.image.label,sizeof(cin.image.label)); + (void) SetImageProperty(image,"dpx:image.label",property,exception); offset+=ReadBlob(image,sizeof(cin.image.reserve),(unsigned char *) cin.image.reserve); /* @@ -581,39 +584,50 @@ static Image *ReadCINImage(const ImageInfo *image_info, /* Image origination information. */ - cin.origination.x_offset=(long) ReadBlobLong(image); + cin.origination.x_offset=(int) ReadBlobLong(image); offset+=4; - if ((unsigned long) cin.origination.x_offset != ~0UL) - (void) FormatImageProperty(image,"cin:origination.x_offset","%ld", - cin.origination.x_offset); - cin.origination.y_offset=(long) ReadBlobLong(image); + if ((size_t) cin.origination.x_offset != ~0UL) + (void) FormatImageProperty(image,"dpx:origination.x_offset","%.20g", + (double) cin.origination.x_offset); + cin.origination.y_offset=(ssize_t) ReadBlobLong(image); offset+=4; - if ((unsigned long) cin.origination.y_offset != ~0UL) - (void) FormatImageProperty(image,"cin:origination.y_offset","%ld", - cin.origination.y_offset); + if ((size_t) cin.origination.y_offset != ~0UL) + (void) FormatImageProperty(image,"dpx:origination.y_offset","%.20g", + (double) cin.origination.y_offset); offset+=ReadBlob(image,sizeof(cin.origination.filename),(unsigned char *) cin.origination.filename); - (void) SetImageProperty(image,"cin:origination.filename", - cin.origination.filename); + (void) CopyMagickString(property,cin.origination.filename, + sizeof(cin.origination.filename)); + (void) SetImageProperty(image,"dpx:origination.filename",property,exception); offset+=ReadBlob(image,sizeof(cin.origination.create_date),(unsigned char *) cin.origination.create_date); - (void) SetImageProperty(image,"cin:origination.create_date", - cin.origination.create_date); + (void) CopyMagickString(property,cin.origination.create_date, + sizeof(cin.origination.create_date)); + (void) SetImageProperty(image,"dpx:origination.create_date",property, + exception); offset+=ReadBlob(image,sizeof(cin.origination.create_time),(unsigned char *) cin.origination.create_time); - (void) SetImageProperty(image,"cin:origination.create_time", - cin.origination.create_time); + (void) CopyMagickString(property,cin.origination.create_time, + sizeof(cin.origination.create_time)); + (void) SetImageProperty(image,"dpx:origination.create_time",property, + exception); offset+=ReadBlob(image,sizeof(cin.origination.device),(unsigned char *) cin.origination.device); - (void) SetImageProperty(image,"cin:origination.device", - cin.origination.device); + (void) CopyMagickString(property,cin.origination.device, + sizeof(cin.origination.device)); + (void) SetImageProperty(image,"dpx:origination.device",property,exception); offset+=ReadBlob(image,sizeof(cin.origination.model),(unsigned char *) cin.origination.model); - (void) SetImageProperty(image,"cin:origination.model",cin.origination.model); + (void) CopyMagickString(property,cin.origination.model, + sizeof(cin.origination.model)); + (void) SetImageProperty(image,"dpx:origination.model",property,exception); + (void) ResetMagickMemory(cin.origination.serial,0, + sizeof(cin.origination.serial)); offset+=ReadBlob(image,sizeof(cin.origination.serial),(unsigned char *) cin.origination.serial); - (void) SetImageProperty(image,"cin:origination.serial", - cin.origination.serial); + (void) CopyMagickString(property,cin.origination.serial, + sizeof(cin.origination.serial)); + (void) SetImageProperty(image,"dpx:origination.serial",property,exception); cin.origination.x_pitch=ReadBlobFloat(image); offset+=4; cin.origination.y_pitch=ReadBlobFloat(image); @@ -626,50 +640,61 @@ static Image *ReadCINImage(const ImageInfo *image_info, cin.origination.reserve); if ((cin.file.image_offset > 2048) && (cin.file.user_length != 0)) { + int + c; + /* Image film information. */ cin.film.id=ReadBlobByte(image); offset++; - if ((unsigned long) cin.film.id != ~0UL) - (void) FormatImageProperty(image,"cin:film.id","%d",cin.film.id); + c=cin.film.id; + if (c != ~0) + (void) FormatImageProperty(image,"dpx:film.id","%d",cin.film.id); cin.film.type=ReadBlobByte(image); offset++; - if ((unsigned long) cin.film.type != ~0UL) - (void) FormatImageProperty(image,"cin:film.type","%d",cin.film.type); + c=cin.film.type; + if (c != ~0) + (void) FormatImageProperty(image,"dpx:film.type","%d",cin.film.type); cin.film.offset=ReadBlobByte(image); offset++; - if ((unsigned long) cin.film.offset != ~0UL) - (void) FormatImageProperty(image,"cin:film.offset","%d", + c=cin.film.offset; + if (c != ~0) + (void) FormatImageProperty(image,"dpx:film.offset","%d", cin.film.offset); cin.film.reserve1=ReadBlobByte(image); offset++; cin.film.prefix=ReadBlobLong(image); offset+=4; if (cin.film.prefix != ~0UL) - (void) FormatImageProperty(image,"cin:film.prefix","%lu", + (void) FormatImageProperty(image,"dpx:film.prefix","%.20g",(double) cin.film.prefix); cin.film.count=ReadBlobLong(image); offset+=4; offset+=ReadBlob(image,sizeof(cin.film.format),(unsigned char *) cin.film.format); - (void) SetImageProperty(image,"cin:film.format",cin.film.format); + (void) CopyMagickString(property,cin.film.format,sizeof(cin.film.format)); + (void) SetImageProperty(image,"dpx:film.format",property,exception); cin.film.frame_position=ReadBlobLong(image); offset+=4; if (cin.film.frame_position != ~0UL) - (void) FormatImageProperty(image,"cin:film.frame_position","%lu", - cin.film.frame_position); + (void) FormatImageProperty(image,"dpx:film.frame_position","%.20g", + (double) cin.film.frame_position); cin.film.frame_rate=ReadBlobFloat(image); offset+=4; if (IsFloatDefined(cin.film.frame_rate) != MagickFalse) - (void) FormatImageProperty(image,"cin:film.frame_rate","%g", + (void) FormatImageProperty(image,"dpx:film.frame_rate","%g", cin.film.frame_rate); offset+=ReadBlob(image,sizeof(cin.film.frame_id),(unsigned char *) cin.film.frame_id); - (void) SetImageProperty(image,"cin:film.frame_id",cin.film.frame_id); + (void) CopyMagickString(property,cin.film.frame_id, + sizeof(cin.film.frame_id)); + (void) SetImageProperty(image,"dpx:film.frame_id",property,exception); offset+=ReadBlob(image,sizeof(cin.film.slate_info),(unsigned char *) cin.film.slate_info); - (void) SetImageProperty(image,"cin:film.slate_info",cin.film.slate_info); + (void) CopyMagickString(property,cin.film.slate_info, + sizeof(cin.film.slate_info)); + (void) SetImageProperty(image,"dpx:film.slate_info",property,exception); offset+=ReadBlob(image,sizeof(cin.film.reserve),(unsigned char *) cin.film.reserve); } @@ -681,22 +706,36 @@ static Image *ReadCINImage(const ImageInfo *image_info, /* User defined data. */ - profile=AcquireStringInfo(cin.file.user_length); + profile=BlobToStringInfo((const unsigned char *) NULL,cin.file.user_length); + if (profile == (StringInfo *) NULL) + ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); offset+=ReadBlob(image,GetStringInfoLength(profile), GetStringInfoDatum(profile)); - (void) SetImageProfile(image,"cin:user.data",profile); + (void) SetImageProfile(image,"dpx:user.data",profile,exception); profile=DestroyStringInfo(profile); } - for ( ; offset < (long) cin.file.image_offset; offset++) - (void) ReadBlobByte(image); image->depth=cin.image.channel[0].bits_per_pixel; image->columns=cin.image.channel[0].pixels_per_line; image->rows=cin.image.channel[0].lines_per_image; - if (image_info->ping) + if (image_info->ping != MagickFalse) { (void) CloseBlob(image); return(image); } + for ( ; offset < (MagickOffsetType) cin.file.image_offset; offset++) + { + int + c; + + c=ReadBlobByte(image); + if (c == EOF) + break; + } + if (offset < (MagickOffsetType) cin.file.image_offset) + ThrowReaderException(CorruptImageError,"ImproperImageHeader"); + status=SetImageExtent(image,image->columns,image->rows,exception); + if (status == MagickFalse) + return(DestroyImageList(image)); /* Convert CIN raster image to pixel packets. */ @@ -706,7 +745,6 @@ static Image *ReadCINImage(const ImageInfo *image_info, quantum_info->quantum=32; quantum_info->pack=MagickFalse; quantum_type=RGBQuantum; - pixels=GetQuantumPixels(quantum_info); length=GetQuantumExtent(image,quantum_info,quantum_type); length=GetBytesPerRow(image->columns,3,image->depth,MagickTrue); if (cin.image.number_channels == 1) @@ -714,12 +752,13 @@ static Image *ReadCINImage(const ImageInfo *image_info, quantum_type=GrayQuantum; length=GetBytesPerRow(image->columns,1,image->depth,MagickTrue); } - for (y=0; y < (long) image->rows; y++) + for (y=0; y < (ssize_t) image->rows; y++) { q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); - if (q == (PixelPacket *) NULL) + if (q == (Quantum *) NULL) break; - count=ReadBlob(image,length,pixels); + pixels=(const unsigned char *) ReadBlobStream(image,length, + GetQuantumPixels(quantum_info),&count); if ((size_t) count != length) break; (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info, @@ -728,7 +767,8 @@ static Image *ReadCINImage(const ImageInfo *image_info, break; if (image->previous == (Image *) NULL) { - status=SetImageProgress(image,LoadImageTag,y,image->rows); + status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y, + image->rows); if (status == MagickFalse) break; } @@ -738,7 +778,7 @@ static Image *ReadCINImage(const ImageInfo *image_info, if (EOFBlob(image) != MagickFalse) ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile", image->filename); - image->colorspace=LogColorspace; + SetImageColorspace(image,LogColorspace,exception); (void) CloseBlob(image); return(GetFirstImageInList(image)); } @@ -762,20 +802,19 @@ static Image *ReadCINImage(const ImageInfo *image_info, % % The format of the RegisterCINImage method is: % -% unsigned long RegisterCINImage(void) +% size_t RegisterCINImage(void) % */ -ModuleExport unsigned long RegisterCINImage(void) +ModuleExport size_t RegisterCINImage(void) { MagickInfo *entry; - entry=SetMagickInfo("CIN"); + entry=AcquireMagickInfo("CIN","CIN","Cineon Image File"); entry->decoder=(DecodeImageHandler *) ReadCINImage; entry->encoder=(EncodeImageHandler *) WriteCINImage; entry->magick=(IsImageFormatHandler *) IsCIN; - entry->description=ConstantString("Cineon Image File"); - entry->module=ConstantString("CIN"); + entry->flags^=CoderAdjoinFlag; (void) RegisterMagickInfo(entry); return(MagickImageCoderSignature); } @@ -819,7 +858,8 @@ ModuleExport void UnregisterCINImage(void) % % The format of the WriteCINImage method is: % -% MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) +% MagickBooleanType WriteCINImage(const ImageInfo *image_info, +% Image *image,ExceptionInfo *exception) % % A description of each parameter follows. % @@ -827,10 +867,12 @@ ModuleExport void UnregisterCINImage(void) % % o image: The image. % +% o exception: return any errors or warnings in this structure. +% */ static inline const char *GetCINProperty(const ImageInfo *image_info, - const Image *image,const char *property) + const Image *image,const char *property,ExceptionInfo *exception) { const char *value; @@ -838,11 +880,15 @@ static inline const char *GetCINProperty(const ImageInfo *image_info, value=GetImageOption(image_info,property); if (value != (const char *) NULL) return(value); - return(GetImageProperty(image,property)); + return(GetImageProperty(image,property,exception)); } -static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) +static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image, + ExceptionInfo *exception) { + char + timestamp[MagickPathExtent]; + const char *value; @@ -852,9 +898,6 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) const StringInfo *profile; - long - y; - MagickBooleanType status; @@ -867,17 +910,18 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) QuantumType quantum_type; - register const PixelPacket + register const Quantum *p; - register long + register ssize_t i; size_t length; ssize_t - count; + count, + y; struct tm local_time; @@ -897,43 +941,40 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); - status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); + assert(exception != (ExceptionInfo *) NULL); + assert(exception->signature == MagickSignature); + status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception); if (status == MagickFalse) return(status); if (image->colorspace != LogColorspace) - (void) TransformImageColorspace(image,LogColorspace); + (void) TransformImageColorspace(image,LogColorspace,exception); /* Write image information. */ (void) ResetMagickMemory(&cin,0,sizeof(cin)); offset=0; cin.file.magic=0x802A5FD7UL; - offset+=WriteBlobLong(image,cin.file.magic); + offset+=WriteBlobLong(image,(unsigned int) cin.file.magic); cin.file.image_offset=0x800; - profile=GetImageProfile(image,"cin:user.data"); - if (profile != (StringInfo *) NULL) - { - cin.file.image_offset+=(unsigned long) GetStringInfoLength(profile); - cin.file.image_offset=(((cin.file.image_offset+0x2000-1)/0x2000)*0x2000); - } - offset+=WriteBlobLong(image,cin.file.image_offset); + offset+=WriteBlobLong(image,(unsigned int) cin.file.image_offset); cin.file.generic_length=0x400; - offset+=WriteBlobLong(image,cin.file.generic_length); + offset+=WriteBlobLong(image,(unsigned int) cin.file.generic_length); cin.file.industry_length=0x400; - offset+=WriteBlobLong(image,cin.file.industry_length); + offset+=WriteBlobLong(image,(unsigned int) cin.file.industry_length); cin.file.user_length=0x00; + profile=GetImageProfile(image,"dpx:user.data"); if (profile != (StringInfo *) NULL) { - cin.file.user_length+=(unsigned long) GetStringInfoLength(profile); + cin.file.user_length+=(size_t) GetStringInfoLength(profile); cin.file.user_length=(((cin.file.user_length+0x2000-1)/0x2000)*0x2000); } - offset+=WriteBlobLong(image,cin.file.user_length); + offset+=WriteBlobLong(image,(unsigned int) cin.file.user_length); cin.file.file_size=4*image->columns*image->rows+0x2000; - offset+=WriteBlobLong(image,cin.file.file_size); + offset+=WriteBlobLong(image,(unsigned int) cin.file.file_size); (void) CopyMagickString(cin.file.version,"V4.5",sizeof(cin.file.version)); offset+=WriteBlob(image,sizeof(cin.file.version),(unsigned char *) cin.file.version); - value=GetCINProperty(image_info,image,"cin:file.filename"); + value=GetCINProperty(image_info,image,"dpx:file.filename",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.file.filename,value,sizeof(cin.file.filename)); else @@ -947,12 +988,14 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) #else (void) memcpy(&local_time,localtime(&seconds),sizeof(local_time)); #endif - (void) strftime(cin.file.create_date,sizeof(cin.file.create_date),"%Y:%m:%d", - &local_time); + (void) memset(timestamp,0,sizeof(timestamp)); + (void) strftime(timestamp,MagickPathExtent,"%Y:%m:%d:%H:%M:%S%Z",&local_time); + (void) memset(cin.file.create_date,0,sizeof(cin.file.create_date)); + (void) CopyMagickString(cin.file.create_date,timestamp,11); offset+=WriteBlob(image,sizeof(cin.file.create_date),(unsigned char *) cin.file.create_date); - (void) strftime(cin.file.create_time,sizeof(cin.file.create_time), - "%H:%M:%S%Z",&local_time); + (void) memset(cin.file.create_time,0,sizeof(cin.file.create_time)); + (void) CopyMagickString(cin.file.create_time,timestamp+11,11); offset+=WriteBlob(image,sizeof(cin.file.create_time),(unsigned char *) cin.file.create_time); offset+=WriteBlob(image,sizeof(cin.file.reserve),(unsigned char *) @@ -973,9 +1016,11 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) offset+=WriteBlobByte(image,cin.image.channel[0].bits_per_pixel); offset+=WriteBlobByte(image,cin.image.channel[0].reserve); cin.image.channel[i].pixels_per_line=image->columns; - offset+=WriteBlobLong(image,cin.image.channel[0].pixels_per_line); + offset+=WriteBlobLong(image,(unsigned int) + cin.image.channel[0].pixels_per_line); cin.image.channel[i].lines_per_image=image->rows; - offset+=WriteBlobLong(image,cin.image.channel[0].lines_per_image); + offset+=WriteBlobLong(image,(unsigned int) + cin.image.channel[0].lines_per_image); cin.image.channel[i].min_data=0; offset+=WriteBlobFloat(image,cin.image.channel[0].min_data); cin.image.channel[i].min_quantity=0.0; @@ -994,7 +1039,7 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) offset+=WriteBlobFloat(image,image->chromaticity.green_primary.y); offset+=WriteBlobFloat(image,image->chromaticity.blue_primary.x); offset+=WriteBlobFloat(image,image->chromaticity.blue_primary.y); - value=GetCINProperty(image_info,image,"cin:image.label"); + value=GetCINProperty(image_info,image,"dpx:image.label",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.image.label,value,sizeof(cin.image.label)); offset+=WriteBlob(image,sizeof(cin.image.label),(unsigned char *) @@ -1006,32 +1051,32 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) */ cin.data_format.interleave=0; /* pixel interleave (rgbrgbr...) */ offset+=WriteBlobByte(image,cin.data_format.interleave); - cin.data_format.packing=5; /* packing longword (32bit) boundaries */ + cin.data_format.packing=5; /* packing ssize_tword (32bit) boundaries */ offset+=WriteBlobByte(image,cin.data_format.packing); cin.data_format.sign=0; /* unsigned data */ offset+=WriteBlobByte(image,cin.data_format.sign); cin.data_format.sense=0; /* image sense: positive image */ offset+=WriteBlobByte(image,cin.data_format.sense); cin.data_format.line_pad=0; - offset+=WriteBlobLong(image,cin.data_format.line_pad); + offset+=WriteBlobLong(image,(unsigned int) cin.data_format.line_pad); cin.data_format.channel_pad=0; - offset+=WriteBlobLong(image,cin.data_format.channel_pad); + offset+=WriteBlobLong(image,(unsigned int) cin.data_format.channel_pad); offset+=WriteBlob(image,sizeof(cin.data_format.reserve),(unsigned char *) cin.data_format.reserve); /* Write origination information. */ cin.origination.x_offset=0UL; - value=GetCINProperty(image_info,image,"cin:origination.x_offset"); + value=GetCINProperty(image_info,image,"dpx:origination.x_offset",exception); if (value != (const char *) NULL) - cin.origination.x_offset=StringToLong(value); - offset+=WriteBlobLong(image,(unsigned long) cin.origination.x_offset); + cin.origination.x_offset=(ssize_t) StringToLong(value); + offset+=WriteBlobLong(image,(unsigned int) cin.origination.x_offset); cin.origination.y_offset=0UL; - value=GetCINProperty(image_info,image,"cin:origination.y_offset"); + value=GetCINProperty(image_info,image,"dpx:origination.y_offset",exception); if (value != (const char *) NULL) - cin.origination.y_offset=StringToLong(value); - offset+=WriteBlobLong(image,(unsigned long) cin.origination.y_offset); - value=GetCINProperty(image_info,image,"cin:origination.filename"); + cin.origination.y_offset=(ssize_t) StringToLong(value); + offset+=WriteBlobLong(image,(unsigned int) cin.origination.y_offset); + value=GetCINProperty(image_info,image,"dpx:origination.filename",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.origination.filename,value, sizeof(cin.origination.filename)); @@ -1041,41 +1086,45 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) offset+=WriteBlob(image,sizeof(cin.origination.filename),(unsigned char *) cin.origination.filename); seconds=time((time_t *) NULL); - (void) strftime(cin.origination.create_date, - sizeof(cin.origination.create_date),"%Y:%m:%d",&local_time); + (void) memset(timestamp,0,sizeof(timestamp)); + (void) strftime(timestamp,MagickPathExtent,"%Y:%m:%d:%H:%M:%S%Z",&local_time); + (void) memset(cin.origination.create_date,0, + sizeof(cin.origination.create_date)); + (void) CopyMagickString(cin.origination.create_date,timestamp,11); offset+=WriteBlob(image,sizeof(cin.origination.create_date),(unsigned char *) cin.origination.create_date); - (void) strftime(cin.origination.create_time, - sizeof(cin.origination.create_time),"%H:%M:%S%Z",&local_time); + (void) memset(cin.origination.create_time,0, + sizeof(cin.origination.create_time)); + (void) CopyMagickString(cin.origination.create_time,timestamp+11,15); offset+=WriteBlob(image,sizeof(cin.origination.create_time),(unsigned char *) cin.origination.create_time); - value=GetCINProperty(image_info,image,"cin:origination.device"); + value=GetCINProperty(image_info,image,"dpx:origination.device",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.origination.device,value, sizeof(cin.origination.device)); offset+=WriteBlob(image,sizeof(cin.origination.device),(unsigned char *) cin.origination.device); - value=GetCINProperty(image_info,image,"cin:origination.model"); + value=GetCINProperty(image_info,image,"dpx:origination.model",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.origination.model,value, sizeof(cin.origination.model)); offset+=WriteBlob(image,sizeof(cin.origination.model),(unsigned char *) cin.origination.model); - value=GetCINProperty(image_info,image,"cin:origination.serial"); + value=GetCINProperty(image_info,image,"dpx:origination.serial",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.origination.serial,value, sizeof(cin.origination.serial)); offset+=WriteBlob(image,sizeof(cin.origination.serial),(unsigned char *) cin.origination.serial); cin.origination.x_pitch=0.0f; - value=GetCINProperty(image_info,image,"cin:origination.x_pitch"); + value=GetCINProperty(image_info,image,"dpx:origination.x_pitch",exception); if (value != (const char *) NULL) - cin.origination.x_pitch=StringToDouble(value); + cin.origination.x_pitch=StringToDouble(value,(char **) NULL); offset+=WriteBlobFloat(image,cin.origination.x_pitch); cin.origination.y_pitch=0.0f; - value=GetCINProperty(image_info,image,"cin:origination.y_pitch"); + value=GetCINProperty(image_info,image,"dpx:origination.y_pitch",exception); if (value != (const char *) NULL) - cin.origination.y_pitch=StringToDouble(value); + cin.origination.y_pitch=StringToDouble(value,(char **) NULL); offset+=WriteBlobFloat(image,cin.origination.y_pitch); cin.origination.gamma=image->gamma; offset+=WriteBlobFloat(image,cin.origination.gamma); @@ -1085,52 +1134,52 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) Image film information. */ cin.film.id=0; - value=GetCINProperty(image_info,image,"cin:film.id"); + value=GetCINProperty(image_info,image,"dpx:film.id",exception); if (value != (const char *) NULL) cin.film.id=(char) StringToLong(value); offset+=WriteBlobByte(image,(unsigned char) cin.film.id); cin.film.type=0; - value=GetCINProperty(image_info,image,"cin:film.type"); + value=GetCINProperty(image_info,image,"dpx:film.type",exception); if (value != (const char *) NULL) cin.film.type=(char) StringToLong(value); offset+=WriteBlobByte(image,(unsigned char) cin.film.type); cin.film.offset=0; - value=GetCINProperty(image_info,image,"cin:film.offset"); + value=GetCINProperty(image_info,image,"dpx:film.offset",exception); if (value != (const char *) NULL) cin.film.offset=(char) StringToLong(value); offset+=WriteBlobByte(image,(unsigned char) cin.film.offset); offset+=WriteBlobByte(image,(unsigned char) cin.film.reserve1); cin.film.prefix=0UL; - value=GetCINProperty(image_info,image,"cin:film.prefix"); + value=GetCINProperty(image_info,image,"dpx:film.prefix",exception); if (value != (const char *) NULL) - cin.film.prefix=(unsigned long) StringToLong(value); - offset+=WriteBlobLong(image,cin.film.prefix); + cin.film.prefix=StringToUnsignedLong(value); + offset+=WriteBlobLong(image,(unsigned int) cin.film.prefix); cin.film.count=0UL; - value=GetCINProperty(image_info,image,"cin:film.count"); + value=GetCINProperty(image_info,image,"dpx:film.count",exception); if (value != (const char *) NULL) - cin.film.count=(unsigned long) StringToLong(value); - offset+=WriteBlobLong(image,cin.film.count); - value=GetCINProperty(image_info,image,"cin:film.format"); + cin.film.count=StringToUnsignedLong(value); + offset+=WriteBlobLong(image,(unsigned int) cin.film.count); + value=GetCINProperty(image_info,image,"dpx:film.format",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.film.format,value,sizeof(cin.film.format)); offset+=WriteBlob(image,sizeof(cin.film.format),(unsigned char *) cin.film.format); cin.film.frame_position=0UL; - value=GetCINProperty(image_info,image,"cin:film.frame_position"); + value=GetCINProperty(image_info,image,"dpx:film.frame_position",exception); if (value != (const char *) NULL) - cin.film.frame_position=(unsigned long) StringToLong(value); - offset+=WriteBlobLong(image,cin.film.frame_position); + cin.film.frame_position=StringToUnsignedLong(value); + offset+=WriteBlobLong(image,(unsigned int) cin.film.frame_position); cin.film.frame_rate=0.0f; - value=GetCINProperty(image_info,image,"cin:film.frame_rate"); + value=GetCINProperty(image_info,image,"dpx:film.frame_rate",exception); if (value != (const char *) NULL) - cin.film.frame_rate=StringToDouble(value); + cin.film.frame_rate=StringToDouble(value,(char **) NULL); offset+=WriteBlobFloat(image,cin.film.frame_rate); - value=GetCINProperty(image_info,image,"cin:film.frame_id"); + value=GetCINProperty(image_info,image,"dpx:film.frame_id",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.film.frame_id,value,sizeof(cin.film.frame_id)); offset+=WriteBlob(image,sizeof(cin.film.frame_id),(unsigned char *) cin.film.frame_id); - value=GetCINProperty(image_info,image,"cin:film.slate_info"); + value=GetCINProperty(image_info,image,"dpx:film.slate_info",exception); if (value != (const char *) NULL) (void) CopyMagickString(cin.film.slate_info,value, sizeof(cin.film.slate_info)); @@ -1152,24 +1201,27 @@ static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image) quantum_info->quantum=32; quantum_info->pack=MagickFalse; quantum_type=RGBQuantum; - pixels=GetQuantumPixels(quantum_info); + pixels=(unsigned char *) GetQuantumPixels(quantum_info); length=GetBytesPerRow(image->columns,3,image->depth,MagickTrue); +DisableMSCWarning(4127) if (0) +RestoreMSCWarning { quantum_type=GrayQuantum; - length=GetBytesPerRow(image->columns,3,image->depth,MagickTrue); + length=GetBytesPerRow(image->columns,1,image->depth,MagickTrue); } - for (y=0; y < (long) image->rows; y++) + for (y=0; y < (ssize_t) image->rows; y++) { - p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception); - if (p == (const PixelPacket *) NULL) + p=GetVirtualPixels(image,0,y,image->columns,1,exception); + if (p == (const Quantum *) NULL) break; - (void) ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info, - quantum_type,pixels,&image->exception); + (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info, + quantum_type,pixels,exception); count=WriteBlob(image,length,pixels); if (count != (ssize_t) length) break; - status=SetImageProgress(image,SaveImageTag,y,image->rows); + status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y, + image->rows); if (status == MagickFalse) break; }