| File: | jdk/src/java.desktop/share/native/libsplashscreen/splashscreen_gif.c |
| Warning: | line 283, column 32 Access to field 'Colors' results in a dereference of a null pointer (loaded from variable 'colorMap') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* | |||
| 2 | * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved. | |||
| 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |||
| 4 | * | |||
| 5 | * This code is free software; you can redistribute it and/or modify it | |||
| 6 | * under the terms of the GNU General Public License version 2 only, as | |||
| 7 | * published by the Free Software Foundation. Oracle designates this | |||
| 8 | * particular file as subject to the "Classpath" exception as provided | |||
| 9 | * by Oracle in the LICENSE file that accompanied this code. | |||
| 10 | * | |||
| 11 | * This code is distributed in the hope that it will be useful, but WITHOUT | |||
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |||
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |||
| 14 | * version 2 for more details (a copy is included in the LICENSE file that | |||
| 15 | * accompanied this code). | |||
| 16 | * | |||
| 17 | * You should have received a copy of the GNU General Public License version | |||
| 18 | * 2 along with this work; if not, write to the Free Software Foundation, | |||
| 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |||
| 20 | * | |||
| 21 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |||
| 22 | * or visit www.oracle.com if you need additional information or have any | |||
| 23 | * questions. | |||
| 24 | */ | |||
| 25 | ||||
| 26 | #include "splashscreen_impl.h" | |||
| 27 | #include "splashscreen_gfx.h" | |||
| 28 | ||||
| 29 | #include <gif_lib.h> | |||
| 30 | ||||
| 31 | #include "sizecalc.h" | |||
| 32 | ||||
| 33 | #define GIF_TRANSPARENT0x01 0x01 | |||
| 34 | #define GIF_USER_INPUT0x02 0x02 | |||
| 35 | #define GIF_DISPOSE_MASK0x07 0x07 | |||
| 36 | #define GIF_DISPOSE_SHIFT2 2 | |||
| 37 | ||||
| 38 | #define GIF_NOT_TRANSPARENT-1 -1 | |||
| 39 | ||||
| 40 | #define GIF_DISPOSE_NONE0 0 // No disposal specified. The decoder is | |||
| 41 | // not required to take any action. | |||
| 42 | #define GIF_DISPOSE_LEAVE1 1 // Do not dispose. The graphic is to be left | |||
| 43 | // in place. | |||
| 44 | #define GIF_DISPOSE_BACKGND2 2 // Restore to background color. The area used by the | |||
| 45 | // graphic must be restored to the background color. | |||
| 46 | ||||
| 47 | #define GIF_DISPOSE_RESTORE3 3 // Restore to previous. The decoder is required to | |||
| 48 | // restore the area overwritten by the graphic with | |||
| 49 | // what was there prior to rendering the graphic. | |||
| 50 | ||||
| 51 | static const char szNetscape20ext[11] = "NETSCAPE2.0"; | |||
| 52 | ||||
| 53 | #define NSEXT_LOOP0x01 0x01 // Loop Count field code | |||
| 54 | ||||
| 55 | // convert libungif samples to our ones | |||
| 56 | #define MAKE_QUAD_GIF(c,a)((((unsigned)(a))<<24)&0xFF000000)| ((((c).Red)<< 16)&0x00FF0000)| ((((c).Green)<<8)&0x0000FF00)| ((((c).Blue)<<0)&0x000000FF) MAKE_QUAD((c).Red, (c).Green, (c).Blue, (unsigned)(a))((((unsigned)(a))<<24)&0xFF000000)| ((((c).Red)<< 16)&0x00FF0000)| ((((c).Green)<<8)&0x0000FF00)| ((((c).Blue)<<0)&0x000000FF) | |||
| 57 | ||||
| 58 | /* stdio FILE* and memory input functions for libungif */ | |||
| 59 | int | |||
| 60 | SplashStreamGifInputFunc(GifFileType * gif, GifByteType * buf, int n) | |||
| 61 | { | |||
| 62 | SplashStream* io = (SplashStream*)gif->UserData; | |||
| 63 | int rc = io->read(io, buf, n); | |||
| 64 | return rc; | |||
| 65 | } | |||
| 66 | ||||
| 67 | /* These macro help to ensure that we only take part of frame that fits into | |||
| 68 | logical screen. */ | |||
| 69 | ||||
| 70 | /* Ensure that p belongs to [pmin, pmax) interval. Returns fixed point (if fix is needed) */ | |||
| 71 | #define FIX_POINT(p, pmin, pmax)( ((p) < (pmin)) ? (pmin) : (((p) > (pmax)) ? (pmax) : ( p))) ( ((p) < (pmin)) ? (pmin) : (((p) > (pmax)) ? (pmax) : (p))) | |||
| 72 | /* Ensures that line starting at point p does not exceed boundary pmax. | |||
| 73 | Returns fixed length (if fix is needed) */ | |||
| 74 | #define FIX_LENGTH(p, len, pmax)( ((p) + (len)) > (pmax) ? ((pmax) - (p)) : (len)) ( ((p) + (len)) > (pmax) ? ((pmax) - (p)) : (len)) | |||
| 75 | ||||
| 76 | int | |||
| 77 | SplashDecodeGif(Splash * splash, GifFileType * gif) | |||
| 78 | { | |||
| 79 | int stride; | |||
| 80 | int bufferSize; | |||
| 81 | byte_t *pBitmapBits, *pOldBitmapBits; | |||
| 82 | int i, j; | |||
| 83 | int imageIndex; | |||
| 84 | int cx, cy, cw, ch; /* clamped coordinates */ | |||
| 85 | const int interlacedOffset[] = { 0, 4, 2, 1, 0 }; /* The way Interlaced image should. */ | |||
| 86 | const int interlacedJumps[] = { 8, 8, 4, 2, 1 }; /* be read - offsets and jumps... */ | |||
| 87 | ||||
| 88 | if (DGifSlurp(gif) == GIF_ERROR0) { | |||
| ||||
| 89 | return 0; | |||
| 90 | } | |||
| 91 | ||||
| 92 | SplashCleanup(splash); | |||
| 93 | ||||
| 94 | if (!SAFE_TO_ALLOC(gif->SWidth, splash->imageFormat.depthBytes)(((gif->SWidth) > 0) && ((splash->imageFormat .depthBytes) > 0) && ((0xffffffffu / ((unsigned int )(gif->SWidth))) > (unsigned int)(splash->imageFormat .depthBytes)))) { | |||
| 95 | return 0; | |||
| 96 | } | |||
| 97 | stride = gif->SWidth * splash->imageFormat.depthBytes; | |||
| 98 | if (splash->byteAlignment > 1) | |||
| 99 | stride = | |||
| 100 | (stride + splash->byteAlignment - 1) & ~(splash->byteAlignment - 1); | |||
| 101 | ||||
| 102 | if (!SAFE_TO_ALLOC(gif->SHeight, stride)(((gif->SHeight) > 0) && ((stride) > 0) && ((0xffffffffu / ((unsigned int)(gif->SHeight))) > (unsigned int)(stride)))) { | |||
| 103 | return 0; | |||
| 104 | } | |||
| 105 | ||||
| 106 | if (!SAFE_TO_ALLOC(gif->ImageCount, sizeof(SplashImage*))(((gif->ImageCount) > 0) && ((sizeof(SplashImage *)) > 0) && ((0xffffffffu / ((unsigned int)(gif-> ImageCount))) > (unsigned int)(sizeof(SplashImage*))))) { | |||
| 107 | return 0; | |||
| 108 | } | |||
| 109 | bufferSize = stride * gif->SHeight; | |||
| 110 | pBitmapBits = (byte_t *) malloc(bufferSize); | |||
| 111 | if (!pBitmapBits) { | |||
| 112 | return 0; | |||
| 113 | } | |||
| 114 | pOldBitmapBits = (byte_t *) malloc(bufferSize); | |||
| 115 | if (!pOldBitmapBits) { | |||
| 116 | free(pBitmapBits); | |||
| 117 | return 0; | |||
| 118 | } | |||
| 119 | memset(pBitmapBits, 0, bufferSize); | |||
| 120 | ||||
| 121 | splash->width = gif->SWidth; | |||
| 122 | splash->height = gif->SHeight; | |||
| 123 | splash->frameCount = gif->ImageCount; | |||
| 124 | splash->frames = (SplashImage *) | |||
| 125 | SAFE_SIZE_ARRAY_ALLOC(malloc, sizeof(SplashImage), gif->ImageCount)(((((sizeof(SplashImage))) >= 0 && (unsigned long long )((sizeof(SplashImage))) <= (18446744073709551615UL)) && (((gif->ImageCount)) >= 0 && (unsigned long long )((gif->ImageCount)) <= (18446744073709551615UL)) && (((sizeof(SplashImage))) == 0 || ((gif->ImageCount)) == 0 || (size_t)((gif->ImageCount)) <= ((18446744073709551615UL ) / (size_t)((sizeof(SplashImage)))))) ? ((malloc)((sizeof(SplashImage )) * (gif->ImageCount))) : ((void*)0)); | |||
| 126 | if (!splash->frames) { | |||
| 127 | free(pBitmapBits); | |||
| 128 | free(pOldBitmapBits); | |||
| 129 | return 0; | |||
| 130 | } | |||
| 131 | memset(splash->frames, 0, sizeof(SplashImage) * gif->ImageCount); | |||
| 132 | splash->loopCount = 1; | |||
| 133 | ||||
| 134 | for (imageIndex = 0; imageIndex
| |||
| 135 | SavedImage *image = &(gif->SavedImages[imageIndex]); | |||
| 136 | GifImageDesc *desc = &(image->ImageDesc); | |||
| 137 | ColorMapObject *colorMap = | |||
| 138 | desc->ColorMap ? desc->ColorMap : gif->SColorMap; | |||
| 139 | ||||
| 140 | int transparentColor = -1; | |||
| 141 | int frameDelay = 100; | |||
| 142 | int disposeMethod = GIF_DISPOSE_RESTORE3; | |||
| 143 | int colorCount = 0; | |||
| 144 | rgbquad_t colorMapBuf[SPLASH_COLOR_MAP_SIZE0x100]; | |||
| 145 | ||||
| 146 | cx = FIX_POINT(desc->Left, 0, gif->SWidth)( ((desc->Left) < (0)) ? (0) : (((desc->Left) > ( gif->SWidth)) ? (gif->SWidth) : (desc->Left))); | |||
| 147 | cy = FIX_POINT(desc->Top, 0, gif->SHeight)( ((desc->Top) < (0)) ? (0) : (((desc->Top) > (gif ->SHeight)) ? (gif->SHeight) : (desc->Top))); | |||
| 148 | cw = FIX_LENGTH(desc->Left, desc->Width, gif->SWidth)( ((desc->Left) + (desc->Width)) > (gif->SWidth) ? ((gif->SWidth) - (desc->Left)) : (desc->Width)); | |||
| 149 | ch = FIX_LENGTH(desc->Top, desc->Height, gif->SHeight)( ((desc->Top) + (desc->Height)) > (gif->SHeight) ? ((gif->SHeight) - (desc->Top)) : (desc->Height)); | |||
| 150 | ||||
| 151 | if (colorMap) { | |||
| 152 | if (colorMap->ColorCount <= SPLASH_COLOR_MAP_SIZE0x100) { | |||
| 153 | colorCount = colorMap->ColorCount; | |||
| 154 | } else { | |||
| 155 | colorCount = SPLASH_COLOR_MAP_SIZE0x100; | |||
| 156 | } | |||
| 157 | } | |||
| 158 | ||||
| 159 | /* the code below is loosely based around gif extension processing from win32 libungif sample */ | |||
| 160 | ||||
| 161 | for (i = 0; i < image->ExtensionBlockCount; i++) { | |||
| 162 | byte_t *pExtension = (byte_t *) image->ExtensionBlocks[i].Bytes; | |||
| 163 | unsigned size = image->ExtensionBlocks[i].ByteCount; | |||
| 164 | ||||
| 165 | switch (image->ExtensionBlocks[i].Function) { | |||
| 166 | case GRAPHICS_EXT_FUNC_CODE0xf9: | |||
| 167 | { | |||
| 168 | int flag = pExtension[0]; | |||
| 169 | ||||
| 170 | frameDelay = (((int)pExtension[2]) << 8) | pExtension[1]; | |||
| 171 | if (frameDelay < 10) | |||
| 172 | frameDelay = 10; | |||
| 173 | if (flag & GIF_TRANSPARENT0x01) { | |||
| 174 | transparentColor = pExtension[3]; | |||
| 175 | } else { | |||
| 176 | transparentColor = GIF_NOT_TRANSPARENT-1; | |||
| 177 | } | |||
| 178 | disposeMethod = | |||
| 179 | (flag >> GIF_DISPOSE_SHIFT2) & GIF_DISPOSE_MASK0x07; | |||
| 180 | break; | |||
| 181 | } | |||
| 182 | case APPLICATION_EXT_FUNC_CODE0xff: | |||
| 183 | { | |||
| 184 | if (size == sizeof(szNetscape20ext) | |||
| 185 | && memcmp(pExtension, szNetscape20ext, size) == 0) { | |||
| 186 | int iSubCode; | |||
| 187 | ||||
| 188 | if (++i >= image->ExtensionBlockCount) | |||
| 189 | break; | |||
| 190 | pExtension = (byte_t *) image->ExtensionBlocks[i].Bytes; | |||
| 191 | if (image->ExtensionBlocks[i].ByteCount != 3) | |||
| 192 | break; | |||
| 193 | iSubCode = pExtension[0] & 0x07; | |||
| 194 | if (iSubCode == NSEXT_LOOP0x01) { | |||
| 195 | splash->loopCount = | |||
| 196 | (pExtension[1] | (((int)pExtension[2]) << 8)) - 1; | |||
| 197 | } | |||
| 198 | } | |||
| 199 | break; | |||
| 200 | } | |||
| 201 | default: | |||
| 202 | break; | |||
| 203 | } | |||
| 204 | } | |||
| 205 | ||||
| 206 | if (colorMap
| |||
| 207 | for (i = 0; i < colorCount; i++) { | |||
| 208 | colorMapBuf[i] = MAKE_QUAD_GIF(colorMap->Colors[i], 0xff)((((unsigned)(0xff))<<24)&0xFF000000)| ((((colorMap ->Colors[i]).Red)<<16)&0x00FF0000)| ((((colorMap ->Colors[i]).Green)<<8)&0x0000FF00)| ((((colorMap ->Colors[i]).Blue)<<0)&0x000000FF); | |||
| 209 | } | |||
| 210 | } | |||
| 211 | { | |||
| 212 | ||||
| 213 | byte_t *pSrc = image->RasterBits; | |||
| 214 | ImageFormat srcFormat; | |||
| 215 | ImageRect srcRect, dstRect; | |||
| 216 | int pass = 4, npass = 5; | |||
| 217 | ||||
| 218 | #if GIFLIB_MAJOR5 < 5 | |||
| 219 | /* Interlaced gif support is broken in giflib < 5 | |||
| 220 | so we need to work around this */ | |||
| 221 | if (desc->Interlace) { | |||
| 222 | pass = 0; | |||
| 223 | npass = 4; | |||
| 224 | } | |||
| 225 | #endif | |||
| 226 | ||||
| 227 | srcFormat.colorMap = colorMapBuf; | |||
| 228 | srcFormat.depthBytes = 1; | |||
| 229 | srcFormat.byteOrder = BYTE_ORDER_NATIVE; | |||
| 230 | srcFormat.transparentColor = transparentColor; | |||
| 231 | srcFormat.fixedBits = QUAD_ALPHA_MASK0xFF000000; // fixed 100% alpha | |||
| 232 | srcFormat.premultiplied = 0; | |||
| 233 | ||||
| 234 | for (; pass < npass; ++pass) { | |||
| 235 | int jump = interlacedJumps[pass]; | |||
| 236 | int ofs = interlacedOffset[pass]; | |||
| 237 | /* Number of source lines for current pass */ | |||
| 238 | int numPassLines = (desc->Height + jump - ofs - 1) / jump; | |||
| 239 | /* Number of lines that fits to dest buffer */ | |||
| 240 | int numLines = (ch + jump - ofs - 1) / jump; | |||
| 241 | ||||
| 242 | initRect(&srcRect, 0, 0, desc->Width, numLines, 1, | |||
| 243 | desc->Width, pSrc, &srcFormat); | |||
| 244 | ||||
| 245 | if (numLines > 0) { | |||
| 246 | initRect(&dstRect, cx, cy + ofs, cw, | |||
| 247 | numLines , jump, stride, pBitmapBits, &splash->imageFormat); | |||
| 248 | ||||
| 249 | pSrc += convertRect(&srcRect, &dstRect, CVT_ALPHATEST); | |||
| 250 | } | |||
| 251 | // skip extra source data | |||
| 252 | pSrc += (numPassLines - numLines) * srcRect.stride; | |||
| 253 | } | |||
| 254 | } | |||
| 255 | ||||
| 256 | // now dispose of the previous frame correctly | |||
| 257 | ||||
| 258 | splash->frames[imageIndex].bitmapBits = | |||
| 259 | (rgbquad_t *) malloc(bufferSize); // bufferSize is safe (checked above) | |||
| 260 | if (!splash->frames[imageIndex].bitmapBits) { | |||
| 261 | free(pBitmapBits); | |||
| 262 | free(pOldBitmapBits); | |||
| 263 | /* Assuming that callee will take care of splash frames we have already allocated */ | |||
| 264 | return 0; | |||
| 265 | } | |||
| 266 | memcpy(splash->frames[imageIndex].bitmapBits, pBitmapBits, bufferSize); | |||
| 267 | ||||
| 268 | SplashInitFrameShape(splash, imageIndex); | |||
| 269 | ||||
| 270 | splash->frames[imageIndex].delay = frameDelay * 10; // 100ths of second to milliseconds | |||
| 271 | switch (disposeMethod) { | |||
| 272 | case GIF_DISPOSE_LEAVE1: | |||
| 273 | memcpy(pOldBitmapBits, pBitmapBits, bufferSize); | |||
| 274 | break; | |||
| 275 | case GIF_DISPOSE_NONE0: | |||
| 276 | break; | |||
| 277 | case GIF_DISPOSE_BACKGND2: | |||
| 278 | { | |||
| 279 | ImageRect dstRect; | |||
| 280 | rgbquad_t fillColor = 0; // 0 is transparent | |||
| 281 | ||||
| 282 | if (transparentColor
| |||
| 283 | fillColor= MAKE_QUAD_GIF(((((unsigned)(0xff))<<24)&0xFF000000)| ((((colorMap ->Colors[gif->SBackGroundColor]).Red)<<16)&0x00FF0000 )| ((((colorMap->Colors[gif->SBackGroundColor]).Green)<< 8)&0x0000FF00)| ((((colorMap->Colors[gif->SBackGroundColor ]).Blue)<<0)&0x000000FF) | |||
| ||||
| 284 | colorMap->Colors[gif->SBackGroundColor], 0xff)((((unsigned)(0xff))<<24)&0xFF000000)| ((((colorMap ->Colors[gif->SBackGroundColor]).Red)<<16)&0x00FF0000 )| ((((colorMap->Colors[gif->SBackGroundColor]).Green)<< 8)&0x0000FF00)| ((((colorMap->Colors[gif->SBackGroundColor ]).Blue)<<0)&0x000000FF); | |||
| 285 | } | |||
| 286 | initRect(&dstRect, | |||
| 287 | cx, cy, cw, ch, | |||
| 288 | 1, stride, | |||
| 289 | pBitmapBits, &splash->imageFormat); | |||
| 290 | fillRect(fillColor, &dstRect); | |||
| 291 | } | |||
| 292 | break; | |||
| 293 | case GIF_DISPOSE_RESTORE3: | |||
| 294 | { | |||
| 295 | int lineSize = cw * splash->imageFormat.depthBytes; | |||
| 296 | if (lineSize > 0) { | |||
| 297 | int lineOffset = cx * splash->imageFormat.depthBytes; | |||
| 298 | int lineIndex = cy * stride + lineOffset; | |||
| 299 | for (j=0; j<ch; j++) { | |||
| 300 | memcpy(pBitmapBits + lineIndex, pOldBitmapBits + lineIndex, | |||
| 301 | lineSize); | |||
| 302 | lineIndex += stride; | |||
| 303 | } | |||
| 304 | } | |||
| 305 | } | |||
| 306 | break; | |||
| 307 | } | |||
| 308 | } | |||
| 309 | ||||
| 310 | free(pBitmapBits); | |||
| 311 | free(pOldBitmapBits); | |||
| 312 | ||||
| 313 | #if GIFLIB_MAJOR5 > 5 || (GIFLIB_MAJOR5 == 5 && GIFLIB_MINOR2 >= 1) | |||
| 314 | if (DGifCloseFile(gif, NULL((void*)0)) == GIF_ERROR0) { | |||
| 315 | return 0; | |||
| 316 | } | |||
| 317 | #else | |||
| 318 | DGifCloseFile(gif); | |||
| 319 | #endif | |||
| 320 | ||||
| 321 | return 1; | |||
| 322 | } | |||
| 323 | ||||
| 324 | int | |||
| 325 | SplashDecodeGifStream(Splash * splash, SplashStream * stream) | |||
| 326 | { | |||
| 327 | #if GIFLIB_MAJOR5 >= 5 | |||
| 328 | GifFileType *gif = DGifOpen((void *) stream, SplashStreamGifInputFunc, NULL((void*)0)); | |||
| 329 | #else | |||
| 330 | GifFileType *gif = DGifOpen((void *) stream, SplashStreamGifInputFunc); | |||
| 331 | #endif | |||
| 332 | ||||
| 333 | if (!gif) | |||
| 334 | return 0; | |||
| 335 | return SplashDecodeGif(splash, gif); | |||
| 336 | } |