/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e Y U V I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteYUVImage writes an image to a file in the digital YUV
% (CCIR 601 4:1:1) format.
%
% The format of the WriteYUVImage method is:
%
% unsigned int WriteYUVImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteYUVImage 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 an ImageInfo structure.
%
% o image: A pointer to a Image structure.
%
%
*/
Export unsigned int WriteYUVImage(const ImageInfo *image_info,Image *image)
{
Image
*chroma_image,
*yuv_image;
int
y;
register int
x;
register PixelPacket
*p;
unsigned int
height,
scene,
status,
width;
if (image_info->interlace != PartitionInterlace)
{
/*
Open output image file.
*/
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
}
if (image_info->interlace == PartitionInterlace)
{
AppendImageFormat("Y",image->filename);
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
}
scene=0;
do
{
/*
Sample image to an even width and height.
*/
TransformRGBImage(image,RGBColorspace);
width=image->columns+(image->columns & 0x01);
height=image->rows+(image->rows & 0x01);
image->orphan=True;
yuv_image=SampleImage(image,width,height);
if (yuv_image == (Image *) NULL)
WriterExit(ResourceLimitWarning,"Unable to zoom image",image);
RGBTransformImage(yuv_image,YCbCrColorspace);
/*
Initialize Y channel.
*/
for (y=0; y < (int) yuv_image->rows; y++)
{
p=GetPixelCache(yuv_image,0,y,yuv_image->columns,1);
if (p == (PixelPacket *) NULL)
break;
for (x=0; x < (int) yuv_image->columns; x++)
{
(void) WriteByte(image,DownScale(p->red));
p++;
}
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
ProgressMonitor(SaveImageText,y,image->rows);
}
DestroyImage(yuv_image);
/*
Downsample image.
*/
image->orphan=True;
chroma_image=SampleImage(image,width/2,height/2);
if (chroma_image == (Image *) NULL)
WriterExit(ResourceLimitWarning,"Unable to zoom image",image);
RGBTransformImage(chroma_image,YCbCrColorspace);
/*
Initialize U channel.
*/
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("U",image->filename);
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
}
for (y=0; y < (int) chroma_image->rows; y++)
{
p=GetPixelCache(chroma_image,0,y,chroma_image->columns,1);
if (p == (PixelPacket *) NULL)
break;
for (x=0; x < (int) chroma_image->columns; x++)
{
(void) WriteByte(image,DownScale(p->green));
p++;
}
}
/*
Initialize V channel.
*/
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("V",image->filename);
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
}
for (y=0; y < (int) chroma_image->rows; y++)
{
p=GetPixelCache(chroma_image,0,y,chroma_image->columns,1);
if (p == (PixelPacket *) NULL)
break;
for (x=0; x < (int) chroma_image->columns; x++)
{
(void) WriteByte(image,DownScale(p->blue));
p++;
}
}
DestroyImage(chroma_image);
if (image_info->interlace == PartitionInterlace)
(void) strcpy(image->filename,image_info->filename);
if (image->next == (Image *) NULL)
break;
image=GetNextImage(image);
ProgressMonitor(SaveImagesText,scene++,GetNumberScenes(image));
} while (image_info->adjoin);
if (image_info->adjoin)
while (image->previous != (Image *) NULL)
image=image->previous;
CloseBlob(image);
return(True);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e H T M L I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteHTMLImage writes an image in the HTML encoded image format.
%
% The format of the WriteHTMLImage method is:
%
% unsigned int WriteHTMLImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteHTMLImage 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 an ImageInfo structure.
%
% o image: A pointer to a Image structure.
%
%
*/
Export unsigned int WriteHTMLImage(const ImageInfo *image_info,Image *image)
{
char
buffer[MaxTextExtent],
filename[MaxTextExtent],
mapname[MaxTextExtent],
url[MaxTextExtent];
Image
*next;
ImageInfo
*local_info;
int
x,
y;
register char
*p;
register PixelPacket
*q;
unsigned int
height,
status,
width;
/*
Open image.
*/
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
CloseBlob(image);
TransformRGBImage(image,RGBColorspace);
*url='\0';
if ((Latin1Compare(image_info->magick,"FTP") == 0) ||
(Latin1Compare(image_info->magick,"HTTP") == 0))
{
/*
Extract URL base from filename.
*/
p=strrchr(image->filename,'/');
if (p)
{
p++;
(void) strcpy(url,image_info->magick);
(void) strcat(url,":");
url[Extent(url)+p-image->filename]='\0';
(void) strncat(url,image->filename,p-image->filename);
(void) strcpy(image->filename,p);
}
}
/*
Refer to image map file.
*/
(void) strcpy(filename,image->filename);
AppendImageFormat("map",filename);
(void) strcpy(mapname,BaseFilename(filename));
(void) strcpy(image->filename,image_info->filename);
(void) strcpy(filename,image->filename);
local_info=CloneImageInfo(image_info);
if (local_info == (ImageInfo *) NULL)
WriterExit(FileOpenWarning,"Unable to allocate memory",image);
local_info->adjoin=True;
status=True;
if (Latin1Compare(image_info->magick,"SHTML") != 0)
{
/*
Open output image file.
*/
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
/*
Write the HTML image file.
*/
(void) strcpy(buffer,"<html version=\"2.0\">\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<head>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer,"<title>%.1024s</title>\n",
image->label ? image->label : BaseFilename(image->filename));
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"</head>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<body>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<center>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer,"<h1>%.1024s</h1>\n",image->filename);
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"<br><br>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(filename,image->filename);
AppendImageFormat("gif",filename);
(void) sprintf(buffer,
"<img ismap usemap=#%.1024s src=\"%.1024s\" border=0>\n",
mapname,filename);
(void) WriteBlob(image,strlen(buffer),buffer);
/*
Determine the size and location of each image tile.
*/
width=image->columns;
height=image->rows;
x=0;
y=0;
if (image->montage != (char *) NULL)
(void) ParseGeometry(image->montage,&x,&y,&width,&height);
/*
Write an image map.
*/
(void) sprintf(buffer,"<map name=%.1024s>\n",mapname);
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
if (image->directory == (char *) NULL)
{
(void) sprintf(buffer,"%.1024s shape=rect coords=0,0,%u,%u>\n",
image->filename,width-1,height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
}
else
for (p=image->directory; *p != '\0'; p++)
if (*p != '\n')
(void) WriteByte(image,*p);
else
{
(void) sprintf(buffer," shape=rect coords=%d,%d,%d,%d>\n",
x,y,x+(int) width-1,y+(int) height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
if (*(p+1) != '\0')
{
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
}
x+=width;
if (x >= (int) image->columns)
{
x=0;
y+=height;
}
}
(void) strcpy(buffer,"</map>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
if (image->montage != (char *) NULL)
{
char
color[MaxTextExtent] = "#000";
/*
Make montage background transparent.
*/
q=GetPixelCache(image,0,0,1,1);
if (q != (PixelPacket *) NULL)
FormatString(color,HexColorFormat,q->red,q->green,q->blue);
TransparentImage(image,color);
}
(void) strcpy(filename,image->filename);
(void) strcpy(buffer,"</center>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"</body>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
(void) strcpy(buffer,"</html>\n");
status=WriteBlob(image,strlen(buffer),buffer);
CloseBlob(image);
/*
Write the image as transparent GIF.
*/
(void) strcpy(image->filename,filename);
AppendImageFormat("gif",image->filename);
next=image->next;
image->next=(Image *) NULL;
status|=WriteGIFImage(local_info,image);
image->next=next;
/*
Determine image map filename.
*/
(void) strcpy(image->filename,filename);
for (p=filename+Extent(filename)-1; p > (filename+1); p--)
if (*p == '.')
{
(void) strncpy(image->filename,filename,p-filename);
image->filename[p-filename]='\0';
break;
}
(void) strcat(image->filename,"_map.shtml");
}
/*
Open image map.
*/
status=OpenBlob(local_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
DestroyImageInfo(local_info);
/*
Determine the size and location of each image tile.
*/
width=image->columns;
height=image->rows;
x=0;
y=0;
if (image->montage != (char *) NULL)
(void) ParseGeometry(image->montage,&x,&y,&width,&height);
/*
Write an image map.
*/
(void) sprintf(buffer,"<map name=%.1024s>\n",mapname);
(void) WriteBlob(image,strlen(buffer),buffer);
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
if (image->directory == (char *) NULL)
{
(void) sprintf(buffer,"%.1024s shape=rect coords=0,0,%u,%u>\n",
image->filename,width-1,height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
}
else
for (p=image->directory; *p != '\0'; p++)
if (*p != '\n')
(void) WriteByte(image,*p);
else
{
(void) sprintf(buffer," shape=rect coords=%d,%d,%d,%d>\n",x,y,
x+(int) width-1,y+(int) height-1);
(void) WriteBlob(image,strlen(buffer),buffer);
if (*(p+1) != '\0')
{
(void) sprintf(buffer," <area href=""%.1024s""",url);
(void) WriteBlob(image,strlen(buffer),buffer);
}
x+=width;
if (x >= (int) image->columns)
{
x=0;
y+=height;
}
}
(void) strcpy(buffer,"</map>\n");
(void) WriteBlob(image,strlen(buffer),buffer);
CloseBlob(image);
(void) strcpy(image->filename,filename);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d I P T C I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadIPTCImage reads an image file in the IPTC format and returns it.
% It allocates the memory necessary for the new Image structure and returns a
% pointer to the new image. This method differs from the other decoder
% methods in that only the iptc profile information is useful in the
% returned image.
%
% The format of the ReadIPTCImage method is:
%
% Image *ReadIPTCImage(const ImageInfo *image_info)
%
% A description of each parameter follows:
%
% o image: Method ReadIPTCImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or if
% the image cannot be read.
%
% o image_info: Specifies a pointer to an ImageInfo structure.
%
%
*/
Export Image *ReadIPTCImage(const ImageInfo *image_info)
{
Image
*image;
int
c;
register unsigned char
*q;
unsigned char
*data;
unsigned int
tag_length,
length,
status;
/*
Allocate image structure.
*/
image=AllocateImage(image_info);
if (image == (Image *) NULL)
return((Image *) NULL);
/*
Open image file.
*/
status=OpenBlob(image_info,image,ReadBinaryType);
if (status == False)
ReaderExit(FileOpenWarning,"Unable to open file",image);
/*
Read IPTC image.
*/
length=MaxTextExtent;
tag_length=12;
data=(unsigned char *)
AllocateMemory((length+2)*sizeof(unsigned char));
if (data == (unsigned char *) NULL)
WriterExit(ResourceLimitWarning,"Memory allocation failed",image);
(void) memcpy((char *) data,"8BIM\04\04\0\0\0\0\0\0",tag_length);
q=data;
q+=tag_length;
while (1)
{
c=ReadByte(image);
if (c == EOF)
break;
if ((q-data+1) >= (int) length)
{
image->iptc_profile.length=q-data;
length<<=1;
data=(unsigned char *) ReallocateMemory((char *)
data,(length+2)*sizeof(unsigned char));
if (data == (unsigned char *) NULL)
break;
q=data+image->iptc_profile.length;
}
*q++=(unsigned char) c;
}
image->iptc_profile.length=0;
if (data != (unsigned char *) NULL)
{
image->iptc_profile.length=q-data;
length=image->iptc_profile.length-tag_length;
data[10]=length >> 8;
data[11]=length & 0xff;
image->iptc_profile.info=data;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e E P T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteEPTImage writes an image in the Adobe Encapsulated Postscript
% format with a TIFF preview.
%
% The format of the WriteEPTImage method is:
%
% unsigned int WriteEPTImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteEPTImage 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 an ImageInfo structure.
%
% o image: A pointer to a Image structure.
%
%
*/
Export unsigned int WriteEPTImage(const ImageInfo *image_info,Image *image)
{
char
filename[MaxTextExtent];
FILE
*ps_file,
*tiff_file;
int
c;
unsigned int
status;
unsigned long
eps_length,
tiff_length;
ps_file=(FILE *) NULL;
if (Latin1Compare(image_info->magick,"PS") == 0)
ps_file=fopen(image->magick_filename,ReadBinaryType);
if (ps_file != (FILE *) NULL)
{
struct stat
attributes;
/*
Read existing Encapsulated Postscript.
*/
eps_length=
fstat(fileno(ps_file),&attributes) < 0 ? 0 : attributes.st_size;
}
else
{
/*
Write image as Encapsulated Postscript to a temporary file.
*/
(void) strcpy(filename,image->filename);
TemporaryFilename(image->filename);
status=WritePSImage(image_info,image);
if (status == False)
return(status);
status=OpenBlob(image_info,image,ReadBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
(void) remove(image->filename);
eps_length=image->filesize;
ps_file=image->file;
image->file=(FILE *) NULL;
}
/*
Write image as TIFF to a temporary file.
*/
TemporaryFilename(image->filename);
status=WriteTIFFImage(image_info,image);
if (status == False)
return(status);
status=OpenBlob(image_info,image,ReadBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
(void) remove(image->filename);
tiff_length=image->filesize;
tiff_file=image->file;
image->file=(FILE *) NULL;
/*
Write EPT image.
*/
(void) strcpy(image->filename,filename);
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
LSBFirstWriteLong(image,0xc6d3d0c5ul);
LSBFirstWriteLong(image,30);
LSBFirstWriteLong(image,eps_length);
LSBFirstWriteLong(image,0);
LSBFirstWriteLong(image,0);
LSBFirstWriteLong(image,eps_length+30);
LSBFirstWriteLong(image,tiff_length);
LSBFirstWriteShort(image,0xffff);
for (c=fgetc(ps_file); c != EOF; c=fgetc(ps_file))
(void) WriteByte(image,(char) c);
for (c=fgetc(tiff_file); c != EOF; c=fgetc(tiff_file))
(void) WriteByte(image,(char) c);
(void) fclose(tiff_file);
CloseBlob(image);
return(True);
}
