+++ /dev/null
-/*
-HOW TO USE:
-
- In exactly one translation unit (.c or .cpp file), #define MSF_GIF_IMPL before including the header, like so:
-
- #define MSF_GIF_IMPL
- #include "msf_gif.h"
-
- Everywhere else, just include the header like normal.
-
-
-USAGE EXAMPLE:
-
- int width = 480, height = 320, centisecondsPerFrame = 5, bitDepth = 16;
- MsfGifState gifState = {};
- msf_gif_begin(&gifState, width, height);
- msf_gif_frame(&gifState, ..., centisecondsPerFrame, bitDepth, width * 4); //frame 1
- msf_gif_frame(&gifState, ..., centisecondsPerFrame, bitDepth, width * 4); //frame 2
- msf_gif_frame(&gifState, ..., centisecondsPerFrame, bitDepth, width * 4); //frame 3, etc...
- MsfGifResult result = msf_gif_end(&gifState);
- FILE * fp = fopen("MyGif.gif", "wb");
- fwrite(result.data, result.dataSize, 1, fp);
- fclose(fp);
- msf_gif_free(result);
-
-Detailed function documentation can be found in the header section below.
-
-
-REPLACING MALLOC:
-
- This library uses malloc+realloc+free internally for memory allocation.
- To facilitate integration with custom memory allocators, these calls go through macros, which can be redefined.
- The expected function signature equivalents of the macros are as follows:
-
- void * MSF_GIF_MALLOC(void * context, size_t newSize)
- void * MSF_GIF_REALLOC(void * context, void * oldMemory, size_t oldSize, size_t newSize)
- void MSF_GIF_FREE(void * context, void * oldMemory, size_t oldSize)
-
- If your allocator needs a context pointer, you can set the `customAllocatorContext` field of the MsfGifState struct
- before calling msf_gif_begin(), and it will be passed to all subsequent allocator macro calls.
-
-See end of file for license information.
-*/
-
-//version 2.1
-
-#ifndef MSF_GIF_H
-#define MSF_GIF_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-typedef struct {
- void * data;
- size_t dataSize;
-
- size_t allocSize; //internal use
- void * contextPointer; //internal use
-} MsfGifResult;
-
-typedef struct { //internal use
- uint32_t * pixels;
- int depth, count, rbits, gbits, bbits;
-} MsfCookedFrame;
-
-typedef struct {
- MsfCookedFrame previousFrame;
- uint8_t * listHead;
- uint8_t * listTail;
- int width, height;
- void * customAllocatorContext;
-} MsfGifState;
-
-#ifdef __cplusplus
-extern "C" {
-#endif //__cplusplus
-
-/**
- * @param width Image width in pixels.
- * @param height Image height in pixels.
- * @return Non-zero on success, 0 on error.
- */
-int msf_gif_begin(MsfGifState * handle, int width, int height);
-
-/**
- * @param pixelData Pointer to raw framebuffer data. Rows must be contiguous in memory, in RGBA8 format.
- * Note: This function does NOT free `pixelData`. You must free it yourself afterwards.
- * @param centiSecondsPerFrame How many hundredths of a second this frame should be displayed for.
- * Note: This being specified in centiseconds is a limitation of the GIF format.
- * @param maxBitDepth Limits how many bits per pixel can be used when quantizing the gif.
- * The actual bit depth chosen for a given frame will be less than or equal to
- * the supplied maximum, depending on the variety of colors used in the frame.
- * `maxBitDepth` will be clamped between 1 and 16. The recommended default is 16.
- * Lowering this value can result in faster exports and smaller gifs,
- * but the quality may suffer.
- * Please experiment with this value to find what works best for your application.
- * @param pitchInBytes The number of bytes from the beginning of one row of pixels to the beginning of the next.
- * If you want to flip the image, just pass in a negative pitch.
- * @return Non-zero on success, 0 on error.
- */
-int msf_gif_frame(MsfGifState * handle, uint8_t * pixelData, int centiSecondsPerFame, int maxBitDepth, int pitchInBytes);
-
-/**
- * @return A block of memory containing the gif file data, or NULL on error.
- * You are responsible for freeing this via `msf_gif_free()`.
- */
-MsfGifResult msf_gif_end(MsfGifState * handle);
-
-/**
- * @param result The MsfGifResult struct, verbatim as it was returned from `msf_gif_end()`.
- */
-void msf_gif_free(MsfGifResult result);
-
-#ifdef __cplusplus
-}
-#endif //__cplusplus
-
-#endif //MSF_GIF_H
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// IMPLEMENTATION ///
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#ifdef MSF_GIF_IMPL
-#ifndef MSF_GIF_ALREADY_IMPLEMENTED_IN_THIS_TRANSLATION_UNIT
-#define MSF_GIF_ALREADY_IMPLEMENTED_IN_THIS_TRANSLATION_UNIT
-
-#ifndef MSF_GIF_BUFFER_INIT_SIZE
-#define MSF_GIF_BUFFER_INIT_SIZE 1024 * 1024 * 4 //4MB by default, you can increase this if you want to realloc less
-#endif
-
-//ensure the library user has either defined all of malloc/realloc/free, or none
-#if defined(MSF_GIF_MALLOC) && defined(MSF_GIF_REALLOC) && defined(MSF_GIF_FREE) //ok
-#elif !defined(MSF_GIF_MALLOC) && !defined(MSF_GIF_REALLOC) && !defined(MSF_GIF_FREE) //ok
-#else
-#error "You must either define all of MSF_GIF_MALLOC, MSF_GIF_REALLOC, and MSF_GIF_FREE, or define none of them"
-#endif
-
-//provide default allocator definitions that redirect to the standard global allocator
-#if !defined(MSF_GIF_MALLOC)
-#include <stdlib.h> //malloc, etc.
-#define MSF_GIF_MALLOC(contextPointer, newSize) malloc(newSize)
-#define MSF_GIF_REALLOC(contextPointer, oldMemory, oldSize, newSize) realloc(oldMemory, newSize)
-#define MSF_GIF_FREE(contextPointer, oldMemory, oldSize) free(oldMemory)
-#endif
-
-//instrumentation for capturing profiling traces (useless for the library user, but useful for the library author)
-#ifdef MSF_GIF_ENABLE_TRACING
-#define MsfTimeFunc TimeFunc
-#define MsfTimeLoop TimeLoop
-#define msf_init_profiling_thread init_profiling_thread
-#else
-#define MsfTimeFunc
-#define MsfTimeLoop(name)
-#define msf_init_profiling_thread()
-#endif //MSF_GIF_ENABLE_TRACING
-
-#include <string.h> //memcpy
-
-//TODO: use compiler-specific notation to force-inline functions currently marked inline
-#if defined(__GNUC__) //gcc, clang
-static inline int msf_bit_log(int i) { return 32 - __builtin_clz(i); }
-#elif defined(_MSC_VER) //msvc
-#include <intrin.h>
-static inline int msf_bit_log(int i) { unsigned long idx; _BitScanReverse(&idx, i); return idx + 1; }
-#else //fallback implementation for other compilers
-//from https://stackoverflow.com/a/31718095/3064745 - thanks!
-static inline int msf_bit_log(int i) {
- static const int MultiplyDeBruijnBitPosition[32] = {
- 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
- 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31,
- };
- i |= i >> 1;
- i |= i >> 2;
- i |= i >> 4;
- i |= i >> 8;
- i |= i >> 16;
- return MultiplyDeBruijnBitPosition[(uint32_t)(i * 0x07C4ACDDU) >> 27] + 1;
-}
-#endif
-static inline int msf_imin(int a, int b) { return a < b? a : b; }
-static inline int msf_imax(int a, int b) { return b < a? a : b; }
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// Frame Cooking ///
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if (defined (__SSE2__) || defined (_M_X64) || _M_IX86_FP == 2) && !defined(MSF_GIF_NO_SSE2)
-#include <emmintrin.h>
-#endif
-
-static MsfCookedFrame msf_cook_frame(void * allocContext, uint8_t * raw, uint8_t * used,
- int width, int height, int pitch, int depth)
-{ MsfTimeFunc
- //bit depth for each channel
- const static int rdepths[17] = { 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5 };
- const static int gdepths[17] = { 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6 };
- const static int bdepths[17] = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5 };
-
- const static int ditherKernel[16] = {
- 0 << 12, 8 << 12, 2 << 12, 10 << 12,
- 12 << 12, 4 << 12, 14 << 12, 6 << 12,
- 3 << 12, 11 << 12, 1 << 12, 9 << 12,
- 15 << 12, 7 << 12, 13 << 12, 5 << 12,
- };
-
- uint32_t * cooked = (uint32_t *) MSF_GIF_MALLOC(allocContext, width * height * sizeof(uint32_t));
- if (!cooked) { MsfCookedFrame blank = {0}; return blank; }
-
- int count = 0;
- MsfTimeLoop("do") do {
- int rbits = rdepths[depth], gbits = gdepths[depth], bbits = bdepths[depth];
- int paletteSize = 1 << (rbits + gbits + bbits);
- memset(used, 0, paletteSize * sizeof(uint8_t));
-
- //TODO: document what this math does and why it's correct
- int rdiff = (1 << (8 - rbits)) - 1;
- int gdiff = (1 << (8 - gbits)) - 1;
- int bdiff = (1 << (8 - bbits)) - 1;
- short rmul = (short) ((255.0f - rdiff) / 255.0f * 257);
- short gmul = (short) ((255.0f - gdiff) / 255.0f * 257);
- short bmul = (short) ((255.0f - bdiff) / 255.0f * 257);
-
- int gmask = ((1 << gbits) - 1) << rbits;
- int bmask = ((1 << bbits) - 1) << rbits << gbits;
-
- MsfTimeLoop("cook") for (int y = 0; y < height; ++y) {
- int x = 0;
-
- #if (defined (__SSE2__) || defined (_M_X64) || _M_IX86_FP == 2) && !defined(MSF_GIF_NO_SSE2)
- __m128i k = _mm_loadu_si128((__m128i *) &ditherKernel[(y & 3) * 4]);
- __m128i k2 = _mm_or_si128(_mm_srli_epi32(k, rbits), _mm_slli_epi32(_mm_srli_epi32(k, bbits), 16));
- // MsfTimeLoop("SIMD")
- for (; x < width - 3; x += 4) {
- uint8_t * pixels = &raw[y * pitch + x * 4];
- __m128i p = _mm_loadu_si128((__m128i *) pixels);
-
- __m128i rb = _mm_and_si128(p, _mm_set1_epi32(0x00FF00FF));
- __m128i rb1 = _mm_mullo_epi16(rb, _mm_set_epi16(bmul, rmul, bmul, rmul, bmul, rmul, bmul, rmul));
- __m128i rb2 = _mm_adds_epu16(rb1, k2);
- __m128i r3 = _mm_srli_epi32(_mm_and_si128(rb2, _mm_set1_epi32(0x0000FFFF)), 16 - rbits);
- __m128i b3 = _mm_and_si128(_mm_srli_epi32(rb2, 32 - rbits - gbits - bbits), _mm_set1_epi32(bmask));
-
- __m128i g = _mm_and_si128(_mm_srli_epi32(p, 8), _mm_set1_epi32(0x000000FF));
- __m128i g1 = _mm_mullo_epi16(g, _mm_set1_epi32(gmul));
- __m128i g2 = _mm_adds_epu16(g1, _mm_srli_epi32(k, gbits));
- __m128i g3 = _mm_and_si128(_mm_srli_epi32(g2, 16 - rbits - gbits), _mm_set1_epi32(gmask));
-
- //TODO: does storing this as a __m128i then reading it back as a uint32_t violate strict aliasing?
- uint32_t * c = &cooked[y * width + x];
- __m128i out = _mm_or_si128(_mm_or_si128(r3, g3), b3);
- _mm_storeu_si128((__m128i *) c, out);
- }
- #endif
-
- //scalar cleanup loop
- // MsfTimeLoop("scalar")
- for (; x < width; ++x) {
- uint8_t * p = &raw[y * pitch + x * 4];
- int dx = x & 3, dy = y & 3;
- int k = ditherKernel[dy * 4 + dx];
- cooked[y * width + x] =
- (msf_imin(65535, p[2] * bmul + (k >> bbits)) >> (16 - rbits - gbits - bbits) & bmask) |
- (msf_imin(65535, p[1] * gmul + (k >> gbits)) >> (16 - rbits - gbits ) & gmask) |
- msf_imin(65535, p[0] * rmul + (k >> rbits)) >> (16 - rbits );
- }
- }
-
- count = 0;
- MsfTimeLoop("mark and count") for (int i = 0; i < width * height; ++i) {
- used[cooked[i]] = 1;
- }
-
- //count used colors
- MsfTimeLoop("count") for (int j = 0; j < paletteSize; ++j) {
- count += used[j];
- }
- } while (count >= 256 && --depth);
-
- MsfCookedFrame ret = { cooked, depth, count, rdepths[depth], gdepths[depth], bdepths[depth] };
- return ret;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// Frame Compression ///
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-typedef struct {
- uint8_t * next;
- size_t size;
-} MsfBufferHeader;
-
-static inline int msf_put_code(uint8_t * * writeHead, uint32_t * blockBits, int len, uint32_t code) {
- //insert new code into block buffer
- int idx = *blockBits / 8;
- int bit = *blockBits % 8;
- (*writeHead)[idx + 0] |= code << bit ;
- (*writeHead)[idx + 1] |= code >> ( 8 - bit);
- (*writeHead)[idx + 2] |= code >> (16 - bit);
- *blockBits += len;
-
- //prep the next block buffer if the current one is full
- if (*blockBits >= 256 * 8) {
- *blockBits -= 255 * 8;
- (*writeHead) += 256;
- (*writeHead)[2] = (*writeHead)[1];
- (*writeHead)[1] = (*writeHead)[0];
- (*writeHead)[0] = 255;
- memset((*writeHead) + 4, 0, 256);
- }
-
- return 1;
-}
-
-typedef struct {
- int16_t * data;
- int len;
- int stride;
-} MsfStridedList;
-
-static inline void msf_lzw_reset(MsfStridedList * lzw, int tableSize, int stride) { MsfTimeFunc
- memset(lzw->data, 0xFF, 4096 * stride * sizeof(int16_t));
- lzw->len = tableSize + 2;
- lzw->stride = stride;
-}
-
-static uint8_t * msf_compress_frame(void * allocContext, int width, int height, int centiSeconds,
- MsfCookedFrame frame, MsfCookedFrame previous, uint8_t * used)
-{ MsfTimeFunc
- //NOTE: we reserve enough memory for theoretical the worst case upfront because it's a reasonable amount,
- // and prevents us from ever having to check size or realloc during compression
- int maxBufSize = sizeof(MsfBufferHeader) + 32 + 256 * 3 + width * height * 3 / 2; //headers + color table + data
- uint8_t * allocation = (uint8_t *) MSF_GIF_MALLOC(allocContext, maxBufSize);
- if (!allocation) { return NULL; }
- uint8_t * writeBase = allocation + sizeof(MsfBufferHeader);
- uint8_t * writeHead = writeBase;
- int lzwAllocSize = 4096 * (frame.count + 1) * sizeof(int16_t);
- MsfStridedList lzw = { (int16_t *) MSF_GIF_MALLOC(allocContext, lzwAllocSize) };
- if (!lzw.data) { MSF_GIF_FREE(allocContext, allocation, maxBufSize); return NULL; }
-
- //allocate tlb
- int totalBits = frame.rbits + frame.gbits + frame.bbits;
- int tlbSize = 1 << totalBits;
- uint8_t tlb[1 << 16]; //only 64k, so stack allocating is fine
-
- //generate palette
- typedef struct { uint8_t r, g, b; } Color3;
- Color3 table[256] = { {0} };
- int tableIdx = 1; //we start counting at 1 because 0 is the transparent color
- MsfTimeLoop("table") for (int i = 0; i < tlbSize; ++i) {
- if (used[i]) {
- tlb[i] = tableIdx;
- int rmask = (1 << frame.rbits) - 1;
- int gmask = (1 << frame.gbits) - 1;
- //isolate components
- int r = i & rmask;
- int g = i >> frame.rbits & gmask;
- int b = i >> (frame.rbits + frame.gbits);
- //shift into highest bits
- r <<= 8 - frame.rbits;
- g <<= 8 - frame.gbits;
- b <<= 8 - frame.bbits;
- table[tableIdx].r = r | r >> frame.rbits | r >> (frame.rbits * 2) | r >> (frame.rbits * 3);
- table[tableIdx].g = g | g >> frame.gbits | g >> (frame.gbits * 2) | g >> (frame.gbits * 3);
- table[tableIdx].b = b | b >> frame.bbits | b >> (frame.bbits * 2) | b >> (frame.bbits * 3);
- ++tableIdx;
- }
- }
-
- //SPEC: "Because of some algorithmic constraints however, black & white images which have one color bit
- // must be indicated as having a code size of 2."
- int tableBits = msf_imax(2, msf_bit_log(tableIdx - 1));
- int tableSize = 1 << tableBits;
- //NOTE: we don't just compare `depth` field here because it will be wrong for the first frame and we will segfault
- int hasSamePal = frame.rbits == previous.rbits && frame.gbits == previous.gbits && frame.bbits == previous.bbits;
-
- //NOTE: because __attribute__((__packed__)) is annoyingly compiler-specific, we do this unreadable weirdness
- char headerBytes[19] = "\x21\xF9\x04\x05\0\0\0\0" "\x2C\0\0\0\0\0\0\0\0\x80";
- memcpy(&headerBytes[4], ¢iSeconds, 2);
- memcpy(&headerBytes[13], &width, 2);
- memcpy(&headerBytes[15], &height, 2);
- headerBytes[17] |= tableBits - 1;
- memcpy(writeHead, headerBytes, 18);
- writeHead += 18;
-
- //local color table
- memcpy(writeHead, table, tableSize * sizeof(Color3));
- writeHead += tableSize * sizeof(Color3);
- *writeHead++ = tableBits;
-
- //prep block
- memset(writeHead, 0, 260);
- writeHead[0] = 255;
- uint32_t blockBits = 8; //relative to block.head
-
- //SPEC: "Encoders should output a Clear code as the first code of each image data stream."
- msf_lzw_reset(&lzw, tableSize, tableIdx);
- msf_put_code(&writeHead, &blockBits, msf_bit_log(lzw.len - 1), tableSize);
-
- int lastCode = hasSamePal && frame.pixels[0] == previous.pixels[0]? 0 : tlb[frame.pixels[0]];
- MsfTimeLoop("compress") for (int i = 1; i < width * height; ++i) {
- //PERF: branching vs. branchless version of this line is observed to have no discernable impact on speed
- int color = hasSamePal && frame.pixels[i] == previous.pixels[i]? 0 : tlb[frame.pixels[i]];
- //PERF: branchless version must use && otherwise it will segfault on frame 1, but it's well-predicted so OK
- // int color = (!(hasSamePal && frame.pixels[i] == previous.pixels[i])) * tlb[frame.pixels[i]];
- int code = (&lzw.data[lastCode * lzw.stride])[color];
- if (code < 0) {
- //write to code stream
- int codeBits = msf_bit_log(lzw.len - 1);
- msf_put_code(&writeHead, &blockBits, codeBits, lastCode);
-
- if (lzw.len > 4095) {
- //reset buffer code table
- msf_put_code(&writeHead, &blockBits, codeBits, tableSize);
- msf_lzw_reset(&lzw, tableSize, tableIdx);
- } else {
- (&lzw.data[lastCode * lzw.stride])[color] = lzw.len;
- ++lzw.len;
- }
-
- lastCode = color;
- } else {
- lastCode = code;
- }
- }
-
- MSF_GIF_FREE(allocContext, lzw.data, lzwAllocSize);
- MSF_GIF_FREE(allocContext, previous.pixels, width * height * sizeof(uint32_t));
-
- //write code for leftover index buffer contents, then the end code
- msf_put_code(&writeHead, &blockBits, msf_imin(12, msf_bit_log(lzw.len - 1)), lastCode);
- msf_put_code(&writeHead, &blockBits, msf_imin(12, msf_bit_log(lzw.len)), tableSize + 1);
-
- //flush remaining data
- if (blockBits > 8) {
- int bytes = (blockBits + 7) / 8; //round up
- writeHead[0] = bytes - 1;
- writeHead += bytes;
- }
- *writeHead++ = 0; //terminating block
-
- //filling in buffer header and shrink buffer to fit data
- MsfBufferHeader * header = (MsfBufferHeader *) allocation;
- header->next = NULL;
- header->size = writeHead - writeBase;
- uint8_t * moved = (uint8_t *) MSF_GIF_REALLOC(allocContext, allocation, maxBufSize, writeHead - allocation);
- if (!moved) { MSF_GIF_FREE(allocContext, allocation, maxBufSize); return NULL; }
- return moved;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// Incremental API ///
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-int msf_gif_begin(MsfGifState * handle, int width, int height) { MsfTimeFunc
- MsfCookedFrame empty = {0}; //god I hate MSVC...
- handle->previousFrame = empty;
- handle->width = width;
- handle->height = height;
-
- //setup header buffer header (lol)
- handle->listHead = (uint8_t *) MSF_GIF_MALLOC(handle->customAllocatorContext, sizeof(MsfBufferHeader) + 32);
- if (!handle->listHead) { return 0; }
- handle->listTail = handle->listHead;
- MsfBufferHeader * header = (MsfBufferHeader *) handle->listHead;
- header->next = NULL;
- header->size = 32;
-
- //NOTE: because __attribute__((__packed__)) is annoyingly compiler-specific, we do this unreadable weirdness
- char headerBytes[33] = "GIF89a\0\0\0\0\x10\0\0" "\x21\xFF\x0BNETSCAPE2.0\x03\x01\0\0\0";
- memcpy(&headerBytes[6], &width, 2);
- memcpy(&headerBytes[8], &height, 2);
- memcpy(handle->listHead + sizeof(MsfBufferHeader), headerBytes, 32);
- return 1;
-}
-
-int msf_gif_frame(MsfGifState * handle, uint8_t * pixelData, int centiSecondsPerFame, int maxBitDepth, int pitchInBytes)
-{ MsfTimeFunc
- if (!handle->listHead) { return 0; }
-
- maxBitDepth = msf_imax(1, msf_imin(16, maxBitDepth));
- if (pitchInBytes == 0) pitchInBytes = handle->width * 4;
- if (pitchInBytes < 0) pixelData -= pitchInBytes * (handle->height - 1);
-
- uint8_t used[1 << 16]; //only 64k, so stack allocating is fine
- MsfCookedFrame frame =
- msf_cook_frame(handle->customAllocatorContext, pixelData, used, handle->width, handle->height, pitchInBytes,
- msf_imin(maxBitDepth, handle->previousFrame.depth + 160 / msf_imax(1, handle->previousFrame.count)));
- //TODO: de-duplicate cleanup code
- if (!frame.pixels) {
- MSF_GIF_FREE(handle->customAllocatorContext,
- handle->previousFrame.pixels, handle->width * handle->height * sizeof(uint32_t));
- for (uint8_t * node = handle->listHead; node;) {
- MsfBufferHeader * header = (MsfBufferHeader *) node;
- node = header->next;
- MSF_GIF_FREE(handle->customAllocatorContext, header, sizeof(MsfBufferHeader) + header->size);
- }
- handle->listHead = handle->listTail = NULL;
- return 0;
- }
-
- uint8_t * buffer = msf_compress_frame(handle->customAllocatorContext,
- handle->width, handle->height, centiSecondsPerFame, frame, handle->previousFrame, used);
- ((MsfBufferHeader *) handle->listTail)->next = buffer;
- handle->listTail = buffer;
- if (!buffer) {
- MSF_GIF_FREE(handle->customAllocatorContext, frame.pixels, handle->width * handle->height * sizeof(uint32_t));
- MSF_GIF_FREE(handle->customAllocatorContext,
- handle->previousFrame.pixels, handle->width * handle->height * sizeof(uint32_t));
- for (uint8_t * node = handle->listHead; node;) {
- MsfBufferHeader * header = (MsfBufferHeader *) node;
- node = header->next;
- MSF_GIF_FREE(handle->customAllocatorContext, header, sizeof(MsfBufferHeader) + header->size);
- }
- handle->listHead = handle->listTail = NULL;
- return 0;
- }
-
- handle->previousFrame = frame;
- return 1;
-}
-
-MsfGifResult msf_gif_end(MsfGifState * handle) { MsfTimeFunc
- if (!handle->listHead) { MsfGifResult empty = {0}; return empty; }
-
- MSF_GIF_FREE(handle->customAllocatorContext,
- handle->previousFrame.pixels, handle->width * handle->height * sizeof(uint32_t));
-
- //first pass: determine total size
- size_t total = 1; //1 byte for trailing marker
- for (uint8_t * node = handle->listHead; node;) {
- MsfBufferHeader * header = (MsfBufferHeader *) node;
- node = header->next;
- total += header->size;
- }
-
- //second pass: write data
- uint8_t * buffer = (uint8_t *) MSF_GIF_MALLOC(handle->customAllocatorContext, total);
- if (buffer) {
- uint8_t * writeHead = buffer;
- for (uint8_t * node = handle->listHead; node;) {
- MsfBufferHeader * header = (MsfBufferHeader *) node;
- memcpy(writeHead, node + sizeof(MsfBufferHeader), header->size);
- writeHead += header->size;
- node = header->next;
- }
- *writeHead++ = 0x3B;
- }
-
- //third pass: free buffers
- for (uint8_t * node = handle->listHead; node;) {
- MsfBufferHeader * header = (MsfBufferHeader *) node;
- node = header->next;
- MSF_GIF_FREE(handle->customAllocatorContext, header, sizeof(MsfBufferHeader) + header->size);
- }
-
- MsfGifResult ret = { buffer, total, total, handle->customAllocatorContext };
- return ret;
-}
-
-void msf_gif_free(MsfGifResult result) {
- if (result.data) { MSF_GIF_FREE(result.contextPointer, result.data, result.allocSize); }
-}
-
-#endif //MSF_GIF_ALREADY_IMPLEMENTED_IN_THIS_TRANSLATION_UNIT
-#endif //MSF_GIF_IMPL
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2020 Miles Fogle
-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.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-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 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.
-------------------------------------------------------------------------------
-*/
projects / pistorm / blobdiff