circuitpython/shared-module/displayio/gif.c

994 lines
39 KiB
C

//
// GIF Animator
// written by Larry Bank
// bitbank@pobox.com
// Arduino port started 7/5/2020
// Original GIF code written 20+ years ago :)
// The goal of this code is to decode images up to 480x320
// using no more than 22K of RAM (if sent directly to an LCD display)
//
// Copyright 2020 BitBank Software, Inc. All Rights Reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ===========================================================================
#define __LINUX__
#include "AnimatedGIF_circuitpy.h"
#include "py/mperrno.h"
#include "py/runtime.h"
#ifdef HAL_ESP32_HAL_H_
#define memcpy_P memcpy
#endif
static const unsigned char cGIFBits[9] = {1,4,4,4,8,8,8,8,8}; // convert odd bpp values to ones we can handle
// forward references
static int GIFInit(GIFIMAGE *pGIF);
static int GIFParseInfo(GIFIMAGE *pPage, int bInfoOnly);
static int GIFGetMoreData(GIFIMAGE *pPage);
static void GIFMakePels(GIFIMAGE *pPage, unsigned int code);
static int DecodeLZW(GIFIMAGE *pImage, int iOptions);
static int32_t readMem(GIFFILE *pFile, uint8_t *pBuf, int32_t iLen);
static int32_t seekMem(GIFFILE *pFile, int32_t iPosition);
int GIF_getInfo(GIFIMAGE *pPage, GIFINFO *pInfo);
#if defined(PICO_BUILD) || defined(__LINUX__) || defined(__MCUXPRESSO)
static int32_t readFile(GIFFILE *pFile, uint8_t *pBuf, int32_t iLen);
static int32_t seekFile(GIFFILE *pFile, int32_t iPosition);
static void closeFile(void *handle);
// C API
int GIF_openRAM(GIFIMAGE *pGIF, uint8_t *pData, int iDataSize, GIF_DRAW_CALLBACK *pfnDraw) {
pGIF->iError = GIF_SUCCESS;
pGIF->pfnRead = readMem;
pGIF->pfnSeek = seekMem;
pGIF->pfnDraw = pfnDraw;
pGIF->pfnOpen = NULL;
pGIF->pfnClose = NULL;
pGIF->GIFFile.iSize = iDataSize;
pGIF->GIFFile.pData = pData;
return GIFInit(pGIF);
} /* GIF_openRAM() */
#ifdef __LINUX__
int GIF_openFile(GIFIMAGE *pGIF, const char *szFilename, GIF_DRAW_CALLBACK *pfnDraw) {
pGIF->iError = GIF_SUCCESS;
pGIF->pfnRead = readFile;
pGIF->pfnSeek = seekFile;
pGIF->pfnDraw = pfnDraw;
pGIF->pfnOpen = NULL;
pGIF->pfnClose = closeFile;
pGIF->GIFFile.fHandle = fopen(szFilename, "r+b");
if (pGIF->GIFFile.fHandle == NULL) {
return 0;
}
fseek((FILE *)pGIF->GIFFile.fHandle, 0, SEEK_END);
pGIF->GIFFile.iSize = (int)ftell((FILE *)pGIF->GIFFile.fHandle);
fseek((FILE *)pGIF->GIFFile.fHandle, 0, SEEK_SET);
return GIFInit(pGIF);
} /* GIF_openFile() */
#endif
void GIF_close(GIFIMAGE *pGIF) {
if (pGIF->pfnClose) {
(*pGIF->pfnClose)(pGIF->GIFFile.fHandle);
}
} /* GIF_close() */
void GIF_begin(GIFIMAGE *pGIF, unsigned char ucPaletteType) {
memset(pGIF, 0, sizeof(GIFIMAGE));
pGIF->ucPaletteType = ucPaletteType;
} /* GIF_begin() */
void GIF_reset(GIFIMAGE *pGIF) {
(*pGIF->pfnSeek)(&pGIF->GIFFile, 0);
} /* GIF_reset() */
//
// Return value:
// 1 = good decode, more frames exist
// 0 = good decode, no more frames
// -1 = error
//
int GIF_playFrame(GIFIMAGE *pGIF, int *delayMilliseconds, void *pUser) {
int rc;
if (delayMilliseconds) {
*delayMilliseconds = 0; // clear any old valid
}
if (pGIF->GIFFile.iPos >= pGIF->GIFFile.iSize - 1) { // no more data exists
(*pGIF->pfnSeek)(&pGIF->GIFFile, 0); // seek to start
}
if (GIFParseInfo(pGIF, 0)) {
pGIF->pUser = pUser;
if (pGIF->iError == GIF_EMPTY_FRAME) { // don't try to decode it
return 0;
}
rc = DecodeLZW(pGIF, 0);
if (rc != 0) { // problem
return 0;
}
} else {
return 0; // error parsing the frame info, we may be at the end of the file
}
// Return 1 for more frames or 0 if this was the last frame
if (delayMilliseconds) { // if not NULL, return the frame delay time
*delayMilliseconds = pGIF->iFrameDelay;
}
return pGIF->GIFFile.iPos < pGIF->GIFFile.iSize - 1;
} /* GIF_playFrame() */
int GIF_getCanvasWidth(GIFIMAGE *pGIF) {
return pGIF->iCanvasWidth;
} /* GIF_getCanvasWidth() */
int GIF_getCanvasHeight(GIFIMAGE *pGIF) {
return pGIF->iCanvasHeight;
} /* GIF_getCanvasHeight() */
int GIF_getLoopCount(GIFIMAGE *pGIF) {
return pGIF->iRepeatCount;
} /* GIF_getLoopCount() */
int GIF_getComment(GIFIMAGE *pGIF, char *pDest) {
int32_t iOldPos;
iOldPos = pGIF->GIFFile.iPos; // keep old position
(*pGIF->pfnSeek)(&pGIF->GIFFile, pGIF->iCommentPos);
(*pGIF->pfnRead)(&pGIF->GIFFile, (uint8_t *)pDest, pGIF->sCommentLen);
(*pGIF->pfnSeek)(&pGIF->GIFFile, iOldPos);
pDest[pGIF->sCommentLen] = 0; // zero terminate the string
return (int)pGIF->sCommentLen;
} /* GIF_getComment() */
int GIF_getLastError(GIFIMAGE *pGIF) {
return pGIF->iError;
} /* GIF_getLastError() */
int GIF_init(GIFIMAGE *pGIF) {
return GIFInit(pGIF);
}
#endif // !__cplusplus
//
// Helper functions for memory based images
//
static int32_t readMem(GIFFILE *pFile, uint8_t *pBuf, int32_t iLen) {
int32_t iBytesRead;
iBytesRead = iLen;
if ((pFile->iSize - pFile->iPos) < iLen) {
iBytesRead = pFile->iSize - pFile->iPos;
}
if (iBytesRead <= 0) {
return 0;
}
memmove(pBuf, &pFile->pData[pFile->iPos], iBytesRead);
pFile->iPos += iBytesRead;
return iBytesRead;
} /* readMem() */
/*
static int32_t readFLASH(GIFFILE *pFile, uint8_t *pBuf, int32_t iLen)
{
int32_t iBytesRead;
iBytesRead = iLen;
if ((pFile->iSize - pFile->iPos) < iLen)
iBytesRead = pFile->iSize - pFile->iPos;
if (iBytesRead <= 0)
return 0;
memcpy_P(pBuf, &pFile->pData[pFile->iPos], iBytesRead);
pFile->iPos += iBytesRead;
return iBytesRead;
} *//* readFLASH() */
static int32_t seekMem(GIFFILE *pFile, int32_t iPosition) {
if (iPosition < 0) {
iPosition = 0;
} else if (iPosition >= pFile->iSize) {
iPosition = pFile->iSize - 1;
}
pFile->iPos = iPosition;
return iPosition;
} /* seekMem() */
#if defined(__LINUX__) || defined(__MCUXPRESSO)
static void closeFile(void *handle) {
fclose((FILE *)handle);
} /* closeFile() */
static int32_t seekFile(GIFFILE *pFile, int32_t iPosition) {
if (iPosition < 0) {
iPosition = 0;
} else if (iPosition >= pFile->iSize) {
iPosition = pFile->iSize - 1;
}
pFile->iPos = iPosition;
fseek((FILE *)pFile->fHandle, iPosition, SEEK_SET);
return iPosition;
} /* seekMem() */
static int32_t readFile(GIFFILE *pFile, uint8_t *pBuf, int32_t iLen) {
int32_t iBytesRead;
iBytesRead = iLen;
if ((pFile->iSize - pFile->iPos) < iLen) {
iBytesRead = pFile->iSize - pFile->iPos;
}
if (iBytesRead <= 0) {
return 0;
}
iBytesRead = (int)fread(pBuf, 1, iBytesRead, (FILE *)pFile->fHandle);
pFile->iPos += iBytesRead;
return iBytesRead;
} /* readFile() */
#endif // __LINUX__
//
// The following functions are written in plain C and have no
// 3rd party dependencies, not even the C runtime library
//
//
// Initialize a GIF file and callback access from a file on SD or memory
// returns 1 for success, 0 for failure
// Fills in the canvas size of the GIFIMAGE structure
//
static int GIFInit(GIFIMAGE *pGIF) {
pGIF->GIFFile.iPos = 0; // start at beginning of file
if (!GIFParseInfo(pGIF, 1)) { // gather info for the first frame
return 0; // something went wrong; not a GIF file?
}
(*pGIF->pfnSeek)(&pGIF->GIFFile, 0); // seek back to start of the file
if (pGIF->iCanvasWidth > MAX_WIDTH) { // need to allocate more space
pGIF->iError = GIF_TOO_WIDE;
return 0;
}
return 1;
} /* GIFInit() */
//
// Parse the GIF header, gather the size and palette info
// If called with bInfoOnly set to true, it will test for a valid file
// and return the canvas size only
// Returns 1 for success, 0 for failure
//
static int GIFParseInfo(GIFIMAGE *pPage, int bInfoOnly) {
int i, j, iColorTableBits;
int iBytesRead;
unsigned char c, *p;
int32_t iOffset = 0;
int32_t iStartPos = pPage->GIFFile.iPos; // starting file position
int iReadSize;
pPage->bUseLocalPalette = 0; // assume no local palette
pPage->bEndOfFrame = 0; // we're just getting started
pPage->iFrameDelay = 0; // may not have a gfx extension block
pPage->iRepeatCount = -1; // assume NETSCAPE loop count is not specified
iReadSize = (bInfoOnly) ? 12 : MAX_CHUNK_SIZE;
// If you try to read past the EOF, the SD lib will return garbage data
if (iStartPos + iReadSize > pPage->GIFFile.iSize) {
iReadSize = (pPage->GIFFile.iSize - iStartPos - 1);
}
p = pPage->ucFileBuf;
iBytesRead = (*pPage->pfnRead)(&pPage->GIFFile, pPage->ucFileBuf, iReadSize); // 255 is plenty for now
if (iBytesRead != iReadSize) { // we're at the end of the file
pPage->iError = GIF_EARLY_EOF;
return 0;
}
if (iStartPos == 0) { // start of the file
// canvas size
if (memcmp(p, "GIF89", 5) != 0 && memcmp(p, "GIF87", 5) != 0) { // not a GIF file
pPage->iError = GIF_BAD_FILE;
return 0;
}
pPage->iCanvasWidth = pPage->iWidth = INTELSHORT(&p[6]);
pPage->iCanvasHeight = pPage->iHeight = INTELSHORT(&p[8]);
pPage->iBpp = ((p[10] & 0x70) >> 4) + 1;
if (bInfoOnly) {
return 1; // we've got the info we needed, leave
}
iColorTableBits = (p[10] & 7) + 1; // Log2(size) of the color table
pPage->ucBackground = p[11]; // background color
pPage->ucGIFBits = 0;
iOffset = 13;
if (p[10] & 0x80) { // global color table?
// by default, convert to byte-reversed RGB565 for immediate use
// Read enough additional data for the color table
iBytesRead += (*pPage->pfnRead)(&pPage->GIFFile, &pPage->ucFileBuf[iBytesRead], 3 * (1 << iColorTableBits));
if (pPage->ucPaletteType == GIF_PALETTE_RGB565_LE || pPage->ucPaletteType == GIF_PALETTE_RGB565_BE) {
for (i = 0; i < (1 << iColorTableBits); i++)
{
uint16_t usRGB565;
usRGB565 = ((p[iOffset] >> 3) << 11); // R
usRGB565 |= ((p[iOffset + 1] >> 2) << 5); // G
usRGB565 |= (p[iOffset + 2] >> 3); // B
if (pPage->ucPaletteType == GIF_PALETTE_RGB565_LE) {
pPage->pPalette[i] = usRGB565;
} else {
pPage->pPalette[i] = __builtin_bswap16(usRGB565); // SPI wants MSB first
}
iOffset += 3;
}
} else { // just copy it as-is
memcpy(pPage->pPalette, &p[iOffset], (1 << iColorTableBits) * 3);
iOffset += (1 << iColorTableBits) * 3;
}
}
}
while (p[iOffset] != ',' && p[iOffset] != ';') { /* Wait for image separator */
if (p[iOffset] == '!') { /* Extension block */
iOffset++;
switch (p[iOffset++]) /* Block type */
{
case 0xf9: /* Graphic extension */
if (p[iOffset] == 4) { // correct length
pPage->ucGIFBits = p[iOffset + 1]; // packed fields
pPage->iFrameDelay = (INTELSHORT(&p[iOffset + 2])) * 10; // delay in ms
if (pPage->iFrameDelay <= 1) { // 0-1 is going to make it run at 60fps; use 100 (10fps) as a reasonable substitute
pPage->iFrameDelay = 100;
}
if (pPage->ucGIFBits & 1) { // transparent color is used
pPage->ucTransparent = p[iOffset + 4]; // transparent color index
}
iOffset += 6;
}
// else // error
break;
case 0xff: /* App extension */
c = 1;
while (c) { /* Skip all data sub-blocks */
c = p[iOffset++]; /* Block length */
if ((iBytesRead - iOffset) < (c + 32)) { // need to read more data first
memmove(pPage->ucFileBuf, &pPage->ucFileBuf[iOffset], (iBytesRead - iOffset)); // move existing data down
iBytesRead -= iOffset;
iStartPos += iOffset;
iOffset = 0;
iBytesRead += (*pPage->pfnRead)(&pPage->GIFFile, &pPage->ucFileBuf[iBytesRead], c + 32);
}
if (c == 11) { // fixed block length
// Netscape app block contains the repeat count
if (memcmp(&p[iOffset], "NETSCAPE2.0", 11) == 0) {
if (p[iOffset + 11] == 3 && p[iOffset + 12] == 1) { // loop count
pPage->iRepeatCount = INTELSHORT(&p[iOffset + 13]);
}
}
}
iOffset += (int)c; /* Skip to next sub-block */
}
break;
case 0x01: /* Text extension */
c = 1;
j = 0;
while (c) { /* Skip all data sub-blocks */
c = p[iOffset++]; /* Block length */
if (j == 0) { // use only first block
j = c;
if (j > 127) { // max comment length = 127
j = 127;
}
// memcpy(pPage->szInfo1, &p[iOffset], j);
// pPage->szInfo1[j] = '\0';
j = 1;
}
iOffset += (int)c; /* Skip this sub-block */
}
break;
case 0xfe: /* Comment */
c = 1;
while (c) { /* Skip all data sub-blocks */
c = p[iOffset++]; /* Block length */
if ((iBytesRead - iOffset) < (c + 32)) { // need to read more data first
memmove(pPage->ucFileBuf, &pPage->ucFileBuf[iOffset], (iBytesRead - iOffset)); // move existing data down
iBytesRead -= iOffset;
iStartPos += iOffset;
iOffset = 0;
iBytesRead += (*pPage->pfnRead)(&pPage->GIFFile, &pPage->ucFileBuf[iBytesRead], c + 32);
}
if (pPage->iCommentPos == 0) { // Save first block info
pPage->iCommentPos = iStartPos + iOffset;
pPage->sCommentLen = c;
}
iOffset += (int)c; /* Skip this sub-block */
}
break;
default:
/* Bad header info */
pPage->iError = GIF_DECODE_ERROR;
return 0;
} /* switch */
} else { // invalid byte, stop decoding
if (pPage->GIFFile.iSize - iStartPos < 32) { // non-image bytes at end of file?
pPage->iError = GIF_EMPTY_FRAME;
} else {
/* Bad header info */
pPage->iError = GIF_DECODE_ERROR;
}
return 0;
}
} /* while */
if (p[iOffset] == ';') { // end of file, quit and return a correct error code
pPage->iError = GIF_EMPTY_FRAME;
return 1;
}
if (p[iOffset] == ',') {
iOffset++;
}
// This particular frame's size and position on the main frame (if animated)
pPage->iX = INTELSHORT(&p[iOffset]);
pPage->iY = INTELSHORT(&p[iOffset + 2]);
pPage->iWidth = INTELSHORT(&p[iOffset + 4]);
pPage->iHeight = INTELSHORT(&p[iOffset + 6]);
iOffset += 8;
/* Image descriptor
7 6 5 4 3 2 1 0 M=0 - use global color map, ignore pixel
M I 0 0 0 pixel M=1 - local color map follows, use pixel
I=0 - Image in sequential order
I=1 - Image in interlaced order
pixel+1 = # bits per pixel for this image
*/
pPage->ucMap = p[iOffset++];
if (pPage->ucMap & 0x80) { // local color table?
// by default, convert to byte-reversed RGB565 for immediate use
j = (1 << ((pPage->ucMap & 7) + 1));
// Read enough additional data for the color table
iBytesRead += (*pPage->pfnRead)(&pPage->GIFFile, &pPage->ucFileBuf[iBytesRead], j *3);
if (pPage->ucPaletteType == GIF_PALETTE_RGB565_LE || pPage->ucPaletteType == GIF_PALETTE_RGB565_BE) {
for (i = 0; i < j; i++)
{
uint16_t usRGB565;
usRGB565 = ((p[iOffset] >> 3) << 11); // R
usRGB565 |= ((p[iOffset + 1] >> 2) << 5); // G
usRGB565 |= (p[iOffset + 2] >> 3); // B
if (pPage->ucPaletteType == GIF_PALETTE_RGB565_LE) {
pPage->pLocalPalette[i] = usRGB565;
} else {
pPage->pLocalPalette[i] = __builtin_bswap16(usRGB565); // SPI wants MSB first
}
iOffset += 3;
}
} else { // just copy it as-is
memcpy(pPage->pLocalPalette, &p[iOffset], j * 3);
iOffset += j * 3;
}
pPage->bUseLocalPalette = 1;
}
pPage->ucCodeStart = p[iOffset++]; /* initial code size */
/* Since GIF can be 1-8 bpp, we only allow 1,4,8 */
pPage->iBpp = cGIFBits[pPage->ucCodeStart];
// we are re-using the same buffer turning GIF file data
// into "pure" LZW
pPage->iLZWSize = 0; // we're starting with no LZW data yet
c = 1; // get chunk length
while (c && iOffset < iBytesRead) {
// Serial.printf("iOffset=%d, iBytesRead=%d\n", iOffset, iBytesRead);
c = p[iOffset++]; // get chunk length
// Serial.printf("Chunk size = %d\n", c);
if (c <= (iBytesRead - iOffset)) {
memcpy(&pPage->ucLZW[pPage->iLZWSize], &p[iOffset], c);
pPage->iLZWSize += c;
iOffset += c;
} else { // partial chunk in our buffer
int iPartialLen = (iBytesRead - iOffset);
memcpy(&pPage->ucLZW[pPage->iLZWSize], &p[iOffset], iPartialLen);
pPage->iLZWSize += iPartialLen;
iOffset += iPartialLen;
(*pPage->pfnRead)(&pPage->GIFFile, &pPage->ucLZW[pPage->iLZWSize], c - iPartialLen);
pPage->iLZWSize += (c - iPartialLen);
}
if (c == 0) {
pPage->bEndOfFrame = 1; // signal not to read beyond the end of the frame
}
}
// seeking on an SD card is VERY VERY SLOW, so use the data we've already read by de-chunking it
// in this case, there's too much data, so we have to seek backwards a bit
if (iOffset < iBytesRead) {
// Serial.printf("Need to seek back %d bytes\n", iBytesRead - iOffset);
(*pPage->pfnSeek)(&pPage->GIFFile, iStartPos + iOffset); // position file to new spot
}
return 1; // we are now at the start of the chunk data
} /* GIFParseInfo() */
//
// Gather info about an animated GIF file
//
int GIF_getInfo(GIFIMAGE *pPage, GIFINFO *pInfo) {
int iOff, iNumFrames;
int iDelay, iMaxDelay, iMinDelay, iTotalDelay;
int iReadAmount;
int iDataAvailable = 0;
int iDataRemaining = 0;
uint32_t lFileOff = 0;
int bDone = 0;
int bExt;
uint8_t c, *cBuf;
iMaxDelay = iTotalDelay = 0;
iMinDelay = 10000;
iNumFrames = 1;
iDataRemaining = pPage->GIFFile.iSize;
cBuf = (uint8_t *)pPage->ucFileBuf;
(*pPage->pfnSeek)(&pPage->GIFFile, 0);
iDataAvailable = (*pPage->pfnRead)(&pPage->GIFFile, cBuf, FILE_BUF_SIZE);
iDataRemaining -= iDataAvailable;
lFileOff += iDataAvailable;
iOff = 10;
c = cBuf[iOff]; // get info bits
iOff += 3; /* Skip flags, background color & aspect ratio */
if (c & 0x80) { /* Deal with global color table */
c &= 7; /* Get the number of colors defined */
iOff += (2 << c) * 3; /* skip color table */
}
while (!bDone) { // && iNumFrames < MAX_FRAMES)
bExt = 1; /* skip extension blocks */
while (bExt && iOff < iDataAvailable) {
if ((iDataAvailable - iOff) < 258) { // need to read more data first
memmove(cBuf, &cBuf[iOff], (iDataAvailable - iOff)); // move existing data down
iDataAvailable -= iOff;
iOff = 0;
iReadAmount = (*pPage->pfnRead)(&pPage->GIFFile, &cBuf[iDataAvailable], FILE_BUF_SIZE - iDataAvailable);
iDataAvailable += iReadAmount;
iDataRemaining -= iReadAmount;
lFileOff += iReadAmount;
}
switch (cBuf[iOff])
{
case 0x3b: /* End of file */
/* we were fooled into thinking there were more pages */
iNumFrames--;
goto gifpagesz;
// F9 = Graphic Control Extension (fixed length of 4 bytes)
// FE = Comment Extension
// FF = Application Extension
// 01 = Plain Text Extension
case 0x21: /* Extension block */
if (cBuf[iOff + 1] == 0xf9 && cBuf[iOff + 2] == 4) { // Graphic Control Extension
// cBuf[iOff+3]; // page disposition flags
iDelay = cBuf[iOff + 4]; // delay low byte
iDelay |= ((uint16_t)(cBuf[iOff + 5]) << 8); // delay high byte
if (iDelay < 2) { // too fast, provide a default
iDelay = 2;
}
iDelay *= 10; // turn JIFFIES into milliseconds
iTotalDelay += iDelay;
if (iDelay > iMaxDelay) {
iMaxDelay = iDelay;
} else if (iDelay < iMinDelay) {
iMinDelay = iDelay;
}
// (cBuf[iOff+6]; // transparent color index
}
iOff += 2; /* skip to length */
iOff += (int)cBuf[iOff]; /* Skip the data block */
iOff++;
// block terminator or optional sub blocks
c = cBuf[iOff++]; /* Skip any sub-blocks */
while (c) {
iOff += (int)c;
c = cBuf[iOff++];
if ((iDataAvailable - iOff) < (c + 258)) { // need to read more data first
memmove(cBuf, &cBuf[iOff], (iDataAvailable - iOff)); // move existing data down
iDataAvailable -= iOff;
iOff = 0;
iReadAmount = (*pPage->pfnRead)(&pPage->GIFFile, &cBuf[iDataAvailable], FILE_BUF_SIZE - iDataAvailable);
iDataAvailable += iReadAmount;
iDataRemaining -= iReadAmount;
lFileOff += iReadAmount;
}
}
if (c != 0) { // problem, we went past the end
iNumFrames--; // possible corrupt data; stop
goto gifpagesz;
}
break;
case 0x2c: /* Start of image data */
bExt = 0; /* Stop doing extension blocks */
break;
default:
/* Corrupt data, stop here */
iNumFrames--;
goto gifpagesz;
} // switch
} // while
if (iOff >= iDataAvailable) { // problem
iNumFrames--; // possible corrupt data; stop
goto gifpagesz;
}
/* Start of image data */
c = cBuf[iOff + 9]; /* Get the flags byte */
iOff += 10; /* Skip image position and size */
if (c & 0x80) { /* Local color table */
c &= 7;
iOff += (2 << c) * 3;
}
iOff++; /* Skip LZW code size byte */
if ((iDataAvailable - iOff) < (c + 258)) { // need to read more data first
if (iOff < iDataAvailable) {
memmove(cBuf, &cBuf[iOff], (iDataAvailable - iOff)); // move existing data down
iDataAvailable -= iOff;
iOff = 0;
} else { // already points beyond end
iOff -= iDataAvailable;
iDataAvailable = 0;
}
iReadAmount = (*pPage->pfnRead)(&pPage->GIFFile, &cBuf[iDataAvailable], FILE_BUF_SIZE - iDataAvailable);
iDataAvailable += iReadAmount;
iDataRemaining -= iReadAmount;
lFileOff += iReadAmount;
}
c = cBuf[iOff++];
while (c) { /* While there are more data blocks */
if (iOff > (3 * FILE_BUF_SIZE / 4) && iDataRemaining > 0) { /* Near end of buffer, re-align */
memmove(cBuf, &cBuf[iOff], (iDataAvailable - iOff)); // move existing data down
iDataAvailable -= iOff;
iOff = 0;
iReadAmount = (FILE_BUF_SIZE - iDataAvailable);
if (iReadAmount > iDataRemaining) {
iReadAmount = iDataRemaining;
}
iReadAmount = (*pPage->pfnRead)(&pPage->GIFFile, &cBuf[iDataAvailable], iReadAmount);
iDataAvailable += iReadAmount;
iDataRemaining -= iReadAmount;
lFileOff += iReadAmount;
}
iOff += (int)c; /* Skip this data block */
// if ((int)lFileOff + iOff > pPage->GIFFile.iSize) // past end of file, stop
// {
// iNumFrames--; // don't count this page
// break; // last page is corrupted, don't use it
// }
c = cBuf[iOff++]; /* Get length of next */
}
/* End of image data, check for more pages... */
if (cBuf[iOff] == 0x3b || (iDataRemaining == 0 && (iDataAvailable - iOff) < 32)) {
bDone = 1; /* End of file has been reached */
} else { /* More pages to scan */
iNumFrames++;
// read new page data starting at this offset
if (pPage->GIFFile.iSize > FILE_BUF_SIZE && iDataRemaining > 0) { // since we didn't read the whole file in one shot
memmove(cBuf, &cBuf[iOff], (iDataAvailable - iOff)); // move existing data down
iDataAvailable -= iOff;
iOff = 0;
iReadAmount = (FILE_BUF_SIZE - iDataAvailable);
if (iReadAmount > iDataRemaining) {
iReadAmount = iDataRemaining;
}
iReadAmount = (*pPage->pfnRead)(&pPage->GIFFile, &cBuf[iDataAvailable], iReadAmount);
iDataAvailable += iReadAmount;
iDataRemaining -= iReadAmount;
lFileOff += iReadAmount;
}
}
} /* while !bDone */
gifpagesz:
pInfo->iFrameCount = iNumFrames;
pInfo->iMaxDelay = iMaxDelay;
pInfo->iMinDelay = iMinDelay;
pInfo->iDuration = iTotalDelay;
return 1;
} /* GIF_getInfo() */
//
// Unpack more chunk data for decoding
// returns 1 to signify more data available for this image
// 0 indicates there is no more data
//
static int GIFGetMoreData(GIFIMAGE *pPage) {
int iDelta = (pPage->iLZWSize - pPage->iLZWOff);
unsigned char c = 1;
// move any existing data down
if (pPage->bEndOfFrame || iDelta >= (LZW_BUF_SIZE - MAX_CHUNK_SIZE) || iDelta <= 0) {
return 1; // frame is finished or buffer is already full; no need to read more data
}
if (pPage->iLZWOff != 0) {
// NB: memcpy() fails on some systems because the src and dest ptrs overlap
// so copy the bytes in a simple loop to avoid problems
for (int i = 0; i < pPage->iLZWSize - pPage->iLZWOff; i++) {
pPage->ucLZW[i] = pPage->ucLZW[i + pPage->iLZWOff];
}
pPage->iLZWSize -= pPage->iLZWOff;
pPage->iLZWOff = 0;
}
while (c && pPage->GIFFile.iPos < pPage->GIFFile.iSize && pPage->iLZWSize < (LZW_BUF_SIZE - MAX_CHUNK_SIZE)) {
(*pPage->pfnRead)(&pPage->GIFFile, &c, 1); // current length
(*pPage->pfnRead)(&pPage->GIFFile, &pPage->ucLZW[pPage->iLZWSize], c);
pPage->iLZWSize += c;
}
if (c == 0) { // end of frame
pPage->bEndOfFrame = 1;
}
return c != 0 && pPage->GIFFile.iPos < pPage->GIFFile.iSize; // more data available?
} /* GIFGetMoreData() */
//
// Handle transparent pixels and disposal method
// Used only when a frame buffer is allocated
//
static void DrawNewPixels(GIFIMAGE *pPage, GIFDRAW *pDraw) {
uint8_t *d, *s;
int x, iPitch = pPage->iCanvasWidth;
s = pDraw->pPixels;
d = &pPage->pFrameBuffer[pDraw->iX + (pDraw->y + pDraw->iY) * iPitch]; // dest pointer in our complete canvas buffer
if (pDraw->ucDisposalMethod == 2) { // restore to background color
memset(d, pDraw->ucBackground, pDraw->iWidth);
}
// Apply the new pixels to the main image
if (pDraw->ucHasTransparency) { // if transparency used
uint8_t c, ucTransparent = pDraw->ucTransparent;
for (x = 0; x < pDraw->iWidth; x++)
{
c = *s++;
if (c != ucTransparent) {
*d = c;
}
d++;
}
} else {
memcpy(d, s, pDraw->iWidth); // just overwrite the old pixels
}
} /* DrawNewPixels() */
//
// Convert current line of pixels through the palette
// to either RGB565 or RGB888 output
// Used only when a frame buffer has been allocated
//
static void ConvertNewPixels(GIFIMAGE *pPage, GIFDRAW *pDraw) {
uint8_t *d, *s;
int x;
s = &pPage->pFrameBuffer[(pPage->iCanvasWidth * (pDraw->iY + pDraw->y)) + pDraw->iX];
d = &pPage->pFrameBuffer[pPage->iCanvasHeight * pPage->iCanvasWidth]; // point past bottom of frame buffer
if (pPage->ucPaletteType == GIF_PALETTE_RGB565_LE || pPage->ucPaletteType == GIF_PALETTE_RGB565_BE) {
uint16_t *pPal, *pu16;
pPal = (uint16_t *)pDraw->pPalette;
pu16 = (uint16_t *)d;
for (x = 0; x < pPage->iWidth; x++)
{
*pu16++ = pPal[*s++]; // convert to RGB565 pixels
}
} else {
uint8_t *pPal;
int pixel;
pPal = (uint8_t *)pDraw->pPalette;
for (x = 0; x < pPage->iWidth; x++)
{
pixel = *s++;
*d++ = pPal[(pixel * 3) + 0]; // convert to RGB888 pixels
*d++ = pPal[(pixel * 3) + 1];
*d++ = pPal[(pixel * 3) + 2];
}
}
} /* ConvertNewPixels() */
//
// GIFMakePels
//
static void GIFMakePels(GIFIMAGE *pPage, unsigned int code) {
int iPixCount;
unsigned short *giftabs;
unsigned char *buf, *s, *pEnd, *gifpels;
unsigned char ucNeedMore = 0;
/* Copy this string of sequential pixels to output buffer */
// iPixCount = 0;
s = pPage->ucFileBuf + FILE_BUF_SIZE; /* Pixels will come out in reversed order */
buf = pPage->ucLineBuf + (pPage->iWidth - pPage->iXCount);
giftabs = pPage->usGIFTable;
gifpels = &pPage->ucGIFPixels[PIXEL_LAST];
while (code < LINK_UNUSED) {
if (s == pPage->ucFileBuf) { /* Houston, we have a problem */
return; /* Exit with error */
}
*(--s) = gifpels[code];
code = giftabs[code];
}
iPixCount = (int)(intptr_t)(pPage->ucFileBuf + FILE_BUF_SIZE - s);
while (iPixCount && pPage->iYCount > 0) {
if (pPage->iXCount > iPixCount) { /* Pixels fit completely on the line */
// memcpy(buf, s, iPixCount);
// buf += iPixCount;
pEnd = buf + iPixCount;
while (buf < pEnd) {
*buf++ = *s++;
}
pPage->iXCount -= iPixCount;
// iPixCount = 0;
if (ucNeedMore) {
GIFGetMoreData(pPage); // check if we need to read more LZW data every 4 lines
}
return;
} else { /* Pixels cross into next line */
GIFDRAW gd;
pEnd = buf + pPage->iXCount;
while (buf < pEnd) {
*buf++ = *s++;
}
iPixCount -= pPage->iXCount;
pPage->iXCount = pPage->iWidth; /* Reset pixel count */
// Prepare GIDRAW structure for callback
gd.iX = pPage->iX;
gd.iY = pPage->iY;
gd.iWidth = pPage->iWidth;
gd.iHeight = pPage->iHeight;
gd.pPixels = pPage->ucLineBuf;
gd.pPalette = (pPage->bUseLocalPalette) ? pPage->pLocalPalette : pPage->pPalette;
gd.pPalette24 = (uint8_t *)gd.pPalette; // just cast the pointer for RGB888
gd.ucIsGlobalPalette = pPage->bUseLocalPalette == 1?0:1;
gd.y = pPage->iHeight - pPage->iYCount;
// Ugly logic to handle the interlaced line position, but it
// saves having to have another set of state variables
if (pPage->ucMap & 0x40) { // interlaced?
int height = pPage->iHeight - 1;
if (gd.y > height / 2) {
gd.y = gd.y * 2 - (height | 1);
} else if (gd.y > height / 4) {
gd.y = gd.y * 4 - ((height & ~1) | 2);
} else if (gd.y > height / 8) {
gd.y = gd.y * 8 - ((height & ~3) | 4);
} else {
gd.y = gd.y * 8;
}
}
gd.ucDisposalMethod = (pPage->ucGIFBits & 0x1c) >> 2;
gd.ucTransparent = pPage->ucTransparent;
gd.ucHasTransparency = pPage->ucGIFBits & 1;
gd.ucBackground = pPage->ucBackground;
gd.pUser = pPage->pUser;
if (pPage->pFrameBuffer) { // update the frame buffer
DrawNewPixels(pPage, &gd);
if (pPage->ucDrawType == GIF_DRAW_COOKED) {
ConvertNewPixels(pPage, &gd); // prepare for output
gd.pPixels = &pPage->pFrameBuffer[pPage->iCanvasWidth * pPage->iCanvasHeight];
}
}
(*pPage->pfnDraw)(&gd); // callback to handle this line
pPage->iYCount--;
buf = pPage->ucLineBuf;
if ((pPage->iYCount & 3) == 0) { // since we support only small images...
ucNeedMore = 1;
}
}
} /* while */
if (ucNeedMore) {
GIFGetMoreData(pPage); // check if we need to read more LZW data every 4 lines
}
return;
} /* GIFMakePels() */
//
// Macro to extract a variable length code
//
#define GET_CODE if (bitnum > (REGISTER_WIDTH - codesize)) { pImage->iLZWOff += (bitnum >> 3); \
bitnum &= 7; ulBits = INTELLONG(&p[pImage->iLZWOff]); } \
code = (unsigned short)(ulBits >> bitnum); /* Read a 32-bit chunk */ \
code &= sMask; bitnum += codesize;
//
// Decode LZW into an image
//
static int DecodeLZW(GIFIMAGE *pImage, int iOptions) {
int i, bitnum;
unsigned short oldcode, codesize, nextcode, nextlim;
unsigned short *giftabs, cc, eoi;
signed short sMask;
unsigned char *gifpels, *p;
// int iStripSize;
// unsigned char **index;
uint32_t ulBits;
unsigned short code;
(void)iOptions; // not used for now
// if output can be used for string table, do it faster
// if (bGIF && (OutPage->cBitsperpixel == 8 && ((OutPage->iWidth & 3) == 0)))
// return PILFastLZW(InPage, OutPage, bGIF, iOptions);
p = pImage->ucLZW; // un-chunked LZW data
sMask = 0xffff << (pImage->ucCodeStart + 1);
sMask = 0xffff - sMask;
cc = (sMask >> 1) + 1; /* Clear code */
eoi = cc + 1;
giftabs = pImage->usGIFTable;
gifpels = pImage->ucGIFPixels;
pImage->iYCount = pImage->iHeight; // count down the lines
pImage->iXCount = pImage->iWidth;
bitnum = 0;
pImage->iLZWOff = 0; // Offset into compressed data
GIFGetMoreData(pImage); // Read some data to start
// Initialize code table
// this part only needs to be initialized once
for (i = 0; i < cc; i++)
{
gifpels[PIXEL_FIRST + i] = gifpels[PIXEL_LAST + i] = (unsigned short)i;
giftabs[i] = LINK_END;
}
init_codetable:
codesize = pImage->ucCodeStart + 1;
sMask = 0xffff << (pImage->ucCodeStart + 1);
sMask = 0xffff - sMask;
nextcode = cc + 2;
nextlim = (unsigned short)((1 << codesize));
// This part of the table needs to be reset multiple times
memset(&giftabs[cc], LINK_UNUSED, (4096 - cc) * sizeof(short));
ulBits = INTELLONG(&p[pImage->iLZWOff]); // start by reading 4 bytes of LZW data
GET_CODE
if (code == cc) { // we just reset the dictionary, so get another code
GET_CODE
}
oldcode = code;
GIFMakePels(pImage, code); // first code is output as the first pixel
// Main decode loop
while (code != eoi && pImage->iYCount > 0) { // && y < pImage->iHeight+1) /* Loop through all lines of the image (or strip) */
GET_CODE
if (code == cc) { /* Clear code?, and not first code */
goto init_codetable;
}
if (code != eoi) {
if (nextcode < nextlim) { // for deferred cc case, don't let it overwrite the last entry (fff)
giftabs[nextcode] = oldcode;
gifpels[PIXEL_FIRST + nextcode] = gifpels[PIXEL_FIRST + oldcode];
if (giftabs[code] == LINK_UNUSED) { /* Old code */
gifpels[PIXEL_LAST + nextcode] = gifpels[PIXEL_FIRST + oldcode];
} else {
gifpels[PIXEL_LAST + nextcode] = gifpels[PIXEL_FIRST + code];
}
}
nextcode++;
if (nextcode >= nextlim && codesize < 12) {
codesize++;
nextlim <<= 1;
sMask = (sMask << 1) | 1;
}
GIFMakePels(pImage, code);
oldcode = code;
}
} /* while not end of LZW code stream */
return 0;
// gif_forced_error:
// free(pImage->pPixels);
// pImage->pPixels = NULL;
// return -1;
} /* DecodeLZW() */
void GIF_setDrawCallback(GIFIMAGE *pGIF, GIF_DRAW_CALLBACK *pfnDraw) {
pGIF->pfnDraw = pfnDraw;
} /* GIF_setDrawCallback() */
//
// Scale 2 scanlines down by 50% with pixel averaging
// writes new values over previous line
// expects RGB565 little endian pixels as input
//
void GIF_scaleHalf(uint16_t *pCurrent, uint16_t *pPrev, int iWidth, int bBigEndian) {
int x;
uint16_t *d = pPrev;
uint32_t gSum, rbSum, pix0,pix1,pix2,pix3;
const uint32_t RBMask = 0xf81f, GMask = 0x7e0;
for (x = 0; x < iWidth; x += 2)
{
pix0 = pCurrent[0];
pix1 = pCurrent[1];
pix2 = pPrev[0];
pix3 = pPrev[1];
pCurrent += 2;
pPrev += 2;
gSum = (pix0 & GMask) + (pix1 & GMask) + (pix2 & GMask) + (pix3 & GMask);
gSum = ((gSum + 0x40) >> 2) & GMask; // for rounding towards 1
rbSum = (pix0 & RBMask) + (pix1 & RBMask) + (pix2 & RBMask) + (pix3 & RBMask);
rbSum = ((rbSum + 0x1002) >> 2) & RBMask;
if (bBigEndian) {
*d++ = __builtin_bswap16((uint16_t)(gSum + rbSum));
} else {
*d++ = (uint16_t)(gSum + rbSum); // store finished pixel
}
} // for x
} /* GIF_scaleHalf() */