| /* |
| * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved. |
| * 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. |
| */ |
| |
| #include "splashscreen_impl.h" |
| #include "splashscreen_gfx.h" |
| |
| #include "../giflib/gif_lib.h" |
| |
| #define GIF_TRANSPARENT 0x01 |
| #define GIF_USER_INPUT 0x02 |
| #define GIF_DISPOSE_MASK 0x07 |
| #define GIF_DISPOSE_SHIFT 2 |
| |
| #define GIF_NOT_TRANSPARENT -1 |
| |
| #define GIF_DISPOSE_NONE 0 // No disposal specified. The decoder is |
| // not required to take any action. |
| #define GIF_DISPOSE_LEAVE 1 // Do not dispose. The graphic is to be left |
| // in place. |
| #define GIF_DISPOSE_BACKGND 2 // Restore to background color. The area used by the |
| // graphic must be restored to the background color. |
| |
| #define GIF_DISPOSE_RESTORE 3 // Restore to previous. The decoder is required to |
| // restore the area overwritten by the graphic with |
| // what was there prior to rendering the graphic. |
| |
| static const char szNetscape20ext[11] = "NETSCAPE2.0"; |
| |
| #define NSEXT_LOOP 0x01 // Loop Count field code |
| |
| // convert libungif samples to our ones |
| #define MAKE_QUAD_GIF(c,a) MAKE_QUAD((c).Red, (c).Green, (c).Blue, (a)) |
| |
| /* stdio FILE* and memory input functions for libungif */ |
| int |
| SplashStreamGifInputFunc(GifFileType * gif, GifByteType * buf, int n) |
| { |
| SplashStream* io = (SplashStream*)gif->UserData; |
| int rc = io->read(io, buf, n); |
| return rc; |
| } |
| |
| /* These macro help to ensure that we only take part of frame that fits into |
| logical screen. */ |
| |
| /* Ensure that p belongs to [pmin, pmax) interval. Returns fixed point (if fix is needed) */ |
| #define FIX_POINT(p, pmin, pmax) ( ((p) < (pmin)) ? (pmin) : (((p) > (pmax)) ? (pmax) : (p))) |
| /* Ensures that line starting at point p does not exceed boundary pmax. |
| Returns fixed length (if fix is needed) */ |
| #define FIX_LENGTH(p, len, pmax) ( ((p) + (len)) > (pmax) ? ((pmax) - (p)) : (len)) |
| |
| int |
| SplashDecodeGif(Splash * splash, GifFileType * gif) |
| { |
| int stride; |
| int bufferSize; |
| byte_t *pBitmapBits, *pOldBitmapBits; |
| int i, j; |
| int imageIndex; |
| int cx, cy, cw, ch; /* clamped coordinates */ |
| const int interlacedOffset[] = { 0, 4, 2, 1, 0 }; /* The way Interlaced image should. */ |
| const int interlacedJumps[] = { 8, 8, 4, 2, 1 }; /* be read - offsets and jumps... */ |
| |
| if (DGifSlurp(gif) == GIF_ERROR) { |
| return 0; |
| } |
| |
| SplashCleanup(splash); |
| |
| if (!SAFE_TO_ALLOC(gif->SWidth, splash->imageFormat.depthBytes)) { |
| return 0; |
| } |
| stride = gif->SWidth * splash->imageFormat.depthBytes; |
| if (splash->byteAlignment > 1) |
| stride = |
| (stride + splash->byteAlignment - 1) & ~(splash->byteAlignment - 1); |
| |
| if (!SAFE_TO_ALLOC(gif->SHeight, stride)) { |
| return 0; |
| } |
| |
| if (!SAFE_TO_ALLOC(gif->ImageCount, sizeof(SplashImage*))) { |
| return 0; |
| } |
| bufferSize = stride * gif->SHeight; |
| pBitmapBits = (byte_t *) malloc(bufferSize); |
| if (!pBitmapBits) { |
| return 0; |
| } |
| pOldBitmapBits = (byte_t *) malloc(bufferSize); |
| if (!pOldBitmapBits) { |
| free(pBitmapBits); |
| return 0; |
| } |
| memset(pBitmapBits, 0, bufferSize); |
| |
| splash->width = gif->SWidth; |
| splash->height = gif->SHeight; |
| splash->frameCount = gif->ImageCount; |
| splash->frames = (SplashImage *) |
| malloc(sizeof(SplashImage) * gif->ImageCount); |
| if (!splash->frames) { |
| free(pBitmapBits); |
| free(pOldBitmapBits); |
| return 0; |
| } |
| memset(splash->frames, 0, sizeof(SplashImage) * gif->ImageCount); |
| splash->loopCount = 1; |
| |
| for (imageIndex = 0; imageIndex < gif->ImageCount; imageIndex++) { |
| SavedImage *image = &(gif->SavedImages[imageIndex]); |
| GifImageDesc *desc = &(image->ImageDesc); |
| ColorMapObject *colorMap = |
| desc->ColorMap ? desc->ColorMap : gif->SColorMap; |
| |
| int transparentColor = -1; |
| int frameDelay = 100; |
| int disposeMethod = GIF_DISPOSE_RESTORE; |
| int colorCount = 0; |
| rgbquad_t colorMapBuf[SPLASH_COLOR_MAP_SIZE]; |
| |
| cx = FIX_POINT(desc->Left, 0, gif->SWidth); |
| cy = FIX_POINT(desc->Top, 0, gif->SHeight); |
| cw = FIX_LENGTH(desc->Left, desc->Width, gif->SWidth); |
| ch = FIX_LENGTH(desc->Top, desc->Height, gif->SHeight); |
| |
| if (colorMap) { |
| if (colorMap->ColorCount <= SPLASH_COLOR_MAP_SIZE) { |
| colorCount = colorMap->ColorCount; |
| } else { |
| colorCount = SPLASH_COLOR_MAP_SIZE; |
| } |
| } |
| |
| /* the code below is loosely based around gif extension processing from win32 libungif sample */ |
| |
| for (i = 0; i < image->ExtensionBlockCount; i++) { |
| byte_t *pExtension = (byte_t *) image->ExtensionBlocks[i].Bytes; |
| unsigned size = image->ExtensionBlocks[i].ByteCount; |
| |
| switch (image->ExtensionBlocks[i].Function) { |
| case GRAPHICS_EXT_FUNC_CODE: |
| { |
| int flag = pExtension[0]; |
| |
| frameDelay = (pExtension[2] << 8) | pExtension[1]; |
| if (frameDelay < 10) |
| frameDelay = 10; |
| if (flag & GIF_TRANSPARENT) { |
| transparentColor = pExtension[3]; |
| } else { |
| transparentColor = GIF_NOT_TRANSPARENT; |
| } |
| disposeMethod = |
| (flag >> GIF_DISPOSE_SHIFT) & GIF_DISPOSE_MASK; |
| break; |
| } |
| case APPLICATION_EXT_FUNC_CODE: |
| { |
| if (size == sizeof(szNetscape20ext) |
| && memcmp(pExtension, szNetscape20ext, size) == 0) { |
| int iSubCode; |
| |
| if (++i >= image->ExtensionBlockCount) |
| break; |
| pExtension = (byte_t *) image->ExtensionBlocks[i].Bytes; |
| if (image->ExtensionBlocks[i].ByteCount != 3) |
| break; |
| iSubCode = pExtension[0] & 0x07; |
| if (iSubCode == NSEXT_LOOP) { |
| splash->loopCount = |
| (pExtension[1] | (pExtension[2] << 8)) - 1; |
| } |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| if (colorMap) { |
| for (i = 0; i < colorCount; i++) { |
| colorMapBuf[i] = MAKE_QUAD_GIF(colorMap->Colors[i], 0xff); |
| } |
| } |
| { |
| |
| byte_t *pSrc = image->RasterBits; |
| ImageFormat srcFormat; |
| ImageRect srcRect, dstRect; |
| int pass, npass; |
| |
| if (desc->Interlace) { |
| pass = 0; |
| npass = 4; |
| } |
| else { |
| pass = 4; |
| npass = 5; |
| } |
| |
| srcFormat.colorMap = colorMapBuf; |
| srcFormat.depthBytes = 1; |
| srcFormat.byteOrder = BYTE_ORDER_NATIVE; |
| srcFormat.transparentColor = transparentColor; |
| srcFormat.fixedBits = QUAD_ALPHA_MASK; // fixed 100% alpha |
| srcFormat.premultiplied = 0; |
| |
| for (; pass < npass; ++pass) { |
| int jump = interlacedJumps[pass]; |
| int ofs = interlacedOffset[pass]; |
| /* Number of source lines for current pass */ |
| 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, |
| desc->Width, pSrc, &srcFormat); |
| |
| if (numLines > 0) { |
| initRect(&dstRect, cx, cy + ofs, cw, |
| numLines , jump, stride, pBitmapBits, &splash->imageFormat); |
| |
| pSrc += convertRect(&srcRect, &dstRect, CVT_ALPHATEST); |
| } |
| // skip extra source data |
| pSrc += (numPassLines - numLines) * srcRect.stride; |
| } |
| } |
| |
| // now dispose of the previous frame correctly |
| |
| splash->frames[imageIndex].bitmapBits = |
| (rgbquad_t *) malloc(bufferSize); |
| if (!splash->frames[imageIndex].bitmapBits) { |
| free(pBitmapBits); |
| free(pOldBitmapBits); |
| /* Assuming that callee will take care of splash frames we have already allocated */ |
| return 0; |
| } |
| memcpy(splash->frames[imageIndex].bitmapBits, pBitmapBits, bufferSize); |
| |
| SplashInitFrameShape(splash, imageIndex); |
| |
| splash->frames[imageIndex].delay = frameDelay * 10; // 100ths of second to milliseconds |
| switch (disposeMethod) { |
| case GIF_DISPOSE_LEAVE: |
| memcpy(pOldBitmapBits, pBitmapBits, bufferSize); |
| break; |
| case GIF_DISPOSE_NONE: |
| break; |
| case GIF_DISPOSE_BACKGND: |
| { |
| ImageRect dstRect; |
| rgbquad_t fillColor = 0; // 0 is transparent |
| |
| if (transparentColor > 0) { |
| fillColor= MAKE_QUAD_GIF( |
| colorMap->Colors[gif->SBackGroundColor], 0xff); |
| } |
| initRect(&dstRect, |
| cx, cy, cw, ch, |
| 1, stride, |
| pBitmapBits, &splash->imageFormat); |
| fillRect(fillColor, &dstRect); |
| } |
| break; |
| case GIF_DISPOSE_RESTORE: |
| { |
| int lineSize = cw * splash->imageFormat.depthBytes; |
| if (lineSize > 0) { |
| int lineOffset = cx * splash->imageFormat.depthBytes; |
| int lineIndex = cy * stride + lineOffset; |
| for (j=0; j<ch; j++) { |
| memcpy(pBitmapBits + lineIndex, pOldBitmapBits + lineIndex, |
| lineSize); |
| lineIndex += stride; |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| free(pBitmapBits); |
| free(pOldBitmapBits); |
| |
| DGifCloseFile(gif); |
| |
| return 1; |
| } |
| |
| int |
| SplashDecodeGifStream(Splash * splash, SplashStream * stream) |
| { |
| GifFileType *gif = DGifOpen((void *) stream, SplashStreamGifInputFunc); |
| |
| if (!gif) |
| return 0; |
| return SplashDecodeGif(splash, gif); |
| } |
