Skip to content

D
dragonwell8_jdk

openanolis / dragonwell8_jdk

通知 4
Star 2
Fork 0
D
dragonwell8_jdk
提交 2e480e33 编写于 作者: A azvegint
浏览文件
操作

8077982: GIFLIB upgrade 

Reviewed-by: ant, serb
上级 069614f0
隐藏空白更改
内联 并排
Showing with 1071 addition and 716 deletion
src/share/native/sun/awt/giflib/COPYING 0 → 100644
浏览文件 @ 2e480e33
The GIFLIB distribution is Copyright (c) 1997 Eric S. Raymond
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
src/share/native/sun/awt/giflib/dgif_lib.c
浏览文件 @ 2e480e33
...@@ -23,219 +23,211 @@ ...@@ -23,219 +23,211 @@
*/ */
/****************************************************************************** /******************************************************************************
* "Gif-Lib" - Yet another gif library.
*
* Written by: Gershon Elber IBM PC Ver 1.1, Aug. 1990
******************************************************************************
* The kernel of the GIF Decoding process can be found here.
******************************************************************************
* History:
* 16 Jun 89 - Version 1.0 by Gershon Elber.
* 3 Sep 90 - Version 1.1 by Gershon Elber (Support for Gif89, Unique names).
*****************************************************************************/
/* !!!! */ dgif_lib.c - GIF decoding
The functions here and in egif_lib.c are partitioned carefully so that
if you only require one of read and write capability, only one of these
two modules will be linked. Preserve this property!
#ifdef HAVE_CONFIG_H *****************************************************************************/
#include <config.h>
#endif
#include <stdlib.h> #include <stdlib.h>
#if defined (__MSDOS__) && !defined(__DJGPP__) && !defined(__GNUC__) #include <limits.h>
#include <io.h> #include <stdint.h>
#include <alloc.h> #include <fcntl.h>
#include <sys\stat.h> #include <stdio.h>
#else #include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#endif /* __MSDOS__ */
#ifdef _WIN32 #ifdef _WIN32
#include <io.h> #include <io.h>
#define _OPEN_BINARY
#else #else
#include <unistd.h> #include <unistd.h>
#endif #endif /* _WIN32 */
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include "gif_lib.h" #include "gif_lib.h"
#include "gif_lib_private.h" #include "gif_lib_private.h"
#define COMMENT_EXT_FUNC_CODE 0xfe /* Extension function code for /* compose unsigned little endian value */
comment. */ #define UNSIGNED_LITTLE_ENDIAN(lo, hi) ((lo) | ((hi) << 8))
/* avoid extra function call in case we use fread (TVT) */ /* avoid extra function call in case we use fread (TVT) */
#define READ(_gif,_buf,_len) \ #define READ(_gif,_buf,_len) \
(((GifFilePrivateType*)_gif->Private)->Read ? \ (((GifFilePrivateType*)_gif->Private)->Read ? \
(size_t)((GifFilePrivateType*)_gif->Private)->Read(_gif,_buf,_len) : \ ((GifFilePrivateType*)_gif->Private)->Read(_gif,_buf,_len) : \
fread(_buf,1,_len,((GifFilePrivateType*)_gif->Private)->File)) fread(_buf,1,_len,((GifFilePrivateType*)_gif->Private)->File))
static int DGifGetWord(GifFileType *GifFile, int *Word); static int DGifGetWord(GifFileType *GifFile, GifWord *Word);
static int DGifSetupDecompress(GifFileType *GifFile); static int DGifSetupDecompress(GifFileType *GifFile);
static int DGifDecompressLine(GifFileType *GifFile, GifPixelType *Line, static int DGifDecompressLine(GifFileType *GifFile, GifPixelType *Line,
int LineLen); int LineLen);
static int DGifGetPrefixChar(unsigned int *Prefix, int Code, int ClearCode); static int DGifGetPrefixChar(GifPrefixType *Prefix, int Code, int ClearCode);
static int DGifDecompressInput(GifFileType *GifFile, int *Code); static int DGifDecompressInput(GifFileType *GifFile, int *Code);
static int DGifBufferedInput(GifFileType *GifFile, GifByteType *Buf, static int DGifBufferedInput(GifFileType *GifFile, GifByteType *Buf,
GifByteType *NextByte); GifByteType *NextByte);
/****************************************************************************** /******************************************************************************
* Open a new gif file for read, given by its name. Open a new GIF file for read, given by its name.
* Returns GifFileType pointer dynamically allocated which serves as the gif Returns dynamically allocated GifFileType pointer which serves as the GIF
* info record. _GifError is cleared if succesfull. info record.
*****************************************************************************/ ******************************************************************************/
GifFileType * GifFileType *
DGifOpenFileName(const char *FileName) { DGifOpenFileName(const char *FileName, int *Error)
{
int FileHandle; int FileHandle;
GifFileType *GifFile; GifFileType *GifFile;
if ((FileHandle = open(FileName, O_RDONLY if ((FileHandle = open(FileName, O_RDONLY)) == -1) {
#if defined(__MSDOS__) || defined(_OPEN_BINARY) if (Error != NULL)
| O_BINARY *Error = D_GIF_ERR_OPEN_FAILED;
#endif /* __MSDOS__ || _OPEN_BINARY */
)) == -1) {
_GifError = D_GIF_ERR_OPEN_FAILED;
return NULL; return NULL;
} }
GifFile = DGifOpenFileHandle(FileHandle); GifFile = DGifOpenFileHandle(FileHandle, Error);
if (GifFile == (GifFileType *)NULL)
close(FileHandle);
return GifFile; return GifFile;
} }
/****************************************************************************** /******************************************************************************
* Update a new gif file, given its file handle. Update a new GIF file, given its file handle.
* Returns GifFileType pointer dynamically allocated which serves as the gif Returns dynamically allocated GifFileType pointer which serves as the GIF
* info record. _GifError is cleared if succesfull. info record.
*****************************************************************************/ ******************************************************************************/
GifFileType * GifFileType *
DGifOpenFileHandle(int FileHandle) { DGifOpenFileHandle(int FileHandle, int *Error)
{
unsigned char Buf[GIF_STAMP_LEN + 1]; char Buf[GIF_STAMP_LEN + 1];
GifFileType *GifFile; GifFileType *GifFile;
GifFilePrivateType *Private; GifFilePrivateType *Private;
FILE *f; FILE *f;
GifFile = (GifFileType *)malloc(sizeof(GifFileType)); GifFile = (GifFileType *)malloc(sizeof(GifFileType));
if (GifFile == NULL) { if (GifFile == NULL) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; if (Error != NULL)
*Error = D_GIF_ERR_NOT_ENOUGH_MEM;
(void)close(FileHandle);
return NULL; return NULL;
} }
memset(GifFile, '\0', sizeof(GifFileType)); /*@i1@*/memset(GifFile, '\0', sizeof(GifFileType));
/* Belt and suspenders, in case the null pointer isn't zero */
GifFile->SavedImages = NULL;
GifFile->SColorMap = NULL;
Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType)); Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType));
if (Private == NULL) { if (Private == NULL) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; if (Error != NULL)
*Error = D_GIF_ERR_NOT_ENOUGH_MEM;
(void)close(FileHandle);
free((char *)GifFile); free((char *)GifFile);
return NULL; return NULL;
} }
#ifdef __MSDOS__ #ifdef _WIN32
setmode(FileHandle, O_BINARY); /* Make sure it is in binary mode. */ _setmode(FileHandle, O_BINARY); /* Make sure it is in binary mode. */
#endif /* __MSDOS__ */ #endif /* _WIN32 */
f = fdopen(FileHandle, "rb"); /* Make it into a stream: */ f = fdopen(FileHandle, "rb"); /* Make it into a stream: */
#ifdef __MSDOS__ /*@-mustfreeonly@*/
setvbuf(f, NULL, _IOFBF, GIF_FILE_BUFFER_SIZE); /* And inc. stream GifFile->Private = (void *)Private;
buffer. */
#endif /* __MSDOS__ */
GifFile->Private = (VoidPtr)Private;
Private->FileHandle = FileHandle; Private->FileHandle = FileHandle;
Private->File = f; Private->File = f;
Private->FileState = FILE_STATE_READ; Private->FileState = FILE_STATE_READ;
Private->Read = 0; /* don't use alternate input method (TVT) */ Private->Read = NULL; /* don't use alternate input method (TVT) */
GifFile->UserData = 0; /* TVT */ GifFile->UserData = NULL; /* TVT */
/*@=mustfreeonly@*/
/* Lets see if this is a GIF file: */
if (READ(GifFile, Buf, GIF_STAMP_LEN) != GIF_STAMP_LEN) { /* Let's see if this is a GIF file: */
_GifError = D_GIF_ERR_READ_FAILED; /* coverity[check_return] */
fclose(f); if (READ(GifFile, (unsigned char *)Buf, GIF_STAMP_LEN) != GIF_STAMP_LEN) {
if (Error != NULL)
*Error = D_GIF_ERR_READ_FAILED;
(void)fclose(f);
free((char *)Private); free((char *)Private);
free((char *)GifFile); free((char *)GifFile);
return NULL; return NULL;
} }
/* The GIF Version number is ignored at this time. Maybe we should do /* Check for GIF prefix at start of file */
* something more useful with it. */
Buf[GIF_STAMP_LEN] = 0; Buf[GIF_STAMP_LEN] = 0;
if (strncmp(GIF_STAMP, (const char*)Buf, GIF_VERSION_POS) != 0) { if (strncmp(GIF_STAMP, Buf, GIF_VERSION_POS) != 0) {
_GifError = D_GIF_ERR_NOT_GIF_FILE; if (Error != NULL)
fclose(f); *Error = D_GIF_ERR_NOT_GIF_FILE;
(void)fclose(f);
free((char *)Private); free((char *)Private);
free((char *)GifFile); free((char *)GifFile);
return NULL; return NULL;
} }
if (DGifGetScreenDesc(GifFile) == GIF_ERROR) { if (DGifGetScreenDesc(GifFile) == GIF_ERROR) {
fclose(f); (void)fclose(f);
free((char *)Private); free((char *)Private);
free((char *)GifFile); free((char *)GifFile);
return NULL; return NULL;
} }
_GifError = 0; GifFile->Error = 0;
/* What version of GIF? */
Private->gif89 = (Buf[GIF_VERSION_POS] == '9');
return GifFile; return GifFile;
} }
/****************************************************************************** /******************************************************************************
* GifFileType constructor with user supplied input function (TVT) GifFileType constructor with user supplied input function (TVT)
*****************************************************************************/ ******************************************************************************/
GifFileType * GifFileType *
DGifOpen(void *userData, DGifOpen(void *userData, InputFunc readFunc, int *Error)
InputFunc readFunc) { {
char Buf[GIF_STAMP_LEN + 1];
unsigned char Buf[GIF_STAMP_LEN + 1];
GifFileType *GifFile; GifFileType *GifFile;
GifFilePrivateType *Private; GifFilePrivateType *Private;
if (!readFunc) {
_GifError = D_GIF_ERR_READ_FAILED;
return NULL;
}
GifFile = (GifFileType *)malloc(sizeof(GifFileType)); GifFile = (GifFileType *)malloc(sizeof(GifFileType));
if (GifFile == NULL) { if (GifFile == NULL) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; if (Error != NULL)
*Error = D_GIF_ERR_NOT_ENOUGH_MEM;
return NULL; return NULL;
} }
memset(GifFile, '\0', sizeof(GifFileType)); memset(GifFile, '\0', sizeof(GifFileType));
/* Belt and suspenders, in case the null pointer isn't zero */
GifFile->SavedImages = NULL;
GifFile->SColorMap = NULL;
Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType)); Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType));
if (!Private) { if (!Private) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; if (Error != NULL)
*Error = D_GIF_ERR_NOT_ENOUGH_MEM;
free((char *)GifFile); free((char *)GifFile);
return NULL; return NULL;
} }
GifFile->Private = (VoidPtr)Private; GifFile->Private = (void *)Private;
Private->FileHandle = 0; Private->FileHandle = 0;
Private->File = 0; Private->File = NULL;
Private->FileState = FILE_STATE_READ; Private->FileState = FILE_STATE_READ;
Private->Read = readFunc; /* TVT */ Private->Read = readFunc; /* TVT */
GifFile->UserData = userData; /* TVT */ GifFile->UserData = userData; /* TVT */
/* Lets see if this is a GIF file: */ /* Lets see if this is a GIF file: */
if (READ(GifFile, Buf, GIF_STAMP_LEN) != GIF_STAMP_LEN) { /* coverity[check_return] */
_GifError = D_GIF_ERR_READ_FAILED; if (READ(GifFile, (unsigned char *)Buf, GIF_STAMP_LEN) != GIF_STAMP_LEN) {
if (Error != NULL)
*Error = D_GIF_ERR_READ_FAILED;
free((char *)Private); free((char *)Private);
free((char *)GifFile); free((char *)GifFile);
return NULL; return NULL;
} }
/* The GIF Version number is ignored at this time. Maybe we should do /* Check for GIF prefix at start of file */
* something more useful with it. */ Buf[GIF_STAMP_LEN] = '\0';
Buf[GIF_STAMP_LEN] = 0; if (strncmp(GIF_STAMP, Buf, GIF_VERSION_POS) != 0) {
if (strncmp(GIF_STAMP, (const char*)Buf, GIF_VERSION_POS) != 0) { if (Error != NULL)
_GifError = D_GIF_ERR_NOT_GIF_FILE; *Error = D_GIF_ERR_NOT_GIF_FILE;
free((char *)Private); free((char *)Private);
free((char *)GifFile); free((char *)GifFile);
return NULL; return NULL;
...@@ -244,28 +236,34 @@ DGifOpen(void *userData, ...@@ -244,28 +236,34 @@ DGifOpen(void *userData,
if (DGifGetScreenDesc(GifFile) == GIF_ERROR) { if (DGifGetScreenDesc(GifFile) == GIF_ERROR) {
free((char *)Private); free((char *)Private);
free((char *)GifFile); free((char *)GifFile);
if (Error != NULL)
*Error = D_GIF_ERR_NO_SCRN_DSCR;
return NULL; return NULL;
} }
_GifError = 0; GifFile->Error = 0;
/* What version of GIF? */
Private->gif89 = (Buf[GIF_VERSION_POS] == '9');
return GifFile; return GifFile;
} }
/****************************************************************************** /******************************************************************************
* This routine should be called before any other DGif calls. Note that This routine should be called before any other DGif calls. Note that
* this routine is called automatically from DGif file open routines. this routine is called automatically from DGif file open routines.
*****************************************************************************/ ******************************************************************************/
int int
DGifGetScreenDesc(GifFileType * GifFile) { DGifGetScreenDesc(GifFileType *GifFile)
{
int i, BitsPerPixel; int BitsPerPixel;
bool SortFlag;
GifByteType Buf[3]; GifByteType Buf[3];
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
...@@ -275,25 +273,33 @@ DGifGetScreenDesc(GifFileType * GifFile) { ...@@ -275,25 +273,33 @@ DGifGetScreenDesc(GifFileType * GifFile) {
return GIF_ERROR; return GIF_ERROR;
if (READ(GifFile, Buf, 3) != 3) { if (READ(GifFile, Buf, 3) != 3) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
GifFreeMapObject(GifFile->SColorMap);
GifFile->SColorMap = NULL;
return GIF_ERROR; return GIF_ERROR;
} }
GifFile->SColorResolution = (((Buf[0] & 0x70) + 1) >> 4) + 1; GifFile->SColorResolution = (((Buf[0] & 0x70) + 1) >> 4) + 1;
SortFlag = (Buf[0] & 0x08) != 0;
BitsPerPixel = (Buf[0] & 0x07) + 1; BitsPerPixel = (Buf[0] & 0x07) + 1;
GifFile->SBackGroundColor = Buf[1]; GifFile->SBackGroundColor = Buf[1];
GifFile->AspectByte = Buf[2];
if (Buf[0] & 0x80) { /* Do we have global color map? */ if (Buf[0] & 0x80) { /* Do we have global color map? */
int i;
GifFile->SColorMap = MakeMapObject(1 << BitsPerPixel, NULL); GifFile->SColorMap = GifMakeMapObject(1 << BitsPerPixel, NULL);
if (GifFile->SColorMap == NULL) { if (GifFile->SColorMap == NULL) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
return GIF_ERROR; return GIF_ERROR;
} }
/* Get the global color map: */ /* Get the global color map: */
GifFile->SColorMap->SortFlag = SortFlag;
for (i = 0; i < GifFile->SColorMap->ColorCount; i++) { for (i = 0; i < GifFile->SColorMap->ColorCount; i++) {
/* coverity[check_return] */
if (READ(GifFile, Buf, 3) != 3) { if (READ(GifFile, Buf, 3) != 3) {
FreeMapObject(GifFile->SColorMap); GifFreeMapObject(GifFile->SColorMap);
_GifError = D_GIF_ERR_READ_FAILED; GifFile->SColorMap = NULL;
GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
GifFile->SColorMap->Colors[i].Red = Buf[0]; GifFile->SColorMap->Colors[i].Red = Buf[0];
...@@ -308,39 +314,39 @@ DGifGetScreenDesc(GifFileType * GifFile) { ...@@ -308,39 +314,39 @@ DGifGetScreenDesc(GifFileType * GifFile) {
} }
/****************************************************************************** /******************************************************************************
* This routine should be called before any attempt to read an image. This routine should be called before any attempt to read an image.
*****************************************************************************/ ******************************************************************************/
int int
DGifGetRecordType(GifFileType * GifFile, DGifGetRecordType(GifFileType *GifFile, GifRecordType* Type)
GifRecordType * Type) { {
GifByteType Buf; GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
/* coverity[check_return] */
if (READ(GifFile, &Buf, 1) != 1) { if (READ(GifFile, &Buf, 1) != 1) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
switch (Buf) { switch (Buf) {
case ',': case DESCRIPTOR_INTRODUCER:
*Type = IMAGE_DESC_RECORD_TYPE; *Type = IMAGE_DESC_RECORD_TYPE;
break; break;
case '!': case EXTENSION_INTRODUCER:
*Type = EXTENSION_RECORD_TYPE; *Type = EXTENSION_RECORD_TYPE;
break; break;
case ';': case TERMINATOR_INTRODUCER:
*Type = TERMINATE_RECORD_TYPE; *Type = TERMINATE_RECORD_TYPE;
break; break;
default: default:
*Type = UNDEFINED_RECORD_TYPE; *Type = UNDEFINED_RECORD_TYPE;
_GifError = D_GIF_ERR_WRONG_RECORD; GifFile->Error = D_GIF_ERR_WRONG_RECORD;
return GIF_ERROR; return GIF_ERROR;
} }
...@@ -348,20 +354,20 @@ DGifGetRecordType(GifFileType * GifFile, ...@@ -348,20 +354,20 @@ DGifGetRecordType(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* This routine should be called before any attempt to read an image. This routine should be called before any attempt to read an image.
* Note it is assumed the Image desc. header (',') has been read. Note it is assumed the Image desc. header has been read.
*****************************************************************************/ ******************************************************************************/
int int
DGifGetImageDesc(GifFileType * GifFile) { DGifGetImageDesc(GifFileType *GifFile)
{
int i, BitsPerPixel; unsigned int BitsPerPixel;
GifByteType Buf[3]; GifByteType Buf[3];
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
SavedImage *sp; SavedImage *sp;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
...@@ -371,51 +377,57 @@ DGifGetImageDesc(GifFileType * GifFile) { ...@@ -371,51 +377,57 @@ DGifGetImageDesc(GifFileType * GifFile) {
DGifGetWord(GifFile, &GifFile->Image.Height) == GIF_ERROR) DGifGetWord(GifFile, &GifFile->Image.Height) == GIF_ERROR)
return GIF_ERROR; return GIF_ERROR;
if (READ(GifFile, Buf, 1) != 1) { if (READ(GifFile, Buf, 1) != 1) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
GifFreeMapObject(GifFile->Image.ColorMap);
GifFile->Image.ColorMap = NULL;
return GIF_ERROR; return GIF_ERROR;
} }
BitsPerPixel = (Buf[0] & 0x07) + 1; BitsPerPixel = (Buf[0] & 0x07) + 1;
GifFile->Image.Interlace = (Buf[0] & 0x40); GifFile->Image.Interlace = (Buf[0] & 0x40) ? true : false;
if (Buf[0] & 0x80) { /* Does this image have local color map? */
/*** FIXME: Why do we check both of these in order to do this? /* Setup the colormap */
* Why do we have both Image and SavedImages? */ if (GifFile->Image.ColorMap) {
if (GifFile->Image.ColorMap && GifFile->SavedImages == NULL) GifFreeMapObject(GifFile->Image.ColorMap);
FreeMapObject(GifFile->Image.ColorMap); GifFile->Image.ColorMap = NULL;
}
/* Does this image have local color map? */
if (Buf[0] & 0x80) {
unsigned int i;
GifFile->Image.ColorMap = MakeMapObject(1 << BitsPerPixel, NULL); GifFile->Image.ColorMap = GifMakeMapObject(1 << BitsPerPixel, NULL);
if (GifFile->Image.ColorMap == NULL) { if (GifFile->Image.ColorMap == NULL) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
return GIF_ERROR; return GIF_ERROR;
} }
/* Get the image local color map: */ /* Get the image local color map: */
for (i = 0; i < GifFile->Image.ColorMap->ColorCount; i++) { for (i = 0; i < GifFile->Image.ColorMap->ColorCount; i++) {
/* coverity[check_return] */
if (READ(GifFile, Buf, 3) != 3) { if (READ(GifFile, Buf, 3) != 3) {
FreeMapObject(GifFile->Image.ColorMap); GifFreeMapObject(GifFile->Image.ColorMap);
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
GifFile->Image.ColorMap = NULL;
return GIF_ERROR; return GIF_ERROR;
} }
GifFile->Image.ColorMap->Colors[i].Red = Buf[0]; GifFile->Image.ColorMap->Colors[i].Red = Buf[0];
GifFile->Image.ColorMap->Colors[i].Green = Buf[1]; GifFile->Image.ColorMap->Colors[i].Green = Buf[1];
GifFile->Image.ColorMap->Colors[i].Blue = Buf[2]; GifFile->Image.ColorMap->Colors[i].Blue = Buf[2];
} }
} else if (GifFile->Image.ColorMap) {
FreeMapObject(GifFile->Image.ColorMap);
GifFile->Image.ColorMap = NULL;
} }
if (GifFile->SavedImages) { if (GifFile->SavedImages) {
if ((GifFile->SavedImages = (SavedImage *)realloc(GifFile->SavedImages, SavedImage* new_saved_images =
sizeof(SavedImage) * (SavedImage *)realloc(GifFile->SavedImages,
(GifFile->ImageCount + 1))) == NULL) { sizeof(SavedImage) * (GifFile->ImageCount + 1));
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; if (new_saved_images == NULL) {
GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
return GIF_ERROR; return GIF_ERROR;
} }
GifFile->SavedImages = new_saved_images;
} else { } else {
if ((GifFile->SavedImages = if ((GifFile->SavedImages =
(SavedImage *) malloc(sizeof(SavedImage))) == NULL) { (SavedImage *) malloc(sizeof(SavedImage))) == NULL) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
return GIF_ERROR; return GIF_ERROR;
} }
} }
...@@ -423,11 +435,11 @@ DGifGetImageDesc(GifFileType * GifFile) { ...@@ -423,11 +435,11 @@ DGifGetImageDesc(GifFileType * GifFile) {
sp = &GifFile->SavedImages[GifFile->ImageCount]; sp = &GifFile->SavedImages[GifFile->ImageCount];
memcpy(&sp->ImageDesc, &GifFile->Image, sizeof(GifImageDesc)); memcpy(&sp->ImageDesc, &GifFile->Image, sizeof(GifImageDesc));
if (GifFile->Image.ColorMap != NULL) { if (GifFile->Image.ColorMap != NULL) {
sp->ImageDesc.ColorMap = MakeMapObject( sp->ImageDesc.ColorMap = GifMakeMapObject(
GifFile->Image.ColorMap->ColorCount, GifFile->Image.ColorMap->ColorCount,
GifFile->Image.ColorMap->Colors); GifFile->Image.ColorMap->Colors);
if (sp->ImageDesc.ColorMap == NULL) { if (sp->ImageDesc.ColorMap == NULL) {
_GifError = D_GIF_ERR_NOT_ENOUGH_MEM; GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
return GIF_ERROR; return GIF_ERROR;
} }
} }
...@@ -440,43 +452,40 @@ DGifGetImageDesc(GifFileType * GifFile) { ...@@ -440,43 +452,40 @@ DGifGetImageDesc(GifFileType * GifFile) {
Private->PixelCount = (long)GifFile->Image.Width * Private->PixelCount = (long)GifFile->Image.Width *
(long)GifFile->Image.Height; (long)GifFile->Image.Height;
return DGifSetupDecompress(GifFile); /* Reset decompress algorithm parameters. */ /* Reset decompress algorithm parameters. */
return DGifSetupDecompress(GifFile);
} }
/****************************************************************************** /******************************************************************************
* Get one full scanned line (Line) of length LineLen from GIF file. Get one full scanned line (Line) of length LineLen from GIF file.
*****************************************************************************/ ******************************************************************************/
int int
DGifGetLine(GifFileType * GifFile, DGifGetLine(GifFileType *GifFile, GifPixelType *Line, int LineLen)
GifPixelType * Line, {
int LineLen) {
GifByteType *Dummy; GifByteType *Dummy;
GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
if (!LineLen) if (!LineLen)
LineLen = GifFile->Image.Width; LineLen = GifFile->Image.Width;
#if defined(__MSDOS__) || defined(__GNUC__)
if ((Private->PixelCount -= LineLen) > 0xffff0000UL) { if ((Private->PixelCount -= LineLen) > 0xffff0000UL) {
#else GifFile->Error = D_GIF_ERR_DATA_TOO_BIG;
if ((Private->PixelCount -= LineLen) > 0xffff0000) {
#endif /* __MSDOS__ */
_GifError = D_GIF_ERR_DATA_TOO_BIG;
return GIF_ERROR; return GIF_ERROR;
} }
if (DGifDecompressLine(GifFile, Line, LineLen) == GIF_OK) { if (DGifDecompressLine(GifFile, Line, LineLen) == GIF_OK) {
if (Private->PixelCount == 0) { if (Private->PixelCount == 0) {
/* We probably would not be called any more, so lets clean /* We probably won't be called any more, so let's clean up
* everything before we return: need to flush out all rest of * everything before we return: need to flush out all the
* image until empty block (size 0) detected. We use GetCodeNext. */ * rest of image until an empty block (size 0)
* detected. We use GetCodeNext.
*/
do do
if (DGifGetCodeNext(GifFile, &Dummy) == GIF_ERROR) if (DGifGetCodeNext(GifFile, &Dummy) == GIF_ERROR)
return GIF_ERROR; return GIF_ERROR;
...@@ -488,35 +497,32 @@ DGifGetLine(GifFileType * GifFile, ...@@ -488,35 +497,32 @@ DGifGetLine(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* Put one pixel (Pixel) into GIF file. Put one pixel (Pixel) into GIF file.
*****************************************************************************/ ******************************************************************************/
int int
DGifGetPixel(GifFileType * GifFile, DGifGetPixel(GifFileType *GifFile, GifPixelType Pixel)
GifPixelType Pixel) { {
GifByteType *Dummy; GifByteType *Dummy;
GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
#if defined(__MSDOS__) || defined(__GNUC__)
if (--Private->PixelCount > 0xffff0000UL) if (--Private->PixelCount > 0xffff0000UL)
#else
if (--Private->PixelCount > 0xffff0000)
#endif /* __MSDOS__ */
{ {
_GifError = D_GIF_ERR_DATA_TOO_BIG; GifFile->Error = D_GIF_ERR_DATA_TOO_BIG;
return GIF_ERROR; return GIF_ERROR;
} }
if (DGifDecompressLine(GifFile, &Pixel, 1) == GIF_OK) { if (DGifDecompressLine(GifFile, &Pixel, 1) == GIF_OK) {
if (Private->PixelCount == 0) { if (Private->PixelCount == 0) {
/* We probably would not be called any more, so lets clean /* We probably won't be called any more, so let's clean up
* everything before we return: need to flush out all rest of * everything before we return: need to flush out all the
* image until empty block (size 0) detected. We use GetCodeNext. */ * rest of image until an empty block (size 0)
* detected. We use GetCodeNext.
*/
do do
if (DGifGetCodeNext(GifFile, &Dummy) == GIF_ERROR) if (DGifGetCodeNext(GifFile, &Dummy) == GIF_ERROR)
return GIF_ERROR; return GIF_ERROR;
...@@ -528,28 +534,27 @@ DGifGetPixel(GifFileType * GifFile, ...@@ -528,28 +534,27 @@ DGifGetPixel(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* Get an extension block (see GIF manual) from gif file. This routine only Get an extension block (see GIF manual) from GIF file. This routine only
* returns the first data block, and DGifGetExtensionNext should be called returns the first data block, and DGifGetExtensionNext should be called
* after this one until NULL extension is returned. after this one until NULL extension is returned.
* The Extension should NOT be freed by the user (not dynamically allocated). The Extension should NOT be freed by the user (not dynamically allocated).
* Note it is assumed the Extension desc. header ('!') has been read. Note it is assumed the Extension description header has been read.
*****************************************************************************/ ******************************************************************************/
int int
DGifGetExtension(GifFileType * GifFile, DGifGetExtension(GifFileType *GifFile, int *ExtCode, GifByteType **Extension)
int *ExtCode, {
GifByteType ** Extension) {
GifByteType Buf; GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
/* coverity[check_return] */
if (READ(GifFile, &Buf, 1) != 1) { if (READ(GifFile, &Buf, 1) != 1) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
*ExtCode = Buf; *ExtCode = Buf;
...@@ -558,26 +563,26 @@ DGifGetExtension(GifFileType * GifFile, ...@@ -558,26 +563,26 @@ DGifGetExtension(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* Get a following extension block (see GIF manual) from gif file. This Get a following extension block (see GIF manual) from GIF file. This
* routine should be called until NULL Extension is returned. routine should be called until NULL Extension is returned.
* The Extension should NOT be freed by the user (not dynamically allocated). The Extension should NOT be freed by the user (not dynamically allocated).
*****************************************************************************/ ******************************************************************************/
int int
DGifGetExtensionNext(GifFileType * GifFile, DGifGetExtensionNext(GifFileType *GifFile, GifByteType ** Extension)
GifByteType ** Extension) { {
GifByteType Buf; GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (READ(GifFile, &Buf, 1) != 1) { if (READ(GifFile, &Buf, 1) != 1) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
if (Buf > 0) { if (Buf > 0) {
*Extension = Private->Buf; /* Use private unused buffer. */ *Extension = Private->Buf; /* Use private unused buffer. */
(*Extension)[0] = Buf; /* Pascal strings notation (pos. 0 is len.). */ (*Extension)[0] = Buf; /* Pascal strings notation (pos. 0 is len.). */
/* coverity[tainted_data,check_return] */
if (READ(GifFile, &((*Extension)[1]), Buf) != Buf) { if (READ(GifFile, &((*Extension)[1]), Buf) != Buf) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
} else } else
...@@ -587,91 +592,141 @@ DGifGetExtensionNext(GifFileType * GifFile, ...@@ -587,91 +592,141 @@ DGifGetExtensionNext(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* This routine should be called last, to close the GIF file. Extract a Graphics Control Block from raw extension data
*****************************************************************************/ ******************************************************************************/
int
DGifCloseFile(GifFileType * GifFile) { int DGifExtensionToGCB(const size_t GifExtensionLength,
const GifByteType *GifExtension,
GraphicsControlBlock *GCB)
{
if (GifExtensionLength != 4) {
return GIF_ERROR;
}
GifFilePrivateType *Private; GCB->DisposalMode = (GifExtension[0] >> 2) & 0x07;
FILE *File; GCB->UserInputFlag = (GifExtension[0] & 0x02) != 0;
GCB->DelayTime = UNSIGNED_LITTLE_ENDIAN(GifExtension[1], GifExtension[2]);
if (GifExtension[0] & 0x01)
GCB->TransparentColor = (int)GifExtension[3];
else
GCB->TransparentColor = NO_TRANSPARENT_COLOR;
if (GifFile == NULL) return GIF_OK;
return GIF_ERROR; }
Private = (GifFilePrivateType *) GifFile->Private; /******************************************************************************
Extract the Graphics Control Block for a saved image, if it exists.
******************************************************************************/
if (!IS_READABLE(Private)) { int DGifSavedExtensionToGCB(GifFileType *GifFile,
/* This file was NOT open for reading: */ int ImageIndex, GraphicsControlBlock *GCB)
_GifError = D_GIF_ERR_NOT_READABLE; {
int i;
if (ImageIndex < 0 || ImageIndex > GifFile->ImageCount - 1)
return GIF_ERROR; return GIF_ERROR;
GCB->DisposalMode = DISPOSAL_UNSPECIFIED;
GCB->UserInputFlag = false;
GCB->DelayTime = 0;
GCB->TransparentColor = NO_TRANSPARENT_COLOR;
for (i = 0; i < GifFile->SavedImages[ImageIndex].ExtensionBlockCount; i++) {
ExtensionBlock *ep = &GifFile->SavedImages[ImageIndex].ExtensionBlocks[i];
if (ep->Function == GRAPHICS_EXT_FUNC_CODE)
return DGifExtensionToGCB(ep->ByteCount, ep->Bytes, GCB);
} }
File = Private->File; return GIF_ERROR;
}
/******************************************************************************
This routine should be called last, to close the GIF file.
******************************************************************************/
int
DGifCloseFile(GifFileType *GifFile, int *ErrorCode)
{
GifFilePrivateType *Private;
if (GifFile == NULL || GifFile->Private == NULL)
return GIF_ERROR;
if (GifFile->Image.ColorMap) { if (GifFile->Image.ColorMap) {
FreeMapObject(GifFile->Image.ColorMap); GifFreeMapObject(GifFile->Image.ColorMap);
GifFile->Image.ColorMap = NULL; GifFile->Image.ColorMap = NULL;
} }
if (GifFile->SColorMap) { if (GifFile->SColorMap) {
FreeMapObject(GifFile->SColorMap); GifFreeMapObject(GifFile->SColorMap);
GifFile->SColorMap = NULL; GifFile->SColorMap = NULL;
} }
if (Private) {
free((char *)Private);
Private = NULL;
}
if (GifFile->SavedImages) { if (GifFile->SavedImages) {
FreeSavedImages(GifFile); GifFreeSavedImages(GifFile);
GifFile->SavedImages = NULL; GifFile->SavedImages = NULL;
} }
free(GifFile); GifFreeExtensions(&GifFile->ExtensionBlockCount, &GifFile->ExtensionBlocks);
Private = (GifFilePrivateType *) GifFile->Private;
if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */
if (ErrorCode != NULL)
*ErrorCode = D_GIF_ERR_NOT_READABLE;
free((char *)GifFile->Private);
free(GifFile);
return GIF_ERROR;
}
if (File && (fclose(File) != 0)) { if (Private->File && (fclose(Private->File) != 0)) {
_GifError = D_GIF_ERR_CLOSE_FAILED; if (ErrorCode != NULL)
*ErrorCode = D_GIF_ERR_CLOSE_FAILED;
free((char *)GifFile->Private);
free(GifFile);
return GIF_ERROR; return GIF_ERROR;
} }
free((char *)GifFile->Private);
free(GifFile);
if (ErrorCode != NULL)
*ErrorCode = D_GIF_SUCCEEDED;
return GIF_OK; return GIF_OK;
} }
/****************************************************************************** /******************************************************************************
* Get 2 bytes (word) from the given file: Get 2 bytes (word) from the given file:
*****************************************************************************/ ******************************************************************************/
static int static int
DGifGetWord(GifFileType * GifFile, DGifGetWord(GifFileType *GifFile, GifWord *Word)
int *Word) { {
unsigned char c[2]; unsigned char c[2];
/* coverity[check_return] */
if (READ(GifFile, c, 2) != 2) { if (READ(GifFile, c, 2) != 2) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
*Word = (((unsigned int)c[1]) << 8) + c[0]; *Word = (GifWord)UNSIGNED_LITTLE_ENDIAN(c[0], c[1]);
return GIF_OK; return GIF_OK;
} }
/****************************************************************************** /******************************************************************************
* Get the image code in compressed form. This routine can be called if the Get the image code in compressed form. This routine can be called if the
* information needed to be piped out as is. Obviously this is much faster information needed to be piped out as is. Obviously this is much faster
* than decoding and encoding again. This routine should be followed by calls than decoding and encoding again. This routine should be followed by calls
* to DGifGetCodeNext, until NULL block is returned. to DGifGetCodeNext, until NULL block is returned.
* The block should NOT be freed by the user (not dynamically allocated). The block should NOT be freed by the user (not dynamically allocated).
*****************************************************************************/ ******************************************************************************/
int int
DGifGetCode(GifFileType * GifFile, DGifGetCode(GifFileType *GifFile, int *CodeSize, GifByteType **CodeBlock)
int *CodeSize, {
GifByteType ** CodeBlock) {
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
...@@ -681,27 +736,30 @@ DGifGetCode(GifFileType * GifFile, ...@@ -681,27 +736,30 @@ DGifGetCode(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* Continue to get the image code in compressed form. This routine should be Continue to get the image code in compressed form. This routine should be
* called until NULL block is returned. called until NULL block is returned.
* The block should NOT be freed by the user (not dynamically allocated). The block should NOT be freed by the user (not dynamically allocated).
*****************************************************************************/ ******************************************************************************/
int int
DGifGetCodeNext(GifFileType * GifFile, DGifGetCodeNext(GifFileType *GifFile, GifByteType **CodeBlock)
GifByteType ** CodeBlock) { {
GifByteType Buf; GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
/* coverity[tainted_data_argument] */
/* coverity[check_return] */
if (READ(GifFile, &Buf, 1) != 1) { if (READ(GifFile, &Buf, 1) != 1) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
/* coverity[lower_bounds] */
if (Buf > 0) { if (Buf > 0) {
*CodeBlock = Private->Buf; /* Use private unused buffer. */ *CodeBlock = Private->Buf; /* Use private unused buffer. */
(*CodeBlock)[0] = Buf; /* Pascal strings notation (pos. 0 is len.). */ (*CodeBlock)[0] = Buf; /* Pascal strings notation (pos. 0 is len.). */
/* coverity[tainted_data] */
if (READ(GifFile, &((*CodeBlock)[1]), Buf) != Buf) { if (READ(GifFile, &((*CodeBlock)[1]), Buf) != Buf) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
} else { } else {
...@@ -714,20 +772,19 @@ DGifGetCodeNext(GifFileType * GifFile, ...@@ -714,20 +772,19 @@ DGifGetCodeNext(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* Setup the LZ decompression for this image: Setup the LZ decompression for this image:
*****************************************************************************/ ******************************************************************************/
static int static int
DGifSetupDecompress(GifFileType * GifFile) { DGifSetupDecompress(GifFileType *GifFile)
{
int i, BitsPerPixel; int i, BitsPerPixel;
GifByteType CodeSize; GifByteType CodeSize;
unsigned int *Prefix; GifPrefixType *Prefix;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
READ(GifFile, &CodeSize, 1); /* Read Code size from file. */ /* coverity[check_return] */
if (CodeSize >= 12) { if (READ(GifFile, &CodeSize, 1) < 1) { /* Read Code size from file. */
/* Invalid initial code size: report failure */ return GIF_ERROR; /* Failed to read Code size. */
return GIF_ERROR;
} }
BitsPerPixel = CodeSize; BitsPerPixel = CodeSize;
...@@ -751,20 +808,18 @@ DGifSetupDecompress(GifFileType * GifFile) { ...@@ -751,20 +808,18 @@ DGifSetupDecompress(GifFileType * GifFile) {
} }
/****************************************************************************** /******************************************************************************
* The LZ decompression routine: The LZ decompression routine:
* This version decompress the given gif file into Line of length LineLen. This version decompress the given GIF file into Line of length LineLen.
* This routine can be called few times (one per scan line, for example), in This routine can be called few times (one per scan line, for example), in
* order the complete the whole image. order the complete the whole image.
*****************************************************************************/ ******************************************************************************/
static int static int
DGifDecompressLine(GifFileType * GifFile, DGifDecompressLine(GifFileType *GifFile, GifPixelType *Line, int LineLen)
GifPixelType * Line, {
int LineLen) {
int i = 0; int i = 0;
int j, CrntCode, EOFCode, ClearCode, CrntPrefix, LastCode, StackPtr; int j, CrntCode, EOFCode, ClearCode, CrntPrefix, LastCode, StackPtr;
GifByteType *Stack, *Suffix; GifByteType *Stack, *Suffix;
unsigned int *Prefix; GifPrefixType *Prefix;
GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
StackPtr = Private->StackPtr; StackPtr = Private->StackPtr;
...@@ -775,8 +830,12 @@ DGifDecompressLine(GifFileType * GifFile, ...@@ -775,8 +830,12 @@ DGifDecompressLine(GifFileType * GifFile,
ClearCode = Private->ClearCode; ClearCode = Private->ClearCode;
LastCode = Private->LastCode; LastCode = Private->LastCode;
if (StackPtr > LZ_MAX_CODE) {
return GIF_ERROR;
}
if (StackPtr != 0) { if (StackPtr != 0) {
/* Let pop the stack off before continueing to read the gif file: */ /* Let pop the stack off before continueing to read the GIF file: */
while (StackPtr != 0 && i < LineLen) while (StackPtr != 0 && i < LineLen)
Line[i++] = Stack[--StackPtr]; Line[i++] = Stack[--StackPtr];
} }
...@@ -789,11 +848,8 @@ DGifDecompressLine(GifFileType * GifFile, ...@@ -789,11 +848,8 @@ DGifDecompressLine(GifFileType * GifFile,
/* Note however that usually we will not be here as we will stop /* Note however that usually we will not be here as we will stop
* decoding as soon as we got all the pixel, or EOF code will * decoding as soon as we got all the pixel, or EOF code will
* not be read at all, and DGifGetLine/Pixel clean everything. */ * not be read at all, and DGifGetLine/Pixel clean everything. */
if (i != LineLen - 1 || Private->PixelCount != 0) { GifFile->Error = D_GIF_ERR_EOF_TOO_SOON;
_GifError = D_GIF_ERR_EOF_TOO_SOON; return GIF_ERROR;
return GIF_ERROR;
}
i++;
} else if (CrntCode == ClearCode) { } else if (CrntCode == ClearCode) {
/* We need to start over again: */ /* We need to start over again: */
for (j = 0; j <= LZ_MAX_CODE; j++) for (j = 0; j <= LZ_MAX_CODE; j++)
...@@ -815,36 +871,37 @@ DGifDecompressLine(GifFileType * GifFile, ...@@ -815,36 +871,37 @@ DGifDecompressLine(GifFileType * GifFile,
* pixels on our stack. If we done, pop the stack in reverse * pixels on our stack. If we done, pop the stack in reverse
* (thats what stack is good for!) order to output. */ * (thats what stack is good for!) order to output. */
if (Prefix[CrntCode] == NO_SUCH_CODE) { if (Prefix[CrntCode] == NO_SUCH_CODE) {
CrntPrefix = LastCode;
/* Only allowed if CrntCode is exactly the running code: /* Only allowed if CrntCode is exactly the running code:
* In that case CrntCode = XXXCode, CrntCode or the * In that case CrntCode = XXXCode, CrntCode or the
* prefix code is last code and the suffix char is * prefix code is last code and the suffix char is
* exactly the prefix of last code! */ * exactly the prefix of last code! */
if (CrntCode == Private->RunningCode - 2) { if (CrntCode == Private->RunningCode - 2) {
CrntPrefix = LastCode;
Suffix[Private->RunningCode - 2] = Suffix[Private->RunningCode - 2] =
Stack[StackPtr++] = DGifGetPrefixChar(Prefix, Stack[StackPtr++] = DGifGetPrefixChar(Prefix,
LastCode, LastCode,
ClearCode); ClearCode);
} else { } else {
_GifError = D_GIF_ERR_IMAGE_DEFECT; Suffix[Private->RunningCode - 2] =
return GIF_ERROR; Stack[StackPtr++] = DGifGetPrefixChar(Prefix,
CrntCode,
ClearCode);
} }
} else } else
CrntPrefix = CrntCode; CrntPrefix = CrntCode;
/* Now (if image is O.K.) we should not get an NO_SUCH_CODE /* Now (if image is O.K.) we should not get a NO_SUCH_CODE
* During the trace. As we might loop forever, in case of * during the trace. As we might loop forever, in case of
* defective image, we count the number of loops we trace * defective image, we use StackPtr as loop counter and stop
* and stop if we got LZ_MAX_CODE. obviously we can not * before overflowing Stack[]. */
* loop more than that. */ while (StackPtr < LZ_MAX_CODE &&
j = 0;
while (j++ <= LZ_MAX_CODE &&
CrntPrefix > ClearCode && CrntPrefix <= LZ_MAX_CODE) { CrntPrefix > ClearCode && CrntPrefix <= LZ_MAX_CODE) {
Stack[StackPtr++] = Suffix[CrntPrefix]; Stack[StackPtr++] = Suffix[CrntPrefix];
CrntPrefix = Prefix[CrntPrefix]; CrntPrefix = Prefix[CrntPrefix];
} }
if (j >= LZ_MAX_CODE || CrntPrefix > LZ_MAX_CODE) { if (StackPtr >= LZ_MAX_CODE || CrntPrefix > LZ_MAX_CODE) {
_GifError = D_GIF_ERR_IMAGE_DEFECT; GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
return GIF_ERROR; return GIF_ERROR;
} }
/* Push the last character on stack: */ /* Push the last character on stack: */
...@@ -854,7 +911,7 @@ DGifDecompressLine(GifFileType * GifFile, ...@@ -854,7 +911,7 @@ DGifDecompressLine(GifFileType * GifFile,
while (StackPtr != 0 && i < LineLen) while (StackPtr != 0 && i < LineLen)
Line[i++] = Stack[--StackPtr]; Line[i++] = Stack[--StackPtr];
} }
if (LastCode != NO_SUCH_CODE) { if (LastCode != NO_SUCH_CODE && Prefix[Private->RunningCode - 2] == NO_SUCH_CODE) {
Prefix[Private->RunningCode - 2] = LastCode; Prefix[Private->RunningCode - 2] = LastCode;
if (CrntCode == Private->RunningCode - 2) { if (CrntCode == Private->RunningCode - 2) {
...@@ -880,37 +937,38 @@ DGifDecompressLine(GifFileType * GifFile, ...@@ -880,37 +937,38 @@ DGifDecompressLine(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* Routine to trace the Prefixes linked list until we get a prefix which is Routine to trace the Prefixes linked list until we get a prefix which is
* not code, but a pixel value (less than ClearCode). Returns that pixel value. not code, but a pixel value (less than ClearCode). Returns that pixel value.
* If image is defective, we might loop here forever, so we limit the loops to If image is defective, we might loop here forever, so we limit the loops to
* the maximum possible if image O.k. - LZ_MAX_CODE times. the maximum possible if image O.k. - LZ_MAX_CODE times.
*****************************************************************************/ ******************************************************************************/
static int static int
DGifGetPrefixChar(unsigned int *Prefix, DGifGetPrefixChar(GifPrefixType *Prefix, int Code, int ClearCode)
int Code, {
int ClearCode) {
int i = 0; int i = 0;
while (Code > ClearCode && i++ <= LZ_MAX_CODE) while (Code > ClearCode && i++ <= LZ_MAX_CODE) {
if (Code > LZ_MAX_CODE) {
return NO_SUCH_CODE;
}
Code = Prefix[Code]; Code = Prefix[Code];
}
return Code; return Code;
} }
/****************************************************************************** /******************************************************************************
* Interface for accessing the LZ codes directly. Set Code to the real code Interface for accessing the LZ codes directly. Set Code to the real code
* (12bits), or to -1 if EOF code is returned. (12bits), or to -1 if EOF code is returned.
*****************************************************************************/ ******************************************************************************/
int int
DGifGetLZCodes(GifFileType * GifFile, DGifGetLZCodes(GifFileType *GifFile, int *Code)
int *Code) { {
GifByteType *CodeBlock; GifByteType *CodeBlock;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private; GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_READABLE(Private)) { if (!IS_READABLE(Private)) {
/* This file was NOT open for reading: */ /* This file was NOT open for reading: */
_GifError = D_GIF_ERR_NOT_READABLE; GifFile->Error = D_GIF_ERR_NOT_READABLE;
return GIF_ERROR; return GIF_ERROR;
} }
...@@ -936,32 +994,38 @@ DGifGetLZCodes(GifFileType * GifFile, ...@@ -936,32 +994,38 @@ DGifGetLZCodes(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* The LZ decompression input routine: The LZ decompression input routine:
* This routine is responsable for the decompression of the bit stream from This routine is responsable for the decompression of the bit stream from
* 8 bits (bytes) packets, into the real codes. 8 bits (bytes) packets, into the real codes.
* Returns GIF_OK if read succesfully. Returns GIF_OK if read successfully.
*****************************************************************************/ ******************************************************************************/
static int static int
DGifDecompressInput(GifFileType * GifFile, DGifDecompressInput(GifFileType *GifFile, int *Code)
int *Code) { {
static const unsigned short CodeMasks[] = {
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
GifByteType NextByte;
static unsigned int CodeMasks[] = {
0x0000, 0x0001, 0x0003, 0x0007, 0x0000, 0x0001, 0x0003, 0x0007,
0x000f, 0x001f, 0x003f, 0x007f, 0x000f, 0x001f, 0x003f, 0x007f,
0x00ff, 0x01ff, 0x03ff, 0x07ff, 0x00ff, 0x01ff, 0x03ff, 0x07ff,
0x0fff 0x0fff
}; };
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
GifByteType NextByte;
/* The image can't contain more than LZ_BITS per code. */
if (Private->RunningBits > LZ_BITS) {
GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
return GIF_ERROR;
}
while (Private->CrntShiftState < Private->RunningBits) { while (Private->CrntShiftState < Private->RunningBits) {
/* Needs to get more bytes from input stream for next code: */ /* Needs to get more bytes from input stream for next code: */
if (DGifBufferedInput(GifFile, Private->Buf, &NextByte) == GIF_ERROR) { if (DGifBufferedInput(GifFile, Private->Buf, &NextByte) == GIF_ERROR) {
return GIF_ERROR; return GIF_ERROR;
} }
Private->CrntShiftDWord |= Private->CrntShiftDWord |=
((unsigned long)NextByte) << Private->CrntShiftState; ((unsigned long)NextByte) << Private->CrntShiftState;
Private->CrntShiftState += 8; Private->CrntShiftState += 8;
} }
*Code = Private->CrntShiftDWord & CodeMasks[Private->RunningBits]; *Code = Private->CrntShiftDWord & CodeMasks[Private->RunningBits];
...@@ -970,37 +1034,45 @@ DGifDecompressInput(GifFileType * GifFile, ...@@ -970,37 +1034,45 @@ DGifDecompressInput(GifFileType * GifFile,
Private->CrntShiftState -= Private->RunningBits; Private->CrntShiftState -= Private->RunningBits;
/* If code cannot fit into RunningBits bits, must raise its size. Note /* If code cannot fit into RunningBits bits, must raise its size. Note
* however that codes above 4095 are used for special signaling. */ * however that codes above 4095 are used for special signaling.
if (++Private->RunningCode > Private->MaxCode1) { * If we're using LZ_BITS bits already and we're at the max code, just
if (Private->RunningBits < LZ_BITS) { * keep using the table as it is, don't increment Private->RunningCode.
Private->MaxCode1 <<= 1; */
Private->RunningBits++; if (Private->RunningCode < LZ_MAX_CODE + 2 &&
} else { ++Private->RunningCode > Private->MaxCode1 &&
Private->RunningCode = Private->MaxCode1; Private->RunningBits < LZ_BITS) {
} Private->MaxCode1 <<= 1;
Private->RunningBits++;
} }
return GIF_OK; return GIF_OK;
} }
/****************************************************************************** /******************************************************************************
* This routines read one gif data block at a time and buffers it internally This routines read one GIF data block at a time and buffers it internally
* so that the decompression routine could access it. so that the decompression routine could access it.
* The routine returns the next byte from its internal buffer (or read next The routine returns the next byte from its internal buffer (or read next
* block in if buffer empty) and returns GIF_OK if succesful. block in if buffer empty) and returns GIF_OK if succesful.
*****************************************************************************/ ******************************************************************************/
static int static int
DGifBufferedInput(GifFileType * GifFile, DGifBufferedInput(GifFileType *GifFile, GifByteType *Buf, GifByteType *NextByte)
GifByteType * Buf, {
GifByteType * NextByte) {
if (Buf[0] == 0) { if (Buf[0] == 0) {
/* Needs to read the next buffer - this one is empty: */ /* Needs to read the next buffer - this one is empty: */
/* coverity[check_return] */
if (READ(GifFile, Buf, 1) != 1) { if (READ(GifFile, Buf, 1) != 1) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR;
}
/* There shouldn't be any empty data blocks here as the LZW spec
* says the LZW termination code should come first. Therefore we
* shouldn't be inside this routine at that point.
*/
if (Buf[0] == 0) {
GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
return GIF_ERROR; return GIF_ERROR;
} }
if (READ(GifFile, &Buf[1], Buf[0]) != Buf[0]) { if (READ(GifFile, &Buf[1], Buf[0]) != Buf[0]) {
_GifError = D_GIF_ERR_READ_FAILED; GifFile->Error = D_GIF_ERR_READ_FAILED;
return GIF_ERROR; return GIF_ERROR;
} }
*NextByte = Buf[1]; *NextByte = Buf[1];
...@@ -1015,21 +1087,21 @@ DGifBufferedInput(GifFileType * GifFile, ...@@ -1015,21 +1087,21 @@ DGifBufferedInput(GifFileType * GifFile,
} }
/****************************************************************************** /******************************************************************************
* This routine reads an entire GIF into core, hanging all its state info off This routine reads an entire GIF into core, hanging all its state info off
* the GifFileType pointer. Call DGifOpenFileName() or DGifOpenFileHandle() the GifFileType pointer. Call DGifOpenFileName() or DGifOpenFileHandle()
* first to initialize I/O. Its inverse is EGifSpew(). first to initialize I/O. Its inverse is EGifSpew().
******************************************************************************/ *******************************************************************************/
int int
DGifSlurp(GifFileType * GifFile) { DGifSlurp(GifFileType *GifFile)
{
int ImageSize; size_t ImageSize;
GifRecordType RecordType; GifRecordType RecordType;
SavedImage *sp; SavedImage *sp;
GifByteType *ExtData; GifByteType *ExtData;
SavedImage temp_save; int ExtFunction;
temp_save.ExtensionBlocks = NULL; GifFile->ExtensionBlocks = NULL;
temp_save.ExtensionBlockCount = 0; GifFile->ExtensionBlockCount = 0;
do { do {
if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR)
...@@ -1041,44 +1113,77 @@ DGifSlurp(GifFileType * GifFile) { ...@@ -1041,44 +1113,77 @@ DGifSlurp(GifFileType * GifFile) {
return (GIF_ERROR); return (GIF_ERROR);
sp = &GifFile->SavedImages[GifFile->ImageCount - 1]; sp = &GifFile->SavedImages[GifFile->ImageCount - 1];
/* Allocate memory for the image */
if (sp->ImageDesc.Width < 0 && sp->ImageDesc.Height < 0 &&
sp->ImageDesc.Width > (INT_MAX / sp->ImageDesc.Height)) {
return GIF_ERROR;
}
ImageSize = sp->ImageDesc.Width * sp->ImageDesc.Height; ImageSize = sp->ImageDesc.Width * sp->ImageDesc.Height;
if (ImageSize > (SIZE_MAX / sizeof(GifPixelType))) {
return GIF_ERROR;
}
sp->RasterBits = (unsigned char *)malloc(ImageSize * sp->RasterBits = (unsigned char *)malloc(ImageSize *
sizeof(GifPixelType)); sizeof(GifPixelType));
if (sp->RasterBits == NULL) { if (sp->RasterBits == NULL) {
return GIF_ERROR; return GIF_ERROR;
} }
if (DGifGetLine(GifFile, sp->RasterBits, ImageSize) ==
GIF_ERROR)
return (GIF_ERROR);
if (temp_save.ExtensionBlocks) {
sp->ExtensionBlocks = temp_save.ExtensionBlocks;
sp->ExtensionBlockCount = temp_save.ExtensionBlockCount;
temp_save.ExtensionBlocks = NULL; if (sp->ImageDesc.Interlace) {
temp_save.ExtensionBlockCount = 0; int i, j;
/*
* The way an interlaced image should be read -
* offsets and jumps...
*/
int InterlacedOffset[] = { 0, 4, 2, 1 };
int InterlacedJumps[] = { 8, 8, 4, 2 };
/* Need to perform 4 passes on the image */
for (i = 0; i < 4; i++)
for (j = InterlacedOffset[i];
j < sp->ImageDesc.Height;
j += InterlacedJumps[i]) {
if (DGifGetLine(GifFile,
sp->RasterBits+j*sp->ImageDesc.Width,
sp->ImageDesc.Width) == GIF_ERROR)
return GIF_ERROR;
}
}
else {
if (DGifGetLine(GifFile,sp->RasterBits,ImageSize)==GIF_ERROR)
return (GIF_ERROR);
}
if (GifFile->ExtensionBlocks) {
sp->ExtensionBlocks = GifFile->ExtensionBlocks;
sp->ExtensionBlockCount = GifFile->ExtensionBlockCount;
/* FIXME: The following is wrong. It is left in only for GifFile->ExtensionBlocks = NULL;
* backwards compatibility. Someday it should go away. Use GifFile->ExtensionBlockCount = 0;
* the sp->ExtensionBlocks->Function variable instead. */
sp->Function = sp->ExtensionBlocks[0].Function;
} }
break; break;
case EXTENSION_RECORD_TYPE: case EXTENSION_RECORD_TYPE:
if (DGifGetExtension(GifFile, &temp_save.Function, &ExtData) == if (DGifGetExtension(GifFile,&ExtFunction,&ExtData) == GIF_ERROR)
GIF_ERROR)
return (GIF_ERROR); return (GIF_ERROR);
while (ExtData != NULL) { /* Create an extension block with our data */
if (ExtData != NULL) {
/* Create an extension block with our data */ if (GifAddExtensionBlock(&GifFile->ExtensionBlockCount,
if (AddExtensionBlock(&temp_save, ExtData[0], &ExtData[1]) &GifFile->ExtensionBlocks,
ExtFunction, ExtData[0], &ExtData[1])
== GIF_ERROR) == GIF_ERROR)
return (GIF_ERROR); return (GIF_ERROR);
}
while (ExtData != NULL) {
if (DGifGetExtensionNext(GifFile, &ExtData) == GIF_ERROR) if (DGifGetExtensionNext(GifFile, &ExtData) == GIF_ERROR)
return (GIF_ERROR); return (GIF_ERROR);
temp_save.Function = 0; /* Continue the extension block */
if (ExtData != NULL)
if (GifAddExtensionBlock(&GifFile->ExtensionBlockCount,
&GifFile->ExtensionBlocks,
CONTINUE_EXT_FUNC_CODE,
ExtData[0], &ExtData[1]) == GIF_ERROR)
return (GIF_ERROR);
} }
break; break;
...@@ -1090,12 +1195,13 @@ DGifSlurp(GifFileType * GifFile) { ...@@ -1090,12 +1195,13 @@ DGifSlurp(GifFileType * GifFile) {
} }
} while (RecordType != TERMINATE_RECORD_TYPE); } while (RecordType != TERMINATE_RECORD_TYPE);
/* Just in case the Gif has an extension block without an associated /* Sanity check for corrupted file */
* image... (Should we save this into a savefile structure with no image if (GifFile->ImageCount == 0) {
* instead? Have to check if the present writing code can handle that as GifFile->Error = D_GIF_ERR_NO_IMAG_DSCR;
* well.... */ return(GIF_ERROR);
if (temp_save.ExtensionBlocks) }
FreeExtension(&temp_save);
return (GIF_OK); return (GIF_OK);
} }
/* end */
src/share/native/sun/awt/giflib/gif_err.c
浏览文件 @ 2e480e33
...@@ -23,71 +23,81 @@ ...@@ -23,71 +23,81 @@
*/ */
/***************************************************************************** /*****************************************************************************
* "Gif-Lib" - Yet another gif library.
*
* Written by: Gershon Elber IBM PC Ver 0.1, Jun. 1989
*****************************************************************************
* Handle error reporting for the GIF library.
*****************************************************************************
* History:
* 17 Jun 89 - Version 1.0 by Gershon Elber.
****************************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include "gif_lib.h"
int _GifError = 0; gif_err.c - handle error reporting for the GIF library.
/***************************************************************************** ****************************************************************************/
* Return the last GIF error (0 if none) and reset the error.
****************************************************************************/
int
GifLastError(void) {
int i = _GifError;
_GifError = 0; #include <stdio.h>
return i; #include "gif_lib.h"
} #include "gif_lib_private.h"
/***************************************************************************** /*****************************************************************************
* Print the last GIF error to stderr. Return a string description of the last GIF error
****************************************************************************/ *****************************************************************************/
void const char *
PrintGifError(void) { GifErrorString(int ErrorCode)
char *Err; {
const char *Err;
switch (_GifError) { switch (ErrorCode) {
case E_GIF_ERR_OPEN_FAILED:
Err = "Failed to open given file";
break;
case E_GIF_ERR_WRITE_FAILED:
Err = "Failed to write to given file";
break;
case E_GIF_ERR_HAS_SCRN_DSCR:
Err = "Screen descriptor has already been set";
break;
case E_GIF_ERR_HAS_IMAG_DSCR:
Err = "Image descriptor is still active";
break;
case E_GIF_ERR_NO_COLOR_MAP:
Err = "Neither global nor local color map";
break;
case E_GIF_ERR_DATA_TOO_BIG:
Err = "Number of pixels bigger than width * height";
break;
case E_GIF_ERR_NOT_ENOUGH_MEM:
Err = "Failed to allocate required memory";
break;
case E_GIF_ERR_DISK_IS_FULL:
Err = "Write failed (disk full?)";
break;
case E_GIF_ERR_CLOSE_FAILED:
Err = "Failed to close given file";
break;
case E_GIF_ERR_NOT_WRITEABLE:
Err = "Given file was not opened for write";
break;
case D_GIF_ERR_OPEN_FAILED: case D_GIF_ERR_OPEN_FAILED:
Err = "Failed to open given file"; Err = "Failed to open given file";
break; break;
case D_GIF_ERR_READ_FAILED: case D_GIF_ERR_READ_FAILED:
Err = "Failed to Read from given file"; Err = "Failed to read from given file";
break; break;
case D_GIF_ERR_NOT_GIF_FILE: case D_GIF_ERR_NOT_GIF_FILE:
Err = "Given file is NOT GIF file"; Err = "Data is not in GIF format";
break; break;
case D_GIF_ERR_NO_SCRN_DSCR: case D_GIF_ERR_NO_SCRN_DSCR:
Err = "No Screen Descriptor detected"; Err = "No screen descriptor detected";
break; break;
case D_GIF_ERR_NO_IMAG_DSCR: case D_GIF_ERR_NO_IMAG_DSCR:
Err = "No Image Descriptor detected"; Err = "No Image Descriptor detected";
break; break;
case D_GIF_ERR_NO_COLOR_MAP: case D_GIF_ERR_NO_COLOR_MAP:
Err = "Neither Global Nor Local color map"; Err = "Neither global nor local color map";
break; break;
case D_GIF_ERR_WRONG_RECORD: case D_GIF_ERR_WRONG_RECORD:
Err = "Wrong record type detected"; Err = "Wrong record type detected";
break; break;
case D_GIF_ERR_DATA_TOO_BIG: case D_GIF_ERR_DATA_TOO_BIG:
Err = "#Pixels bigger than Width * Height"; Err = "Number of pixels bigger than width * height";
break; break;
case D_GIF_ERR_NOT_ENOUGH_MEM: case D_GIF_ERR_NOT_ENOUGH_MEM:
Err = "Fail to allocate required memory"; Err = "Failed to allocate required memory";
break; break;
case D_GIF_ERR_CLOSE_FAILED: case D_GIF_ERR_CLOSE_FAILED:
Err = "Failed to close given file"; Err = "Failed to close given file";
...@@ -99,14 +109,13 @@ PrintGifError(void) { ...@@ -99,14 +109,13 @@ PrintGifError(void) {
Err = "Image is defective, decoding aborted"; Err = "Image is defective, decoding aborted";
break; break;
case D_GIF_ERR_EOF_TOO_SOON: case D_GIF_ERR_EOF_TOO_SOON:
Err = "Image EOF detected, before image complete"; Err = "Image EOF detected before image complete";
break; break;
default: default:
Err = NULL; Err = NULL;
break; break;
} }
if (Err != NULL) return Err;
fprintf(stderr, "\nGIF-LIB error: %s.\n", Err);
else
fprintf(stderr, "\nGIF-LIB undefined error %d.\n", _GifError);
} }
/* end */
src/share/native/sun/awt/giflib/gif_hash.h 0 → 100644
浏览文件 @ 2e480e33
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/******************************************************************************
gif_hash.h - magfic constants and declarations for GIF LZW
******************************************************************************/
#ifndef _GIF_HASH_H_
#define _GIF_HASH_H_
#include <stdint.h>
#define HT_SIZE 8192 /* 12bits = 4096 or twice as big! */
#define HT_KEY_MASK 0x1FFF /* 13bits keys */
#define HT_KEY_NUM_BITS 13 /* 13bits keys */
#define HT_MAX_KEY 8191 /* 13bits - 1, maximal code possible */
#define HT_MAX_CODE 4095 /* Biggest code possible in 12 bits. */
/* The 32 bits of the long are divided into two parts for the key & code: */
/* 1. The code is 12 bits as our compression algorithm is limited to 12bits */
/* 2. The key is 12 bits Prefix code + 8 bit new char or 20 bits. */
/* The key is the upper 20 bits. The code is the lower 12. */
#define HT_GET_KEY(l) (l >> 12)
#define HT_GET_CODE(l) (l & 0x0FFF)
#define HT_PUT_KEY(l) (l << 12)
#define HT_PUT_CODE(l) (l & 0x0FFF)
typedef struct GifHashTableType {
uint32_t HTable[HT_SIZE];
} GifHashTableType;
GifHashTableType *_InitHashTable(void);
void _ClearHashTable(GifHashTableType *HashTable);
void _InsertHashTable(GifHashTableType *HashTable, uint32_t Key, int Code);
int _ExistsHashTable(GifHashTableType *HashTable, uint32_t Key);
#endif /* _GIF_HASH_H_ */
/* end */
src/share/native/sun/awt/giflib/gif_lib.h
浏览文件 @ 2e480e33
...@@ -23,21 +23,10 @@ ...@@ -23,21 +23,10 @@
*/ */
/****************************************************************************** /******************************************************************************
* In order to make life a little bit easier when using the GIF file format,
* this library was written, and which does all the dirty work... gif_lib.h - service library for decoding and encoding GIF images
*
* Written by Gershon Elber, Jun. 1989 *****************************************************************************/
* Hacks by Eric S. Raymond, Sep. 1992
******************************************************************************
* History:
* 14 Jun 89 - Version 1.0 by Gershon Elber.
* 3 Sep 90 - Version 1.1 by Gershon Elber (Support for Gif89, Unique names)
* 15 Sep 90 - Version 2.0 by Eric S. Raymond (Changes to suoport GIF slurp)
* 26 Jun 96 - Version 3.0 by Eric S. Raymond (Full GIF89 support)
* 17 Dec 98 - Version 4.0 by Toshio Kuratomi (Fix extension writing code)
*****************************************************************************/
/* all encoding functionality stripped */
#ifndef _GIF_LIB_H_ #ifndef _GIF_LIB_H_
#define _GIF_LIB_H_ 1 #define _GIF_LIB_H_ 1
...@@ -46,21 +35,21 @@ ...@@ -46,21 +35,21 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#define GIF_LIB_VERSION " Version 4.1, " #define GIFLIB_MAJOR 5
#define GIFLIB_MINOR 1
#define GIFLIB_RELEASE 1
#define GIF_ERROR 0 #define GIF_ERROR 0
#define GIF_OK 1 #define GIF_OK 1
#ifndef TRUE #include <stddef.h>
#define TRUE 1
#endif /* TRUE */
#ifndef FALSE
#define FALSE 0
#endif /* FALSE */
#ifndef NULL #ifdef bool
#define NULL 0 #undef bool
#endif /* NULL */ #endif
typedef int bool;
#define false 0
#define true 1
#define GIF_STAMP "GIFVER" /* First chars in file - GIF stamp. */ #define GIF_STAMP "GIFVER" /* First chars in file - GIF stamp. */
#define GIF_STAMP_LEN sizeof(GIF_STAMP) - 1 #define GIF_STAMP_LEN sizeof(GIF_STAMP) - 1
...@@ -68,21 +57,11 @@ extern "C" { ...@@ -68,21 +57,11 @@ extern "C" {
#define GIF87_STAMP "GIF87a" /* First chars in file - GIF stamp. */ #define GIF87_STAMP "GIF87a" /* First chars in file - GIF stamp. */
#define GIF89_STAMP "GIF89a" /* First chars in file - GIF stamp. */ #define GIF89_STAMP "GIF89a" /* First chars in file - GIF stamp. */
#define GIF_FILE_BUFFER_SIZE 16384 /* Files uses bigger buffers than usual. */
typedef int GifBooleanType;
typedef unsigned char GifPixelType; typedef unsigned char GifPixelType;
typedef unsigned char *GifRowType; typedef unsigned char *GifRowType;
typedef unsigned char GifByteType; typedef unsigned char GifByteType;
typedef unsigned int GifPrefixType;
#define GIF_MESSAGE(Msg) fprintf(stderr, "\n%s: %s\n", PROGRAM_NAME, Msg) typedef int GifWord;
#define GIF_EXIT(Msg) { GIF_MESSAGE(Msg); exit(-3); }
#ifdef SYSV
#define VoidPtr char *
#else
#define VoidPtr void *
#endif /* SYSV */
typedef struct GifColorType { typedef struct GifColorType {
GifByteType Red, Green, Blue; GifByteType Red, Green, Blue;
...@@ -91,27 +70,52 @@ typedef struct GifColorType { ...@@ -91,27 +70,52 @@ typedef struct GifColorType {
typedef struct ColorMapObject { typedef struct ColorMapObject {
int ColorCount; int ColorCount;
int BitsPerPixel; int BitsPerPixel;
bool SortFlag;
GifColorType *Colors; /* on malloc(3) heap */ GifColorType *Colors; /* on malloc(3) heap */
} ColorMapObject; } ColorMapObject;
typedef struct GifImageDesc { typedef struct GifImageDesc {
int Left, Top, Width, Height, /* Current image dimensions. */ GifWord Left, Top, Width, Height; /* Current image dimensions. */
Interlace; /* Sequential/Interlaced lines. */ bool Interlace; /* Sequential/Interlaced lines. */
ColorMapObject *ColorMap; /* The local color map */ ColorMapObject *ColorMap; /* The local color map */
} GifImageDesc; } GifImageDesc;
typedef struct ExtensionBlock {
int ByteCount;
GifByteType *Bytes; /* on malloc(3) heap */
int Function; /* The block function code */
#define CONTINUE_EXT_FUNC_CODE 0x00 /* continuation subblock */
#define COMMENT_EXT_FUNC_CODE 0xfe /* comment */
#define GRAPHICS_EXT_FUNC_CODE 0xf9 /* graphics control (GIF89) */
#define PLAINTEXT_EXT_FUNC_CODE 0x01 /* plaintext */
#define APPLICATION_EXT_FUNC_CODE 0xff /* application block */
} ExtensionBlock;
typedef struct SavedImage {
GifImageDesc ImageDesc;
GifByteType *RasterBits; /* on malloc(3) heap */
int ExtensionBlockCount; /* Count of extensions before image */
ExtensionBlock *ExtensionBlocks; /* Extensions before image */
} SavedImage;
typedef struct GifFileType { typedef struct GifFileType {
int SWidth, SHeight, /* Screen dimensions. */ GifWord SWidth, SHeight; /* Size of virtual canvas */
SColorResolution, /* How many colors can we generate? */ GifWord SColorResolution; /* How many colors can we generate? */
SBackGroundColor; /* I hope you understand this one... */ GifWord SBackGroundColor; /* Background color for virtual canvas */
ColorMapObject *SColorMap; /* NULL if not exists. */ GifByteType AspectByte; /* Used to compute pixel aspect ratio */
int ImageCount; /* Number of current image */ ColorMapObject *SColorMap; /* Global colormap, NULL if nonexistent. */
GifImageDesc Image; /* Block describing current image */ int ImageCount; /* Number of current image (both APIs) */
struct SavedImage *SavedImages; /* Use this to accumulate file state */ GifImageDesc Image; /* Current image (low-level API) */
VoidPtr UserData; /* hook to attach user data (TVT) */ SavedImage *SavedImages; /* Image sequence (high-level API) */
VoidPtr Private; /* Don't mess with this! */ int ExtensionBlockCount; /* Count extensions past last image */
ExtensionBlock *ExtensionBlocks; /* Extensions past last image */
int Error; /* Last error condition reported */
void *UserData; /* hook to attach user data (TVT) */
void *Private; /* Don't mess with this! */
} GifFileType; } GifFileType;
#define GIF_ASPECT_RATIO(n) ((n)+15.0/64.0)
typedef enum { typedef enum {
UNDEFINED_RECORD_TYPE, UNDEFINED_RECORD_TYPE,
SCREEN_DESC_RECORD_TYPE, SCREEN_DESC_RECORD_TYPE,
...@@ -120,58 +124,95 @@ typedef enum { ...@@ -120,58 +124,95 @@ typedef enum {
TERMINATE_RECORD_TYPE /* Begin with ';' */ TERMINATE_RECORD_TYPE /* Begin with ';' */
} GifRecordType; } GifRecordType;
/* DumpScreen2Gif routine constants identify type of window/screen to dump.
* Note all values below 1000 are reserved for the IBMPC different display
* devices (it has many!) and are compatible with the numbering TC2.0
* (Turbo C 2.0 compiler for IBM PC) gives to these devices.
*/
typedef enum {
GIF_DUMP_SGI_WINDOW = 1000,
GIF_DUMP_X_WINDOW = 1001
} GifScreenDumpType;
/* func type to read gif data from arbitrary sources (TVT) */ /* func type to read gif data from arbitrary sources (TVT) */
typedef int (*InputFunc) (GifFileType *, GifByteType *, int); typedef int (*InputFunc) (GifFileType *, GifByteType *, int);
/* func type to write gif data ro arbitrary targets. /* func type to write gif data to arbitrary targets.
* Returns count of bytes written. (MRB) * Returns count of bytes written. (MRB)
*/ */
typedef int (*OutputFunc) (GifFileType *, const GifByteType *, int); typedef int (*OutputFunc) (GifFileType *, const GifByteType *, int);
/****************************************************************************** /******************************************************************************
* GIF89 extension function codes GIF89 structures
******************************************************************************/ ******************************************************************************/
#define COMMENT_EXT_FUNC_CODE 0xfe /* comment */ typedef struct GraphicsControlBlock {
#define GRAPHICS_EXT_FUNC_CODE 0xf9 /* graphics control */ int DisposalMode;
#define PLAINTEXT_EXT_FUNC_CODE 0x01 /* plaintext */ #define DISPOSAL_UNSPECIFIED 0 /* No disposal specified. */
#define APPLICATION_EXT_FUNC_CODE 0xff /* application block */ #define DISPOSE_DO_NOT 1 /* Leave image in place */
#define DISPOSE_BACKGROUND 2 /* Set area too background color */
#define DISPOSE_PREVIOUS 3 /* Restore to previous content */
bool UserInputFlag; /* User confirmation required before disposal */
int DelayTime; /* pre-display delay in 0.01sec units */
int TransparentColor; /* Palette index for transparency, -1 if none */
#define NO_TRANSPARENT_COLOR -1
} GraphicsControlBlock;
/****************************************************************************** /******************************************************************************
* O.K., here are the routines one can access in order to decode GIF file: GIF encoding routines
* (GIF_LIB file DGIF_LIB.C). ******************************************************************************/
*****************************************************************************/
/* Main entry points */
GifFileType *DGifOpenFileName(const char *GifFileName); GifFileType *EGifOpenFileName(const char *GifFileName,
GifFileType *DGifOpenFileHandle(int GifFileHandle); const bool GifTestExistence, int *Error);
GifFileType *DGifOpen(void *userPtr, InputFunc readFunc); /* new one GifFileType *EGifOpenFileHandle(const int GifFileHandle, int *Error);
* (TVT) */ GifFileType *EGifOpen(void *userPtr, OutputFunc writeFunc, int *Error);
int EGifSpew(GifFileType * GifFile);
const char *EGifGetGifVersion(GifFileType *GifFile); /* new in 5.x */
int EGifCloseFile(GifFileType *GifFile, int *ErrorCode);
#define E_GIF_SUCCEEDED 0
#define E_GIF_ERR_OPEN_FAILED 1 /* And EGif possible errors. */
#define E_GIF_ERR_WRITE_FAILED 2
#define E_GIF_ERR_HAS_SCRN_DSCR 3
#define E_GIF_ERR_HAS_IMAG_DSCR 4
#define E_GIF_ERR_NO_COLOR_MAP 5
#define E_GIF_ERR_DATA_TOO_BIG 6
#define E_GIF_ERR_NOT_ENOUGH_MEM 7
#define E_GIF_ERR_DISK_IS_FULL 8
#define E_GIF_ERR_CLOSE_FAILED 9
#define E_GIF_ERR_NOT_WRITEABLE 10
/* These are legacy. You probably do not want to call them directly */
int EGifPutScreenDesc(GifFileType *GifFile,
const int GifWidth, const int GifHeight,
const int GifColorRes,
const int GifBackGround,
const ColorMapObject *GifColorMap);
int EGifPutImageDesc(GifFileType *GifFile,
const int GifLeft, const int GifTop,
const int GifWidth, const int GifHeight,
const bool GifInterlace,
const ColorMapObject *GifColorMap);
void EGifSetGifVersion(GifFileType *GifFile, const bool gif89);
int EGifPutLine(GifFileType *GifFile, GifPixelType *GifLine,
int GifLineLen);
int EGifPutPixel(GifFileType *GifFile, const GifPixelType GifPixel);
int EGifPutComment(GifFileType *GifFile, const char *GifComment);
int EGifPutExtensionLeader(GifFileType *GifFile, const int GifExtCode);
int EGifPutExtensionBlock(GifFileType *GifFile,
const int GifExtLen, const void *GifExtension);
int EGifPutExtensionTrailer(GifFileType *GifFile);
int EGifPutExtension(GifFileType *GifFile, const int GifExtCode,
const int GifExtLen,
const void *GifExtension);
int EGifPutCode(GifFileType *GifFile, int GifCodeSize,
const GifByteType *GifCodeBlock);
int EGifPutCodeNext(GifFileType *GifFile,
const GifByteType *GifCodeBlock);
/******************************************************************************
GIF decoding routines
******************************************************************************/
/* Main entry points */
GifFileType *DGifOpenFileName(const char *GifFileName, int *Error);
GifFileType *DGifOpenFileHandle(int GifFileHandle, int *Error);
int DGifSlurp(GifFileType * GifFile); int DGifSlurp(GifFileType * GifFile);
int DGifGetScreenDesc(GifFileType * GifFile); GifFileType *DGifOpen(void *userPtr, InputFunc readFunc, int *Error); /* new one (TVT) */
int DGifGetRecordType(GifFileType * GifFile, GifRecordType * GifType); int DGifCloseFile(GifFileType * GifFile, int *ErrorCode);
int DGifGetImageDesc(GifFileType * GifFile);
int DGifGetLine(GifFileType * GifFile, GifPixelType * GifLine, int GifLineLen);
int DGifGetPixel(GifFileType * GifFile, GifPixelType GifPixel);
int DGifGetComment(GifFileType * GifFile, char *GifComment);
int DGifGetExtension(GifFileType * GifFile, int *GifExtCode,
GifByteType ** GifExtension);
int DGifGetExtensionNext(GifFileType * GifFile, GifByteType ** GifExtension);
int DGifGetCode(GifFileType * GifFile, int *GifCodeSize,
GifByteType ** GifCodeBlock);
int DGifGetCodeNext(GifFileType * GifFile, GifByteType ** GifCodeBlock);
int DGifGetLZCodes(GifFileType * GifFile, int *GifCode);
int DGifCloseFile(GifFileType * GifFile);
#define D_GIF_SUCCEEDED 0
#define D_GIF_ERR_OPEN_FAILED 101 /* And DGif possible errors. */ #define D_GIF_ERR_OPEN_FAILED 101 /* And DGif possible errors. */
#define D_GIF_ERR_READ_FAILED 102 #define D_GIF_ERR_READ_FAILED 102
#define D_GIF_ERR_NOT_GIF_FILE 103 #define D_GIF_ERR_NOT_GIF_FILE 103
...@@ -186,68 +227,113 @@ int DGifCloseFile(GifFileType * GifFile); ...@@ -186,68 +227,113 @@ int DGifCloseFile(GifFileType * GifFile);
#define D_GIF_ERR_IMAGE_DEFECT 112 #define D_GIF_ERR_IMAGE_DEFECT 112
#define D_GIF_ERR_EOF_TOO_SOON 113 #define D_GIF_ERR_EOF_TOO_SOON 113
/* These are legacy. You probably do not want to call them directly */
int DGifGetScreenDesc(GifFileType *GifFile);
int DGifGetRecordType(GifFileType *GifFile, GifRecordType *GifType);
int DGifGetImageDesc(GifFileType *GifFile);
int DGifGetLine(GifFileType *GifFile, GifPixelType *GifLine, int GifLineLen);
int DGifGetPixel(GifFileType *GifFile, GifPixelType GifPixel);
int DGifGetComment(GifFileType *GifFile, char *GifComment);
int DGifGetExtension(GifFileType *GifFile, int *GifExtCode,
GifByteType **GifExtension);
int DGifGetExtensionNext(GifFileType *GifFile, GifByteType **GifExtension);
int DGifGetCode(GifFileType *GifFile, int *GifCodeSize,
GifByteType **GifCodeBlock);
int DGifGetCodeNext(GifFileType *GifFile, GifByteType **GifCodeBlock);
int DGifGetLZCodes(GifFileType *GifFile, int *GifCode);
/****************************************************************************** /******************************************************************************
* O.K., here are the routines from GIF_LIB file GIF_ERR.C. Color table quantization (deprecated)
******************************************************************************/ ******************************************************************************/
extern void PrintGifError(void); int GifQuantizeBuffer(unsigned int Width, unsigned int Height,
extern int GifLastError(void); int *ColorMapSize, GifByteType * RedInput,
GifByteType * GreenInput, GifByteType * BlueInput,
GifByteType * OutputBuffer,
GifColorType * OutputColorMap);
/****************************************************************************** /******************************************************************************
* O.K., here are the routines from GIF_LIB file DEV2GIF.C. Error handling and reporting.
******************************************************************************/ ******************************************************************************/
extern int DumpScreen2Gif(const char *FileName, extern const char *GifErrorString(int ErrorCode); /* new in 2012 - ESR */
int ReqGraphDriver,
long ReqGraphMode1,
long ReqGraphMode2,
long ReqGraphMode3);
/***************************************************************************** /*****************************************************************************
* Everything below this point is new after version 1.2, supporting `slurp
* Everything below this point is new after version 1.2, supporting `slurp mode' for doing I/O in two big belts with all the image-bashing in core.
* mode' for doing I/O in two big belts with all the image-bashing in core. ******************************************************************************/
*
*****************************************************************************/
/****************************************************************************** /******************************************************************************
* Color Map handling from ALLOCGIF.C Color map handling from gif_alloc.c
*****************************************************************************/ ******************************************************************************/
extern ColorMapObject *MakeMapObject(int ColorCount, extern ColorMapObject *GifMakeMapObject(int ColorCount,
const GifColorType * ColorMap); const GifColorType *ColorMap);
extern void FreeMapObject(ColorMapObject * Object); extern void GifFreeMapObject(ColorMapObject *Object);
extern int BitSize(int n); extern ColorMapObject *GifUnionColorMap(const ColorMapObject *ColorIn1,
const ColorMapObject *ColorIn2,
GifPixelType ColorTransIn2[]);
extern int GifBitSize(int n);
/****************************************************************************** /******************************************************************************
* Support for the in-core structures allocation (slurp mode). Support for the in-core structures allocation (slurp mode).
*****************************************************************************/ ******************************************************************************/
/* This is the in-core version of an extension record */ extern void GifApplyTranslation(SavedImage *Image, GifPixelType Translation[]);
typedef struct { extern int GifAddExtensionBlock(int *ExtensionBlock_Count,
int ByteCount; ExtensionBlock **ExtensionBlocks,
char *Bytes; /* on malloc(3) heap */ int Function,
int Function; /* Holds the type of the Extension block. */ unsigned int Len, unsigned char ExtData[]);
} ExtensionBlock; extern void GifFreeExtensions(int *ExtensionBlock_Count,
ExtensionBlock **ExtensionBlocks);
extern SavedImage *GifMakeSavedImage(GifFileType *GifFile,
const SavedImage *CopyFrom);
extern void GifFreeSavedImages(GifFileType *GifFile);
/* This holds an image header, its unpacked raster bits, and extensions */ /******************************************************************************
typedef struct SavedImage { 5.x functions for GIF89 graphics control blocks
GifImageDesc ImageDesc; ******************************************************************************/
unsigned char *RasterBits; /* on malloc(3) heap */
int Function; /* DEPRECATED: Use ExtensionBlocks[x].Function instead */ int DGifExtensionToGCB(const size_t GifExtensionLength,
int ExtensionBlockCount; const GifByteType *GifExtension,
ExtensionBlock *ExtensionBlocks; /* on malloc(3) heap */ GraphicsControlBlock *GCB);
} SavedImage; size_t EGifGCBToExtension(const GraphicsControlBlock *GCB,
GifByteType *GifExtension);
int DGifSavedExtensionToGCB(GifFileType *GifFile,
int ImageIndex,
GraphicsControlBlock *GCB);
int EGifGCBToSavedExtension(const GraphicsControlBlock *GCB,
GifFileType *GifFile,
int ImageIndex);
/******************************************************************************
The library's internal utility font
******************************************************************************/
#define GIF_FONT_WIDTH 8
#define GIF_FONT_HEIGHT 8
extern const unsigned char GifAsciiTable8x8[][GIF_FONT_WIDTH];
extern void MakeExtension(SavedImage * New, int Function); extern void GifDrawText8x8(SavedImage *Image,
extern int AddExtensionBlock(SavedImage * New, int Len, const int x, const int y,
unsigned char ExtData[]); const char *legend, const int color);
extern void FreeExtension(SavedImage * Image);
extern SavedImage *MakeSavedImage(GifFileType * GifFile,
const SavedImage * CopyFrom);
extern void FreeSavedImages(GifFileType * GifFile);
extern void GifDrawBox(SavedImage *Image,
const int x, const int y,
const int w, const int d, const int color);
extern void GifDrawRectangle(SavedImage *Image,
const int x, const int y,
const int w, const int d, const int color);
extern void GifDrawBoxedText8x8(SavedImage *Image,
const int x, const int y,
const char *legend,
const int border, const int bg, const int fg);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* _GIF_LIB_H */ #endif /* _GIF_LIB_H */
/* end */
src/share/native/sun/awt/giflib/gif_lib_private.h
浏览文件 @ 2e480e33
...@@ -22,21 +22,21 @@ ...@@ -22,21 +22,21 @@
* questions. * questions.
*/ */
/****************************************************************************
gif_lib_private.h - internal giflib routines and structures
****************************************************************************/
#ifndef _GIF_LIB_PRIVATE_H #ifndef _GIF_LIB_PRIVATE_H
#define _GIF_LIB_PRIVATE_H #define _GIF_LIB_PRIVATE_H
#include "gif_lib.h" #include "gif_lib.h"
#include "gif_hash.h"
#define PROGRAM_NAME "LIBUNGIF" #define EXTENSION_INTRODUCER 0x21
#define DESCRIPTOR_INTRODUCER 0x2c
#ifdef SYSV #define TERMINATOR_INTRODUCER 0x3b
#define VersionStr "Gif library module,\t\tEric S. Raymond\n\
(C) Copyright 1997 Eric S. Raymond\n"
#else
#define VersionStr PROGRAM_NAME " IBMPC " GIF_LIB_VERSION \
" Eric S. Raymond, " __DATE__ ", " \
__TIME__ "\n" "(C) Copyright 1997 Eric S. Raymond\n"
#endif /* SYSV */
#define LZ_MAX_CODE 4095 /* Biggest code possible in 12 bits. */ #define LZ_MAX_CODE 4095 /* Biggest code possible in 12 bits. */
#define LZ_BITS 12 #define LZ_BITS 12
...@@ -54,7 +54,7 @@ ...@@ -54,7 +54,7 @@
#define IS_WRITEABLE(Private) (Private->FileState & FILE_STATE_WRITE) #define IS_WRITEABLE(Private) (Private->FileState & FILE_STATE_WRITE)
typedef struct GifFilePrivateType { typedef struct GifFilePrivateType {
int FileState, FileHandle, /* Where all this data goes to! */ GifWord FileState, FileHandle, /* Where all this data goes to! */
BitsPerPixel, /* Bits per pixel (Codes uses at least this + 1). */ BitsPerPixel, /* Bits per pixel (Codes uses at least this + 1). */
ClearCode, /* The CLEAR LZ code. */ ClearCode, /* The CLEAR LZ code. */
EOFCode, /* The EOF LZ code. */ EOFCode, /* The EOF LZ code. */
...@@ -73,9 +73,11 @@ typedef struct GifFilePrivateType { ...@@ -73,9 +73,11 @@ typedef struct GifFilePrivateType {
GifByteType Buf[256]; /* Compressed input is buffered here. */ GifByteType Buf[256]; /* Compressed input is buffered here. */
GifByteType Stack[LZ_MAX_CODE]; /* Decoded pixels are stacked here. */ GifByteType Stack[LZ_MAX_CODE]; /* Decoded pixels are stacked here. */
GifByteType Suffix[LZ_MAX_CODE + 1]; /* So we can trace the codes. */ GifByteType Suffix[LZ_MAX_CODE + 1]; /* So we can trace the codes. */
unsigned int Prefix[LZ_MAX_CODE + 1]; GifPrefixType Prefix[LZ_MAX_CODE + 1];
GifHashTableType *HashTable;
bool gif89;
} GifFilePrivateType; } GifFilePrivateType;
extern int _GifError;
#endif /* _GIF_LIB_PRIVATE_H */ #endif /* _GIF_LIB_PRIVATE_H */
/* end */
src/share/native/sun/awt/giflib/gifalloc.c
浏览文件 @ 2e480e33
...@@ -23,36 +23,27 @@ ...@@ -23,36 +23,27 @@
*/ */
/***************************************************************************** /*****************************************************************************
* "Gif-Lib" - Yet another gif library.
* GIF construction tools
* Written by: Gershon Elber Ver 0.1, Jun. 1989
* Extensively hacked by: Eric S. Raymond Ver 1.?, Sep 1992 ****************************************************************************/
*****************************************************************************
* GIF construction tools
*****************************************************************************
* History:
* 15 Sep 92 - Version 1.0 by Eric Raymond.
****************************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "gif_lib.h" #include "gif_lib.h"
#define MAX(x, y) (((x) > (y)) ? (x) : (y)) #define MAX(x, y) (((x) > (y)) ? (x) : (y))
/****************************************************************************** /******************************************************************************
* Miscellaneous utility functions Miscellaneous utility functions
*****************************************************************************/ ******************************************************************************/
/* return smallest bitfield size n will fit in */ /* return smallest bitfield size n will fit in */
int int
BitSize(int n) { GifBitSize(int n)
{
register int i; register int i;
for (i = 1; i <= 8; i++) for (i = 1; i <= 8; i++)
...@@ -62,22 +53,21 @@ BitSize(int n) { ...@@ -62,22 +53,21 @@ BitSize(int n) {
} }
/****************************************************************************** /******************************************************************************
* Color map object functions Color map object functions
*****************************************************************************/ ******************************************************************************/
/* /*
* Allocate a color map of given size; initialize with contents of * Allocate a color map of given size; initialize with contents of
* ColorMap if that pointer is non-NULL. * ColorMap if that pointer is non-NULL.
*/ */
ColorMapObject * ColorMapObject *
MakeMapObject(int ColorCount, GifMakeMapObject(int ColorCount, const GifColorType *ColorMap)
const GifColorType * ColorMap) { {
ColorMapObject *Object; ColorMapObject *Object;
/*** FIXME: Our ColorCount has to be a power of two. Is it necessary to /*** FIXME: Our ColorCount has to be a power of two. Is it necessary to
* make the user know that or should we automatically round up instead? */ * make the user know that or should we automatically round up instead? */
if (ColorCount != (1 << BitSize(ColorCount))) { if (ColorCount != (1 << GifBitSize(ColorCount))) {
return ((ColorMapObject *) NULL); return ((ColorMapObject *) NULL);
} }
...@@ -93,9 +83,10 @@ MakeMapObject(int ColorCount, ...@@ -93,9 +83,10 @@ MakeMapObject(int ColorCount,
} }
Object->ColorCount = ColorCount; Object->ColorCount = ColorCount;
Object->BitsPerPixel = BitSize(ColorCount); Object->BitsPerPixel = GifBitSize(ColorCount);
Object->SortFlag = false;
if (ColorMap) { if (ColorMap != NULL) {
memcpy((char *)Object->Colors, memcpy((char *)Object->Colors,
(char *)ColorMap, ColorCount * sizeof(GifColorType)); (char *)ColorMap, ColorCount * sizeof(GifColorType));
} }
...@@ -103,118 +94,222 @@ MakeMapObject(int ColorCount, ...@@ -103,118 +94,222 @@ MakeMapObject(int ColorCount,
return (Object); return (Object);
} }
/* /*******************************************************************************
* Free a color map object Free a color map object
*/ *******************************************************************************/
void void
FreeMapObject(ColorMapObject * Object) { GifFreeMapObject(ColorMapObject *Object)
{
if (Object != NULL) { if (Object != NULL) {
free(Object->Colors); (void)free(Object->Colors);
free(Object); (void)free(Object);
Object = NULL;
} }
} }
#ifdef DEBUG #ifdef DEBUG
void void
DumpColorMap(ColorMapObject * Object, DumpColorMap(ColorMapObject *Object,
FILE * fp) { FILE * fp)
{
if (Object) { if (Object != NULL) {
int i, j, Len = Object->ColorCount; int i, j, Len = Object->ColorCount;
for (i = 0; i < Len; i += 4) { for (i = 0; i < Len; i += 4) {
for (j = 0; j < 4 && j < Len; j++) { for (j = 0; j < 4 && j < Len; j++) {
fprintf(fp, "%3d: %02x %02x %02x ", i + j, (void)fprintf(fp, "%3d: %02x %02x %02x ", i + j,
Object->Colors[i + j].Red, Object->Colors[i + j].Red,
Object->Colors[i + j].Green, Object->Colors[i + j].Green,
Object->Colors[i + j].Blue); Object->Colors[i + j].Blue);
} }
fprintf(fp, "\n"); (void)fprintf(fp, "\n");
} }
} }
} }
#endif /* DEBUG */ #endif /* DEBUG */
/****************************************************************************** /*******************************************************************************
* Extension record functions Compute the union of two given color maps and return it. If result can't
*****************************************************************************/ fit into 256 colors, NULL is returned, the allocated union otherwise.
ColorIn1 is copied as is to ColorUnion, while colors from ColorIn2 are
copied iff they didn't exist before. ColorTransIn2 maps the old
ColorIn2 into the ColorUnion color map table./
*******************************************************************************/
ColorMapObject *
GifUnionColorMap(const ColorMapObject *ColorIn1,
const ColorMapObject *ColorIn2,
GifPixelType ColorTransIn2[])
{
int i, j, CrntSlot, RoundUpTo, NewGifBitSize;
ColorMapObject *ColorUnion;
void /*
MakeExtension(SavedImage * New, * We don't worry about duplicates within either color map; if
int Function) { * the caller wants to resolve those, he can perform unions
* with an empty color map.
New->Function = Function; */
/*** FIXME:
* Someday we might have to deal with multiple extensions. /* Allocate table which will hold the result for sure. */
* ??? Was this a note from Gershon or from me? Does the multiple ColorUnion = GifMakeMapObject(MAX(ColorIn1->ColorCount,
* extension blocks solve this or do we need multiple Functions? Or is ColorIn2->ColorCount) * 2, NULL);
* this an obsolete function? (People should use AddExtensionBlock
* instead?) if (ColorUnion == NULL)
* Looks like AddExtensionBlock needs to take the int Function argument return (NULL);
* then it can take the place of this function. Right now people have to
* use both. Fix AddExtensionBlock and add this to the deprecation list. /*
* Copy ColorIn1 to ColorUnion.
*/
for (i = 0; i < ColorIn1->ColorCount; i++)
ColorUnion->Colors[i] = ColorIn1->Colors[i];
CrntSlot = ColorIn1->ColorCount;
/*
* Potentially obnoxious hack:
*
* Back CrntSlot down past all contiguous {0, 0, 0} slots at the end
* of table 1. This is very useful if your display is limited to
* 16 colors.
*/ */
while (ColorIn1->Colors[CrntSlot - 1].Red == 0
&& ColorIn1->Colors[CrntSlot - 1].Green == 0
&& ColorIn1->Colors[CrntSlot - 1].Blue == 0)
CrntSlot--;
/* Copy ColorIn2 to ColorUnion (use old colors if they exist): */
for (i = 0; i < ColorIn2->ColorCount && CrntSlot <= 256; i++) {
/* Let's see if this color already exists: */
for (j = 0; j < ColorIn1->ColorCount; j++)
if (memcmp (&ColorIn1->Colors[j], &ColorIn2->Colors[i],
sizeof(GifColorType)) == 0)
break;
if (j < ColorIn1->ColorCount)
ColorTransIn2[i] = j; /* color exists in Color1 */
else {
/* Color is new - copy it to a new slot: */
ColorUnion->Colors[CrntSlot] = ColorIn2->Colors[i];
ColorTransIn2[i] = CrntSlot++;
}
}
if (CrntSlot > 256) {
GifFreeMapObject(ColorUnion);
return ((ColorMapObject *) NULL);
}
NewGifBitSize = GifBitSize(CrntSlot);
RoundUpTo = (1 << NewGifBitSize);
if (RoundUpTo != ColorUnion->ColorCount) {
register GifColorType *Map = ColorUnion->Colors;
/*
* Zero out slots up to next power of 2.
* We know these slots exist because of the way ColorUnion's
* start dimension was computed.
*/
for (j = CrntSlot; j < RoundUpTo; j++)
Map[j].Red = Map[j].Green = Map[j].Blue = 0;
/* perhaps we can shrink the map? */
if (RoundUpTo < ColorUnion->ColorCount) {
GifColorType *new_map = (GifColorType *)realloc(Map,
sizeof(GifColorType) * RoundUpTo);
if( new_map == NULL ) {
GifFreeMapObject(ColorUnion);
return ((ColorMapObject *) NULL);
}
ColorUnion->Colors = new_map;
}
}
ColorUnion->ColorCount = RoundUpTo;
ColorUnion->BitsPerPixel = NewGifBitSize;
return (ColorUnion);
} }
int /*******************************************************************************
AddExtensionBlock(SavedImage * New, Apply a given color translation to the raster bits of an image
int Len, *******************************************************************************/
unsigned char ExtData[]) { void
GifApplyTranslation(SavedImage *Image, GifPixelType Translation[])
{
register int i;
register int RasterSize = Image->ImageDesc.Height * Image->ImageDesc.Width;
for (i = 0; i < RasterSize; i++)
Image->RasterBits[i] = Translation[Image->RasterBits[i]];
}
/******************************************************************************
Extension record functions
******************************************************************************/
int
GifAddExtensionBlock(int *ExtensionBlockCount,
ExtensionBlock **ExtensionBlocks,
int Function,
unsigned int Len,
unsigned char ExtData[])
{
ExtensionBlock *ep; ExtensionBlock *ep;
if (New->ExtensionBlocks == NULL) if (*ExtensionBlocks == NULL)
New->ExtensionBlocks=(ExtensionBlock *)malloc(sizeof(ExtensionBlock)); *ExtensionBlocks=(ExtensionBlock *)malloc(sizeof(ExtensionBlock));
else else {
New->ExtensionBlocks = (ExtensionBlock *)realloc(New->ExtensionBlocks, ExtensionBlock* ep_new = (ExtensionBlock *)realloc(*ExtensionBlocks,
sizeof(ExtensionBlock) * sizeof(ExtensionBlock) *
(New->ExtensionBlockCount + 1)); (*ExtensionBlockCount + 1));
if( ep_new == NULL )
return (GIF_ERROR);
*ExtensionBlocks = ep_new;
}
if (New->ExtensionBlocks == NULL) if (*ExtensionBlocks == NULL)
return (GIF_ERROR); return (GIF_ERROR);
ep = &New->ExtensionBlocks[New->ExtensionBlockCount++]; ep = &(*ExtensionBlocks)[(*ExtensionBlockCount)++];
ep->Function = Function;
ep->ByteCount=Len; ep->ByteCount=Len;
ep->Bytes = (char *)malloc(ep->ByteCount); ep->Bytes = (GifByteType *)malloc(ep->ByteCount);
if (ep->Bytes == NULL) if (ep->Bytes == NULL)
return (GIF_ERROR); return (GIF_ERROR);
if (ExtData) { if (ExtData != NULL) {
memcpy(ep->Bytes, ExtData, Len); memcpy(ep->Bytes, ExtData, Len);
ep->Function = New->Function;
} }
return (GIF_OK); return (GIF_OK);
} }
void void
FreeExtension(SavedImage * Image) GifFreeExtensions(int *ExtensionBlockCount,
ExtensionBlock **ExtensionBlocks)
{ {
ExtensionBlock *ep; ExtensionBlock *ep;
if ((Image == NULL) || (Image->ExtensionBlocks == NULL)) { if (*ExtensionBlocks == NULL)
return; return;
}
for (ep = Image->ExtensionBlocks; for (ep = *ExtensionBlocks;
ep < (Image->ExtensionBlocks + Image->ExtensionBlockCount); ep++) ep < (*ExtensionBlocks + *ExtensionBlockCount);
ep++)
(void)free((char *)ep->Bytes); (void)free((char *)ep->Bytes);
free((char *)Image->ExtensionBlocks); (void)free((char *)*ExtensionBlocks);
Image->ExtensionBlocks = NULL; *ExtensionBlocks = NULL;
*ExtensionBlockCount = 0;
} }
/****************************************************************************** /******************************************************************************
* Image block allocation functions Image block allocation functions
******************************************************************************/ ******************************************************************************/
/* Private Function: /* Private Function:
* Frees the last image in the GifFile->SavedImages array * Frees the last image in the GifFile->SavedImages array
*/ */
void void
FreeLastSavedImage(GifFileType *GifFile) { FreeLastSavedImage(GifFileType *GifFile)
{
SavedImage *sp; SavedImage *sp;
if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) if ((GifFile == NULL) || (GifFile->SavedImages == NULL))
...@@ -225,20 +320,21 @@ FreeLastSavedImage(GifFileType *GifFile) { ...@@ -225,20 +320,21 @@ FreeLastSavedImage(GifFileType *GifFile) {
sp = &GifFile->SavedImages[GifFile->ImageCount]; sp = &GifFile->SavedImages[GifFile->ImageCount];
/* Deallocate its Colormap */ /* Deallocate its Colormap */
if (sp->ImageDesc.ColorMap) if (sp->ImageDesc.ColorMap != NULL) {
FreeMapObject(sp->ImageDesc.ColorMap); GifFreeMapObject(sp->ImageDesc.ColorMap);
sp->ImageDesc.ColorMap = NULL;
}
/* Deallocate the image data */ /* Deallocate the image data */
if (sp->RasterBits) if (sp->RasterBits != NULL)
free((char *)sp->RasterBits); free((char *)sp->RasterBits);
/* Deallocate any extensions */ /* Deallocate any extensions */
if (sp->ExtensionBlocks) GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
FreeExtension(sp);
/*** FIXME: We could realloc the GifFile->SavedImages structure but is /*** FIXME: We could realloc the GifFile->SavedImages structure but is
* there a point to it? Saves some memory but we'd have to do it every * there a point to it? Saves some memory but we'd have to do it every
* time. If this is used in FreeSavedImages then it would be inefficient * time. If this is used in GifFreeSavedImages then it would be inefficient
* (The whole array is going to be deallocated.) If we just use it when * (The whole array is going to be deallocated.) If we just use it when
* we want to free the last Image it's convenient to do it here. * we want to free the last Image it's convenient to do it here.
*/ */
...@@ -248,11 +344,8 @@ FreeLastSavedImage(GifFileType *GifFile) { ...@@ -248,11 +344,8 @@ FreeLastSavedImage(GifFileType *GifFile) {
* Append an image block to the SavedImages array * Append an image block to the SavedImages array
*/ */
SavedImage * SavedImage *
MakeSavedImage(GifFileType * GifFile, GifMakeSavedImage(GifFileType *GifFile, const SavedImage *CopyFrom)
const SavedImage * CopyFrom) { {
SavedImage *sp;
if (GifFile->SavedImages == NULL) if (GifFile->SavedImages == NULL)
GifFile->SavedImages = (SavedImage *)malloc(sizeof(SavedImage)); GifFile->SavedImages = (SavedImage *)malloc(sizeof(SavedImage));
else else
...@@ -262,10 +355,10 @@ MakeSavedImage(GifFileType * GifFile, ...@@ -262,10 +355,10 @@ MakeSavedImage(GifFileType * GifFile,
if (GifFile->SavedImages == NULL) if (GifFile->SavedImages == NULL)
return ((SavedImage *)NULL); return ((SavedImage *)NULL);
else { else {
sp = &GifFile->SavedImages[GifFile->ImageCount++]; SavedImage *sp = &GifFile->SavedImages[GifFile->ImageCount++];
memset((char *)sp, '\0', sizeof(SavedImage)); memset((char *)sp, '\0', sizeof(SavedImage));
if (CopyFrom) { if (CopyFrom != NULL) {
memcpy((char *)sp, CopyFrom, sizeof(SavedImage)); memcpy((char *)sp, CopyFrom, sizeof(SavedImage));
/* /*
...@@ -275,8 +368,8 @@ MakeSavedImage(GifFileType * GifFile, ...@@ -275,8 +368,8 @@ MakeSavedImage(GifFileType * GifFile,
*/ */
/* first, the local color map */ /* first, the local color map */
if (sp->ImageDesc.ColorMap) { if (sp->ImageDesc.ColorMap != NULL) {
sp->ImageDesc.ColorMap = MakeMapObject( sp->ImageDesc.ColorMap = GifMakeMapObject(
CopyFrom->ImageDesc.ColorMap->ColorCount, CopyFrom->ImageDesc.ColorMap->ColorCount,
CopyFrom->ImageDesc.ColorMap->Colors); CopyFrom->ImageDesc.ColorMap->Colors);
if (sp->ImageDesc.ColorMap == NULL) { if (sp->ImageDesc.ColorMap == NULL) {
...@@ -298,7 +391,7 @@ MakeSavedImage(GifFileType * GifFile, ...@@ -298,7 +391,7 @@ MakeSavedImage(GifFileType * GifFile,
CopyFrom->ImageDesc.Width); CopyFrom->ImageDesc.Width);
/* finally, the extension blocks */ /* finally, the extension blocks */
if (sp->ExtensionBlocks) { if (sp->ExtensionBlocks != NULL) {
sp->ExtensionBlocks = (ExtensionBlock *)malloc( sp->ExtensionBlocks = (ExtensionBlock *)malloc(
sizeof(ExtensionBlock) * sizeof(ExtensionBlock) *
CopyFrom->ExtensionBlockCount); CopyFrom->ExtensionBlockCount);
...@@ -308,17 +401,6 @@ MakeSavedImage(GifFileType * GifFile, ...@@ -308,17 +401,6 @@ MakeSavedImage(GifFileType * GifFile,
} }
memcpy(sp->ExtensionBlocks, CopyFrom->ExtensionBlocks, memcpy(sp->ExtensionBlocks, CopyFrom->ExtensionBlocks,
sizeof(ExtensionBlock) * CopyFrom->ExtensionBlockCount); sizeof(ExtensionBlock) * CopyFrom->ExtensionBlockCount);
/*
* For the moment, the actual blocks can take their
* chances with free(). We'll fix this later.
*** FIXME: [Better check this out... Toshio]
* 2004 May 27: Looks like this was an ESR note.
* It means the blocks are shallow copied from InFile to
* OutFile. However, I don't see that in this code....
* Did ESR fix it but never remove this note (And other notes
* in gifspnge?)
*/
} }
} }
...@@ -327,8 +409,8 @@ MakeSavedImage(GifFileType * GifFile, ...@@ -327,8 +409,8 @@ MakeSavedImage(GifFileType * GifFile,
} }
void void
FreeSavedImages(GifFileType * GifFile) { GifFreeSavedImages(GifFileType *GifFile)
{
SavedImage *sp; SavedImage *sp;
if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) { if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) {
...@@ -336,15 +418,18 @@ FreeSavedImages(GifFileType * GifFile) { ...@@ -336,15 +418,18 @@ FreeSavedImages(GifFileType * GifFile) {
} }
for (sp = GifFile->SavedImages; for (sp = GifFile->SavedImages;
sp < GifFile->SavedImages + GifFile->ImageCount; sp++) { sp < GifFile->SavedImages + GifFile->ImageCount; sp++) {
if (sp->ImageDesc.ColorMap) if (sp->ImageDesc.ColorMap != NULL) {
FreeMapObject(sp->ImageDesc.ColorMap); GifFreeMapObject(sp->ImageDesc.ColorMap);
sp->ImageDesc.ColorMap = NULL;
}
if (sp->RasterBits) if (sp->RasterBits != NULL)
free((char *)sp->RasterBits); free((char *)sp->RasterBits);
if (sp->ExtensionBlocks) GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
FreeExtension(sp);
} }
free((char *)GifFile->SavedImages); free((char *)GifFile->SavedImages);
GifFile->SavedImages=NULL; GifFile->SavedImages = NULL;
} }
/* end */
src/share/native/sun/awt/splashscreen/splashscreen_gif.c
浏览文件 @ 2e480e33
...@@ -82,8 +82,8 @@ SplashDecodeGif(Splash * splash, GifFileType * gif) ...@@ -82,8 +82,8 @@ SplashDecodeGif(Splash * splash, GifFileType * gif)
int i, j; int i, j;
int imageIndex; int imageIndex;
int cx, cy, cw, ch; /* clamped coordinates */ int cx, cy, cw, ch; /* clamped coordinates */
const int interlacedOffset[] = { 0, 4, 2, 1, 0 }; /* The way Interlaced image should. */ int numLines;
const int interlacedJumps[] = { 8, 8, 4, 2, 1 }; /* be read - offsets and jumps... */ int numPassLines;
if (DGifSlurp(gif) == GIF_ERROR) { if (DGifSlurp(gif) == GIF_ERROR) {
return 0; return 0;
...@@ -213,16 +213,6 @@ SplashDecodeGif(Splash * splash, GifFileType * gif) ...@@ -213,16 +213,6 @@ SplashDecodeGif(Splash * splash, GifFileType * gif)
byte_t *pSrc = image->RasterBits; byte_t *pSrc = image->RasterBits;
ImageFormat srcFormat; ImageFormat srcFormat;
ImageRect srcRect, dstRect; ImageRect srcRect, dstRect;
int pass, npass;
if (desc->Interlace) {
pass = 0;
npass = 4;
}
else {
pass = 4;
npass = 5;
}
srcFormat.colorMap = colorMapBuf; srcFormat.colorMap = colorMapBuf;
srcFormat.depthBytes = 1; srcFormat.depthBytes = 1;
...@@ -231,26 +221,22 @@ SplashDecodeGif(Splash * splash, GifFileType * gif) ...@@ -231,26 +221,22 @@ SplashDecodeGif(Splash * splash, GifFileType * gif)
srcFormat.fixedBits = QUAD_ALPHA_MASK; // fixed 100% alpha srcFormat.fixedBits = QUAD_ALPHA_MASK; // fixed 100% alpha
srcFormat.premultiplied = 0; srcFormat.premultiplied = 0;
for (; pass < npass; ++pass) { /* Number of source lines for current pass */
int jump = interlacedJumps[pass]; numPassLines = desc->Height;
int ofs = interlacedOffset[pass]; /* Number of lines that fits to dest buffer */
/* Number of source lines for current pass */ numLines = ch;
int numPassLines = (desc->Height + jump - ofs - 1) / jump;
/* Number of lines that fits to dest buffer */
int numLines = (ch + jump - ofs - 1) / jump;
initRect(&srcRect, 0, 0, desc->Width, numLines, 1, initRect(&srcRect, 0, 0, desc->Width, numLines, 1,
desc->Width, pSrc, &srcFormat); desc->Width, pSrc, &srcFormat);
if (numLines > 0) { if (numLines > 0) {
initRect(&dstRect, cx, cy + ofs, cw, initRect(&dstRect, cx, cy, cw,
numLines , jump, stride, pBitmapBits, &splash->imageFormat); numLines , 1, stride, pBitmapBits, &splash->imageFormat);
pSrc += convertRect(&srcRect, &dstRect, CVT_ALPHATEST); pSrc += convertRect(&srcRect, &dstRect, CVT_ALPHATEST);
}
// skip extra source data
pSrc += (numPassLines - numLines) * srcRect.stride;
} }
// skip extra source data
pSrc += (numPassLines - numLines) * srcRect.stride;
} }
// now dispose of the previous frame correctly // now dispose of the previous frame correctly
...@@ -310,7 +296,7 @@ SplashDecodeGif(Splash * splash, GifFileType * gif) ...@@ -310,7 +296,7 @@ SplashDecodeGif(Splash * splash, GifFileType * gif)
free(pBitmapBits); free(pBitmapBits);
free(pOldBitmapBits); free(pOldBitmapBits);
DGifCloseFile(gif); DGifCloseFile(gif, NULL);
return 1; return 1;
} }
...@@ -318,7 +304,7 @@ SplashDecodeGif(Splash * splash, GifFileType * gif) ...@@ -318,7 +304,7 @@ SplashDecodeGif(Splash * splash, GifFileType * gif)
int int
SplashDecodeGifStream(Splash * splash, SplashStream * stream) SplashDecodeGifStream(Splash * splash, SplashStream * stream)
{ {
GifFileType *gif = DGifOpen((void *) stream, SplashStreamGifInputFunc); GifFileType *gif = DGifOpen((void *) stream, SplashStreamGifInputFunc, NULL);
if (!gif) if (!gif)
return 0; return 0;
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或