/******************************************************************************
Open a new GIF file for read, given by its name.
Returns dynamically allocated GifFileType pointer which serves as the GIF
info record.
******************************************************************************/
GifFileType *
DGifOpenFileName(const char *FileName, int *Error)
{
int FileHandle;
GifFileType *GifFile;
if ((FileHandle = open(FileName, O_RDONLY)) == -1) {
if (Error != NULL)
*Error = D_GIF_ERR_OPEN_FAILED;
return NULL;
}
GifFile = DGifOpenFileHandle(FileHandle, Error);
return GifFile;
}
/******************************************************************************
Open a new GIF file for read, given by its name.
Returns dynamically allocated GifFileType pointer which serves as the GIF
info record.
******************************************************************************/
GifFileType *
DGifOpenFileName(const char *FileName, int *Error)
{
int FileHandle;
GifFileType *GifFile;
errno_t theError = _sopen_s(&FileHandle, FileName, _O_RDONLY, _SH_DENYWR, 0);
if (FileHandle == -1) {
if (Error != NULL)
*Error = D_GIF_ERR_OPEN_FAILED;
return NULL;
}
GifFile = DGifOpenFileHandle(FileHandle, Error);
return GifFile;
}
/******************************************************************************
Open a new GIF file for read, given by its name.
Returns dynamically allocated GifFileType pointer which serves as the GIF
info record.
******************************************************************************/
GifFileType *
DGifOpenFileName(const char *FileName, int *Error)
{
int FileHandle;
GifFileType *GifFile;
//根据文件名返回文件句柄
if ((FileHandle = open(FileName, O_RDONLY)) == -1) {
if (Error != NULL)
*Error = D_GIF_ERR_OPEN_FAILED;
return NULL;
}
//根据句柄打开文件 并返回GifFileType(内部包含gif记录信息)
GifFile = DGifOpenFileHandle(FileHandle, Error);
return GifFile;
}
/******************************************************************************
* Open a new gif file for read, given by its name.
* Returns GifFileType pointer dynamically allocated which serves as the gif
* info record. _GifError is cleared if succesfull.
*****************************************************************************/
GifFileType *
DGifOpenFileName(const char *FileName) {
int FileHandle;
GifFileType *GifFile;
if ((FileHandle = open(FileName, O_RDONLY
#if defined(__MSDOS__) || defined(WIN32) || defined(WIN64) || defined(_OPEN_BINARY)
| O_BINARY
#endif /* __MSDOS__ || _OPEN_BINARY */
)) == -1) {
_GifError = D_GIF_ERR_OPEN_FAILED;
return NULL;
}
GifFile = DGifOpenFileHandle(FileHandle);
return GifFile;
}
/******************************************************************************
* Open a new gif file for read, given by its name. *
* Returns GifFileType pointer dynamically allocated which serves as the gif *
* info record. _GifError is cleared if succesfull. *
******************************************************************************/
GifFileType *DGifOpenFileName(const char *FileName)
{
int FileHandle;
GifFileType *GifFile;
if ((FileHandle = open(FileName, O_RDONLY
#ifdef __MSDOS__
| O_BINARY
#endif /* __MSDOS__ */
)) == -1) {
_GifError = D_GIF_ERR_OPEN_FAILED;
return NULL;
}
GifFile = DGifOpenFileHandle(FileHandle);
if (GifFile == (GifFileType *)NULL)
close(FileHandle);
return GifFile;
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
void main(int argc, char **argv)
{
int i, j, Error, NumFiles, ImageNum = 0, Size, Row, Col, Width, Height,
ExtCode, Count;
GifRecordType RecordType;
GifByteType *Extension;
char **FileName = NULL;
GifRowType *ScreenBuffer;
GifFileType *GifFile;
if ((Error = GAGetArgs(argc, argv, CtrlStr,
&GifQuitePrint, &PosFlag, &XPosX, &XPosY,
&DisplayFlag, &DisplayName, &ForceFlag,
&HelpFlag, &NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(1);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(0);
}
if (NumFiles == 1) {
if ((GifFile = DGifOpenFileName(*FileName)) == NULL) {
PrintGifError();
exit(-1);
}
}
else {
/* Use the stdin instead: */
#ifdef __MSDOS__
setmode(0, O_BINARY);
#endif /* __MSDOS__ */
if ((GifFile = DGifOpenFileHandle(0)) == NULL) {
PrintGifError();
exit(-1);
}
}
/* Lets see if we can get access to the X server before we even start: */
if ((XDisplay = (Display *) XOpenDisplay(DisplayName)) == NULL)
GIF_EXIT("Failed to access X server, abored.");
XScreen = DefaultScreen(XDisplay);
Xroot = RootWindow(XDisplay, XScreen);
XColorMap = DefaultColormap(XDisplay, XScreen);
XGraphContext = DefaultGC(XDisplay, XScreen);
XVisual = DefaultVisual(XDisplay, XScreen);
XSetBackground(XDisplay, XGraphContext, BlackPixel(XDisplay, XScreen));
XSetForeground(XDisplay, XGraphContext, WhitePixel(XDisplay, XScreen));
/* Allocate the screen as vector of column of rows. We cannt allocate */
/* the all screen at once, as this broken minded CPU can allocate up to */
/* 64k at a time and our image can be bigger than that: */
/* Note this screen is device independent - its the screen as defined by */
/* the GIF file parameters itself. */
if ((ScreenBuffer = (GifRowType *)
malloc(GifFile -> SHeight * sizeof(GifRowType *))) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
Size = GifFile -> SWidth * sizeof(GifPixelType);/* Size in bytes one row.*/
if ((ScreenBuffer[0] = (GifRowType) malloc(Size)) == NULL) /* First row. */
GIF_EXIT("Failed to allocate memory required, aborted.");
for (i = 0; i < GifFile -> SWidth; i++) /* Set its color to BackGround. */
ScreenBuffer[0][i] = GifFile -> SBackGroundColor;
for (i = 1; i < GifFile -> SHeight; i++) {
/* Allocate the other rows, and set their color to background too: */
if ((ScreenBuffer[i] = (GifRowType) malloc(Size)) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
memcpy(ScreenBuffer[i], ScreenBuffer[0], Size);
}
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
Row = GifFile -> ITop; /* Image Position relative to Screen. */
Col = GifFile -> ILeft;
Width = GifFile -> IWidth;
Height = GifFile -> IHeight;
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ++ImageNum, Col, Row, Width, Height);
if (GifFile -> ILeft + GifFile -> IWidth > GifFile -> SWidth ||
GifFile -> ITop + GifFile -> IHeight > GifFile -> SHeight) {
fprintf(stderr, "Image %d is not confined to screen dimension, aborted.\n");
exit(-2);
}
if (GifFile -> IInterlace) {
/* Need to perform 4 passes on the images: */
for (Count = i = 0; i < 4; i++)
for (j = Row + InterlacedOffset[i]; j<Row + Height;
j += InterlacedJumps[i]) {
GifQprintf("\b\b\b\b%-4d", Count++);
if (DGifGetLine(GifFile, &ScreenBuffer[j][Col],
Width) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
}
else {
for (i = 0; i < Height; i++) {
GifQprintf("\b\b\b\b%-4d", i);
if (DGifGetLine(GifFile, &ScreenBuffer[Row++][Col],
Width) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
/* Lets display it - set the global variables required and do it: */
BackGround = GifFile -> SBackGroundColor;
ColorMap = (GifFile -> IColorMap ? GifFile -> IColorMap :
GifFile -> SColorMap);
ColorMapSize = 1 << (GifFile -> IColorMap ? GifFile -> IBitsPerPixel :
GifFile -> SBitsPerPixel);
Screen2X(argc, argv, ScreenBuffer, GifFile -> SWidth, GifFile -> SHeight);
if (DGifCloseFile(GifFile) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
GifQprintf("\n");
}
/******************************************************************************
* Perform the disassembly operation - take one input files into few output. *
******************************************************************************/
static int DoDisassemblyNum(const char *InFileName, char *OutFileName, int FileNum)
{
int ExtCode, CodeSize, FileEmpty;
GifRecordType RecordType;
char CrntFileName[80], *p;
GifByteType *Extension, *CodeBlock;
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
int ErrorCode;
/* If name has type postfix, strip it out, and make sure name is less */
/* or equal to 6 chars, so we will have 2 chars in name for numbers. */
//strupr(OutFileName); /* Make sure all is upper case */
#if 0
printf("OutFileName : %s\n", OutFileName);
if ((p = strrchr(OutFileName, '.')) != NULL && strlen(p) <= 4) p[0] = 0;
if ((p = strrchr(OutFileName, '/')) != NULL ||
(p = strrchr(OutFileName, '\\')) != NULL ||
(p = strrchr(OutFileName, ':')) != NULL) {
if (strlen(p) > 7) p[7] = 0; /* p includes the '/', '\\', ':' char */
}
else {
/* Only name is given for current directory: */
//if (strlen(OutFileName) > 6) OutFileName[6] = 0;
}
printf("OutFileName : %s\n", OutFileName);
#endif
/* Open input file: */
if (InFileName != NULL) {
if ((GifFileIn = DGifOpenFileName(InFileName, &ErrorCode)) == NULL)
return QuitGifError(GifFileIn, GifFileOut);
}
else {
/* Use the stdin instead: */
if ((GifFileIn = DGifOpenFileHandle(0, &ErrorCode)) == NULL)
return QuitGifError(GifFileIn, GifFileOut);
}
/* Scan the content of GIF file and dump image(s) to seperate file(s): */
//sprintf(CrntFileName, "%s_%02d.gif", OutFileName, FileNum);
sprintf(CrntFileName, "%s", OutFileName);
if ((GifFileOut = EGifOpenFileName(CrntFileName, TRUE, &ErrorCode)) == NULL)
return QuitGifError(GifFileIn, GifFileOut);
FileEmpty = TRUE;
/* And dump out its exactly same screen information: */
if (EGifPutScreenDesc(GifFileOut,
GifFileIn->SWidth, GifFileIn->SHeight,
GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,
GifFileIn->SColorMap) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
FileEmpty = FALSE;
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
/* Put same image descriptor to out file: */
if (EGifPutImageDesc(GifFileOut,
GifFileIn->Image.Left, GifFileIn->Image.Top,
GifFileIn->Image.Width, GifFileIn->Image.Height,
GifFileIn->Image.Interlace,
GifFileIn->Image.ColorMap) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
/* Now read image itself in decoded form as we dont */
/* really care what is there, and this is much faster. */
if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR
|| EGifPutCode(GifFileOut, CodeSize, CodeBlock) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
while (CodeBlock != NULL)
if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR ||
EGifPutCodeNext(GifFileOut, CodeBlock) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
break;
case EXTENSION_RECORD_TYPE:
FileEmpty = FALSE;
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension)
== GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],
Extension) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
/* No support to more than one extension blocks, discard */
while (Extension != NULL)
if (DGifGetExtensionNext(GifFileIn, &Extension)
== GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType */
break;
}
}
while (RecordType != IMAGE_DESC_RECORD_TYPE &&
RecordType != TERMINATE_RECORD_TYPE);
if (EGifCloseFile(GifFileOut, &ErrorCode) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
if (FileEmpty) {
/* Might happen on last file - delete it if so: */
unlink(CrntFileName);
}
if (DGifCloseFile(GifFileIn, &ErrorCode) == GIF_ERROR)
return QuitGifError(GifFileIn, GifFileOut);
}
static void Gif2Icon(char *FileName,
int fdin, int fdout,
char NameTable[])
{
int i, ExtCode, ImageNum = 1;
GifPixelType *Line, *cp;
GifRecordType RecordType;
GifByteType *Extension;
GifFileType *GifFile;
if (fdin == -1) {
if ((GifFile = DGifOpenFileName(FileName)) == NULL) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
else {
/* Use stdin instead: */
if ((GifFile = DGifOpenFileHandle(fdin)) == NULL) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
printf("screen width %d\nscreen height %d\n",
GifFile->SWidth, GifFile->SHeight);
printf("screen colors %d\nscreen background %d\n\n",
GifFile->SColorResolution,
GifFile->SBackGroundColor);
if (GifFile->SColorMap)
{
if (GifFile->SColorMap->ColorCount >= (int)strlen(NameTable))
{
(void) fprintf(stderr,
"%s: global color map has unprintable pixels\n",
FileName);
exit(EXIT_FAILURE);
}
printf("screen map\n");
for (i = 0; i < GifFile->SColorMap->ColorCount; i++)
printf("\trgb %03d %03d %03d is %c\n",
GifFile->SColorMap ->Colors[i].Red,
GifFile->SColorMap ->Colors[i].Green,
GifFile->SColorMap ->Colors[i].Blue,
NameTable[i]);
printf("end\n\n");
}
do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
printf("image # %d\nimage left %d\nimage top %d\n",
ImageNum++,
GifFile->Image.Left, GifFile->Image.Top);
if (GifFile->Image.Interlace)
printf("interlaced\n");
if (GifFile->Image.ColorMap)
{
if (GifFile->Image.ColorMap->ColorCount >= (int)strlen(NameTable))
{
(void) fprintf(stderr,
"%s: global color map has unprintable pixels\n",
FileName);
exit(EXIT_FAILURE);
}
printf("image map\n");
for (i = 0; i < GifFile->Image.ColorMap->ColorCount; i++)
printf("\trgb %03d %03d %03d is %c\n",
GifFile->Image.ColorMap ->Colors[i].Red,
GifFile->Image.ColorMap ->Colors[i].Green,
GifFile->Image.ColorMap ->Colors[i].Blue,
NameTable[i]);
printf("end\n\n");
}
printf("image bits %d by %d\n",
GifFile->Image.Width, GifFile->Image.Height);
Line = (GifPixelType *) malloc(GifFile->Image.Width *
sizeof(GifPixelType));
for (i = 0; i < GifFile->Image.Height; i++) {
if (DGifGetLine(GifFile, Line, GifFile->Image.Width)
== GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
for (cp = Line; cp < Line + GifFile->Image.Width; cp++)
putchar(NameTable[*cp]);
putchar('\n');
}
free((char *) Line);
putchar('\n');
break;
case EXTENSION_RECORD_TYPE:
if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
if (ExtCode == COMMENT_EXT_FUNC_CODE)
printf("comment\n");
else if (ExtCode == PLAINTEXT_EXT_FUNC_CODE)
printf("plaintext\n");
else if (isalpha(ExtCode))
printf("extension %02x # %c\n", ExtCode, ExtCode);
else
printf("extension %02x\n", ExtCode);
while (Extension != NULL) {
VisibleDumpBuffer((char *)(Extension + 1), Extension[0]);
putchar('\n');
if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
printf("end\n\n");
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType */
break;
}
}
while
(RecordType != TERMINATE_RECORD_TYPE);
/* Tell EMACS this is a picture... */
printf("# The following sets edit modes for GNU EMACS\n");
printf("# Local "); /* ...break this up, so that EMACS doesn't */
printf("Variables:\n"); /* get confused when visiting *this* file! */
printf("# mode:picture\n");
printf("# truncate-lines:t\n");
printf("# End:\n");
if (fdin == -1)
(void) printf("# End of %s dump\n", FileName);
if (DGifCloseFile(GifFile) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
/*!
* pixReadStreamGif()
*
* Input: stream
* Return: pix, or null on error
*/
PIX *
pixReadStreamGif(FILE *fp)
{
l_int32 fd, wpl, i, j, w, h, d, cindex, ncolors;
l_int32 rval, gval, bval;
l_uint32 *data, *line;
GifFileType *gif;
PIX *pixd, *pixdi;
PIXCMAP *cmap;
ColorMapObject *gif_cmap;
SavedImage si;
PROCNAME("pixReadStreamGif");
if ((fd = fileno(fp)) < 0)
return (PIX *)ERROR_PTR("invalid file descriptor", procName, NULL);
#ifndef _MSC_VER
lseek(fd, 0, SEEK_SET);
#else
_lseek(fd, 0, SEEK_SET);
#endif /* _MSC_VER */
if ((gif = DGifOpenFileHandle(fd)) == NULL)
return (PIX *)ERROR_PTR("invalid file or file not found",
procName, NULL);
/* Read all the data, but use only the first image found */
if (DGifSlurp(gif) != GIF_OK) {
DGifCloseFile(gif);
return (PIX *)ERROR_PTR("failed to read GIF data", procName, NULL);
}
if (gif->SavedImages == NULL) {
DGifCloseFile(gif);
return (PIX *)ERROR_PTR("no images found in GIF", procName, NULL);
}
si = gif->SavedImages[0];
w = si.ImageDesc.Width;
h = si.ImageDesc.Height;
if (w <= 0 || h <= 0) {
DGifCloseFile(gif);
return (PIX *)ERROR_PTR("invalid image dimensions", procName, NULL);
}
if (si.RasterBits == NULL) {
DGifCloseFile(gif);
return (PIX *)ERROR_PTR("no raster data in GIF", procName, NULL);
}
if (si.ImageDesc.ColorMap) {
/* private cmap for this image */
gif_cmap = si.ImageDesc.ColorMap;
}
else if (gif->SColorMap) {
/* global cmap for whole picture */
gif_cmap = gif->SColorMap;
}
else {
/* don't know where to take cmap from */
DGifCloseFile(gif);
return (PIX *)ERROR_PTR("color map is missing", procName, NULL);
}
ncolors = gif_cmap->ColorCount;
if (ncolors <= 2)
d = 1;
else if (ncolors <= 4)
d = 2;
else if (ncolors <= 16)
d = 4;
else
d = 8;
if ((cmap = pixcmapCreate(d)) == NULL)
return (PIX *)ERROR_PTR("cmap creation failed", procName, NULL);
for (cindex = 0; cindex < ncolors; cindex++) {
rval = gif_cmap->Colors[cindex].Red;
gval = gif_cmap->Colors[cindex].Green;
bval = gif_cmap->Colors[cindex].Blue;
pixcmapAddColor(cmap, rval, gval, bval);
}
if ((pixd = pixCreate(w, h, d)) == NULL) {
DGifCloseFile(gif);
pixcmapDestroy(&cmap);
return (PIX *)ERROR_PTR("failed to allocate pixd", procName, NULL);
}
pixSetColormap(pixd, cmap);
wpl = pixGetWpl(pixd);
data = pixGetData(pixd);
for (i = 0; i < h; i++) {
line = data + i * wpl;
if (d == 1) {
for (j = 0; j < w; j++) {
if (si.RasterBits[i * w + j])
SET_DATA_BIT(line, j);
}
}
else if (d == 2) {
for (j = 0; j < w; j++)
SET_DATA_DIBIT(line, j, si.RasterBits[i * w + j]);
}
else if (d == 4) {
for (j = 0; j < w; j++)
SET_DATA_QBIT(line, j, si.RasterBits[i * w + j]);
}
else { /* d == 8 */
for (j = 0; j < w; j++)
SET_DATA_BYTE(line, j, si.RasterBits[i * w + j]);
}
}
if (gif->Image.Interlace) {
pixdi = pixInterlaceGIF(pixd);
pixTransferAllData(pixd, &pixdi, 0, 0);
}
DGifCloseFile(gif);
return pixd;
}
/******************************************************************************
Interpret the command line and scan the given GIF file.
******************************************************************************/
int main(int argc, char **argv)
{
int i, j, ExtCode, ErrorCode, CodeSize, NumFiles, Len, ImageNum = 1;
bool Error,
ColorMapFlag = false, EncodedFlag = false, LZCodesFlag = false,
PixelFlag = false, HelpFlag = false, RawFlag = false;
char *GifFileName, **FileName = NULL;
GifPixelType *Line;
GifRecordType RecordType;
GifByteType *CodeBlock, *Extension;
GifFileType *GifFile;
if ((Error = GAGetArgs(argc, argv, CtrlStr,
&GifNoisyPrint, &ColorMapFlag, &EncodedFlag,
&LZCodesFlag, &PixelFlag, &RawFlag, &HelpFlag,
&NumFiles, &FileName)) != false ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
(void)fprintf(stderr, VersionStr, GIFLIB_MAJOR, GIFLIB_MINOR);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
if (NumFiles == 1) {
GifFileName = *FileName;
if ((GifFile = DGifOpenFileName(*FileName, &ErrorCode)) == NULL) {
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
}
else {
/* Use stdin instead: */
GifFileName = "Stdin";
if ((GifFile = DGifOpenFileHandle(0, &ErrorCode)) == NULL) {
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
}
/* Because we write binary data - make sure no text will be written. */
if (RawFlag) {
ColorMapFlag = EncodedFlag = LZCodesFlag = PixelFlag = false;
#ifdef _WIN32
_setmode(1, O_BINARY); /* Make sure it is in binary mode. */
#endif /* _WIN32 */
}
else {
printf("\n%s:\n\n\tScreen Size - Width = %d, Height = %d.\n",
GifFileName, GifFile->SWidth, GifFile->SHeight);
printf("\tColorResolution = %d, BitsPerPixel = %d, BackGround = %d, Aspect = %d.\n",
GifFile->SColorResolution,
GifFile->SColorMap ? GifFile->SColorMap->BitsPerPixel : 0,
GifFile->SBackGroundColor,
GifFile->AspectByte);
if (GifFile->SColorMap)
printf("\tHas Global Color Map.\n\n");
else
printf("\tNo Global Color Map.\n\n");
if (ColorMapFlag && GifFile->SColorMap) {
printf("\tGlobal Color Map:\n");
Len = GifFile->SColorMap->ColorCount;
printf("\tSort Flag: %s\n",
GifFile->SColorMap->SortFlag ? "on":"off");
for (i = 0; i < Len; i+=4) {
for (j = 0; j < 4 && j < Len; j++) {
printf("%3d: %02xh %02xh %02xh ", i + j,
GifFile->SColorMap->Colors[i + j].Red,
GifFile->SColorMap->Colors[i + j].Green,
GifFile->SColorMap->Colors[i + j].Blue);
}
printf("\n");
}
}
}
do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
if (!RawFlag) {
printf("\nImage #%d:\n\n\tImage Size - Left = %d, Top = %d, Width = %d, Height = %d.\n",
ImageNum++, GifFile->Image.Left, GifFile->Image.Top,
GifFile->Image.Width, GifFile->Image.Height);
printf("\tImage is %s",
GifFile->Image.Interlace ? "Interlaced" :
"Non Interlaced");
if (GifFile->Image.ColorMap != NULL)
printf(", BitsPerPixel = %d.\n",
GifFile->Image.ColorMap->BitsPerPixel);
else
printf(".\n");
if (GifFile->Image.ColorMap)
printf("\tImage Has Color Map.\n");
else
printf("\tNo Image Color Map.\n");
if (ColorMapFlag && GifFile->Image.ColorMap) {
printf("\tSort Flag: %s\n",
GifFile->Image.ColorMap->SortFlag ? "on":"off");
Len = 1 << GifFile->Image.ColorMap->BitsPerPixel;
for (i = 0; i < Len; i+=4) {
for (j = 0; j < 4 && j < Len; j++) {
printf("%3d: %02xh %02xh %02xh ", i + j,
GifFile->Image.ColorMap->Colors[i + j].Red,
GifFile->Image.ColorMap->Colors[i + j].Green,
GifFile->Image.ColorMap->Colors[i + j].Blue);
}
printf("\n");
}
}
}
if (EncodedFlag) {
if (DGifGetCode(GifFile, &CodeSize, &CodeBlock) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
printf("\nImage LZ compressed Codes (Code Size = %d):\n",
CodeSize);
PrintCodeBlock(GifFile, CodeBlock, true);
while (CodeBlock != NULL) {
if (DGifGetCodeNext(GifFile, &CodeBlock) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
PrintCodeBlock(GifFile, CodeBlock, false);
}
}
else if (LZCodesFlag) {
PrintLZCodes(GifFile);
}
else if (PixelFlag) {
Line = (GifPixelType *) malloc(GifFile->Image.Width *
sizeof(GifPixelType));
for (i = 0; i < GifFile->Image.Height; i++) {
if (DGifGetLine(GifFile, Line, GifFile->Image.Width)
== GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
PrintPixelBlock(Line, GifFile->Image.Width, i == 0);
}
PrintPixelBlock(NULL, GifFile->Image.Width, false);
free((char *) Line);
}
else if (RawFlag) {
Line = (GifPixelType *) malloc(GifFile->Image.Width *
sizeof(GifPixelType));
for (i = 0; i < GifFile->Image.Height; i++) {
if (DGifGetLine(GifFile, Line, GifFile->Image.Width)
== GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
fwrite(Line, 1, GifFile->Image.Width, stdout);
}
free((char *) Line);
}
else {
/* Skip the image: */
if (DGifGetCode(GifFile, &CodeSize, &CodeBlock) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
while (CodeBlock != NULL) {
if (DGifGetCodeNext(GifFile, &CodeBlock) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
}
}
break;
case EXTENSION_RECORD_TYPE:
if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
if (!RawFlag) {
putchar('\n');
switch (ExtCode)
{
case COMMENT_EXT_FUNC_CODE:
printf("GIF89 comment");
break;
case GRAPHICS_EXT_FUNC_CODE:
printf("GIF89 graphics control");
break;
case PLAINTEXT_EXT_FUNC_CODE:
printf("GIF89 plaintext");
break;
case APPLICATION_EXT_FUNC_CODE:
printf("GIF89 application block");
break;
default:
printf("Extension record of unknown type");
break;
}
printf(" (Ext Code = %d [%c]):\n",
ExtCode, MAKE_PRINTABLE(ExtCode));
PrintExtBlock(Extension, true);
if (ExtCode == GRAPHICS_EXT_FUNC_CODE) {
GraphicsControlBlock gcb;
if (DGifExtensionToGCB(Extension[0], Extension+1, &gcb) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
printf("\tDisposal Mode: %d\n", gcb.DisposalMode);
printf("\tUser Input Flag: %d\n", gcb.UserInputFlag);
printf("\tTransparency on: %s\n",
gcb.TransparentColor != -1 ? "yes" : "no");
printf("\tDelayTime: %d\n", gcb.DelayTime);
printf("\tTransparent Index: %d\n", gcb.TransparentColor);
}
}
for (;;) {
if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
if (Extension == NULL)
break;
PrintExtBlock(Extension, false);
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be trapped by DGifGetRecordType */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
if (DGifCloseFile(GifFile, &ErrorCode) == GIF_ERROR) {
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
if (!RawFlag) printf("\nGIF file terminated normally.\n");
return 0;
}
/******************************************************************************
Main sequence
******************************************************************************/
int main(int argc, char **argv)
{
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
GifRecordType RecordType;
int CodeSize, ExtCode, ErrorCode;
GifByteType *CodeBlock, *Extension;
/*
* Command-line processing goes here.
*/
/* Use stdin as input (note this also read screen descriptor in: */
if ((GifFileIn = DGifOpenFileHandle(0, &ErrorCode)) == NULL) {
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
/* Use the stdout as output: */
if ((GifFileOut = EGifOpenFileHandle(1, &ErrorCode)) == NULL) {
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
/* And dump out its screen information: */
if (EGifPutScreenDesc(GifFileOut,
GifFileIn->SWidth, GifFileIn->SHeight,
GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,
GifFileIn->SColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Scan the content of the input GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Put image descriptor to out file: */
if (EGifPutImageDesc(GifFileOut,
GifFileIn->Image.Left, GifFileIn->Image.Top,
GifFileIn->Image.Width, GifFileIn->Image.Height,
GifFileIn->Image.Interlace,
GifFileIn->Image.ColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Now read image itself in decoded form as we dont really */
/* care what we have there, and this is much faster. */
if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR ||
EGifPutCode(GifFileOut, CodeSize, CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
while (CodeBlock != NULL) {
if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR ||
EGifPutCodeNext(GifFileOut, CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case EXTENSION_RECORD_TYPE:
/* pass through extension records */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifPutExtensionLeader(GifFileOut, ExtCode) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifPutExtensionBlock(GifFileOut,
Extension[0],
Extension + 1) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFileIn, &Extension)==GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (Extension != NULL)
if (EGifPutExtensionBlock(GifFileOut,
Extension[0],
Extension + 1) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
if (EGifPutExtensionTrailer(GifFileOut) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be trapped by DGifGetRecordType */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
if (DGifCloseFile(GifFileIn, &ErrorCode) == GIF_ERROR)
{
PrintGifError(ErrorCode);
if (GifFileIn != NULL) {
EGifCloseFile(GifFileIn, NULL);
}
exit(EXIT_FAILURE);
}
if (EGifCloseFile(GifFileOut, &ErrorCode) == GIF_ERROR)
{
PrintGifError(ErrorCode);
if (GifFileOut != NULL) {
EGifCloseFile(GifFileOut, NULL);
}
exit(EXIT_FAILURE);
}
return 0;
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
void main(int argc, char **argv)
{
int i, j, k, Error, NumFiles, Size, Row, Col, Width, Height, ExtCode,
Count, ColorMapSize, GraphDriver, GraphMode, Sum,
HelpFlag = FALSE,
BGIPathFlag = FALSE,
BGIUserDriverFlag = FALSE,
ZoomFlag = FALSE;
GifRecordType RecordType;
GifByteType *Extension;
char Str[80], *BGIUserDriverNameMode,
**FileName = NULL;
GifRowType *ScreenBuffer;
GifFileType *GifFile;
struct text_info TextInfo; /* So we can restore starting text mode. */
if ((Error = GAGetArgs(argc, argv, CtrlStr,
&GifQuitePrint, &BGIPathFlag, &BGIPath,
&BGIUserDriverFlag, &BGIUserDriverNameMode,
&ZoomFlag, &ZoomFactor,
&BeepsDisabled, &HelpFlag,
&NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(1);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(0);
}
if (BGIUserDriverFlag) {
/* Use the driver supplied by the user! */
BGIInstallUserDriver(BGIUserDriverNameMode);
installuserdriver(BGIUserDriverName, detectVGA);
GraphDriver = BGI_USER_INSTALL;
}
else {
/* Sense type of display we have and attempt to load right driver. */
detectgraph(&GraphDriver, &GraphMode);
if (GraphDriver < 0)
GIF_EXIT("BGI Auto detect: No graphics device detected.");
}
/* Put in the following any graphic driver specific setup: */
switch (GraphDriver) {
case CGA:
GraphMode = CGAHI;
break;
case EGA:
GraphMode = EGAHI;
break;
case EGA64:
GraphMode = EGA64HI;
break;
case EGAMONO:
GraphMode = EGAMONOHI;
break;
case HERCMONO:
GraphMode = HERCMONOHI;
break;
case VGA:
GraphMode = VGAHI;
break;
case BGI_USER_INSTALL:
GraphDriver = DETECT;
GraphMode = BGIUserDriverMode;
break;
default:
GIF_EXIT("Requested graphic device is not supported.");
break;
}
if (NumFiles == 1) {
GifFileName = *FileName;
if ((GifFile = DGifOpenFileName(*FileName)) == NULL) {
PrintGifError();
exit(-1);
}
}
else {
/* Use the stdin instead: */
GifFileName = "Stdin";
setmode(0, O_BINARY);
if ((GifFile = DGifOpenFileHandle(0)) == NULL) {
PrintGifError();
exit(-1);
}
}
/* Allocate the screen as vector of column of rows. We cannt allocate */
/* the all screen at once, as this broken minded CPU can allocate up to */
/* 64k at a time and our image can be bigger than that: */
/* Note this screen is device independent - its the screen as defined by */
/* the GIF file parameters itself. */
if ((ScreenBuffer = (GifRowType *)
malloc(GifFile -> SHeight * sizeof(GifRowType *))) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
Size = GifFile -> SWidth * sizeof(GifPixelType);/* Size in bytes of one row.*/
if ((ScreenBuffer[0] = (GifRowType) malloc(Size)) == NULL) /* First row. */
GIF_EXIT("Failed to allocate memory required, aborted.");
for (i = 0; i < GifFile -> SWidth; i++) /* Set its color to BackGround. */
ScreenBuffer[0][i] = GifFile -> SBackGroundColor;
MaximumScreenHeight = GifFile -> SHeight - 1;
for (i = 1; i < GifFile -> SHeight; i++) {
/* Allocate the other rows, and set their color to background too: */
if ((ScreenBuffer[i] = (GifRowType) malloc(Size)) == NULL) {
if (i > 30) {
/* Free some memory for the BGI driver and auxilary. */
for (j = 1; j < 28; j++)
free((char *) ScreenBuffer[i - j]);
MaximumScreenHeight = i - 28;
fprintf(stderr, "\n%s: Failed to allocate all memory required, last line %d.\n",
PROGRAM_NAME, MaximumScreenHeight);
break;
}
else
GIF_EXIT("Failed to allocate memory required, aborted.");
}
memcpy(ScreenBuffer[i], ScreenBuffer[0], Size);
}
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
PrintGifError();
break;
}
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
Row = GifFile -> ITop; /* Image Position relative to Screen. */
Col = GifFile -> ILeft;
Width = GifFile -> IWidth;
Height = GifFile -> IHeight;
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ++ImageNum, Col, Row, Width, Height);
if (GifFile -> ILeft + GifFile -> IWidth > GifFile -> SWidth ||
GifFile -> ITop + GifFile -> IHeight > GifFile -> SHeight) {
fprintf(stderr, "Image %d is not confined to screen dimension, aborted.\n");
exit(-2);
}
if (GifFile -> IInterlace) {
/* Need to perform 4 passes on the images: */
for (Count = i = 0; i < 4; i++)
for (j = Row + InterlacedOffset[i]; j < Row + Height;
j += InterlacedJumps[i]) {
GifQprintf("\b\b\b\b%-4d", Count++);
if (DGifGetLine(GifFile,
&ScreenBuffer[MIN(j, MaximumScreenHeight)][Col],
Width) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
}
else {
for (i = 0; i < Height; i++, Row++) {
GifQprintf("\b\b\b\b%-4d", i);
if (DGifGetLine(GifFile, &ScreenBuffer[MIN(Row, MaximumScreenHeight)][Col],
Width) == GIF_ERROR) {
PrintGifError();
MaximumScreenHeight = MIN(i - 1, MaximumScreenHeight);
}
}
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
/* Lets display it - set the global variables required and do it: */
BackGround = GifFile -> SBackGroundColor;
ColorMap = (GifFile -> IColorMap ? GifFile -> IColorMap :
GifFile -> SColorMap);
ColorMapSize = 1 << (GifFile -> IColorMap ? GifFile -> IBitsPerPixel :
GifFile -> SBitsPerPixel);
gettextinfo(&TextInfo); /* Save current mode so we can recover. */
initgraph(&GraphDriver, &GraphMode, BGIPath);
if (graphresult() != grOk) /* Error occured during init. */
GIF_EXIT("Graphics System Error, failed to initialize driver.");
if (getmaxcolor() + 1 < ColorMapSize) {
sprintf(Str, "GIF Image color map (%d) is too big for device (%d).\n",
ColorMapSize, getmaxcolor() + 1);
closegraph();
GIF_EXIT(Str);
}
/* Initialize hardware pallete and also select fore/background color. */
BackGround = ForeGround = 1;
Sum = ((int) ColorMap[1].Red) +
((int) ColorMap[1].Green) +
((int) ColorMap[1].Blue);
j = k = Sum;
for (i = 0; i < ColorMapSize; i++) {
setrgbpalette(i, ColorMap[i].Red >> 2,
ColorMap[i].Green >> 2,
ColorMap[i].Blue >> 2);
Sum = ((int) ColorMap[i].Red) +
((int) ColorMap[i].Green) +
((int) ColorMap[i].Blue);
if (i != 0 && Sum > j) { /* Dont use color 0. */
ForeGround = i;
j = Sum;
}
if (i != 0 && Sum <= k) { /* Dont use color 0. */
BackGround = i;
k = Sum;
}
}
DeviceMaxX = getmaxx(); /* Read size of physical screen. */
DeviceMaxY = getmaxy();
ScreenWidth = GifFile -> SWidth;
ScreenHeight = MIN(GifFile -> SHeight, MaximumScreenHeight);
Tone(500, 10);
DisplayScreen(ScreenBuffer, GifFile);
if (DGifCloseFile(GifFile) == GIF_ERROR) {
PrintGifError();
closegraph();
exit(-1);
}
closegraph();
textmode(TextInfo.currmode);
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
int main(int argc, char **argv)
{
int i, j, Error, NumFiles, ExtCode, Row, Col, Width, Height,
DarkestColor = 0, ColorIntens = 10000, HelpFlag = FALSE;
GifRecordType RecordType;
GifByteType *Extension;
char **FileName = NULL;
GifRowType LineBuffer;
ColorMapObject *ColorMap;
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifQuietPrint, &HelpFlag,
&NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
if (NumFiles == 1) {
if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
else {
/* Use the stdin instead: */
if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
/* Open stdout for the output file: */
if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
/* Dump out exactly same screen information: */
if (EGifPutScreenDesc(GifFileOut,
GifFileIn->SWidth, GifFileIn->SHeight,
GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,
GifFileIn->SColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if ((LineBuffer = (GifRowType) malloc(GifFileIn->SWidth)) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (GifFileIn->Image.Interlace)
GIF_EXIT("Cannt fix interlaced images.");
Row = GifFileIn->Image.Top; /* Image Position relative to Screen. */
Col = GifFileIn->Image.Left;
Width = GifFileIn->Image.Width;
Height = GifFileIn->Image.Height;
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ++ImageNum, Col, Row, Width, Height);
/* Put the image descriptor to out file: */
if (EGifPutImageDesc(GifFileOut, Col, Row, Width, Height,
FALSE, GifFileIn->Image.ColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Find the darkest color in color map to use as a filler. */
ColorMap = (GifFileIn->Image.ColorMap ? GifFileIn->Image.ColorMap :
GifFileIn->SColorMap);
for (i = 0; i < ColorMap->ColorCount; i++) {
j = ((int) ColorMap->Colors[i].Red) * 30 +
((int) ColorMap->Colors[i].Green) * 59 +
((int) ColorMap->Colors[i].Blue) * 11;
if (j < ColorIntens) {
ColorIntens = j;
DarkestColor = i;
}
}
/* Load the image, and dump it. */
for (i = 0; i < Height; i++) {
GifQprintf("\b\b\b\b%-4d", i);
if (DGifGetLine(GifFileIn, LineBuffer, Width)
== GIF_ERROR) break;
if (EGifPutLine(GifFileOut, LineBuffer, Width)
== GIF_ERROR) QuitGifError(GifFileIn, GifFileOut);
}
if (i < Height) {
fprintf(stderr, "\nFollowing error occured (and ignored):");
PrintGifError();
/* Fill in with the darkest color in color map. */
for (j = 0; j < Width; j++)
LineBuffer[j] = DarkestColor;
for (; i < Height; i++)
if (EGifPutLine(GifFileOut, LineBuffer, Width)
== GIF_ERROR) QuitGifError(GifFileIn, GifFileOut);
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (Extension && EGifPutExtension(GifFileOut, ExtCode,
Extension[0], Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* No support to more than one extension blocks, so discard: */
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
if (DGifCloseFile(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifCloseFile(GifFileOut) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
return 0;
}
/******************************************************************************
Interpret the command line, prepar global data and call the Gif routines.
******************************************************************************/
int main(int argc, char **argv)
{
int NumFiles, ImageWidth, ImageHeight, Dummy, Red, Green, Blue, ErrorCode;
static bool Error,
ImageSizeFlag = false, ColorMapFlag = false, HelpFlag = false,
TextifyFlag = false;
char **FileName = NULL, *ColorMapFile;
ColorMapObject *ColorMap;
FILE *InColorMapFile;
if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifNoisyPrint,
&ImageSizeFlag, &ImageWidth, &ImageHeight,
&ColorMapFlag, &ColorMapFile,
&TextifyFlag,
&HelpFlag,
&NumFiles, &FileName)) != false ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
(void)fprintf(stderr, VersionStr, GIFLIB_MAJOR, GIFLIB_MINOR);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
if (ImageSizeFlag) {
if (ColorMapFlag) {
int ColorMapSize;
/* Read color map from given file: */
if ((InColorMapFile = fopen(ColorMapFile, "rt")) == NULL) {
GIF_MESSAGE("Failed to open COLOR MAP file (not exists!?).");
exit(EXIT_FAILURE);
}
if ((ColorMap = GifMakeMapObject(256, NULL)) == NULL) {
GIF_MESSAGE("Failed to allocate bitmap, aborted.");
exit(EXIT_FAILURE);
}
for (ColorMapSize = 0;
ColorMapSize < 256 && !feof(InColorMapFile);
ColorMapSize++) {
if (fscanf(InColorMapFile, "%3d %3d %3d %3d\n",
&Dummy, &Red, &Green, &Blue) == 4) {
ColorMap->Colors[ColorMapSize].Red = Red;
ColorMap->Colors[ColorMapSize].Green = Green;
ColorMap->Colors[ColorMapSize].Blue = Blue;
}
}
}
else {
ColorMap = GifMakeMapObject(EGA_PALETTE_SIZE, EGAPalette);
}
if (NumFiles == 1) {
int InFileHandle;
#ifdef _WIN32
if ((InFileHandle = open(*FileName, O_RDONLY | O_BINARY)) == -1) {
#else
if ((InFileHandle = open(*FileName, O_RDONLY)) == -1) {
#endif /* _WIN32 */
GIF_MESSAGE("Failed to open RAW image file (not exists!?).");
exit(EXIT_FAILURE);
}
dup2(InFileHandle, 0); /* Make stdin from this file. */
}
else {
#ifdef _WIN32
_setmode(0, O_BINARY); /* Make sure it is in binary mode. */
#endif /* _WIN32 */
}
/* Convert Raw image from stdin to GIF file in stdout: */
Raw2Gif(ImageWidth, ImageHeight, ColorMap);
}
else {
GifFileType *GifFile;
if (NumFiles == 1) {
if ((GifFile = DGifOpenFileName(*FileName, &ErrorCode)) == NULL) {
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
}
else {
/* Use stdin instead: */
if ((GifFile = DGifOpenFileHandle(0, &ErrorCode)) == NULL) {
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
}
Gif2Raw(GifFile, TextifyFlag);
}
return 0;
// cppcheck-suppress resourceLeak
}
/******************************************************************************
Convert raw image (One byte per pixel) into GIF file. Raw data is read from
stdin, and GIF is dumped to stdout. ImagwWidth times ImageHeight bytes are
read. Color map is dumped from ColorMap.
******************************************************************************/
void Raw2Gif(int ImageWidth, int ImageHeight, ColorMapObject *ColorMap)
{
int i, j, ErrorCode;
static GifPixelType *ScanLine;
GifFileType *GifFile;
if ((ScanLine = (GifPixelType *) malloc(sizeof(GifPixelType) * ImageWidth))
== NULL) {
GIF_MESSAGE("Failed to allocate scan line, aborted.");
exit(EXIT_FAILURE);
}
if ((GifFile = EGifOpenFileHandle(1, &ErrorCode)) == NULL) { /* Gif to stdout. */
free((char *) ScanLine);
PrintGifError(ErrorCode);
exit(EXIT_FAILURE);
}
if (EGifPutScreenDesc(GifFile, ImageWidth, ImageHeight, ColorMap->BitsPerPixel,
0, ColorMap) == GIF_ERROR) {
free((char *) ScanLine);
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
if (EGifPutImageDesc(GifFile, 0, 0, ImageWidth, ImageHeight, false,
NULL) == GIF_ERROR) {
free((char *) ScanLine);
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
/* Here it is - get one raw line from stdin, and dump to stdout Gif: */
GifQprintf("\n%s: Image 1 at (0, 0) [%dx%d]: ",
PROGRAM_NAME, ImageWidth, ImageHeight);
for (i = 0; i < ImageHeight; i++) {
/* Note we assume here PixelSize == Byte, which is not necessarily */
/* so. If not - must read one byte at a time, and coerce to pixel. */
if (fread(ScanLine, 1, ImageWidth, stdin) != (unsigned)ImageWidth) {
GIF_MESSAGE("RAW input file ended prematurely.");
exit(EXIT_FAILURE);
}
for (j = 0; j < ImageWidth; j++)
if (ScanLine[j] >= ColorMap->ColorCount)
GIF_MESSAGE("Warning: RAW data color > maximum color map entry.");
if (EGifPutLine(GifFile, ScanLine, ImageWidth) == GIF_ERROR) {
free((char *) ScanLine);
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
GifQprintf("\b\b\b\b%-4d", i);
}
if (EGifCloseFile(GifFile) == GIF_ERROR) {
free((char *) ScanLine);
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
free((char *) ScanLine);
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
int main(int argc, char **argv)
{
int i, j, Error, NumFiles, Size, Row, Col, Width, Height, ExtCode, Count;
GifRecordType RecordType;
GifByteType *Extension;
char **FileName = NULL;
GifRowType *ScreenBuffer;
GifFileType *GifFile;
if ((Error = GAGetArgs(argc, argv, CtrlStr,&GifQuietPrint,
&ForceXFlag, &ForceYFlag, &SizeFlag, &PSSizeX, &PSSizeY,
&PosFlag, &PSPosX, &PSPosY,
&InvertFlag, &NumCopiesFlag, &NumOfCopies, &HelpFlag,
&NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
if (ForceXFlag)
PSOrientation = HORIZONTAL_ORIENT;
else if (ForceYFlag)
PSOrientation = VERTICAL_ORIENT;
else
PSOrientation = UNKNOWN_ORIENT;
if (NumFiles == 1) {
if ((GifFile = DGifOpenFileName(*FileName)) == NULL) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
else {
/* Use the stdin instead: */
#ifdef __MSDOS__
setmode(0, O_BINARY);
#endif /* __MSDOS__ */
if ((GifFile = DGifOpenFileHandle(0)) == NULL) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
/* Allocate the screen as vector of column of rows. We cannt allocate */
/* the all screen at once, as this broken minded CPU can allocate up to */
/* 64k at a time and our image can be bigger than that: */
/* Note this screen is device independent - its the screen as defined by */
/* the GIF file parameters itself. */
if ((ScreenBuffer = (GifRowType *)
malloc(GifFile->SHeight * sizeof(GifRowType *))) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
Size = GifFile->SWidth * sizeof(GifPixelType);/* Size in bytes one row.*/
if ((ScreenBuffer[0] = (GifRowType) malloc(Size)) == NULL) /* First row. */
GIF_EXIT("Failed to allocate memory required, aborted.");
for (i = 0; i < GifFile->SWidth; i++) /* Set its color to BackGround. */
ScreenBuffer[0][i] = GifFile->SBackGroundColor;
for (i = 1; i < GifFile->SHeight; i++) {
/* Allocate the other rows, and set their color to background too: */
if ((ScreenBuffer[i] = (GifRowType) malloc(Size)) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
memcpy(ScreenBuffer[i], ScreenBuffer[0], Size);
}
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
Row = GifFile->Image.Top; /* Image Position relative to Screen. */
Col = GifFile->Image.Left;
Width = GifFile->Image.Width;
Height = GifFile->Image.Height;
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ++ImageNum, Col, Row, Width, Height);
if (GifFile->Image.Left + GifFile->Image.Width > GifFile->SWidth ||
GifFile->Image.Top + GifFile->Image.Height > GifFile->SHeight) {
fprintf(stderr, "Image %d is not confined to screen dimension, aborted.\n",ImageNum);
exit(EXIT_FAILURE);
}
if (GifFile->Image.Interlace) {
/* Need to perform 4 passes on the images: */
for (Count = i = 0; i < 4; i++)
for (j = Row + InterlacedOffset[i]; j < Row + Height;
j += InterlacedJumps[i]) {
GifQprintf("\b\b\b\b%-4d", Count++);
if (DGifGetLine(GifFile, &ScreenBuffer[j][Col],
Width) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
}
else {
for (i = 0; i < Height; i++) {
GifQprintf("\b\b\b\b%-4d", i);
if (DGifGetLine(GifFile, &ScreenBuffer[Row++][Col],
Width) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
/* Lets display it - set the global variables required and do it: */
BackGround = GifFile->SBackGroundColor;
ColorMap = (GifFile->Image.ColorMap
? GifFile->Image.ColorMap->Colors
: GifFile->SColorMap->Colors);
DumpScreen2PS(ScreenBuffer, GifFile->SWidth, GifFile->SHeight);
if (DGifCloseFile(GifFile) == GIF_ERROR) {
PrintGifError();
exit(EXIT_FAILURE);
}
return 0;
}
G_MODULE_EXPORT gboolean
tracker_extract_get_metadata (TrackerExtractInfo *info)
{
TrackerSparqlBuilder *preupdate, *metadata;
goffset size;
GifFileType *gifFile = NULL;
GString *where;
const gchar *graph;
gchar *filename, *uri;
GFile *file;
int fd;
#if GIFLIB_MAJOR >= 5
int err;
#endif
preupdate = tracker_extract_info_get_preupdate_builder (info);
metadata = tracker_extract_info_get_metadata_builder (info);
graph = tracker_extract_info_get_graph (info);
file = tracker_extract_info_get_file (info);
filename = g_file_get_path (file);
size = tracker_file_get_size (filename);
if (size < 64) {
g_free (filename);
return FALSE;
}
fd = tracker_file_open_fd (filename);
if (fd == -1) {
g_warning ("Could not open GIF file '%s': %s\n",
filename,
g_strerror (errno));
g_free (filename);
return FALSE;
}
#if GIFLIB_MAJOR < 5
if ((gifFile = DGifOpenFileHandle (fd)) == NULL) {
PrintGifError ();
#else /* GIFLIB_MAJOR < 5 */
if ((gifFile = DGifOpenFileHandle (fd, &err)) == NULL) {
gif_error ("Could not open GIF file with handle", err);
#endif /* GIFLIB_MAJOR < 5 */
close (fd);
return FALSE;
}
g_free (filename);
tracker_sparql_builder_predicate (metadata, "a");
tracker_sparql_builder_object (metadata, "nfo:Image");
tracker_sparql_builder_object (metadata, "nmm:Photo");
where = g_string_new ("");
uri = g_file_get_uri (file);
read_metadata (preupdate, metadata, where, gifFile, uri, graph);
tracker_extract_info_set_where_clause (info, where->str);
g_string_free (where, TRUE);
g_free (uri);
if (DGifCloseFile (gifFile) != GIF_OK) {
#if GIFLIB_MAJOR < 5
PrintGifError ();
#else /* GIFLIB_MAJOR < 5 */
gif_error ("Could not close GIF file", gifFile->Error);
#endif /* GIFLIB_MAJOR < 5 */
}
return TRUE;
}
char
load(ImlibImage * im, ImlibProgressFunction progress, char progress_granularity,
char immediate_load)
{
DATA32 *ptr;
GifFileType *gif;
GifRowType *rows;
GifRecordType rec;
ColorMapObject *cmap;
int i, j, done, bg, r, g, b, w = 0, h = 0;
float per = 0.0, per_inc;
int last_per = 0, last_y = 0;
int intoffset[] = { 0, 4, 2, 1 };
int intjump[] = { 8, 8, 4, 2 };
int transp;
int fd;
done = 0;
rows = NULL;
transp = -1;
/* if immediate_load is 1, then dont delay image laoding as below, or */
/* already data in this image - dont load it again */
if (im->data)
return 0;
#ifndef __EMX__
fd = open(im->real_file, O_RDONLY);
#else
fd = open(im->real_file, O_RDONLY | O_BINARY);
#endif
if (fd < 0)
return 0;
gif = DGifOpenFileHandle(fd);
if (!gif)
{
close(fd);
return 0;
}
do
{
if (DGifGetRecordType(gif, &rec) == GIF_ERROR)
{
/* PrintGifError(); */
rec = TERMINATE_RECORD_TYPE;
}
if ((rec == IMAGE_DESC_RECORD_TYPE) && (!done))
{
if (DGifGetImageDesc(gif) == GIF_ERROR)
{
/* PrintGifError(); */
rec = TERMINATE_RECORD_TYPE;
}
w = gif->Image.Width;
h = gif->Image.Height;
if (!IMAGE_DIMENSIONS_OK(w, h))
{
DGifCloseFile(gif);
return 0;
}
rows = malloc(h * sizeof(GifRowType *));
if (!rows)
{
DGifCloseFile(gif);
return 0;
}
for (i = 0; i < h; i++)
{
rows[i] = NULL;
}
for (i = 0; i < h; i++)
{
rows[i] = malloc(w * sizeof(GifPixelType));
if (!rows[i])
{
DGifCloseFile(gif);
for (i = 0; i < h; i++)
{
if (rows[i])
{
free(rows[i]);
}
}
free(rows);
return 0;
}
}
if (gif->Image.Interlace)
{
for (i = 0; i < 4; i++)
{
for (j = intoffset[i]; j < h; j += intjump[i])
{
DGifGetLine(gif, rows[j], w);
}
}
}
else
{
for (i = 0; i < h; i++)
{
DGifGetLine(gif, rows[i], w);
}
}
done = 1;
}
else if (rec == EXTENSION_RECORD_TYPE)
{
int ext_code;
GifByteType *ext;
ext = NULL;
DGifGetExtension(gif, &ext_code, &ext);
while (ext)
{
if ((ext_code == 0xf9) && (ext[1] & 1) && (transp < 0))
{
transp = (int)ext[4];
}
ext = NULL;
DGifGetExtensionNext(gif, &ext);
}
}
}
while (rec != TERMINATE_RECORD_TYPE);
if (transp >= 0)
{
SET_FLAG(im->flags, F_HAS_ALPHA);
}
else
{
UNSET_FLAG(im->flags, F_HAS_ALPHA);
}
/* set the format string member to the lower-case full extension */
/* name for the format - so example names would be: */
/* "png", "jpeg", "tiff", "ppm", "pgm", "pbm", "gif", "xpm" ... */
im->w = w;
im->h = h;
if (!im->format)
im->format = strdup("gif");
if (im->loader || immediate_load || progress)
{
bg = gif->SBackGroundColor;
cmap = (gif->Image.ColorMap ? gif->Image.ColorMap : gif->SColorMap);
im->data = (DATA32 *) malloc(sizeof(DATA32) * w * h);
if (!im->data)
{
DGifCloseFile(gif);
free(rows);
return 0;
}
ptr = im->data;
per_inc = 100.0 / (((float)w) * h);
for (i = 0; i < h; i++)
{
for (j = 0; j < w; j++)
{
if (rows[i][j] == transp)
{
r = cmap->Colors[bg].Red;
g = cmap->Colors[bg].Green;
b = cmap->Colors[bg].Blue;
*ptr++ = 0x00ffffff & ((r << 16) | (g << 8) | b);
}
else
{
r = cmap->Colors[rows[i][j]].Red;
g = cmap->Colors[rows[i][j]].Green;
b = cmap->Colors[rows[i][j]].Blue;
*ptr++ = (0xff << 24) | (r << 16) | (g << 8) | b;
}
per += per_inc;
if (progress && (((int)per) != last_per)
&& (((int)per) % progress_granularity == 0))
{
last_per = (int)per;
if (!(progress(im, (int)per, 0, last_y, w, i)))
{
DGifCloseFile(gif);
for (i = 0; i < h; i++)
{
free(rows[i]);
}
free(rows);
return 2;
}
last_y = i;
}
}
}
}
if (progress)
{
progress(im, 100, 0, last_y, w, h);
}
DGifCloseFile(gif);
for (i = 0; i < h; i++)
{
free(rows[i]);
}
free(rows);
return 1;
}
static void*
gif_init(FILE *fp, char *filename, unsigned int page,
struct ida_image_info *info, int thumbnail)
{
struct gif_state *h;
GifRecordType RecordType;
int i, image = 0;
h = (gif_state*)fim_calloc(sizeof(*h),1);
if(!h)goto oops;
memset(h,0,sizeof(*h));
h->infile = fp;
h->gif = DGifOpenFileHandle(fileno(fp));
h->row = (GifPixelType*)fim_malloc(h->gif->SWidth * sizeof(GifPixelType));
if(!h->row)goto oops;
while (0 == image) {
RecordType = gif_fileread(h);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (GIF_ERROR == DGifGetImageDesc(h->gif)) {
if (FbiStuff::fim_filereading_debug())
FIM_FBI_PRINTF("gif: DGifGetImageDesc failed\n");
PrintGifError();
}
if (NULL == h->gif->SColorMap &&
NULL == h->gif->Image.ColorMap) {
if (FbiStuff::fim_filereading_debug())
FIM_FBI_PRINTF("gif: oops: no colormap found\n");
goto oops;
}
#if 0
info->width = h->w = h->gif->SWidth;
info->height = h->h = h->gif->SHeight;
#else
info->width = h->w = h->gif->Image.Width;
info->height = h->h = h->gif->Image.Height;
#endif
info->npages = 1;
image = 1;
if (FbiStuff::fim_filereading_debug())
FIM_FBI_PRINTF("gif: reading image record ...\n");
if (h->gif->Image.Interlace) {
if (FbiStuff::fim_filereading_debug())
FIM_FBI_PRINTF("gif: interlaced\n");
{
h->il = (GifPixelType*)fim_malloc(h->w * h->h * sizeof(GifPixelType));
if(!h->il)goto oops;
}
for (i = 0; i < h->h; i += 8)
DGifGetLine(h->gif, h->il + h->w*i,h->w);
for (i = 4; i < h->gif->SHeight; i += 8)
DGifGetLine(h->gif, h->il + h->w*i,h->w);
for (i = 2; i < h->gif->SHeight; i += 4)
DGifGetLine(h->gif, h->il + h->w*i,h->w);
}
break;
case TERMINATE_RECORD_TYPE:
default:
goto oops;
}
}
if (0 == info->width || 0 == info->height)
goto oops;
if (FbiStuff::fim_filereading_debug())
FIM_FBI_PRINTF("gif: s=%dx%d i=%dx%d\n",
h->gif->SWidth,h->gif->SHeight,
h->gif->Image.Width,h->gif->Image.Height);
return h;
oops:
if (FbiStuff::fim_filereading_debug())
FIM_FBI_PRINTF("gif: fatal error, aborting\n");
DGifCloseFile(h->gif);
fclose(h->infile);
if(h && h->il )fim_free(h->il );
if(h && h->row)fim_free(h->row);
if(h)fim_free(h);
return NULL;
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
int main(int argc, char **argv)
{
int i, j, Size, Error, NumFiles, ExtCode, CodeSize, NumColors = 2, Color,
Count, ImageNum = 0, TextFlag = FALSE, SizeFlag = FALSE,
ImageNFlag = FALSE, BackGroundFlag = FALSE, HelpFlag = FALSE;
long Scaler, Histogram[256];
GifRecordType RecordType;
GifByteType *Extension, *CodeBlock;
char **FileName = NULL;
GifRowType Line;
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
/* Same image dimension vars for both Image & ImageN as only one allowed */
if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifQuietPrint,
&TextFlag, &SizeFlag, &ImageWidth, &ImageHeight,
&ImageNFlag, &ImageN, &BackGroundFlag,
&HelpFlag, &NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
if (NumFiles == 1) {
if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
else {
/* Use the stdin instead: */
if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
for (i = 0; i < 256; i++) Histogram[i] = 0; /* Reset counters. */
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (GifFileIn->Image.ColorMap)
NumColors = GifFileIn->Image.ColorMap->ColorCount;
else if (GifFileIn->SColorMap)
NumColors = GifFileIn->SColorMap->ColorCount;
else
GIF_EXIT("Neither Screen nor Image color map exists.");
if ((ImageHeight / NumColors) * NumColors != ImageHeight)
GIF_EXIT("Image height specified not dividable by #colors.");
if (++ImageNum == ImageN) {
/* This is the image we should make histogram for: */
Line = (GifRowType) malloc(GifFileIn->Image.Width *
sizeof(GifPixelType));
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ImageNum,
GifFileIn->Image.Left, GifFileIn->Image.Top,
GifFileIn->Image.Width, GifFileIn->Image.Height);
for (i = 0; i < GifFileIn->Image.Height; i++) {
if (DGifGetLine(GifFileIn, Line, GifFileIn->Image.Width)
== GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
for (j = 0; j < GifFileIn->Image.Width; j++)
Histogram[Line[j]]++;
GifQprintf("\b\b\b\b%-4d", i);
}
free((char *) Line);
}
else {
/* Skip the image: */
/* Now read image itself in decoded form as we dont */
/* really care what is there, and this is much faster. */
if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
while (CodeBlock != NULL)
if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
/* We we requested to kill back ground count: */
if (BackGroundFlag) Histogram[GifFileIn->SBackGroundColor] = 0;
if (DGifCloseFile(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* We may required to dump out the histogram as text file: */
if (TextFlag) {
for (i = 0; i < NumColors; i++)
printf("%12ld %3d\n", Histogram[i], i);
}
else {
/* Open stdout for the histogram output file: */
if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
/* Dump out screen descriptor to fit histogram dimensions: */
if (EGifPutScreenDesc(GifFileOut,
ImageWidth, ImageHeight, HISTO_BITS_PER_PIXEL, 0,
MakeMapObject(4, HistoColorMap)) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Dump out image descriptor to fit histogram dimensions: */
if (EGifPutImageDesc(GifFileOut,
0, 0, ImageWidth, ImageHeight, FALSE, NULL) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Prepare scan line for histogram file, and find scaler to scale */
/* histogram to be between 0 and ImageWidth: */
Line = (GifRowType) malloc(ImageWidth * sizeof(GifPixelType));
for (Scaler = 0, i = 0; i < NumColors; i++) if (Histogram[i] > Scaler)
Scaler = Histogram[i];
Scaler /= ImageWidth;
if (Scaler == 0) Scaler = 1; /* In case maximum is less than width. */
/* Dump out the image itself: */
for (Count = ImageHeight, i = 0, Color = 1; i < NumColors; i++) {
if ((Size = Histogram[i] / Scaler) > ImageWidth) Size = ImageWidth;
for (j = 0; j < Size; j++)
Line[j] = Color;
for (j = Size; j < ImageWidth; j++)
Line[j] = GifFileOut->SBackGroundColor;
/* Move to next color: */
if (++Color >= (1 << HISTO_BITS_PER_PIXEL)) Color = 1;
/* Dump this histogram entry as many times as required: */
for (j = 0; j < ImageHeight / NumColors; j++) {
if (EGifPutLine(GifFileOut, Line, ImageWidth) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
GifQprintf("\b\b\b\b%-4d", Count--);
}
}
if (EGifCloseFile(GifFileOut) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
return 0;
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
void main(int argc, char **argv)
{
int Error, NumFiles, ExtCode;
GifRecordType RecordType;
GifByteType *Extension;
char **FileName = NULL;
GifRowType *ImageBuffer;
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifQuitePrint,
&InterlacedFlag, &SequencialFlag, &HelpFlag,
&NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(1);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(0);
}
if (NumFiles == 1) {
if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
else {
/* Use the stdin instead: */
if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
/* Open stdout for the output file: */
if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
/* And dump out exactly same screen information: */
if (EGifPutScreenDesc(GifFileOut,
GifFileIn -> SWidth, GifFileIn -> SHeight,
GifFileIn -> SColorResolution, GifFileIn -> SBackGroundColor,
GifFileIn -> SBitsPerPixel, GifFileIn -> SColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Put the image descriptor to out file: */
if (EGifPutImageDesc(GifFileOut,
GifFileIn -> ILeft, GifFileIn -> ITop,
GifFileIn -> IWidth, GifFileIn -> IHeight,
InterlacedFlag, GifFileIn -> IBitsPerPixel,
GifFileIn -> IColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Load the image (either Interlaced or not), and dump it as */
/* defined in GifFileOut -> IInterlaced. */
if (LoadImage(GifFileIn, &ImageBuffer) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (DumpImage(GifFileOut, ImageBuffer) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],
Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* No support to more than one extension blocks, so discard: */
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
if (DGifCloseFile(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifCloseFile(GifFileOut) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
int main(int argc, char **argv)
{
int i, Error, NumFiles, ExtCode, CodeSize, ImageNum = 0,
ImageFlag = FALSE, ImageNFlag = FALSE, ImageN, ImageX1, ImageY1,
ImageX2, ImageY2, ImageWidth, ImageDepth,
Complement = FALSE, HelpFlag = FALSE;
GifRecordType RecordType;
GifByteType *Extension, *CodeBlock;
char **FileName = NULL;
GifRowType Line;
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
/* Same image dimension vars for both Image & ImageN as only one allowed.*/
if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifQuietPrint, &Complement,
&ImageFlag, &ImageX1, &ImageY1, &ImageX2, &ImageY2,
&ImageNFlag, &ImageN, &ImageX1, &ImageY1, &ImageX2, &ImageY2,
&HelpFlag, &NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
/* Test to make sure exactly one of ImageFlag & ImageNFlag is set: */
if ((ImageFlag && ImageNFlag) || (!ImageFlag && !ImageNFlag)) {
GIF_MESSAGE("Exactly one of [-i ...] && [-n ...] please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (ImageFlag) ImageN = 1; /* Its first image we are after. */
/* Make sure the first coordinates of clipping box are smaller: */
if (ImageX1 > ImageX2) {
i = ImageX1;
ImageX1 = ImageX2;
ImageX2 = i;
}
if (ImageY1 > ImageY2) {
i = ImageX1;
ImageY1 = ImageY2;
ImageY2 = i;
}
if (NumFiles == 1) {
if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
else {
/* Use the stdin instead: */
if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
/* Open stdout for the output file: */
if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
/* Width and depth of clipped image. */
if (!Complement)
ImageWidth = ImageX2 - ImageX1 + 1;
else
ImageWidth = GifFileIn->SWidth
- (ImageX2 != ImageX1) * (ImageX2 - ImageX1 + 1);
if (!Complement)
ImageDepth = ImageY2 - ImageY1 + 1;
else
ImageDepth = GifFileIn->SHeight
- (ImageY2 != ImageY1) * (ImageY2 - ImageY1 + 1);
/* And dump out exactly same screen information: */
if (EGifPutScreenDesc(GifFileOut,
GifFileIn->SWidth, GifFileIn->SHeight,
GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,
GifFileIn->SColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (++ImageNum == ImageN) {
/* We can handle only non interlaced images here: */
if (GifFileIn->Image.Interlace)
GIF_EXIT("Image to clip is interlaced - use GifInter first.");
/* This is the image we should clip - test sizes and */
/* dump out new clipped screen descriptor if o.k. */
if (GifFileIn->Image.Width <= ImageX2 ||
GifFileIn->Image.Height <= ImageY2)
GIF_EXIT("Image is smaller than given clip dimensions.");
/* Put the image descriptor to out file: */
if (EGifPutImageDesc(GifFileOut,
GifFileIn->Image.Left, GifFileIn->Image.Top,
ImageWidth, ImageDepth,
FALSE, GifFileIn->Image.ColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* o.k. - read the image and clip it: */
Line = (GifRowType) malloc(GifFileIn->Image.Width *
sizeof(GifPixelType));
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ImageNum,
GifFileIn->Image.Left, GifFileIn->Image.Top,
GifFileIn->Image.Width, GifFileIn->Image.Height);
/* Skip lines below ImageY1: */
for (i = 0; i < ImageY1; i++) {
if (DGifGetLine(GifFileIn, Line, GifFileIn->Image.Width)
== GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (Complement) {
if (ImageX1 == ImageX2) {
/* don't remove any vertical band */
if (EGifPutLine(GifFileOut, Line,
ImageWidth) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
else
{
if (EGifPutLine(GifFileOut, Line,
ImageX1) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifPutLine(GifFileOut,
&Line[ImageX2 + 1],
GifFileIn->SWidth - (ImageX2 + 1)
) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
}
GifQprintf("\b\b\b\b%-4d", i);
}
/* Clip the lines from ImageY1 to ImageY2 (to X1 - X2): */
for (i = ImageY1; i <= ImageY2; i++) {
if (DGifGetLine(GifFileIn, Line, GifFileIn->Image.Width)
== GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (!Complement)
if (EGifPutLine(GifFileOut, &Line[ImageX1],
ImageWidth) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
GifQprintf("\b\b\b\b%-4d", i);
}
/* Skip lines above ImageY2: */
for (i = ImageY2 + 1; i < GifFileIn->Image.Height; i++) {
if (DGifGetLine(GifFileIn, Line, GifFileIn->Image.Width)
== GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (Complement) {
if (ImageX1 == ImageX2) {
/* don't remove any vertical band */
if (EGifPutLine(GifFileOut, Line,
ImageWidth) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
else
{
if (EGifPutLine(GifFileOut, Line,
ImageX1) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifPutLine(GifFileOut,
&Line[ImageX2 + 1],
GifFileIn->SWidth - (ImageX2 + 1)
) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
}
GifQprintf("\b\b\b\b%-4d", i);
}
free((char *) Line);
}
else {
/* Copy the image as is (we dont modify this one): */
if (EGifPutImageDesc(GifFileOut,
GifFileIn->Image.Left, GifFileIn->Image.Top,
GifFileIn->Image.Width, GifFileIn->Image.Height,
GifFileIn->Image.Interlace,
GifFileIn->Image.ColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Now read image itself in decoded form as we dont */
/* really care what is there, and this is much faster. */
if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR
|| EGifPutCode(GifFileOut, CodeSize, CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
while (CodeBlock != NULL)
if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR ||
EGifPutCodeNext(GifFileOut, CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],
Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* No support to more than one extension blocks, so discard: */
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
if (DGifCloseFile(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifCloseFile(GifFileOut) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
return 0;
}
unsigned char *
loader_gif(FILE *f, int *w, int *h, int *t)
{
unsigned char *data, *ptr;
GifFileType *gif;
GifRowType *rows;
GifRecordType rec;
ColorMapObject *cmap;
int i, j, done, bg, csize, r, g, b;
int intoffset[] = {0, 4, 2, 1};
int intjump[] = {8, 8, 4, 2};
int istransp, transp;
int fd;
done = 0;
istransp = 0;
fd = fileno(f);
/* Apparently rewind(f) isn't sufficient */
lseek(fd, (long) 0, 0);
gif = DGifOpenFileHandle(fd);
transp = -1;
data = NULL;
rows = NULL;
if (!gif)
return NULL;
do
{
if (DGifGetRecordType(gif, &rec) == GIF_ERROR)
{
PrintGifError();
rec = TERMINATE_RECORD_TYPE;
}
if ((rec == IMAGE_DESC_RECORD_TYPE) && (!done))
{
if (DGifGetImageDesc(gif) == GIF_ERROR)
{
PrintGifError();
rec = TERMINATE_RECORD_TYPE;
}
*w = gif->Image.Width;
*h = gif->Image.Height;
if(*h > 32767 || *w > 32767)
{
return NULL;
}
rows = malloc(*h * sizeof(GifRowType *));
if (!rows)
{
DGifCloseFile(gif);
return NULL;
}
data = _gdk_malloc_image(*w, *h);
if (!data)
{
DGifCloseFile(gif);
free(rows);
return NULL;
}
for (i = 0; i < *h; i++)
rows[i] = NULL;
for (i = 0; i < *h; i++)
{
rows[i] = malloc(*w * sizeof(GifPixelType));
if (!rows[i])
{
DGifCloseFile(gif);
for (i = 0; i < *h; i++)
if (rows[i])
free(rows[i]);
free(rows);
free(data);
return NULL;
}
}
if (gif->Image.Interlace)
{
for (i = 0; i < 4; i++)
{
for (j = intoffset[i]; j < *h; j += intjump[i])
DGifGetLine(gif, rows[j], *w);
}
}
else
{
for (i = 0; i < *h; i++)
DGifGetLine(gif, rows[i], *w);
}
done = 1;
}
else if (rec == EXTENSION_RECORD_TYPE)
{
int ext_code;
GifByteType *ext;
ext = NULL;
DGifGetExtension(gif, &ext_code, &ext);
while (ext)
{
if ((ext_code == 0xf9) && (ext[1] & 1) && (transp < 0))
{
istransp = 1;
transp = (int)ext[4];
}
ext = NULL;
DGifGetExtensionNext(gif, &ext);
}
}
}
while (rec != TERMINATE_RECORD_TYPE);
bg = gif->SBackGroundColor;
cmap = (gif->Image.ColorMap ? gif->Image.ColorMap : gif->SColorMap);
csize = cmap->ColorCount;
ptr = data;
if (!istransp)
{
for (i = 0; i < *h; i++)
{
for (j = 0; j < *w; j++)
{
r = cmap->Colors[rows[i][j]].Red;
g = cmap->Colors[rows[i][j]].Green;
b = cmap->Colors[rows[i][j]].Blue;
*ptr++ = r;
*ptr++ = g;
*ptr++ = b;
}
}
}
else
{
for (i = 0; i < *h; i++)
{
for (j = 0; j < *w; j++)
{
if (rows[i][j] == transp)
{
*ptr++ = 255;
*ptr++ = 0;
*ptr++ = 255;
}
else
{
r = cmap->Colors[rows[i][j]].Red;
g = cmap->Colors[rows[i][j]].Green;
b = cmap->Colors[rows[i][j]].Blue;
if (r == 255 && g == 0 && b == 255)
r = 254;
*ptr++ = r;
*ptr++ = g;
*ptr++ = b;
}
}
}
}
DGifCloseFile(gif);
for (i = 0; i < *h; i++)
free(rows[i]);
free(rows);
*t = istransp;
return data;
}
/**
* Reads an image from a stream. Earlier functions have decided that
* this is the proper function to use for this stream. Therefore, we
* will not lay much weight on excessive error checking when it comes
* to the possibility of wrong image types.
* The end product is converted into an appropriate format for the
* user interface.
*
* @param fd The file descriptor of the stream to read the image data from.
* @param width The requested width of the image, or a negative value if the
* @param width width is to be taken from the image.
* @param height The requested height of the image, or a negative value if the
* @param height height is to be taken from the image.
*
* @return an allocated struct with the converted image and information
* @return about it, or NULL if an error occurred.
*/
struct image_data *image_gif_read(int fd, int width, int height)
{
GifFileType *gifp;
GifRecordType record;
GifByteType *extension;
int i, j, ret, extcode, rowsize, images_read, step;
int row, col, image_width, image_height;
struct image_data *picture;
unsigned char *picturep;
GifRowType *buffer;
ColorMapObject *colourmap;
GifColorType *colour;
char *status;
int interlaceoffset[] = { 0, 4, 2, 1 };
int interlacejump[] = { 8, 8, 4, 2 };
gifp = DGifOpenFileHandle(fd);
if(gifp == NULL) {
return NULL;
}
#if 0
/* First duplicate the file descriptor, so that we can close it in the
* correct way, without interfering with the method libmagick has chosen
* to operate in.
*/
#ifndef _WIN32_WCE
new_fd = dup(fd);
#else
new_fd = fd;
#endif
#if defined _WIN32_WCE || WIN32
if(fd == -1) {
#else
if(fd < 0) {
#endif
/* If there is an error here, we could theoretically proceed with some
* special treatment of the streams, but it indicates that something is
* more wrong that we want it to be, so we just return an error here.
*/
return NULL;
}
#ifndef _WIN32_WCE
fp = _fdopen(new_fd, "r");
if(fp == NULL) {
RalCloseFile(new_fd);
return NULL;
}
#endif
#endif
ui_functions_set_status("Reading and processing GIF image...");
picture = (struct image_data *)malloc(sizeof(struct image_data));
if(picture == NULL) {
DGifCloseFile(gifp);
return NULL;
}
picture->data = NULL;
#if 0
fprintf(stderr, "screen width=%d, height=%d\n",
gifp->SWidth, gifp->SHeight);
#endif
buffer = (GifRowType *)malloc(gifp->SHeight * sizeof(GifRowType *));
if(buffer == NULL) {
free(picture);
DGifCloseFile(gifp);
return NULL;
}
rowsize = gifp->SWidth * sizeof(GifPixelType);
buffer[0] = (GifRowType)malloc(rowsize);
if(buffer[0] == NULL) {
free(buffer);
free(picture);
DGifCloseFile(gifp);
return NULL;
}
for(i = 0 ; i < gifp->SWidth ; i++)
buffer[0][i] = gifp->SBackGroundColor;
for(i = 0 ; i < gifp->SHeight ; i++) {
buffer[i] = (GifRowType)malloc(rowsize);
if(buffer[i] == NULL) {
while(--i >= 0)
free(buffer[i]);
free(buffer);
free(picture);
DGifCloseFile(gifp);
return NULL;
}
memcpy(buffer[i], buffer[0], rowsize);
}
/* We only read the first GIF image right now, since we are not
* supporting animated GIF images. Perhaps the last image would
* actually be a better choice. Oh well.
*/
images_read = 0;
do {
DGifGetRecordType(gifp, &record);
ret = GIF_OK;
switch(record) {
case IMAGE_DESC_RECORD_TYPE:
ret = DGifGetImageDesc(gifp);
if(ret == GIF_ERROR)
break;
#if 0
fprintf(stderr, "image width=%d, height=%d, interlace=%d\n",
gifp->Image.Width, gifp->Image.Height, gifp->Image.Interlace);
#endif
row = gifp->Image.Top;
col = gifp->Image.Left;
image_width = gifp->Image.Width;
image_height = gifp->Image.Height;
if(gifp->Image.Interlace) {
for(i = 0 ; i < 4 ; i++) {
for(j = row + interlaceoffset[i] ;
j < row + image_height ;
j += interlacejump[i]) {
DGifGetLine(gifp, &buffer[j][col], image_width);
}
}
} else {
for(i = 0 ; i < image_height ; i++) {
DGifGetLine(gifp, &buffer[row++][col], image_width);
}
}
images_read++;
break;
/* Read and skip any extension. */
case EXTENSION_RECORD_TYPE:
ret = DGifGetExtension(gifp, &extcode, &extension);
while(extension != NULL)
ret = DGifGetExtensionNext(gifp, &extension);
break;
default:
break;
}
} while(images_read == 0 && ret == GIF_OK &&
record != TERMINATE_RECORD_TYPE);
if(ret == GIF_ERROR) {
for(i = 0 ; i < gifp->SHeight ; i++)
free(buffer[i]);
free(buffer);
free(picture);
DGifCloseFile(gifp);
return NULL;
}
/* Since scaling is not possible yet, we only use the original
* geometry of the image.
*/
picture->width = gifp->SWidth;
picture->height = gifp->SHeight;
/* Allocate space for the image data in our struct. */
picture->size = (picture->width * picture->height *
user_interface.ui_display.bit_depth) / 8;
picture->data = (unsigned char *)malloc(picture->size);
if(picture->data == NULL) {
free(picture);
for(i = 0 ; i < gifp->SHeight ; i++)
free(buffer[i]);
free(buffer);
DGifCloseFile(gifp);
return NULL;
}
if(gifp->Image.ColorMap != NULL)
colourmap = gifp->Image.ColorMap;
else
colourmap = gifp->SColorMap;
status = (char *)malloc(128);
picturep = picture->data;
for(i = 0 ; i < picture->height ; i++) {
for(j = 0 ; j < picture->width ; j++) {
colour = &colourmap->Colors[buffer[i][j]];
step = image_get_real_colour(picturep, colour->Red,
colour->Green, colour->Blue);
picturep += step;
}
if(status != NULL) {
sprintf(status, "Reading and processing GIF image... %d%%",
(int)((100 * (i+1)) / picture->height));
ui_functions_set_status(status);
}
}
for(i = 0 ; i < gifp->SHeight ; i++)
free(buffer[i]);
free(buffer);
DGifCloseFile(gifp);
return picture;
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
int main(int argc, char **argv)
{
int i, iy, last_iy, l, t, w, h, Error, NumFiles, ExtCode,
ImageNum = 0,
SizeFlag = FALSE,
ScaleFlag = FALSE,
XScaleFlag = FALSE,
YScaleFlag = FALSE,
HelpFlag = FALSE;
double Scale, y;
GifRecordType RecordType;
char s[80];
GifByteType *Extension;
GifRowType LineIn, LineOut;
char **FileName = NULL;
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
if ((Error = GAGetArgs(argc, argv, CtrlStr,
&GifQuietPrint, &SizeFlag, &XSize, &YSize, &ScaleFlag, &Scale,
&XScaleFlag, &XScale, &YScaleFlag, &YScale,
&HelpFlag, &NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
/* If specific direction was set, set other direction to 1: */
if (!XScaleFlag && YScaleFlag) XScale = 1.0;
if (!YScaleFlag && XScaleFlag) YScale = 1.0;
/* If the specific direction was not set, but global one did use it: */
if (!XScaleFlag && ScaleFlag) XScale = Scale;
if (!YScaleFlag && ScaleFlag) YScale = Scale;
if (XScale > MAX_SCALE) {
sprintf(s, "XScale too big, maximum scale selected instead (%f).",
MAX_SCALE);
GIF_MESSAGE(s);
XScale = MAX_SCALE;
}
if (YScale > MAX_SCALE) {
sprintf(s, "YScale too big, maximum scale selected instead (%f).",
MAX_SCALE);
GIF_MESSAGE(s);
YScale = MAX_SCALE;
}
if (NumFiles == 1) {
if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
else {
/* Use the stdin instead: */
if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
BackGroundColor = GifFileIn->SBackGroundColor;
/* If size was specified, it is used to derive the scale: */
if (SizeFlag) {
XScale = XSize / ((double) GifFileIn->SWidth);
YScale = YSize / ((double) GifFileIn->SHeight);
}
else
{
XSize = (int) (GifFileIn->SWidth * XScale + 0.5);
YSize = (int) (GifFileIn->SHeight * YScale + 0.5);
}
/* As at this time we know the Screen size of the input gif file, and as */
/* all image(s) in file must be less/equal to it, we can allocate the */
/* scan lines for the input file, and output file. The number of lines */
/* to allocate for each is set by ScaleDown & XScale & YScale: */
LineOut = (GifRowType) malloc(XSize * sizeof(GifPixelType));
LineIn = (GifRowType) malloc(GifFileIn->SWidth * sizeof(GifPixelType));
/* Open stdout for the output file: */
if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
/* And dump out its new scaled screen information: */
if (EGifPutScreenDesc(GifFileOut, XSize, YSize,
GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,
GifFileIn->SColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Put the image descriptor to out file: */
l = (int) (GifFileIn->Image.Left * XScale + 0.5);
w = (int) (GifFileIn->Image.Width * XScale + 0.5);
t = (int) (GifFileIn->Image.Top * YScale + 0.5);
h = (int) (GifFileIn->Image.Height * YScale + 0.5);
if (l < 0) l = 0;
if (t < 0) t = 0;
if (l + w > XSize) w = XSize - l;
if (t + h > YSize) h = YSize - t;
if (EGifPutImageDesc(GifFileOut, l, t, w, h,
GifFileIn->Image.Interlace,
GifFileIn->Image.ColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (GifFileIn->Image.Interlace) {
GIF_EXIT("Cannt resize interlaced images - use GifInter first.");
}
else {
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ++ImageNum,
GifFileOut->Image.Left, GifFileOut->Image.Top,
GifFileOut->Image.Width, GifFileOut->Image.Height);
for (i = GifFileIn->Image.Height, y = 0.0, last_iy = -1;
i-- > 0;
y += YScale) {
if (DGifGetLine(GifFileIn, LineIn,
GifFileIn->Image.Width) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
iy = (int) y;
if (last_iy < iy && last_iy < YSize) {
ResizeLine(LineIn, LineOut,
GifFileIn->Image.Width, GifFileOut->Image.Width);
for (;
last_iy < iy && last_iy < GifFileOut->Image.Height - 1;
last_iy++) {
GifQprintf("\b\b\b\b%-4d", last_iy + 1);
if (EGifPutLine(GifFileOut, LineOut,
GifFileOut->Image.Width) ==
GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
}
}
/* If scale is not dividable - dump last lines: */
while (++last_iy < GifFileOut->Image.Height) {
GifQprintf("\b\b\b\b%-4d", last_iy);
if (EGifPutLine(GifFileOut, LineOut,
GifFileOut->Image.Width) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],
Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* No support to more than one extension blocks, so discard: */
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
if (DGifCloseFile(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (EGifCloseFile(GifFileOut) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
free(LineOut);
free(LineIn);
return 0;
}
static void GIF2RGB(int NumFiles, char *FileName,
bool OneFileFlag,
char *OutFileName)
{
int i, j, Size, Row, Col, Width, Height, ExtCode, Count;
GifRecordType RecordType;
GifByteType *Extension;
GifRowType *ScreenBuffer;
GifFileType *GifFile;
int
InterlacedOffset[] = { 0, 4, 2, 1 }, /* The way Interlaced image should. */
InterlacedJumps[] = { 8, 8, 4, 2 }; /* be read - offsets and jumps... */
int ImageNum = 0;
ColorMapObject *ColorMap;
int Error;
if (NumFiles == 1) {
int Error;
if ((GifFile = DGifOpenFileName(FileName, &Error)) == NULL) {
PrintGifError(Error);
exit(EXIT_FAILURE);
}
}
else {
int Error;
/* Use stdin instead: */
if ((GifFile = DGifOpenFileHandle(0, &Error)) == NULL) {
PrintGifError(Error);
exit(EXIT_FAILURE);
}
}
/*
* Allocate the screen as vector of column of rows. Note this
* screen is device independent - it's the screen defined by the
* GIF file parameters.
*/
if ((ScreenBuffer = (GifRowType *)
malloc(GifFile->SHeight * sizeof(GifRowType))) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
Size = GifFile->SWidth * sizeof(GifPixelType);/* Size in bytes one row.*/
if ((ScreenBuffer[0] = (GifRowType) malloc(Size)) == NULL) /* First row. */
GIF_EXIT("Failed to allocate memory required, aborted.");
for (i = 0; i < GifFile->SWidth; i++) /* Set its color to BackGround. */
ScreenBuffer[0][i] = GifFile->SBackGroundColor;
for (i = 1; i < GifFile->SHeight; i++) {
/* Allocate the other rows, and set their color to background too: */
if ((ScreenBuffer[i] = (GifRowType) malloc(Size)) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
memcpy(ScreenBuffer[i], ScreenBuffer[0], Size);
}
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
{
if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
Row = GifFile->Image.Top; /* Image Position relative to Screen. */
Col = GifFile->Image.Left;
Width = GifFile->Image.Width;
Height = GifFile->Image.Height;
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ++ImageNum, Col, Row, Width, Height);
if (GifFile->Image.Left + GifFile->Image.Width > GifFile->SWidth ||
GifFile->Image.Top + GifFile->Image.Height > GifFile->SHeight) {
fprintf(stderr, "Image %d is not confined to screen dimension, aborted.\n",ImageNum);
exit(EXIT_FAILURE);
}
if (GifFile->Image.Interlace) {
/* Need to perform 4 passes on the images: */
for (Count = i = 0; i < 4; i++)
for (j = Row + InterlacedOffset[i]; j < Row + Height;
j += InterlacedJumps[i]) {
GifQprintf("\b\b\b\b%-4d", Count++);
if (DGifGetLine(GifFile, &ScreenBuffer[j][Col],
Width) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
}
}
else {
for (i = 0; i < Height; i++) {
GifQprintf("\b\b\b\b%-4d", i);
if (DGifGetLine(GifFile, &ScreenBuffer[Row++][Col],
Width) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
}
}
break;
}
case EXTENSION_RECORD_TYPE:
{
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
PrintGifError(GifFile->Error);
exit(EXIT_FAILURE);
}
}
break;
}
case TERMINATE_RECORD_TYPE:
{
break;
}
default: /* Should be trapped by DGifGetRecordType. */
break;
}
} while (RecordType != TERMINATE_RECORD_TYPE);
/* Lets dump it - set the global variables required and do it: */
ColorMap = (GifFile->Image.ColorMap
? GifFile->Image.ColorMap
: GifFile->SColorMap);
if (ColorMap == NULL) {
fprintf(stderr, "Gif Image does not have a colormap\n");
exit(EXIT_FAILURE);
}
DumpScreen2RGB(OutFileName, OneFileFlag,
ColorMap,
ScreenBuffer,
GifFile->SWidth, GifFile->SHeight);
(void)free(ScreenBuffer);
if (DGifCloseFile(GifFile, &Error) == GIF_ERROR) {
PrintGifError(Error);
exit(EXIT_FAILURE);
}
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
int main(int argc, char **argv)
{
int Error, NumFiles, ExtCode, CodeSize, ImageNum = 0,
ImageNFlag = FALSE, ImageN, HelpFlag = FALSE, HasGIFOutput;
GifRecordType RecordType;
GifByteType *Extension, *CodeBlock;
char **FileName = NULL, *ColorFileName, *TranslateFileName;
GifFileType *GifFileIn = NULL, *GifFileOut = NULL;
if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifQuietPrint, &SaveFlag,
&TranslateFlag, &TranslateFileName,
&LoadFlag, &ColorFileName,
&GammaFlag, &Gamma, &ImageNFlag, &ImageN,
&HelpFlag, &NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(EXIT_FAILURE);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(EXIT_SUCCESS);
}
if (SaveFlag + LoadFlag + GammaFlag + TranslateFlag > 1)
GIF_EXIT("Can not handle more than one of -s -l, -t, or -g at the same time.");
if (NumFiles == 1) {
if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
else {
/* Use stdin instead: */
if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
if (SaveFlag) {
/* We are dumping out the color map as text file to stdout: */
ColorFile = stdout;
}
else {
if (TranslateFlag) {
/* We are loading new color map from specified file: */
if ((TranslateFile = fopen(TranslateFileName, "rt")) == NULL)
GIF_EXIT("Failed to open specified color translation file.");
}
if (LoadFlag) {
/* We are loading new color map from specified file: */
if ((ColorFile = fopen(ColorFileName, "rt")) == NULL)
GIF_EXIT("Failed to open specified color map file.");
}
}
if ((HasGIFOutput = (LoadFlag || TranslateFlag || GammaFlag)) != 0) {
/* Open stdout for GIF output file: */
if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)
QuitGifError(GifFileIn, GifFileOut);
}
if (!ImageNFlag) {
/* We are suppose to modify the screen color map, so do it: */
GifFileIn->SColorMap = ModifyColorMap(GifFileIn->SColorMap);
if (!HasGIFOutput) {
/* We can quit here, as we have the color map: */
if (GifFileIn != NULL) DGifCloseFile(GifFileIn);
fclose(ColorFile);
exit(EXIT_SUCCESS);
}
}
/* And dump out its new possible repositioned screen information: */
if (HasGIFOutput)
if (EGifPutScreenDesc(GifFileOut,
GifFileIn->SWidth, GifFileIn->SHeight,
GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,
GifFileIn->SColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if ((++ImageNum == ImageN) && ImageNFlag) {
/* We are suppose to modify this image color map, do it: */
GifFileIn->SColorMap =ModifyColorMap(GifFileIn->SColorMap);
if (!HasGIFOutput) {
/* We can quit here, as we have the color map: */
if (GifFileIn != NULL) DGifCloseFile(GifFileIn);
fclose(ColorFile);
exit(EXIT_SUCCESS);
}
}
if (HasGIFOutput)
if (EGifPutImageDesc(GifFileOut,
GifFileIn->Image.Left, GifFileIn->Image.Top,
GifFileIn->Image.Width, GifFileIn->Image.Height,
GifFileIn->Image.Interlace,
GifFileIn->Image.ColorMap) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (!TranslateFlag || (ImageNFlag && (ImageN != ImageNum)))
{
/* Now read image itself in decoded form as we don't */
/* really care what we have there, and this is much */
/* faster. */
if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (HasGIFOutput)
if (EGifPutCode(GifFileOut, CodeSize, CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
while (CodeBlock != NULL) {
if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (HasGIFOutput)
if (EGifPutCodeNext(GifFileOut, CodeBlock) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
}
else /* we need to mung pixels intices */
{
int i;
register GifPixelType *cp;
GifPixelType *Line
= (GifPixelType *) malloc(GifFileIn->Image.Width *
sizeof(GifPixelType));
for (i = 0; i < GifFileIn->Image.Height; i++) {
if (DGifGetLine(GifFileIn, Line,GifFileIn->Image.Width)
== GIF_ERROR) {
QuitGifError(GifFileIn, GifFileOut);
}
/* translation step goes here */
for (cp = Line; cp < Line+GifFileIn->Image.Width; cp++)
*cp = Translation[*cp];
if (EGifPutLine(GifFileOut,
Line, GifFileIn->Image.Width)
== GIF_ERROR) {
QuitGifError(GifFileIn, GifFileOut);
}
}
free((char *) Line);
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (HasGIFOutput)
if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],
Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
/* No support to more than one extension blocks, so discard: */
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
if (DGifCloseFile(GifFileIn) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
if (HasGIFOutput)
if (EGifCloseFile(GifFileOut) == GIF_ERROR)
QuitGifError(GifFileIn, GifFileOut);
return 0;
}
/******************************************************************************
* Interpret the command line and scan the given GIF file. *
******************************************************************************/
void main(int argc, char **argv)
{
int i, j, Error, NumFiles, Size, Row, Col, Width, Height, ExtCode, Count;
GifRecordType RecordType;
GifByteType *Extension;
char **FileName = NULL;
GifRowType *ScreenBuffer;
GifFileType *GifFile;
if ((Error = GAGetArgs(argc, argv, CtrlStr,
&GifQuitePrint, &DitherFlag, &DitherSize,
&BWThresholdFlag, &Threshold,
&MappingFlag, &Mapping, &InvertFlag,
&NiceFlag, &PrinterFlag, &PrinterName, &HelpFlag,
&NumFiles, &FileName)) != FALSE ||
(NumFiles > 1 && !HelpFlag)) {
if (Error)
GAPrintErrMsg(Error);
else if (NumFiles > 1)
GIF_MESSAGE("Error in command line parsing - one GIF file please.");
GAPrintHowTo(CtrlStr);
exit(1);
}
if (HelpFlag) {
fprintf(stderr, VersionStr);
GAPrintHowTo(CtrlStr);
exit(0);
}
if (!PrinterFlag) PrinterName = "";
if (DitherFlag) {
/* Make sure we are o.k.: */
if (DitherSize > DITHER_MAX_MATRIX) DitherSize = DITHER_MAX_MATRIX;
if (DitherSize < DITHER_MIN_MATRIX) DitherSize = DITHER_MAX_MATRIX;
}
/* As Threshold is in [0..100] range and BWThreshold is [0..25500]: */
if (BWThresholdFlag) {
if (Threshold > 100 || Threshold < 0)
GIF_EXIT("Threshold not in 0..100 percent.");
BWThreshold = Threshold * 255;
if (BWThreshold == 0) BWThreshold = 1; /* Overcome divide by zero! */
}
/* No message is emitted, but mapping method is clipped to exists method.*/
if (MappingFlag) ColorToBWMapping = Mapping % C2BW_NUM_METHODS;
if (NumFiles == 1) {
if ((GifFile = DGifOpenFileName(*FileName)) == NULL) {
PrintGifError();
exit(-1);
}
}
else {
/* Use the stdin instead: */
#ifdef __MSDOS__
setmode(0, O_BINARY);
#endif /* __MSDOS__ */
if ((GifFile = DGifOpenFileHandle(0)) == NULL) {
PrintGifError();
exit(-1);
}
}
/* Allocate the screen as vector of column of rows. We cannt allocate */
/* the all screen at once, as this broken minded CPU can allocate up to */
/* 64k at a time and our image can be bigger than that: */
/* Note this screen is device independent - its the screen as defined by */
/* the GIF file parameters itself. */
if ((ScreenBuffer = (GifRowType *)
malloc(GifFile -> SHeight * sizeof(GifRowType *))) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.");
Size = GifFile -> SWidth * sizeof(GifPixelType);/* Size in bytes one row.*/
if ((ScreenBuffer[0] = (GifRowType) malloc(Size)) == NULL) /* First row. */
GIF_EXIT("Failed to allocate memory required, aborted.");
for (i = 0; i < GifFile -> SWidth; i++) /* Set its color to BackGround. */
ScreenBuffer[0][i] = GifFile -> SBackGroundColor;
for (i = 1; i < GifFile -> SHeight; i++) {
/* Allocate the other rows, andset their color to background too: */
if ((ScreenBuffer[i] = (GifRowType) malloc(Size)) == NULL)
GIF_EXIT("Failed to allocate memory required, aborted.\n");
memcpy(ScreenBuffer[i], ScreenBuffer[0], Size);
}
/* Scan the content of the GIF file and load the image(s) in: */
do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
switch (RecordType) {
case IMAGE_DESC_RECORD_TYPE:
if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
Row = GifFile -> ITop; /* Image Position relative to Screen. */
Col = GifFile -> ILeft;
Width = GifFile -> IWidth;
Height = GifFile -> IHeight;
GifQprintf("\n%s: Image %d at (%d, %d) [%dx%d]: ",
PROGRAM_NAME, ++ImageNum, Col, Row, Width, Height);
if (GifFile -> ILeft + GifFile -> IWidth > GifFile -> SWidth ||
GifFile -> ITop + GifFile -> IHeight > GifFile -> SHeight) {
fprintf(stderr, "Image %d is not confined to screen dimension, aborted.\n");
exit(-2);
}
if (GifFile -> IInterlace) {
/* Need to perform 4 passes on the images: */
for (Count = i = 0; i < 4; i++)
for (j = Row + InterlacedOffset[i]; j < Row + Height;
j += InterlacedJumps[i]) {
GifQprintf("\b\b\b\b%-4d", Count++);
if (DGifGetLine(GifFile, &ScreenBuffer[j][Col],
Width) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
}
else {
for (i = 0; i < Height; i++) {
GifQprintf("\b\b\b\b%-4d", i);
if (DGifGetLine(GifFile, &ScreenBuffer[Row++][Col],
Width) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
}
break;
case EXTENSION_RECORD_TYPE:
/* Skip any extension blocks in file: */
if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
while (Extension != NULL) {
if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be traps by DGifGetRecordType. */
break;
}
}
while (RecordType != TERMINATE_RECORD_TYPE);
/* Lets display it - set the global variables required and do it: */
BackGround = GifFile -> SBackGroundColor;
ColorMap = (GifFile -> IColorMap ? GifFile -> IColorMap :
GifFile -> SColorMap);
DumpScreen2Epsn(ScreenBuffer, GifFile -> SWidth, GifFile -> SHeight);
if (DGifCloseFile(GifFile) == GIF_ERROR) {
PrintGifError();
exit(-1);
}
}
