diff options
Diffstat (limited to 'src/main/jni/gif.c')
| -rw-r--r-- | src/main/jni/gif.c | 847 |
1 files changed, 847 insertions, 0 deletions
diff --git a/src/main/jni/gif.c b/src/main/jni/gif.c new file mode 100644 index 000000000..64dda4793 --- /dev/null +++ b/src/main/jni/gif.c @@ -0,0 +1,847 @@ +//thanks to https://github.com/koral--/android-gif-drawable +/* + MIT License + Copyright (c) + + 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. + + // Copyright (c) 2011 Google Inc. All rights reserved. + // + // Redistribution and use in source and binary forms, with or without + // modification, are permitted provided that the following conditions are + // met: + // + // * Redistributions of source code must retain the above copyright + // notice, this list of conditions and the following disclaimer. + // * Redistributions in binary form must reproduce the above + // copyright notice, this list of conditions and the following disclaimer + // in the documentation and/or other materials provided with the + // distribution. + // * Neither the name of Google Inc. nor the names of its + // contributors may be used to endorse or promote products derived from + // this software without specific prior written permission. + // + // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + The GIFLIB distribution is Copyright (c) 1997 Eric S. Raymond + */ + +#include <jni.h> +#include <stdio.h> +#include <time.h> +#include <limits.h> +#include "gif.h" +#include "giflib/gif_lib.h" + +#define D_GIF_ERR_NO_FRAMES 1000 +#define D_GIF_ERR_INVALID_SCR_DIMS 1001 +#define D_GIF_ERR_INVALID_IMG_DIMS 1002 +#define D_GIF_ERR_IMG_NOT_CONFINED 1003 + +typedef struct { + uint8_t blue; + uint8_t green; + uint8_t red; + uint8_t alpha; +} argb; + +typedef struct { + unsigned int duration; + int transpIndex; + unsigned char disposalMethod; +} FrameInfo; + +typedef struct { + GifFileType *gifFilePtr; + unsigned long lastFrameReaminder; + unsigned long nextStartTime; + int currentIndex; + unsigned int lastDrawIndex; + FrameInfo *infos; + argb *backupPtr; + int startPos; + unsigned char *rasterBits; + char *comment; + unsigned short loopCount; + int currentLoop; + jfloat speedFactor; +} GifInfo; + +static ColorMapObject *defaultCmap = NULL; + +static ColorMapObject *genDefColorMap(void) { + ColorMapObject *cmap = GifMakeMapObject(256, NULL); + if (cmap != NULL) { + int iColor; + for (iColor = 0; iColor < 256; iColor++) { + cmap->Colors[iColor].Red = (GifByteType) iColor; + cmap->Colors[iColor].Green = (GifByteType) iColor; + cmap->Colors[iColor].Blue = (GifByteType) iColor; + } + } + return cmap; +} + +jint gifOnJNILoad(JavaVM *vm, void *reserved, JNIEnv *env) { + defaultCmap = genDefColorMap(); + if (defaultCmap == NULL) { + return -1; + } + return JNI_VERSION_1_6; +} + +void gifOnJNIUnload(JavaVM *vm, void *reserved) { + GifFreeMapObject(defaultCmap); +} + +static int fileReadFunc(GifFileType *gif, GifByteType *bytes, int size) { + FILE *file = (FILE *)gif->UserData; + return fread(bytes, 1, size, file); +} + +static int fileRewindFun(GifInfo *info) { + return fseek(info->gifFilePtr->UserData, info->startPos, SEEK_SET); +} + +static unsigned long getRealTime() { + struct timespec ts; + const clockid_t id = CLOCK_MONOTONIC; + if (id != (clockid_t) - 1 && clock_gettime(id, &ts) != -1) { + return ts.tv_sec * 1000 + ts.tv_nsec / 1000000; + } + return -1; +} + +static void cleanUp(GifInfo *info) { + if (info->backupPtr) { + free(info->backupPtr); + info->backupPtr = NULL; + } + if (info->infos) { + free(info->infos); + info->infos = NULL; + } + if (info->rasterBits) { + free(info->rasterBits); + info->rasterBits = NULL; + } + if (info->comment) { + free(info->comment); + info->comment = NULL; + } + + GifFileType *GifFile = info->gifFilePtr; + if (GifFile->SColorMap == defaultCmap) { + GifFile->SColorMap = NULL; + } + if (GifFile->SavedImages != NULL) { + SavedImage *sp; + for (sp = GifFile->SavedImages; sp < GifFile->SavedImages + GifFile->ImageCount; sp++) { + if (sp->ImageDesc.ColorMap != NULL) { + GifFreeMapObject(sp->ImageDesc.ColorMap); + sp->ImageDesc.ColorMap = NULL; + } + } + free(GifFile->SavedImages); + GifFile->SavedImages = NULL; + } + DGifCloseFile(GifFile); + free(info); +} + +static int getComment(GifByteType *Bytes, char **cmt) { + unsigned int len = (unsigned int) Bytes[0]; + unsigned int offset = *cmt != NULL ? strlen(*cmt) : 0; + char *ret = realloc(*cmt, (len + offset + 1) * sizeof(char)); + if (ret != NULL) { + memcpy(ret + offset, &Bytes[1], len); + ret[len + offset] = 0; + *cmt = ret; + return GIF_OK; + } + return GIF_ERROR; +} + +static void packARGB32(argb *pixel, GifByteType alpha, GifByteType red, GifByteType green, GifByteType blue) { + pixel->alpha = alpha; + pixel->red = red; + pixel->green = green; + pixel->blue = blue; +} + +static void getColorFromTable(int idx, argb *dst, const ColorMapObject *cmap) { + int colIdx = (idx >= cmap->ColorCount) ? 0 : idx; + GifColorType *col = &cmap->Colors[colIdx]; + packARGB32(dst, 0xFF, col->Red, col->Green, col->Blue); +} + +static void eraseColor(argb *bm, int w, int h, argb color) { + int i; + for (i = 0; i < w * h; i++) { + *(bm + i) = color; + } +} + +static inline bool setupBackupBmp(GifInfo *info, short transpIndex) { + GifFileType *fGIF = info->gifFilePtr; + info->backupPtr = calloc(fGIF->SWidth * fGIF->SHeight, sizeof(argb)); + if (!info->backupPtr) { + info->gifFilePtr->Error = D_GIF_ERR_NOT_ENOUGH_MEM; + return false; + } + argb paintingColor; + if (transpIndex == -1) { + getColorFromTable(fGIF->SBackGroundColor, &paintingColor, fGIF->SColorMap); + } else { + packARGB32(&paintingColor, 0, 0, 0, 0); + } + eraseColor(info->backupPtr, fGIF->SWidth, fGIF->SHeight, paintingColor); + return true; +} + +static int readExtensions(int ExtFunction, GifByteType *ExtData, GifInfo *info) { + if (ExtData == NULL) { + return GIF_OK; + } + if (ExtFunction == GRAPHICS_EXT_FUNC_CODE && ExtData[0] == 4) { + FrameInfo *fi = &info->infos[info->gifFilePtr->ImageCount]; + fi->transpIndex = -1; + char *b = (char*) ExtData + 1; + short delay = ((b[2] << 8) | b[1]); + fi->duration = delay > 1 ? delay * 10 : 100; + fi->disposalMethod = ((b[0] >> 2) & 7); + if (ExtData[1] & 1) { + fi->transpIndex = 0xff & b[3]; + } + if (fi->disposalMethod == 3 && info->backupPtr == NULL) { + if (!setupBackupBmp(info, fi->transpIndex)) { + return GIF_ERROR; + } + } + } else if (ExtFunction == COMMENT_EXT_FUNC_CODE) { + if (getComment(ExtData, &info->comment) == GIF_ERROR) { + info->gifFilePtr->Error = D_GIF_ERR_NOT_ENOUGH_MEM; + return GIF_ERROR; + } + } else if (ExtFunction == APPLICATION_EXT_FUNC_CODE && ExtData[0] == 11) { + if (strncmp("NETSCAPE2.0", &ExtData[1], 11) == 0 || strncmp("ANIMEXTS1.0", &ExtData[1], 11) == 0) { + if (DGifGetExtensionNext(info->gifFilePtr, &ExtData, &ExtFunction) == GIF_ERROR) { + return GIF_ERROR; + } + if (ExtFunction == APPLICATION_EXT_FUNC_CODE && ExtData[0] == 3 && ExtData[1] == 1) { + info->loopCount = (unsigned short) (ExtData[2] + (ExtData[3] << 8)); + } + } + } + return GIF_OK; +} + +static int DDGifSlurp(GifFileType *GifFile, GifInfo* info, bool shouldDecode) { + GifRecordType RecordType; + GifByteType *ExtData; + int codeSize; + int ExtFunction; + size_t ImageSize; + do { + if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) { + return (GIF_ERROR); + } + switch (RecordType) { + case IMAGE_DESC_RECORD_TYPE: + + if (DGifGetImageDesc(GifFile, !shouldDecode) == GIF_ERROR) { + return (GIF_ERROR); + } + int i = shouldDecode ? info->currentIndex : GifFile->ImageCount - 1; + SavedImage *sp = &GifFile->SavedImages[i]; + ImageSize = sp->ImageDesc.Width * sp->ImageDesc.Height; + + if (sp->ImageDesc.Width < 1 || sp->ImageDesc.Height < 1 || ImageSize > (SIZE_MAX / sizeof(GifPixelType))) { + GifFile->Error = D_GIF_ERR_INVALID_IMG_DIMS; + return GIF_ERROR; + } + if (sp->ImageDesc.Width > GifFile->SWidth || sp->ImageDesc.Height > GifFile->SHeight) { + GifFile->Error = D_GIF_ERR_IMG_NOT_CONFINED; + return GIF_ERROR; + } + if (shouldDecode) { + sp->RasterBits = info->rasterBits; + if (sp->ImageDesc.Interlace) { + int i, j; + int InterlacedOffset[] = { 0, 4, 2, 1 }; + int InterlacedJumps[] = { 8, 8, 4, 2 }; + for (i = 0; i < 4; i++) { + for (j = InterlacedOffset[i]; j < sp->ImageDesc.Height; j += InterlacedJumps[i]) { + if (DGifGetLine(GifFile, sp->RasterBits + j * sp->ImageDesc.Width, sp->ImageDesc.Width) == GIF_ERROR) { + return GIF_ERROR; + } + } + } + } else { + if (DGifGetLine(GifFile, sp->RasterBits, ImageSize) == GIF_ERROR) { + return (GIF_ERROR); + } + } + if (info->currentIndex >= GifFile->ImageCount - 1) { + if (info->loopCount > 0) { + info->currentLoop++; + } + if (fileRewindFun(info) != 0) { + info->gifFilePtr->Error = D_GIF_ERR_READ_FAILED; + return GIF_ERROR; + } + } + return GIF_OK; + } else { + if (DGifGetCode(GifFile, &codeSize, &ExtData) == GIF_ERROR) { + return (GIF_ERROR); + } + while (ExtData != NULL) { + if (DGifGetCodeNext(GifFile, &ExtData) == GIF_ERROR) { + return (GIF_ERROR); + } + } + } + break; + + case EXTENSION_RECORD_TYPE: + if (DGifGetExtension(GifFile, &ExtFunction, &ExtData) == GIF_ERROR) { + return (GIF_ERROR); + } + + if (!shouldDecode) { + FrameInfo *tmpInfos = realloc(info->infos, (GifFile->ImageCount + 1) * sizeof(FrameInfo)); + if (tmpInfos == NULL) { + return GIF_ERROR; + } + info->infos = tmpInfos; + if (readExtensions(ExtFunction, ExtData, info) == GIF_ERROR) { + return GIF_ERROR; + } + } + while (ExtData != NULL) { + if (DGifGetExtensionNext(GifFile, &ExtData, &ExtFunction) == GIF_ERROR) { + return (GIF_ERROR); + } + if (!shouldDecode) { + if (readExtensions(ExtFunction, ExtData, info) == GIF_ERROR) { + return GIF_ERROR; + } + } + } + break; + + case TERMINATE_RECORD_TYPE: + break; + + default: + break; + } + } while (RecordType != TERMINATE_RECORD_TYPE); + bool ok = true; + if (shouldDecode) { + ok = (fileRewindFun(info) == 0); + } + if (ok) { + return (GIF_OK); + } else { + info->gifFilePtr->Error = D_GIF_ERR_READ_FAILED; + return (GIF_ERROR); + } +} + +static void copyLine(argb *dst, const unsigned char *src, const ColorMapObject *cmap, int transparent, int width) { + for (; width > 0; width--, src++, dst++) { + if (*src != transparent) { + getColorFromTable(*src, dst, cmap); + } + } +} + +static argb *getAddr(argb *bm, int width, int left, int top) { + return bm + top * width + left; +} + +static void blitNormal(argb *bm, int width, int height, const SavedImage *frame, const ColorMapObject *cmap, int transparent) { + const unsigned char* src = (unsigned char*) frame->RasterBits; + argb *dst = getAddr(bm, width, frame->ImageDesc.Left, frame->ImageDesc.Top); + GifWord copyWidth = frame->ImageDesc.Width; + if (frame->ImageDesc.Left + copyWidth > width) { + copyWidth = width - frame->ImageDesc.Left; + } + + GifWord copyHeight = frame->ImageDesc.Height; + if (frame->ImageDesc.Top + copyHeight > height) { + copyHeight = height - frame->ImageDesc.Top; + } + + for (; copyHeight > 0; copyHeight--) { + copyLine(dst, src, cmap, transparent, copyWidth); + src += frame->ImageDesc.Width; + dst += width; + } +} + +static void fillRect(argb *bm, int bmWidth, int bmHeight, GifWord left, GifWord top, GifWord width, GifWord height, argb col) { + uint32_t* dst = (uint32_t*) getAddr(bm, bmWidth, left, top); + GifWord copyWidth = width; + if (left + copyWidth > bmWidth) { + copyWidth = bmWidth - left; + } + + GifWord copyHeight = height; + if (top + copyHeight > bmHeight) { + copyHeight = bmHeight - top; + } + uint32_t* pColor = (uint32_t *) (&col); + for (; copyHeight > 0; copyHeight--) { + memset(dst, *pColor, copyWidth * sizeof(argb)); + dst += bmWidth; + } +} + +static void drawFrame(argb *bm, int bmWidth, int bmHeight, const SavedImage *frame, const ColorMapObject *cmap, short transpIndex) { + if (frame->ImageDesc.ColorMap != NULL) { + cmap = frame->ImageDesc.ColorMap; + if (cmap->ColorCount != (1 << cmap->BitsPerPixel)) { + cmap = defaultCmap; + } + } + blitNormal(bm, bmWidth, bmHeight, frame, cmap, transpIndex); +} + +static bool checkIfCover(const SavedImage *target, const SavedImage *covered) { + if (target->ImageDesc.Left <= covered->ImageDesc.Left + && covered->ImageDesc.Left + covered->ImageDesc.Width + <= target->ImageDesc.Left + target->ImageDesc.Width + && target->ImageDesc.Top <= covered->ImageDesc.Top + && covered->ImageDesc.Top + covered->ImageDesc.Height + <= target->ImageDesc.Top + target->ImageDesc.Height) { + return true; + } + return false; +} + +static inline void disposeFrameIfNeeded(argb *bm, GifInfo *info, unsigned int idx) { + argb* backup = info->backupPtr; + argb color; + packARGB32(&color, 0, 0, 0, 0); + GifFileType *fGif = info->gifFilePtr; + SavedImage* cur = &fGif->SavedImages[idx - 1]; + SavedImage* next = &fGif->SavedImages[idx]; + bool curTrans = info->infos[idx - 1].transpIndex != -1; + int curDisposal = info->infos[idx - 1].disposalMethod; + bool nextTrans = info->infos[idx].transpIndex != -1; + int nextDisposal = info->infos[idx].disposalMethod; + argb *tmp; + if ((curDisposal == 2 || curDisposal == 3) && (nextTrans || !checkIfCover(next, cur))) { + switch (curDisposal) { + case 2: + + fillRect(bm, fGif->SWidth, fGif->SHeight, cur->ImageDesc.Left, cur->ImageDesc.Top, cur->ImageDesc.Width, cur->ImageDesc.Height, color); + break; + + case 3: + tmp = bm; + bm = backup; + backup = tmp; + break; + } + } + + if (nextDisposal == 3) { + memcpy(backup, bm, fGif->SWidth * fGif->SHeight * sizeof(argb)); + } +} + +static void reset(GifInfo *info) { + if (fileRewindFun(info) != 0) { + return; + } + info->nextStartTime = 0; + info->currentLoop = -1; + info->currentIndex = -1; +} + +static void getBitmap(argb *bm, GifInfo *info) { + GifFileType* fGIF = info->gifFilePtr; + + argb paintingColor; + int i = info->currentIndex; + if (DDGifSlurp(fGIF, info, true) == GIF_ERROR) { + return; + } + SavedImage* cur = &fGIF->SavedImages[i]; + int transpIndex = info->infos[i].transpIndex; + if (i == 0) { + if (transpIndex == -1) { + getColorFromTable(fGIF->SBackGroundColor, &paintingColor, fGIF->SColorMap); + } else { + packARGB32(&paintingColor, 0, 0, 0, 0); + } + eraseColor(bm, fGIF->SWidth, fGIF->SHeight, paintingColor); + } else { + disposeFrameIfNeeded(bm, info, i); + } + drawFrame(bm, fGIF->SWidth, fGIF->SHeight, cur, fGIF->SColorMap, transpIndex); +} + +static void setMetaData(int width, int height, int ImageCount, int errorCode, JNIEnv *env, jintArray metaData) { + jint *const ints = (*env)->GetIntArrayElements(env, metaData, 0); + if (ints == NULL) { + return; + } + ints[0] = width; + ints[1] = height; + ints[2] = ImageCount; + ints[3] = errorCode; + (*env)->ReleaseIntArrayElements(env, metaData, ints, 0); +} + +static jint open(GifFileType *GifFileIn, int Error, int startPos, JNIEnv *env, jintArray metaData) { + if (startPos < 0) { + Error = D_GIF_ERR_NOT_READABLE; + DGifCloseFile(GifFileIn); + } + if (Error != 0 || GifFileIn == NULL) { + setMetaData(0, 0, 0, Error, env, metaData); + return (jint) NULL; + } + int width = GifFileIn->SWidth, height = GifFileIn->SHeight; + unsigned int wxh = width * height; + if (wxh < 1 || wxh > INT_MAX) { + DGifCloseFile(GifFileIn); + setMetaData(width, height, 0, D_GIF_ERR_INVALID_SCR_DIMS, env, metaData); + return (jint) NULL; + } + GifInfo *info = malloc(sizeof(GifInfo)); + if (info == NULL) { + DGifCloseFile(GifFileIn); + setMetaData(width, height, 0, D_GIF_ERR_NOT_ENOUGH_MEM, env, metaData); + return (jint) NULL; + } + info->gifFilePtr = GifFileIn; + info->startPos = startPos; + info->currentIndex = -1; + info->nextStartTime = 0; + info->lastFrameReaminder = ULONG_MAX; + info->comment = NULL; + info->loopCount = 0; + info->currentLoop = -1; + info->speedFactor = 1.0; + info->rasterBits = calloc(GifFileIn->SHeight * GifFileIn->SWidth, sizeof(GifPixelType)); + info->infos = malloc(sizeof(FrameInfo)); + info->backupPtr = NULL; + + if (info->rasterBits == NULL || info->infos == NULL) { + cleanUp(info); + setMetaData(width, height, 0, D_GIF_ERR_NOT_ENOUGH_MEM, env, metaData); + return (jint) NULL; + } + info->infos->duration = 0; + info->infos->disposalMethod = 0; + info->infos->transpIndex = -1; + if (GifFileIn->SColorMap == NULL || GifFileIn->SColorMap->ColorCount != (1 << GifFileIn->SColorMap->BitsPerPixel)) { + GifFreeMapObject(GifFileIn->SColorMap); + GifFileIn->SColorMap = defaultCmap; + } + + DDGifSlurp(GifFileIn, info, false); + + int imgCount = GifFileIn->ImageCount; + + if (imgCount < 1) { + Error = D_GIF_ERR_NO_FRAMES; + } + if (fileRewindFun(info) != 0) { + Error = D_GIF_ERR_READ_FAILED; + } + if (Error != 0) { + cleanUp(info); + } + setMetaData(width, height, imgCount, Error, env, metaData); + return (jint)(Error == 0 ? info : NULL); +} + +JNIEXPORT jlong JNICALL Java_org_telegram_ui_Components_GifDrawable_getAllocationByteCount(JNIEnv *env, jclass class, jobject gifInfo) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL) { + return 0; + } + unsigned int pxCount = info->gifFilePtr->SWidth + info->gifFilePtr->SHeight; + jlong sum = pxCount * sizeof(char); + if (info->backupPtr != NULL) { + sum += pxCount * sizeof(argb); + } + return sum; +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_reset(JNIEnv *env, jclass class, jobject gifInfo) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL) { + return; + } + reset(info); +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_setSpeedFactor(JNIEnv *env, jclass class, jobject gifInfo, jfloat factor) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL) { + return; + } + info->speedFactor = factor; +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_seekToTime(JNIEnv *env, jclass class, jobject gifInfo, jint desiredPos, jintArray jPixels) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL || jPixels == NULL) { + return; + } + int imgCount = info->gifFilePtr->ImageCount; + if (imgCount <= 1) { + return; + } + + unsigned long sum = 0; + int i; + for (i = 0; i < imgCount; i++) { + unsigned long newSum = sum + info->infos[i].duration; + if (newSum >= desiredPos) { + break; + } + sum = newSum; + } + if (i < info->currentIndex) { + return; + } + + unsigned long lastFrameRemainder = desiredPos - sum; + if (i == imgCount - 1 && lastFrameRemainder > info->infos[i].duration) { + lastFrameRemainder = info->infos[i].duration; + } + if (i > info->currentIndex) { + jint *const pixels = (*env)->GetIntArrayElements(env, jPixels, 0); + if (pixels == NULL) { + return; + } + while (info->currentIndex <= i) { + info->currentIndex++; + getBitmap((argb*) pixels, info); + } + (*env)->ReleaseIntArrayElements(env, jPixels, pixels, 0); + } + info->lastFrameReaminder = lastFrameRemainder; + + if (info->speedFactor == 1.0) { + info->nextStartTime = getRealTime() + lastFrameRemainder; + } else { + info->nextStartTime = getRealTime() + lastFrameRemainder * info->speedFactor; + } +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_seekToFrame(JNIEnv *env, jclass class, jobject gifInfo, jint desiredIdx, jintArray jPixels) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL|| jPixels==NULL) { + return; + } + if (desiredIdx <= info->currentIndex) { + return; + } + + int imgCount = info->gifFilePtr->ImageCount; + if (imgCount <= 1) { + return; + } + + jint *const pixels = (*env)->GetIntArrayElements(env, jPixels, 0); + if (pixels == NULL) { + return; + } + + info->lastFrameReaminder = 0; + if (desiredIdx >= imgCount) { + desiredIdx = imgCount - 1; + } + + while (info->currentIndex < desiredIdx) { + info->currentIndex++; + getBitmap((argb *) pixels, info); + } + (*env)->ReleaseIntArrayElements(env, jPixels, pixels, 0); + if (info->speedFactor == 1.0) { + info->nextStartTime = getRealTime() + info->infos[info->currentIndex].duration; + } else { + info->nextStartTime = getRealTime() + info->infos[info->currentIndex].duration * info->speedFactor; + } +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_renderFrame(JNIEnv *env, jclass class, jintArray jPixels, jobject gifInfo, jintArray metaData) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL || jPixels == NULL) { + return; + } + bool needRedraw = false; + unsigned long rt = getRealTime(); + + if (rt >= info->nextStartTime && info->currentLoop < info->loopCount) { + if (++info->currentIndex >= info->gifFilePtr->ImageCount) { + info->currentIndex = 0; + } + needRedraw = true; + } + jint *const rawMetaData = (*env)->GetIntArrayElements(env, metaData, 0); + if (rawMetaData == NULL) { + return; + } + + if (needRedraw) { + jint *const pixels = (*env)->GetIntArrayElements(env, jPixels, 0); + if (pixels == NULL) { + (*env)->ReleaseIntArrayElements(env, metaData, rawMetaData, 0); + return; + } + getBitmap((argb *)pixels, info); + rawMetaData[3] = info->gifFilePtr->Error; + + (*env)->ReleaseIntArrayElements(env, jPixels, pixels, 0); + unsigned int scaledDuration = info->infos[info->currentIndex].duration; + if (info->speedFactor != 1.0) { + scaledDuration /= info->speedFactor; + if (scaledDuration<=0) { + scaledDuration=1; + } else if (scaledDuration > INT_MAX) { + scaledDuration = INT_MAX; + } + } + info->nextStartTime = rt + scaledDuration; + rawMetaData[4] = scaledDuration; + } else { + long delay = info->nextStartTime-rt; + if (delay < 0) { + rawMetaData[4] = -1; + } else { + rawMetaData[4] = (int) delay; + } + } + (*env)->ReleaseIntArrayElements(env, metaData, rawMetaData, 0); +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_free(JNIEnv *env, jclass class, jobject gifInfo) { + if (gifInfo == NULL) { + return; + } + GifInfo *info = (GifInfo *)gifInfo; + FILE *file = info->gifFilePtr->UserData; + if (file) { + fclose(file); + } + info->gifFilePtr->UserData = NULL; + cleanUp(info); +} + +JNIEXPORT jstring JNICALL Java_org_telegram_ui_Components_GifDrawable_getComment(JNIEnv *env, jclass class, jobject gifInfo) { + if (gifInfo == NULL) { + return NULL; + } + GifInfo *info = (GifInfo *)gifInfo; + return (*env)->NewStringUTF(env, info->comment); +} + +JNIEXPORT jint JNICALL Java_org_telegram_ui_Components_GifDrawable_getLoopCount(JNIEnv *env, jclass class, jobject gifInfo) { + if (gifInfo == NULL) { + return 0; + } + return ((GifInfo *)gifInfo)->loopCount; +} + +JNIEXPORT jint JNICALL Java_org_telegram_ui_Components_GifDrawable_getDuration(JNIEnv *env, jclass class, jobject gifInfo) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL) { + return 0; + } + int i; + unsigned long sum = 0; + for (i = 0; i < info->gifFilePtr->ImageCount; i++) { + sum += info->infos[i].duration; + } + return sum; +} + +JNIEXPORT jint JNICALL Java_org_telegram_ui_Components_GifDrawable_getCurrentPosition(JNIEnv *env, jclass class, jobject gifInfo) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL) { + return 0; + } + int idx = info->currentIndex; + if (idx < 0 || info->gifFilePtr->ImageCount <= 1) { + return 0; + } + int i; + unsigned int sum = 0; + for (i = 0; i < idx; i++) { + sum += info->infos[i].duration; + } + unsigned long remainder = info->lastFrameReaminder == ULONG_MAX ? getRealTime() - info->nextStartTime : info->lastFrameReaminder; + return (int) (sum + remainder); +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_saveRemainder(JNIEnv *env, jclass class, jobject gifInfo) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL) { + return; + } + info->lastFrameReaminder = getRealTime() - info->nextStartTime; +} + +JNIEXPORT void JNICALL Java_org_telegram_ui_Components_GifDrawable_restoreRemainder(JNIEnv *env, jclass class, jobject gifInfo) { + GifInfo *info = (GifInfo *)gifInfo; + if (info == NULL || info->lastFrameReaminder == ULONG_MAX) { + return; + } + info->nextStartTime = getRealTime() + info->lastFrameReaminder; + info->lastFrameReaminder = ULONG_MAX; +} + +JNIEXPORT jint JNICALL Java_org_telegram_ui_Components_GifDrawable_openFile(JNIEnv *env, jclass class, jintArray metaData, jstring jfname) { + if (jfname == NULL) { + setMetaData(0, 0, 0, D_GIF_ERR_OPEN_FAILED, env, metaData); + return (jint) NULL; + } + + const char *const fname = (*env)->GetStringUTFChars(env, jfname, 0); + FILE *file = fopen(fname, "rb"); + (*env)->ReleaseStringUTFChars(env, jfname, fname); + if (file == NULL) { + setMetaData(0, 0, 0, D_GIF_ERR_OPEN_FAILED, env, metaData); + return (jint) NULL; + } + int Error = 0; + GifFileType *GifFileIn = DGifOpen(file, &fileReadFunc, &Error); + return open(GifFileIn, Error, ftell(file), env, metaData); +} |