stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8077982: GIFLIB upgrade

Browse Source 
Reviewed-by: ant, serb
This commit is contained in:
Alexander Zvegintsev 2015-04-30 16:02:42 +03:00
parent f97624c3a6
commit 71bcae933a
8 changed files with 1077 additions and 722 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
jdk/src/java.desktop/share/native/libsplashscreen/giflib/COPYING Normal file
View File

@ -0,0 +1,19 @@
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.

884
jdk/src/java.desktop/share/native/libsplashscreen/giflib/dgif_lib.c
View File

File diff suppressed because it is too large Load Diff

95
jdk/src/java.desktop/share/native/libsplashscreen/giflib/gif_err.c
View File

@ -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 gif_err.c - handle error reporting for the GIF library.
#include <config.h>
#endif ****************************************************************************/
#include <stdio.h> #include <stdio.h>
#include "gif_lib.h" #include "gif_lib.h"
#include "gif_lib_private.h"
int _GifError = 0;
/***************************************************************************** /*****************************************************************************
* Return the last GIF error (0 if none) and reset the error. Return a string description of the last GIF error
****************************************************************************/ *****************************************************************************/
int const char *
GifLastError(void) { GifErrorString(int ErrorCode)
int i = _GifError; {
const char *Err;
_GifError = 0; switch (ErrorCode) {
case E_GIF_ERR_OPEN_FAILED:
return i; Err = "Failed to open given file";
} break;
case E_GIF_ERR_WRITE_FAILED:
/***************************************************************************** Err = "Failed to write to given file";
* Print the last GIF error to stderr. break;
****************************************************************************/ case E_GIF_ERR_HAS_SCRN_DSCR:
void Err = "Screen descriptor has already been set";
PrintGifError(void) { break;
char *Err; case E_GIF_ERR_HAS_IMAG_DSCR:
Err = "Image descriptor is still active";
switch (_GifError) { 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) {
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 */

62
jdk/src/java.desktop/share/native/libsplashscreen/giflib/gif_hash.h Normal file
View File

@ -0,0 +1,62 @@
/*
* 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 */

342
jdk/src/java.desktop/share/native/libsplashscreen/giflib/gif_lib.h
View File

@ -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...
*
* 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 */ gif_lib.h - service library for decoding and encoding GIF images
*****************************************************************************/
#ifndef _GIF_LIB_H_ #ifndef _GIF_LIB_H_
#define _GIF_LIB_H_ 1 #define _GIF_LIB_H_ 1
@ -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" {
#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 {
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 {
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). ******************************************************************************/
*****************************************************************************/
GifFileType *DGifOpenFileName(const char *GifFileName); /* Main entry points */
GifFileType *DGifOpenFileHandle(int GifFileHandle); GifFileType *EGifOpenFileName(const char *GifFileName,
GifFileType *DGifOpen(void *userPtr, InputFunc readFunc); /* new one const bool GifTestExistence, int *Error);
* (TVT) */ GifFileType *EGifOpenFileHandle(const int GifFileHandle, int *Error);
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);
#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 ExtensionBlockCount;
ExtensionBlock *ExtensionBlocks; /* on malloc(3) heap */
} SavedImage;
extern void MakeExtension(SavedImage * New, int Function); int DGifExtensionToGCB(const size_t GifExtensionLength,
extern int AddExtensionBlock(SavedImage * New, int Len, const GifByteType *GifExtension,
unsigned char ExtData[]); GraphicsControlBlock *GCB);
extern void FreeExtension(SavedImage * Image); size_t EGifGCBToExtension(const GraphicsControlBlock *GCB,
extern SavedImage *MakeSavedImage(GifFileType * GifFile, GifByteType *GifExtension);
const SavedImage * CopyFrom);
extern void FreeSavedImages(GifFileType * GifFile);
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 GifDrawText8x8(SavedImage *Image,
const int x, const int y,
const char *legend, const int color);
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 */

30
jdk/src/java.desktop/share/native/libsplashscreen/giflib/gif_lib_private.h
View File

@ -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 @@
#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 {
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 */

321
jdk/src/java.desktop/share/native/libsplashscreen/giflib/gifalloc.c
View File

@ -23,36 +23,27 @@
*/ */
/***************************************************************************** /*****************************************************************************
* "Gif-Lib" - Yet another gif library.
*
* 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 GIF construction tools
#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) {
} }
/****************************************************************************** /******************************************************************************
* 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,
} }
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,
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.
* ??? Was this a note from Gershon or from me? Does the multiple
* extension blocks solve this or do we need multiple Functions? Or is
* this an obsolete function? (People should use AddExtensionBlock
* instead?)
* Looks like AddExtensionBlock needs to take the int Function argument
* 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.
*/ */
/* Allocate table which will hold the result for sure. */
ColorUnion = GifMakeMapObject(MAX(ColorIn1->ColorCount,
ColorIn2->ColorCount) * 2, NULL);
if (ColorUnion == NULL)
return (NULL);
/*
* 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) {
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) {
* 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,
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,
*/ */
/* 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,
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,
} }
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,
} }
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) {
} }
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 */

46
jdk/src/java.desktop/share/native/libsplashscreen/splashscreen_gif.c
View File

@ -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)
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)
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)
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)
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;