static Image *ReadCINImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
#define MonoColorType 1
#define RGBColorType 3
char
magick[4];
CINInfo
cin;
Image
*image;
ssize_t
y;
MagickBooleanType
status;
MagickOffsetType
offset;
QuantumInfo
*quantum_info;
QuantumType
quantum_type;
register ssize_t
i;
register PixelPacket
*q;
size_t
length;
ssize_t
count;
unsigned char
*pixels;
size_t
lsb_first;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
File information.
*/
offset=0;
count=ReadBlob(image,4,(unsigned char *) 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;
cin.file.image_offset=ReadBlobLong(image);
offset+=4;
cin.file.generic_length=ReadBlobLong(image);
offset+=4;
cin.file.industry_length=ReadBlobLong(image);
offset+=4;
cin.file.user_length=ReadBlobLong(image);
offset+=4;
cin.file.file_size=ReadBlobLong(image);
offset+=4;
offset+=ReadBlob(image,sizeof(cin.file.version),(unsigned char *)
cin.file.version);
(void) SetImageProperty(image,"dpx:file.version",cin.file.version);
offset+=ReadBlob(image,sizeof(cin.file.filename),(unsigned char *)
cin.file.filename);
(void) SetImageProperty(image,"dpx:file.filename",cin.file.filename);
offset+=ReadBlob(image,sizeof(cin.file.create_date),(unsigned char *)
cin.file.create_date);
(void) SetImageProperty(image,"dpx:file.create_date",cin.file.create_date);
offset+=ReadBlob(image,sizeof(cin.file.create_time),(unsigned char *)
cin.file.create_time);
(void) SetImageProperty(image,"dpx:file.create_time",cin.file.create_time);
offset+=ReadBlob(image,sizeof(cin.file.reserve),(unsigned char *)
cin.file.reserve);
/*
Image information.
*/
cin.image.orientation=(unsigned char) ReadBlobByte(image);
offset++;
if (cin.image.orientation != (unsigned char) (~0U))
(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;
}
cin.image.number_channels=(unsigned char) ReadBlobByte(image);
offset++;
offset+=ReadBlob(image,sizeof(cin.image.reserve1),(unsigned char *)
cin.image.reserve1);
for (i=0; i < 8; i++)
{
cin.image.channel[i].designator[0]=(unsigned char) ReadBlobByte(image);
offset++;
cin.image.channel[i].designator[1]=(unsigned char) ReadBlobByte(image);
offset++;
cin.image.channel[i].bits_per_pixel=(unsigned char) ReadBlobByte(image);
offset++;
cin.image.channel[i].reserve=(unsigned char) ReadBlobByte(image);
offset++;
cin.image.channel[i].pixels_per_line=ReadBlobLong(image);
offset+=4;
cin.image.channel[i].lines_per_image=ReadBlobLong(image);
offset+=4;
cin.image.channel[i].min_data=ReadBlobFloat(image);
offset+=4;
cin.image.channel[i].min_quantity=ReadBlobFloat(image);
offset+=4;
cin.image.channel[i].max_data=ReadBlobFloat(image);
offset+=4;
cin.image.channel[i].max_quantity=ReadBlobFloat(image);
offset+=4;
}
cin.image.white_point[0]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.white_point[0]) != MagickFalse)
image->chromaticity.white_point.x=cin.image.white_point[0];
cin.image.white_point[1]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.white_point[1]) != MagickFalse)
image->chromaticity.white_point.y=cin.image.white_point[1];
cin.image.red_primary_chromaticity[0]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.red_primary_chromaticity[0]) != MagickFalse)
image->chromaticity.red_primary.x=cin.image.red_primary_chromaticity[0];
cin.image.red_primary_chromaticity[1]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.red_primary_chromaticity[1]) != MagickFalse)
image->chromaticity.red_primary.y=cin.image.red_primary_chromaticity[1];
cin.image.green_primary_chromaticity[0]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.green_primary_chromaticity[0]) != MagickFalse)
image->chromaticity.red_primary.x=cin.image.green_primary_chromaticity[0];
cin.image.green_primary_chromaticity[1]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.green_primary_chromaticity[1]) != MagickFalse)
image->chromaticity.green_primary.y=cin.image.green_primary_chromaticity[1];
cin.image.blue_primary_chromaticity[0]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.blue_primary_chromaticity[0]) != MagickFalse)
image->chromaticity.blue_primary.x=cin.image.blue_primary_chromaticity[0];
cin.image.blue_primary_chromaticity[1]=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.image.blue_primary_chromaticity[1]) != MagickFalse)
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,"dpx:image.label",cin.image.label);
offset+=ReadBlob(image,sizeof(cin.image.reserve),(unsigned char *)
cin.image.reserve);
/*
Image data format information.
*/
cin.data_format.interleave=(unsigned char) ReadBlobByte(image);
offset++;
cin.data_format.packing=(unsigned char) ReadBlobByte(image);
offset++;
cin.data_format.sign=(unsigned char) ReadBlobByte(image);
offset++;
cin.data_format.sense=(unsigned char) ReadBlobByte(image);
offset++;
cin.data_format.line_pad=ReadBlobLong(image);
offset+=4;
cin.data_format.channel_pad=ReadBlobLong(image);
offset+=4;
offset+=ReadBlob(image,sizeof(cin.data_format.reserve),(unsigned char *)
cin.data_format.reserve);
/*
Image origination information.
*/
cin.origination.x_offset=(int) ReadBlobLong(image);
offset+=4;
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 ((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,"dpx:origination.filename",
cin.origination.filename);
offset+=ReadBlob(image,sizeof(cin.origination.create_date),(unsigned char *)
cin.origination.create_date);
(void) SetImageProperty(image,"dpx:origination.create_date",
cin.origination.create_date);
offset+=ReadBlob(image,sizeof(cin.origination.create_time),(unsigned char *)
cin.origination.create_time);
(void) SetImageProperty(image,"dpx:origination.create_time",
cin.origination.create_time);
offset+=ReadBlob(image,sizeof(cin.origination.device),(unsigned char *)
cin.origination.device);
(void) SetImageProperty(image,"dpx:origination.device",
cin.origination.device);
offset+=ReadBlob(image,sizeof(cin.origination.model),(unsigned char *)
cin.origination.model);
(void) SetImageProperty(image,"dpx:origination.model",cin.origination.model);
offset+=ReadBlob(image,sizeof(cin.origination.serial),(unsigned char *)
cin.origination.serial);
(void) SetImageProperty(image,"dpx:origination.serial",
cin.origination.serial);
cin.origination.x_pitch=ReadBlobFloat(image);
offset+=4;
cin.origination.y_pitch=ReadBlobFloat(image);
offset+=4;
cin.origination.gamma=ReadBlobFloat(image);
offset+=4;
if (IsFloatDefined(cin.origination.gamma) != MagickFalse)
image->gamma=cin.origination.gamma;
offset+=ReadBlob(image,sizeof(cin.origination.reserve),(unsigned char *)
cin.origination.reserve);
if ((cin.file.image_offset > 2048) && (cin.file.user_length != 0))
{
/*
Image film information.
*/
cin.film.id=ReadBlobByte(image);
offset++;
if (((size_t) cin.film.id) != ~0UL)
(void) FormatImageProperty(image,"dpx:film.id","%d",cin.film.id);
cin.film.type=ReadBlobByte(image);
offset++;
if (((size_t) cin.film.type) != ~0UL)
(void) FormatImageProperty(image,"dpx:film.type","%d",cin.film.type);
cin.film.offset=ReadBlobByte(image);
offset++;
if (((size_t) cin.film.offset) != ~0UL)
(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,"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,"dpx:film.format",cin.film.format);
cin.film.frame_position=ReadBlobLong(image);
offset+=4;
if (cin.film.frame_position != ~0UL)
(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,"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,"dpx:film.frame_id",cin.film.frame_id);
offset+=ReadBlob(image,sizeof(cin.film.slate_info),(unsigned char *)
cin.film.slate_info);
(void) SetImageProperty(image,"dpx:film.slate_info",cin.film.slate_info);
offset+=ReadBlob(image,sizeof(cin.film.reserve),(unsigned char *)
cin.film.reserve);
}
if ((cin.file.image_offset > 2048) && (cin.file.user_length != 0))
{
StringInfo
*profile;
/*
User defined data.
*/
profile=AcquireStringInfo(cin.file.user_length);
offset+=ReadBlob(image,GetStringInfoLength(profile),
GetStringInfoDatum(profile));
(void) SetImageProfile(image,"dpx:user.data",profile);
profile=DestroyStringInfo(profile);
}
for ( ; offset < (MagickOffsetType) 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)
{
(void) CloseBlob(image);
return(image);
}
/*
Convert CIN raster image to pixel packets.
*/
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
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)
{
quantum_type=GrayQuantum;
length=GetBytesPerRow(image->columns,1,image->depth,MagickTrue);
}
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
count=ReadBlob(image,length,pixels);
if ((size_t) count != length)
break;
(void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
quantum_type,pixels,exception);
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
}
SetQuantumImageType(image,quantum_type);
quantum_info=DestroyQuantumInfo(quantum_info);
if (EOFBlob(image) != MagickFalse)
ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
image->filename);
image->colorspace=LogColorspace;
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d J N X I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadJNXImage() reads an image in the Garmin tile storage format and returns
% it. It allocates the memory necessary for the new Image structure and
% returns a pointer to the new image.
%
% The format of the ReadJNXImage method is:
%
% Image *ReadJNXImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadJNXImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
#define JNXMaxLevels 20
Image
*image,
*images;
JNXInfo
jnx_info;
JNXLevelInfo
jnx_level_info[JNXMaxLevels];
MagickBooleanType
status;
register ssize_t
i;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Read JNX header.
*/
(void) ResetMagickMemory(&jnx_info,0,sizeof(jnx_info));
jnx_info.version=(int) ReadBlobLSBLong(image);
if ((jnx_info.version != 3) && (jnx_info.version != 4))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
jnx_info.serial=(int) ReadBlobLSBLong(image);
jnx_info.northeast.x=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
jnx_info.northeast.y=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
jnx_info.southwest.x=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
jnx_info.southwest.y=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
jnx_info.levels=(int) ReadBlobLSBLong(image);
if (jnx_info.levels > JNXMaxLevels)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
jnx_info.expire=(int) ReadBlobLSBLong(image);
jnx_info.id=(int) ReadBlobLSBLong(image);
jnx_info.crc=(int) ReadBlobLSBLong(image);
jnx_info.signature=(int) ReadBlobLSBLong(image);
jnx_info.offset=ReadBlobLSBLong(image);
if (jnx_info.version > 3)
jnx_info.order=(int) ReadBlobLSBLong(image);
else
if (jnx_info.version == 3)
jnx_info.order=30;
/*
Read JNX levels.
*/
(void) ResetMagickMemory(&jnx_level_info,0,sizeof(jnx_level_info));
for (i=0; i < (ssize_t) jnx_info.levels; i++)
{
jnx_level_info[i].count=(int) ReadBlobLSBLong(image);
if (jnx_level_info[i].count > 50000)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
jnx_level_info[i].offset=(int) ReadBlobLSBLong(image);
jnx_level_info[i].scale=ReadBlobLSBLong(image);
if (jnx_info.version > 3)
{
register ssize_t
j;
unsigned short
c;
(void) ReadBlobLSBLong(image);
j=0;
while ((c=ReadBlobLSBShort(image)) != 0)
if (j < (MaxTextExtent-1))
jnx_level_info[i].copyright[j++]=c;
jnx_level_info[i].copyright[j]=0;
}
}
/*
Read JNX tiles.
*/
images=NewImageList();
for (i=0; i < (ssize_t) jnx_info.levels; i++)
{
MagickOffsetType
offset;
register ssize_t
j;
offset=SeekBlob(image,(MagickOffsetType) jnx_level_info[i].offset,SEEK_SET);
if (offset != (MagickOffsetType) jnx_level_info[i].offset)
continue;
for (j=0; j < (ssize_t) jnx_level_info[i].count; j++)
{
Image
*tile_image;
ImageInfo
*read_info;
int
tile_offset;
MagickOffsetType
restore_offset;
PointInfo
northeast,
southwest;
ssize_t
count;
unsigned char
*blob;
unsigned int
tile_length;
northeast.x=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
northeast.y=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
southwest.x=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
southwest.y=180.0*((int) ReadBlobLSBLong(image))/0x7fffffff;
(void) ReadBlobLSBShort(image); /* width */
(void) ReadBlobLSBShort(image); /* height */
tile_length=ReadBlobLSBLong(image);
tile_offset=(int) ReadBlobLSBLong(image);
restore_offset=TellBlob(image);
offset=SeekBlob(image,(MagickOffsetType) tile_offset,SEEK_SET);
if (offset != (MagickOffsetType) tile_offset)
continue;
/*
Read a tile.
*/
blob=(unsigned char *) AcquireQuantumMemory((size_t) tile_length+2,
sizeof(*blob));
if (blob == (unsigned char *) NULL)
{
if (images != (Image *) NULL)
images=DestroyImageList(images);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
blob[0]=0xFF;
blob[1]=0xD8;
count=ReadBlob(image,tile_length,blob+2);
if (count != (ssize_t) tile_length)
{
if (images != (Image *) NULL)
images=DestroyImageList(images);
blob=(unsigned char *) RelinquishMagickMemory(blob);
ThrowReaderException(CorruptImageError,"UnexpectedEndOfFile");
}
read_info=CloneImageInfo(image_info);
(void) CopyMagickString(read_info->magick,"JPEG",MaxTextExtent);
tile_image=BlobToImage(read_info,blob,tile_length+2,exception);
read_info=DestroyImageInfo(read_info);
blob=(unsigned char *) RelinquishMagickMemory(blob);
offset=SeekBlob(image,restore_offset,SEEK_SET);
if (tile_image == (Image *) NULL)
continue;
(void) CopyMagickString(tile_image->magick,image->magick,MaxTextExtent);
(void) FormatImageProperty(tile_image,"jnx:northeast","%.20g,%.20g",
northeast.x,northeast.y);
(void) FormatImageProperty(tile_image,"jnx:southwest","%.20g,%.20g",
southwest.x,southwest.y);
AppendImageToList(&images,tile_image);
}
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) i,
(MagickSizeType) jnx_info.levels);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
(void) CloseBlob(image);
image=DestroyImage(image);
if (images == (Image *) NULL)
return((Image *) NULL);
return(GetFirstImageInList(images));
}
