diff --git a/libvips/foreign/libnsgif/Makefile.am b/libvips/foreign/libnsgif/Makefile.am index ef81a9c2..5202a280 100644 --- a/libvips/foreign/libnsgif/Makefile.am +++ b/libvips/foreign/libnsgif/Makefile.am @@ -1,8 +1,8 @@ noinst_LTLIBRARIES = libnsgif.la MY_SOURCES = \ - libnsgif.h \ - libnsgif.c \ + nsgif.h \ + gif.c \ lzw.c \ lzw.h @@ -11,11 +11,10 @@ libnsgif_la_SOURCES = $(MY_SOURCES) endif EXTRA_DIST = \ - README-ns \ + README-ns.md \ README.md \ patches \ - update.sh \ - utils + update.sh if !ENABLE_NSGIF EXTRA_DIST += \ diff --git a/libvips/foreign/libnsgif/README-ns b/libvips/foreign/libnsgif/README-ns deleted file mode 100644 index 498ee466..00000000 --- a/libvips/foreign/libnsgif/README-ns +++ /dev/null @@ -1,36 +0,0 @@ -libnsgif - Decoding GIF files -============================= - -The functions provided by this library allow for efficient progressive -GIF decoding. Whilst the initialisation does not ensure that there is -sufficient image data to complete the entire frame, it does ensure -that the information provided is valid. Any subsequent attempts to -decode an initialised GIF are guaranteed to succeed, and any bytes of -the image not present are assumed to be totally transparent. - -To begin decoding a GIF, the 'gif' structure must be initialised with -the 'gif_data' and 'buffer_size' set to their initial values. The -'buffer_position' should initially be 0, and will be internally -updated as the decoding commences. The caller should then repeatedly -call gif_initialise() with the structure until the function returns 1, -or no more data is avaliable. - -Once the initialisation has begun, the decoder completes the variables -'frame_count' and 'frame_count_partial'. The former being the total -number of frames that have been successfully initialised, and the -latter being the number of frames that a partial amount of data is -available for. This assists the caller in managing the animation -whilst decoding is continuing. - -To decode a frame, the caller must use gif_decode_frame() which -updates the current 'frame_image' to reflect the desired frame. The -required 'disposal_method' is also updated to reflect how the frame -should be plotted. The caller must not assume that the current -'frame_image' will be valid between calls if initialisation is still -occuring, and should either always request that the frame is decoded -(no processing will occur if the 'decoded_frame' has not been -invalidated by initialisation) or perform the check itself. - -It should be noted that gif_finalise() should always be called, even -if no frames were initialised. Additionally, it is the responsibility -of the caller to free 'gif_data'. diff --git a/libvips/foreign/libnsgif/README-ns.md b/libvips/foreign/libnsgif/README-ns.md new file mode 100644 index 00000000..cb380c34 --- /dev/null +++ b/libvips/foreign/libnsgif/README-ns.md @@ -0,0 +1,121 @@ +LibNSGIF: NetSurf GIF decoder +============================= + +LibNSGIF is a C library for decoding GIF format images and animations. +It is licenced under the MIT licence. + +This library aims to provide a simple API for robust decoding of GIF files. + +Details +------- + +The GIF source data is scanned prior to decoding, allowing for efficient +decoding. The scanning phase will scan currently available data and will +resume from where it left off when called with additional data. + +Only one frame is ever fully decoded to a bitmap at a time, reducing memory +usage for large GIFs. + +Using +----- + +LibNSGIF allows the client to allocate the bitmap into which the GIF is +decoded. The client can have an arbitrary bitmap structure, that is simply +a void pointer to LibNSGIF. The client must provide a callback table for +interacting with bitmaps. This table must include as a minimum functions to +create and destroy bitmaps, and a function to get a pointer to the bitmap's +pixel data buffer. + +To load a GIF, first create an nsgif object with `nsgif_create()`. + +```c + err = nsgif_create(&bitmap_callbacks, &gif); + if (err != NSGIF_OK) { + fprintf(stderr, "%s\n", nsgif_strerror(err)); + // Handle error + } +``` + +Now you can load the GIF source data into the nsgif object with +`nsgif_data_scan()`: + +```c + err = nsgif_data_scan(gif, size, data); + if (err != NSGIF_OK) { + fprintf(stderr, "%s\n", nsgif_strerror(err)); + // Handle error + } +``` + +This scans the source data and decodes information about each frame, however +it doesn't decode any of the bitmap data for the frames. The client may call +`nsgif_data_scan()` multiple times as source data is fetched. Once the +function has returned `NSGIF_OK` it has enough data to display at least one +frame. The early frames can be decoded before the later frames are scanned. +Frames have to be scanned before they can be decoded. + +> **Note**: The client must not free the data until after calling +> `nsgif_destroy()`. You can move the data, e.g. if you realloc to a bigger +> buffer. Just be sure to call `nsgif_data_scan()` again with the new pointer +> before making any other calls against that nsgif object. + +To decode the frames, you can call `nsgif_get_info()` to get the frame_count, +and then call `nsgif_frame_decode()` for each frame, and manage the animation, +and non-displayable frames yourself, or you can use the helper function, +`nsgif_frame_prepare()`: + +```c + err = nsgif_frame_prepare(gif, &area, &delay_cs, &frame_new); + if (err != NSGIF_OK) { + fprintf(stderr, "%s\n", nsgif_strerror(err)); + // Handle error + } + + // Update our bitmap to know it should be showing `frame_new` now. + // Trigger redraw of `area` of image. + + if (delay_cs != NSGIF_INFINITE) { + // Schedule next frame in delay_cs. + } +``` + +This will return the number of the next frame to be decoded, the delay in cs +before the next frame should be decoded, and the area of the bitmap that needs +to be redrawn. + +> **Note**: GIF frames may only occupy a portion of the overall bitmap, and only +> redrawing the area that has changed may be more efficient than redrawing the +> whole thing. The returned area comprises both any region that has been +> changed in the disposal of the previous frame and the new frame. + +GIF files can limit the number of animation loops to a finite number or they +may only have one frame. In either of these cases, the returned delay is +`NSGIF_INFINITE` indicating that the animation is complete. Subsequent calls +to `nsgif_frame_prepare()` will return `NSGIF_ERR_ANIMATION_END`. + +To force the repeat of an animation, call `nsgif_reset()`. + +One reason for the two-step decoding of frames is that it enables deferred +decoding. You can call `nsgif_frame_prepare()` and cause a redraw of that +portion of your document. If the GIF is off screen (another tab, or scrolled +out of sight), there is no need to decode it at all. + +Once the bitmap is needed for a redraw, you can decode the correct frame +on-demand with: + +```c + err = nsgif_frame_decode(gif, frame_new, &bitmap); + if (err != NSGIF_OK) { + fprintf(stderr, "%s\n", nsgif_strerror(err)); + // Handle error + } +``` + +Note that this will be a no-op if the requested frame already happens to be +the decoded frame. + +Once you are done with the GIF, free up the nsgif object with: + +```c + nsgif_destroy(gif); +``` diff --git a/libvips/foreign/libnsgif/gif.c b/libvips/foreign/libnsgif/gif.c new file mode 100644 index 00000000..d4d708f1 --- /dev/null +++ b/libvips/foreign/libnsgif/gif.c @@ -0,0 +1,1791 @@ +/* + * Copyright 2004 Richard Wilson + * Copyright 2008 Sean Fox + * Copyright 2013-2022 Michael Drake + * + * This file is part of NetSurf's libnsgif, http://www.netsurf-browser.org/ + * Licenced under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + */ + +#include +#include +#include +#include +#include + +#include "lzw.h" +#include "nsgif.h" + +/** Maximum colour table size */ +#define NSGIF_MAX_COLOURS 256 + +/** GIF frame data */ +typedef struct nsgif_frame { + struct nsgif_frame_info info; + + /** offset (in bytes) to the GIF frame data */ + uint32_t frame_pointer; + /** whether the frame has previously been decoded. */ + bool decoded; + /** whether the frame is totally opaque */ + bool opaque; + /** whether a full image redraw is required */ + bool redraw_required; + + /** the index designating a transparent pixel */ + uint32_t transparency_index; + + /* Frame flags */ + uint32_t flags; +} nsgif_frame; + +/** GIF animation data */ +struct nsgif { + struct nsgif_info info; + + /** LZW decode context */ + void *lzw_ctx; + /** callbacks for bitmap functions */ + nsgif_bitmap_cb_vt bitmap; + /** decoded frames */ + nsgif_frame *frames; + /** current frame */ + uint32_t frame; + /** current frame decoded to bitmap */ + uint32_t decoded_frame; + /** currently decoded image; stored as bitmap from bitmap_create callback */ + nsgif_bitmap_t *frame_image; + + uint16_t delay_min; + uint16_t delay_default; + + /** number of frames partially decoded */ + uint32_t frame_count_partial; + + /** pointer to GIF data */ + const uint8_t *buf; + /** current index into GIF data */ + uint32_t buf_pos; + /** total number of bytes of GIF data available */ + uint32_t buf_len; + + /** current number of frame holders */ + uint32_t frame_holders; + /** background index */ + uint32_t bg_index; + /** image aspect ratio (ignored) */ + uint32_t aspect_ratio; + /** size of colour table (in entries) */ + uint32_t colour_table_size; + + /** whether the GIF has a global colour table */ + bool global_colours; + /** current colour table */ + uint32_t *colour_table; + /** global colour table */ + uint32_t global_colour_table[NSGIF_MAX_COLOURS]; + /** local colour table */ + uint32_t local_colour_table[NSGIF_MAX_COLOURS]; + + /** previous frame for NSGIF_FRAME_RESTORE */ + void *prev_frame; + /** previous frame index */ + uint32_t prev_index; +}; + +/** + * Helper macro to get number of elements in an array. + * + * \param[in] _a Array to count elements of. + * \return NUlber of elements in array. + */ +#define NSGIF_ARRAY_LEN(_a) ((sizeof(_a)) / (sizeof(*_a))) + +/** + * + * \file + * \brief GIF image decoder + * + * The GIF format is thoroughly documented; a full description can be found at + * http://www.w3.org/Graphics/GIF/spec-gif89a.txt + * + * \todo Plain text and comment extensions should be implemented. + */ + +/** Internal flag that the colour table needs to be processed */ +#define NSGIF_PROCESS_COLOURS 0xaa000000 + +/** Internal flag that a frame is invalid/unprocessed */ +#define NSGIF_FRAME_INVALID UINT32_MAX + +/** Transparent colour */ +#define NSGIF_TRANSPARENT_COLOUR 0x00 + +/** No transparency */ +#define NSGIF_NO_TRANSPARENCY (0xFFFFFFFFu) + +/* GIF Flags */ +#define NSGIF_COLOUR_TABLE_MASK 0x80 +#define NSGIF_COLOUR_TABLE_SIZE_MASK 0x07 +#define NSGIF_BLOCK_TERMINATOR 0x00 +#define NSGIF_TRAILER 0x3b + +/** + * Convert an LZW result code to equivalent GIF result code. + * + * \param[in] l_res LZW response code. + * \return GIF result code. + */ +static nsgif_error nsgif__error_from_lzw(lzw_result l_res) +{ + static const nsgif_error g_res[] = { + [LZW_OK] = NSGIF_OK, + [LZW_NO_MEM] = NSGIF_ERR_OOM, + [LZW_OK_EOD] = NSGIF_ERR_END_OF_DATA, + [LZW_NO_DATA] = NSGIF_ERR_END_OF_DATA, + [LZW_EOI_CODE] = NSGIF_ERR_DATA_FRAME, + [LZW_BAD_ICODE] = NSGIF_ERR_DATA_FRAME, + [LZW_BAD_CODE] = NSGIF_ERR_DATA_FRAME, + }; + assert(l_res != LZW_BAD_PARAM); + assert(l_res != LZW_NO_COLOUR); + return g_res[l_res]; +} + +/** + * Updates the sprite memory size + * + * \param gif The animation context + * \param width The width of the sprite + * \param height The height of the sprite + * \return NSGIF_ERR_OOM for a memory error NSGIF_OK for success + */ +static nsgif_error nsgif__initialise_sprite( + struct nsgif *gif, + uint32_t width, + uint32_t height) +{ + /* Already allocated? */ + if (gif->frame_image) { + return NSGIF_OK; + } + + assert(gif->bitmap.create); + gif->frame_image = gif->bitmap.create(width, height); + if (gif->frame_image == NULL) { + return NSGIF_ERR_OOM; + } + + return NSGIF_OK; +} + +/** + * Helper to get the rendering bitmap for a gif. + * + * \param[in] gif The gif object we're decoding. + * \return Client pixel buffer for rendering into. + */ +static inline uint32_t* nsgif__bitmap_get( + struct nsgif *gif) +{ + nsgif_error ret; + + /* Make sure we have a buffer to decode to. */ + ret = nsgif__initialise_sprite(gif, gif->info.width, gif->info.height); + if (ret != NSGIF_OK) { + return NULL; + } + + /* Get the frame data */ + assert(gif->bitmap.get_buffer); + return (void *)gif->bitmap.get_buffer(gif->frame_image); +} + +/** + * Helper to tell the client that their bitmap was modified. + * + * \param[in] gif The gif object we're decoding. + */ +static inline void nsgif__bitmap_modified( + const struct nsgif *gif) +{ + if (gif->bitmap.modified) { + gif->bitmap.modified(gif->frame_image); + } +} + +/** + * Helper to tell the client that whether the bitmap is opaque. + * + * \param[in] gif The gif object we're decoding. + * \param[in] frame The frame that has been decoded. + */ +static inline void nsgif__bitmap_set_opaque( + const struct nsgif *gif, + const struct nsgif_frame *frame) +{ + if (gif->bitmap.set_opaque) { + gif->bitmap.set_opaque( + gif->frame_image, frame->opaque); + } +} + +/** + * Helper to get the client to determine if the bitmap is opaque. + * + * \todo: We don't really need to get the client to do this for us. + * + * \param[in] gif The gif object we're decoding. + * \return true if the bitmap is opaque, false otherwise. + */ +static inline bool nsgif__bitmap_get_opaque( + const struct nsgif *gif) +{ + if (gif->bitmap.test_opaque) { + return gif->bitmap.test_opaque( + gif->frame_image); + } + + return false; +} + +static void nsgif__record_frame( + struct nsgif *gif, + const uint32_t *bitmap) +{ + uint32_t *prev_frame; + + if (gif->decoded_frame == NSGIF_FRAME_INVALID || + gif->decoded_frame == gif->prev_index) { + /* No frame to copy, or already have this frame recorded. */ + return; + } + + bitmap = nsgif__bitmap_get(gif); + if (bitmap == NULL) { + return; + } + + if (gif->prev_frame == NULL) { + prev_frame = realloc(gif->prev_frame, + gif->info.width * gif->info.height * 4); + if (prev_frame == NULL) { + return; + } + } else { + prev_frame = gif->prev_frame; + } + + memcpy(prev_frame, bitmap, gif->info.width * gif->info.height * 4); + + gif->prev_frame = prev_frame; + gif->prev_index = gif->decoded_frame; +} + +static nsgif_error nsgif__recover_frame( + const struct nsgif *gif, + uint32_t *bitmap) +{ + const uint32_t *prev_frame = gif->prev_frame; + unsigned height = gif->info.height; + unsigned width = gif->info.width; + + memcpy(bitmap, prev_frame, height * width * sizeof(*bitmap)); + + return NSGIF_OK; +} + +/** + * Get the next line for GIF decode. + * + * Note that the step size must be initialised to 24 at the start of the frame + * (when y == 0). This is because of the first two passes of the frame have + * the same step size of 8, and the step size is used to determine the current + * pass. + * + * \param[in] height Frame height in pixels. + * \param[in,out] y Current row, starting from 0, updated on exit. + * \param[in,out] step Current step starting with 24, updated on exit. + * \return true if there is a row to process, false at the end of the frame. + */ +static inline bool nsgif__deinterlace(uint32_t height, uint32_t *y, uint8_t *step) +{ + *y += *step & 0xf; + + if (*y < height) return true; + + switch (*step) { + case 24: *y = 4; *step = 8; if (*y < height) return true; + /* Fall through. */ + case 8: *y = 2; *step = 4; if (*y < height) return true; + /* Fall through. */ + case 4: *y = 1; *step = 2; if (*y < height) return true; + /* Fall through. */ + default: + break; + } + + return false; +} + +/** + * Get the next line for GIF decode. + * + * \param[in] interlace Non-zero if the frame is not interlaced. + * \param[in] height Frame height in pixels. + * \param[in,out] y Current row, starting from 0, updated on exit. + * \param[in,out] step Current step starting with 24, updated on exit. + * \return true if there is a row to process, false at the end of the frame. + */ +static inline bool nsgif__next_row(uint32_t interlace, + uint32_t height, uint32_t *y, uint8_t *step) +{ + if (!interlace) { + return (++*y != height); + } else { + return nsgif__deinterlace(height, y, step); + } +} + +/** + * Get any frame clip adjustment for the image extent. + * + * \param[in] frame_off Frame's X or Y offset. + * \param[in] frame_dim Frame width or height. + * \param[in] image_ext Image width or height constraint. + * \return the amount the frame needs to be clipped to fit the image in given + * dimension. + */ +static inline uint32_t gif__clip( + uint32_t frame_off, + uint32_t frame_dim, + uint32_t image_ext) +{ + uint32_t frame_ext = frame_off + frame_dim; + + if (frame_ext <= image_ext) { + return 0; + } + + return frame_ext - image_ext; +} + +/** + * Perform any jump over decoded data, to accommodate clipped portion of frame. + * + * \param[in,out] skip Number of pixels of data to jump. + * \param[in,out] available Number of pixels of data currently available. + * \param[in,out] pos Position in decoded pixel value data. + */ +static inline void gif__jump_data( + uint32_t *skip, + uint32_t *available, + const uint8_t **pos) +{ + uint32_t jump = (*skip < *available) ? *skip : *available; + + *skip -= jump; + *available -= jump; + *pos += jump; +} + +static nsgif_error nsgif__decode_complex( + struct nsgif *gif, + uint32_t width, + uint32_t height, + uint32_t offset_x, + uint32_t offset_y, + uint32_t interlace, + const uint8_t *data, + uint32_t transparency_index, + uint32_t *restrict frame_data, + uint32_t *restrict colour_table) +{ + lzw_result res; + nsgif_error ret = NSGIF_OK; + uint32_t clip_x = gif__clip(offset_x, width, gif->info.width); + uint32_t clip_y = gif__clip(offset_y, height, gif->info.height); + const uint8_t *uncompressed; + uint32_t available = 0; + uint8_t step = 24; + uint32_t skip = 0; + uint32_t y = 0; + + if (offset_x >= gif->info.width || + offset_y >= gif->info.height) { + return NSGIF_OK; + } + + width -= clip_x; + height -= clip_y; + + if (width == 0 || height == 0) { + return NSGIF_OK; + } + + /* Initialise the LZW decoding */ + res = lzw_decode_init(gif->lzw_ctx, data[0], + gif->buf, gif->buf_len, + data + 1 - gif->buf); + if (res != LZW_OK) { + return nsgif__error_from_lzw(res); + } + + do { + uint32_t x; + uint32_t *frame_scanline; + + frame_scanline = frame_data + offset_x + + (y + offset_y) * gif->info.width; + + x = width; + while (x > 0) { + unsigned row_available; + while (available == 0) { + if (res != LZW_OK) { + /* Unexpected end of frame, try to recover */ + if (res == LZW_OK_EOD) { + ret = NSGIF_OK; + } else { + ret = nsgif__error_from_lzw(res); + } + return ret; + } + res = lzw_decode(gif->lzw_ctx, + &uncompressed, &available); + + if (available == 0) { + return NSGIF_OK; + } + gif__jump_data(&skip, &available, &uncompressed); + } + + row_available = x < available ? x : available; + x -= row_available; + available -= row_available; + if (transparency_index > 0xFF) { + while (row_available-- > 0) { + *frame_scanline++ = + colour_table[*uncompressed++]; + } + } else { + while (row_available-- > 0) { + register uint32_t colour; + colour = *uncompressed++; + if (colour != transparency_index) { + *frame_scanline = + colour_table[colour]; + } + frame_scanline++; + } + } + } + + skip = clip_x; + gif__jump_data(&skip, &available, &uncompressed); + } while (nsgif__next_row(interlace, height, &y, &step)); + + return ret; +} + +static nsgif_error nsgif__decode_simple( + struct nsgif *gif, + uint32_t height, + uint32_t offset_y, + const uint8_t *data, + uint32_t transparency_index, + uint32_t *restrict frame_data, + uint32_t *restrict colour_table) +{ + uint32_t pixels = gif->info.width * height; + uint32_t written = 0; + nsgif_error ret = NSGIF_OK; + lzw_result res; + + if (offset_y >= gif->info.height) { + return NSGIF_OK; + } + + height -= gif__clip(offset_y, height, gif->info.height); + + if (height == 0) { + return NSGIF_OK; + } + + /* Initialise the LZW decoding */ + res = lzw_decode_init_map(gif->lzw_ctx, data[0], + transparency_index, colour_table, + gif->buf, gif->buf_len, + data + 1 - gif->buf); + if (res != LZW_OK) { + return nsgif__error_from_lzw(res); + } + + frame_data += (offset_y * gif->info.width); + + while (pixels > 0) { + res = lzw_decode_map(gif->lzw_ctx, + frame_data, pixels, &written); + pixels -= written; + frame_data += written; + if (res != LZW_OK) { + /* Unexpected end of frame, try to recover */ + if (res == LZW_OK_EOD) { + ret = NSGIF_OK; + } else { + ret = nsgif__error_from_lzw(res); + } + break; + } + } + + if (pixels == 0) { + ret = NSGIF_OK; + } + + return ret; +} + +static inline nsgif_error nsgif__decode( + struct nsgif *gif, + struct nsgif_frame *frame, + const uint8_t *data, + uint32_t *restrict frame_data) +{ + enum { + GIF_MASK_INTERLACE = 0x40, + }; + + nsgif_error ret; + uint32_t width = frame->info.rect.x1 - frame->info.rect.x0; + uint32_t height = frame->info.rect.y1 - frame->info.rect.y0; + uint32_t offset_x = frame->info.rect.x0; + uint32_t offset_y = frame->info.rect.y0; + uint32_t interlace = frame->flags & GIF_MASK_INTERLACE; + uint32_t transparency_index = frame->transparency_index; + uint32_t *restrict colour_table = gif->colour_table; + + if (interlace == false && width == gif->info.width && offset_x == 0) { + ret = nsgif__decode_simple(gif, height, offset_y, + data, transparency_index, + frame_data, colour_table); + } else { + ret = nsgif__decode_complex(gif, width, height, + offset_x, offset_y, interlace, + data, transparency_index, + frame_data, colour_table); + } + + return ret; +} + +/** + * Helper to assign a pixel representation from a gif background colour array. + * + * \param[in] bg The background colour to read from. + * \param[out] px The pixel colour to write. + */ +static inline void nsgif__gif_bg_to_px( + const uint8_t bg[4], uint32_t *px) +{ + *px = *(uint32_t *)bg; +} + +/** + * Helper to assign a gif background colour array from a pixel representation. + * + * \param[in] px The pixel colour to read from. + * \param[out] bg The background colour to write. + */ +static inline void nsgif__gif_px_to_bg( + const uint32_t *px, uint8_t bg[4]) +{ + *(uint32_t *)bg = *px; +} + +/** + * Restore a GIF to the background colour. + * + * \param[in] gif The gif object we're decoding. + * \param[in] frame The frame to clear, or NULL. + * \param[in] bitmap The bitmap to clear the frame in. + */ +static void nsgif__restore_bg( + struct nsgif *gif, + struct nsgif_frame *frame, + uint32_t *bitmap) +{ + if (frame == NULL) { + memset(bitmap, NSGIF_TRANSPARENT_COLOUR, + gif->info.width * gif->info.height * sizeof(*bitmap)); + } else { + uint32_t width = frame->info.rect.x1 - frame->info.rect.x0; + uint32_t height = frame->info.rect.y1 - frame->info.rect.y0; + uint32_t offset_x = frame->info.rect.x0; + uint32_t offset_y = frame->info.rect.y0; + + width -= gif__clip(offset_x, width, gif->info.width); + height -= gif__clip(offset_y, height, gif->info.height); + + if (frame->info.display == false || width == 0) { + return; + } + + if (frame->info.transparency) { + for (uint32_t y = 0; y < height; y++) { + uint32_t *scanline = bitmap + offset_x + + (offset_y + y) * gif->info.width; + memset(scanline, NSGIF_TRANSPARENT_COLOUR, + width * sizeof(*bitmap)); + } + } else { + for (uint32_t y = 0; y < height; y++) { + uint32_t *scanline = bitmap + offset_x + + (offset_y + y) * gif->info.width; + for (uint32_t x = 0; x < width; x++) { + nsgif__gif_bg_to_px( + gif->info.background, + &scanline[x]); + } + } + } + } +} + +static nsgif_error nsgif__update_bitmap( + struct nsgif *gif, + struct nsgif_frame *frame, + const uint8_t *data, + uint32_t frame_idx) +{ + nsgif_error ret; + uint32_t *bitmap; + + gif->decoded_frame = frame_idx; + + bitmap = nsgif__bitmap_get(gif); + if (bitmap == NULL) { + return NSGIF_ERR_OOM; + } + + /* Handle any bitmap clearing/restoration required before decoding this + * frame. */ + if (frame_idx == 0 || gif->decoded_frame == NSGIF_FRAME_INVALID) { + nsgif__restore_bg(gif, NULL, bitmap); + + } else { + struct nsgif_frame *prev = &gif->frames[frame_idx - 1]; + + if (prev->info.disposal == NSGIF_DISPOSAL_RESTORE_BG) { + nsgif__restore_bg(gif, prev, bitmap); + + } else if (prev->info.disposal == NSGIF_DISPOSAL_RESTORE_PREV) { + ret = nsgif__recover_frame(gif, bitmap); + if (ret != NSGIF_OK) { + nsgif__restore_bg(gif, prev, bitmap); + } + } + } + + if (frame->info.disposal == NSGIF_DISPOSAL_RESTORE_PREV) { + /* Store the previous frame for later restoration */ + nsgif__record_frame(gif, bitmap); + } + + ret = nsgif__decode(gif, frame, data, bitmap); + + nsgif__bitmap_modified(gif); + + if (!frame->decoded) { + frame->opaque = nsgif__bitmap_get_opaque(gif); + frame->decoded = true; + } + nsgif__bitmap_set_opaque(gif, frame); + + return ret; +} + +/** + * Parse the graphic control extension + * + * \param[in] frame The gif frame object we're decoding. + * \param[in] data The data to decode. + * \param[in] len Byte length of data. + * \return NSGIF_ERR_END_OF_DATA if more data is needed, + * NSGIF_OK for success. + */ +static nsgif_error nsgif__parse_extension_graphic_control( + struct nsgif_frame *frame, + const uint8_t *data, + size_t len) +{ + enum { + GIF_MASK_TRANSPARENCY = 0x01, + GIF_MASK_DISPOSAL = 0x1c, + }; + + /* 6-byte Graphic Control Extension is: + * + * +0 CHAR Graphic Control Label + * +1 CHAR Block Size + * +2 CHAR __Packed Fields__ + * 3BITS Reserved + * 3BITS Disposal Method + * 1BIT User Input Flag + * 1BIT Transparent Color Flag + * +3 SHORT Delay Time + * +5 CHAR Transparent Color Index + */ + if (len < 6) { + return NSGIF_ERR_END_OF_DATA; + } + + frame->info.delay = data[3] | (data[4] << 8); + + if (data[2] & GIF_MASK_TRANSPARENCY) { + frame->info.transparency = true; + frame->transparency_index = data[5]; + } + + frame->info.disposal = ((data[2] & GIF_MASK_DISPOSAL) >> 2); + /* I have encountered documentation and GIFs in the + * wild that use 0x04 to restore the previous frame, + * rather than the officially documented 0x03. I + * believe some (older?) software may even actually + * export this way. We handle this as a type of + * "quirks" mode. */ + if (frame->info.disposal == NSGIF_DISPOSAL_RESTORE_QUIRK) { + frame->info.disposal = NSGIF_DISPOSAL_RESTORE_PREV; + } + + /* if we are clearing the background then we need to + * redraw enough to cover the previous frame too. */ + frame->redraw_required = + frame->info.disposal == NSGIF_DISPOSAL_RESTORE_BG || + frame->info.disposal == NSGIF_DISPOSAL_RESTORE_PREV; + + return NSGIF_OK; +} + +/** + * Parse the application extension + * + * \param[in] gif The gif object we're decoding. + * \param[in] data The data to decode. + * \param[in] len Byte length of data. + * \return NSGIF_ERR_END_OF_DATA if more data is needed, + * NSGIF_OK for success. + */ +static nsgif_error nsgif__parse_extension_application( + struct nsgif *gif, + const uint8_t *data, + size_t len) +{ + /* 14-byte+ Application Extension is: + * + * +0 CHAR Application Extension Label + * +1 CHAR Block Size + * +2 8CHARS Application Identifier + * +10 3CHARS Appl. Authentication Code + * +13 1-256 Application Data (Data sub-blocks) + */ + if (len < 17) { + return NSGIF_ERR_END_OF_DATA; + } + + if ((data[1] == 0x0b) && + (strncmp((const char *)data + 2, "NETSCAPE2.0", 11) == 0) && + (data[13] == 0x03) && (data[14] == 0x01)) { + gif->info.loop_max = data[15] | (data[16] << 8); + } + + return NSGIF_OK; +} + +/** + * Parse the frame's extensions + * + * \param[in] gif The gif object we're decoding. + * \param[in] frame The frame to parse extensions for. + * \param[in] pos Current position in data, updated on exit. + * \param[in] decode Whether to decode or skip over the extension. + * \return NSGIF_ERR_END_OF_DATA if more data is needed, + * NSGIF_OK for success. + */ +static nsgif_error nsgif__parse_frame_extensions( + struct nsgif *gif, + struct nsgif_frame *frame, + const uint8_t **pos, + bool decode) +{ + enum { + GIF_EXT_INTRODUCER = 0x21, + GIF_EXT_GRAPHIC_CONTROL = 0xf9, + GIF_EXT_COMMENT = 0xfe, + GIF_EXT_PLAIN_TEXT = 0x01, + GIF_EXT_APPLICATION = 0xff, + }; + const uint8_t *nsgif_data = *pos; + const uint8_t *nsgif_end = gif->buf + gif->buf_len; + int nsgif_bytes = nsgif_end - nsgif_data; + + /* Initialise the extensions */ + while (nsgif_bytes > 0 && nsgif_data[0] == GIF_EXT_INTRODUCER) { + bool block_step = true; + nsgif_error ret; + + nsgif_data++; + nsgif_bytes--; + + if (nsgif_bytes == 0) { + return NSGIF_ERR_END_OF_DATA; + } + + /* Switch on extension label */ + switch (nsgif_data[0]) { + case GIF_EXT_GRAPHIC_CONTROL: + if (decode) { + ret = nsgif__parse_extension_graphic_control( + frame, + nsgif_data, + nsgif_bytes); + if (ret != NSGIF_OK) { + return ret; + } + } + break; + + case GIF_EXT_APPLICATION: + if (decode) { + ret = nsgif__parse_extension_application( + gif, nsgif_data, nsgif_bytes); + if (ret != NSGIF_OK) { + return ret; + } + } + break; + + case GIF_EXT_COMMENT: + /* Move the pointer to the first data sub-block Skip 1 + * byte for the extension label. */ + ++nsgif_data; + block_step = false; + break; + + default: + break; + } + + if (block_step) { + /* Move the pointer to the first data sub-block Skip 2 + * bytes for the extension label and size fields Skip + * the extension size itself + */ + if (nsgif_bytes < 2) { + return NSGIF_ERR_END_OF_DATA; + } + nsgif_data += 2 + nsgif_data[1]; + } + + /* Repeatedly skip blocks until we get a zero block or run out + * of data. This data is ignored by this gif decoder. */ + while (nsgif_data < nsgif_end && nsgif_data[0] != NSGIF_BLOCK_TERMINATOR) { + nsgif_data += nsgif_data[0] + 1; + if (nsgif_data >= nsgif_end) { + return NSGIF_ERR_END_OF_DATA; + } + } + nsgif_data++; + nsgif_bytes = nsgif_end - nsgif_data; + } + + if (nsgif_data > nsgif_end) { + nsgif_data = nsgif_end; + } + + /* Set buffer position and return */ + *pos = nsgif_data; + return NSGIF_OK; +} + +/** + * Parse a GIF Image Descriptor. + * + * The format is: + * + * +0 CHAR Image Separator (0x2c) + * +1 SHORT Image Left Position + * +3 SHORT Image Top Position + * +5 SHORT Width + * +7 SHORT Height + * +9 CHAR __Packed Fields__ + * 1BIT Local Colour Table Flag + * 1BIT Interlace Flag + * 1BIT Sort Flag + * 2BITS Reserved + * 3BITS Size of Local Colour Table + * + * \param[in] gif The gif object we're decoding. + * \param[in] frame The frame to parse an image descriptor for. + * \param[in] pos Current position in data, updated on exit. + * \param[in] decode Whether to decode the image descriptor. + * \return NSGIF_OK on success, appropriate error otherwise. + */ +static nsgif_error nsgif__parse_image_descriptor( + struct nsgif *gif, + struct nsgif_frame *frame, + const uint8_t **pos, + bool decode) +{ + const uint8_t *data = *pos; + size_t len = gif->buf + gif->buf_len - data; + enum { + NSGIF_IMAGE_DESCRIPTOR_LEN = 10u, + NSGIF_IMAGE_SEPARATOR = 0x2Cu, + }; + + assert(gif != NULL); + assert(frame != NULL); + + if (len < NSGIF_IMAGE_DESCRIPTOR_LEN) { + return NSGIF_ERR_END_OF_DATA; + } + + if (decode) { + uint32_t x, y, w, h; + + if (data[0] != NSGIF_IMAGE_SEPARATOR) { + return NSGIF_ERR_DATA_FRAME; + } + + x = data[1] | (data[2] << 8); + y = data[3] | (data[4] << 8); + w = data[5] | (data[6] << 8); + h = data[7] | (data[8] << 8); + frame->flags = data[9]; + + frame->info.rect.x0 = x; + frame->info.rect.y0 = y; + frame->info.rect.x1 = x + w; + frame->info.rect.y1 = y + h; + + /* Allow first frame to grow image dimensions. */ + if (gif->info.frame_count == 0) { + if (x + w > gif->info.width) { + gif->info.width = x + w; + } + if (y + h > gif->info.height) { + gif->info.height = y + h; + } + } + } + + *pos += NSGIF_IMAGE_DESCRIPTOR_LEN; + return NSGIF_OK; +} + +/** + * Extract a GIF colour table into a LibNSGIF colour table buffer. + * + * \param[in] gif The gif object we're decoding. + * \param[in] colour_table The colour table to populate. + * \param[in] colour_table_entries The number of colour table entries. + * \param[in] pos Current position in data, updated on exit. + * \param[in] decode Whether to decode the colour table. + * \return NSGIF_OK on success, appropriate error otherwise. + */ +static nsgif_error nsgif__colour_table_extract( + struct nsgif *gif, + uint32_t colour_table[NSGIF_MAX_COLOURS], + size_t colour_table_entries, + const uint8_t **pos, + bool decode) +{ + const uint8_t *data = *pos; + size_t len = gif->buf + gif->buf_len - data; + + if (len < colour_table_entries * 3) { + return NSGIF_ERR_END_OF_DATA; + } + + if (decode) { + int count = colour_table_entries; + uint8_t *entry = (uint8_t *)colour_table; + + while (count--) { + /* Gif colour map contents are r,g,b. + * + * We want to pack them bytewise into the + * colour table, such that the red component + * is in byte 0 and the alpha component is in + * byte 3. + */ + + *entry++ = *data++; /* r */ + *entry++ = *data++; /* g */ + *entry++ = *data++; /* b */ + *entry++ = 0xff; /* a */ + } + } + + *pos += colour_table_entries * 3; + return NSGIF_OK; +} + +/** + * Get a frame's colour table. + * + * Sets up gif->colour_table for the frame. + * + * \param[in] gif The gif object we're decoding. + * \param[in] frame The frame to get the colour table for. + * \param[in] pos Current position in data, updated on exit. + * \param[in] decode Whether to decode the colour table. + * \return NSGIF_OK on success, appropriate error otherwise. + */ +static nsgif_error nsgif__parse_colour_table( + struct nsgif *gif, + struct nsgif_frame *frame, + const uint8_t **pos, + bool decode) +{ + nsgif_error ret; + + assert(gif != NULL); + assert(frame != NULL); + + if ((frame->flags & NSGIF_COLOUR_TABLE_MASK) == 0) { + gif->colour_table = gif->global_colour_table; + return NSGIF_OK; + } + + ret = nsgif__colour_table_extract(gif, gif->local_colour_table, + 2 << (frame->flags & NSGIF_COLOUR_TABLE_SIZE_MASK), + pos, decode); + if (ret != NSGIF_OK) { + return ret; + } + + gif->colour_table = gif->local_colour_table; + return NSGIF_OK; +} + +/** + * Parse the image data for a gif frame. + * + * Sets up gif->colour_table for the frame. + * + * \param[in] gif The gif object we're decoding. + * \param[in] frame The frame to parse image data for. + * \param[in] pos Current position in data, updated on exit. + * \param[in] decode Whether to decode the image data. + * \return NSGIF_OK on success, appropriate error otherwise. + */ +static nsgif_error nsgif__parse_image_data( + struct nsgif *gif, + struct nsgif_frame *frame, + const uint8_t **pos, + bool decode) +{ + const uint8_t *data = *pos; + size_t len = gif->buf + gif->buf_len - data; + uint32_t frame_idx = frame - gif->frames; + uint8_t minimum_code_size; + nsgif_error ret; + + assert(gif != NULL); + assert(frame != NULL); + + if (!decode) { + gif->frame_count_partial = frame_idx + 1; + } + + /* Ensure sufficient data remains. A gif trailer or a minimum lzw code + * followed by a gif trailer is treated as OK, although without any + * image data. */ + switch (len) { + default: if (data[0] == NSGIF_TRAILER) return NSGIF_OK; + break; + case 2: if (data[1] == NSGIF_TRAILER) return NSGIF_OK; + /* Fall through. */ + case 1: if (data[0] == NSGIF_TRAILER) return NSGIF_OK; + /* Fall through. */ + case 0: return NSGIF_ERR_END_OF_DATA; + } + + minimum_code_size = data[0]; + if (minimum_code_size >= LZW_CODE_MAX) { + return NSGIF_ERR_DATA_FRAME; + } + + if (decode) { + ret = nsgif__update_bitmap(gif, frame, data, frame_idx); + } else { + uint32_t block_size = 0; + + /* Skip the minimum code size. */ + data++; + len--; + + while (block_size != 1) { + if (len < 1) return NSGIF_ERR_END_OF_DATA; + block_size = data[0] + 1; + /* Check if the frame data runs off the end of the file */ + if (block_size > len) { + block_size = len; + return NSGIF_OK; + } + + len -= block_size; + data += block_size; + } + + *pos = data; + + gif->info.frame_count = frame_idx + 1; + gif->frames[frame_idx].info.display = true; + + return NSGIF_OK; + } + + return ret; +} + +static struct nsgif_frame *nsgif__get_frame( + struct nsgif *gif, + uint32_t frame_idx) +{ + struct nsgif_frame *frame; + + if (gif->frame_holders > frame_idx) { + frame = &gif->frames[frame_idx]; + } else { + /* Allocate more memory */ + size_t count = frame_idx + 1; + struct nsgif_frame *temp; + + temp = realloc(gif->frames, count * sizeof(*frame)); + if (temp == NULL) { + return NULL; + } + gif->frames = temp; + gif->frame_holders = count; + + frame = &gif->frames[frame_idx]; + + frame->transparency_index = NSGIF_NO_TRANSPARENCY; + frame->frame_pointer = gif->buf_pos; + frame->info.transparency = false; + frame->redraw_required = false; + frame->info.display = false; + frame->info.disposal = 0; + frame->info.delay = 10; + frame->decoded = false; + } + + return frame; +} + +/** + * Attempts to initialise the next frame + * + * \param[in] gif The animation context + * \param[in] frame_idx The frame number to decode. + * \param[in] decode Whether to decode the graphical image data. + * \return NSGIF_OK on success, appropriate error otherwise. +*/ +static nsgif_error nsgif__process_frame( + struct nsgif *gif, + uint32_t frame_idx, + bool decode) +{ + nsgif_error ret; + const uint8_t *pos; + const uint8_t *end; + struct nsgif_frame *frame; + + frame = nsgif__get_frame(gif, frame_idx); + if (frame == NULL) { + return NSGIF_ERR_OOM; + } + + end = gif->buf + gif->buf_len; + + if (decode) { + pos = gif->buf + frame->frame_pointer; + + /* Ensure this frame is supposed to be decoded */ + if (frame->info.display == false) { + return NSGIF_OK; + } + + /* Ensure the frame is in range to decode */ + if (frame_idx > gif->frame_count_partial) { + return NSGIF_ERR_END_OF_DATA; + } + + /* Done if frame is already decoded */ + if (frame_idx == gif->decoded_frame) { + return NSGIF_OK; + } + } else { + pos = (uint8_t *)(gif->buf + gif->buf_pos); + + /* Check if we've finished */ + if (pos < end && pos[0] == NSGIF_TRAILER) { + return NSGIF_OK; + } + + /* We could theoretically get some junk data that gives us + * millions of frames, so we ensure that we don't have a + * silly number. */ + if (frame_idx > 4096) { + return NSGIF_ERR_FRAME_COUNT; + } + } + + ret = nsgif__parse_frame_extensions(gif, frame, &pos, !decode); + if (ret != NSGIF_OK) { + goto cleanup; + } + + ret = nsgif__parse_image_descriptor(gif, frame, &pos, !decode); + if (ret != NSGIF_OK) { + goto cleanup; + } + + ret = nsgif__parse_colour_table(gif, frame, &pos, decode); + if (ret != NSGIF_OK) { + goto cleanup; + } + + ret = nsgif__parse_image_data(gif, frame, &pos, decode); + if (ret != NSGIF_OK) { + goto cleanup; + } + +cleanup: + if (!decode) { + gif->buf_pos = pos - gif->buf; + } + + return ret; +} + +/* exported function documented in nsgif.h */ +void nsgif_destroy(nsgif_t *gif) +{ + if (gif == NULL) { + return; + } + + /* Release all our memory blocks */ + if (gif->frame_image) { + assert(gif->bitmap.destroy); + gif->bitmap.destroy(gif->frame_image); + gif->frame_image = NULL; + } + + free(gif->frames); + gif->frames = NULL; + + free(gif->prev_frame); + gif->prev_frame = NULL; + + lzw_context_destroy(gif->lzw_ctx); + gif->lzw_ctx = NULL; + + free(gif); +} + +/* exported function documented in nsgif.h */ +nsgif_error nsgif_create(const nsgif_bitmap_cb_vt *bitmap_vt, nsgif_t **gif_out) +{ + nsgif_t *gif; + + gif = calloc(1, sizeof(*gif)); + if (gif == NULL) { + return NSGIF_ERR_OOM; + } + + gif->bitmap = *bitmap_vt; + gif->decoded_frame = NSGIF_FRAME_INVALID; + gif->prev_index = NSGIF_FRAME_INVALID; + + gif->delay_min = 2; + gif->delay_default = 10; + + *gif_out = gif; + return NSGIF_OK; +} + +/** + * Read GIF header. + * + * 6-byte GIF file header is: + * + * +0 3CHARS Signature ('GIF') + * +3 3CHARS Version ('87a' or '89a') + * + * \param[in] gif The GIF object we're decoding. + * \param[in,out] pos The current buffer position, updated on success. + * \param[in] strict Whether to require a known GIF version. + * \return NSGIF_OK on success, appropriate error otherwise. + */ +static nsgif_error nsgif__parse_header( + struct nsgif *gif, + const uint8_t **pos, + bool strict) +{ + const uint8_t *data = *pos; + size_t len = gif->buf + gif->buf_len - data; + + if (len < 6) { + return NSGIF_ERR_END_OF_DATA; + } + + if (strncmp((const char *) data, "GIF", 3) != 0) { + return NSGIF_ERR_DATA; + } + data += 3; + + if (strict == true) { + if ((strncmp((const char *) data, "87a", 3) != 0) && + (strncmp((const char *) data, "89a", 3) != 0)) { + return NSGIF_ERR_DATA; + } + } + data += 3; + + *pos = data; + return NSGIF_OK; +} + +/** + * Read Logical Screen Descriptor. + * + * 7-byte Logical Screen Descriptor is: + * + * +0 SHORT Logical Screen Width + * +2 SHORT Logical Screen Height + * +4 CHAR __Packed Fields__ + * 1BIT Global Colour Table Flag + * 3BITS Colour Resolution + * 1BIT Sort Flag + * 3BITS Size of Global Colour Table + * +5 CHAR Background Colour Index + * +6 CHAR Pixel Aspect Ratio + * + * \param[in] gif The GIF object we're decoding. + * \param[in,out] pos The current buffer position, updated on success. + * \return NSGIF_OK on success, appropriate error otherwise. + */ +static nsgif_error nsgif__parse_logical_screen_descriptor( + struct nsgif *gif, + const uint8_t **pos) +{ + const uint8_t *data = *pos; + size_t len = gif->buf + gif->buf_len - data; + + if (len < 7) { + return NSGIF_ERR_END_OF_DATA; + } + + gif->info.width = data[0] | (data[1] << 8); + gif->info.height = data[2] | (data[3] << 8); + gif->global_colours = data[4] & NSGIF_COLOUR_TABLE_MASK; + gif->colour_table_size = 2 << (data[4] & NSGIF_COLOUR_TABLE_SIZE_MASK); + gif->bg_index = data[5]; + gif->aspect_ratio = data[6]; + gif->info.loop_max = 1; + + *pos += 7; + return NSGIF_OK; +} + +/* exported function documented in nsgif.h */ +nsgif_error nsgif_data_scan( + nsgif_t *gif, + size_t size, + const uint8_t *data) +{ + const uint8_t *nsgif_data; + nsgif_error ret; + uint32_t frames; + + /* Initialize values */ + gif->buf_len = size; + gif->buf = data; + + /* Get our current processing position */ + nsgif_data = gif->buf + gif->buf_pos; + + /* See if we should initialise the GIF */ + if (gif->buf_pos == 0) { + /* We want everything to be NULL before we start so we've no + * chance of freeing bad pointers (paranoia) + */ + gif->frame_image = NULL; + gif->frames = NULL; + gif->frame_holders = 0; + + /* The caller may have been lazy and not reset any values */ + gif->info.frame_count = 0; + gif->frame_count_partial = 0; + gif->decoded_frame = NSGIF_FRAME_INVALID; + gif->frame = NSGIF_FRAME_INVALID; + + ret = nsgif__parse_header(gif, &nsgif_data, false); + if (ret != NSGIF_OK) { + return ret; + } + + ret = nsgif__parse_logical_screen_descriptor(gif, &nsgif_data); + if (ret != NSGIF_OK) { + return ret; + } + + /* Remember we've done this now */ + gif->buf_pos = nsgif_data - gif->buf; + + /* Some broken GIFs report the size as the screen size they + * were created in. As such, we detect for the common cases and + * set the sizes as 0 if they are found which results in the + * GIF being the maximum size of the frames. + */ + if (((gif->info.width == 640) && (gif->info.height == 480)) || + ((gif->info.width == 640) && (gif->info.height == 512)) || + ((gif->info.width == 800) && (gif->info.height == 600)) || + ((gif->info.width == 1024) && (gif->info.height == 768)) || + ((gif->info.width == 1280) && (gif->info.height == 1024)) || + ((gif->info.width == 1600) && (gif->info.height == 1200)) || + ((gif->info.width == 0) || (gif->info.height == 0)) || + ((gif->info.width > 2048) || (gif->info.height > 2048))) { + gif->info.width = 1; + gif->info.height = 1; + } + + /* Set the first colour to a value that will never occur in + * reality so we know if we've processed it + */ + gif->global_colour_table[0] = NSGIF_PROCESS_COLOURS; + + /* Check if the GIF has no frame data (13-byte header + 1-byte + * termination block) Although generally useless, the GIF + * specification does not expressly prohibit this + */ + if (gif->buf_len == gif->buf_pos + 1) { + if (nsgif_data[0] == NSGIF_TRAILER) { + return NSGIF_OK; + } + } + } + + /* Do the colour map if we haven't already. As the top byte is always + * 0xff or 0x00 depending on the transparency we know if it's been + * filled in. + */ + if (gif->global_colour_table[0] == NSGIF_PROCESS_COLOURS) { + /* Check for a global colour map signified by bit 7 */ + if (gif->global_colours) { + ret = nsgif__colour_table_extract(gif, + gif->global_colour_table, + gif->colour_table_size, + &nsgif_data, true); + if (ret != NSGIF_OK) { + return ret; + } + + gif->buf_pos = (nsgif_data - gif->buf); + } else { + /* Create a default colour table with the first two + * colours as black and white + */ + uint32_t *entry = gif->global_colour_table; + + entry[0] = 0x00000000; + /* Force Alpha channel to opaque */ + ((uint8_t *) entry)[3] = 0xff; + + entry[1] = 0xffffffff; + } + + if (gif->global_colours && + gif->bg_index < gif->colour_table_size) { + size_t bg_idx = gif->bg_index; + nsgif__gif_px_to_bg( + &gif->global_colour_table[bg_idx], + gif->info.background); + } else { + nsgif__gif_px_to_bg( + &gif->global_colour_table[0], + gif->info.background); + } + } + + if (gif->lzw_ctx == NULL) { + lzw_result res = lzw_context_create( + (struct lzw_ctx **)&gif->lzw_ctx); + if (res != LZW_OK) { + return nsgif__error_from_lzw(res); + } + } + + /* Try to initialise all frames. */ + do { + frames = gif->info.frame_count; + ret = nsgif__process_frame(gif, frames, false); + } while (gif->info.frame_count > frames); + + if (ret == NSGIF_ERR_END_OF_DATA && gif->info.frame_count > 0) { + ret = NSGIF_OK; + } + + return ret; +} + +static void nsgif__redraw_rect_extend( + const nsgif_rect_t *frame, + nsgif_rect_t *redraw) +{ + if (redraw->x1 == 0 || redraw->y1 == 0) { + *redraw = *frame; + } else { + if (redraw->x0 > frame->x0) { + redraw->x0 = frame->x0; + } + if (redraw->x1 < frame->x1) { + redraw->x1 = frame->x1; + } + if (redraw->y0 > frame->y0) { + redraw->y0 = frame->y0; + } + if (redraw->y1 < frame->y1) { + redraw->y1 = frame->y1; + } + } +} + +static uint32_t nsgif__frame_next( + nsgif_t *gif, + bool partial, + uint32_t frame) +{ + uint32_t frames = partial ? + gif->frame_count_partial : + gif->info.frame_count; + + if (frames == 0) { + return NSGIF_FRAME_INVALID; + } + + frame++; + return (frame >= frames) ? 0 : frame; +} + +static nsgif_error nsgif__next_displayable_frame( + nsgif_t *gif, + uint32_t *frame, + uint32_t *delay) +{ + uint32_t next = *frame; + + do { + next = nsgif__frame_next(gif, false, next); + if (next == *frame || next == NSGIF_FRAME_INVALID) { + return NSGIF_ERR_FRAME_DISPLAY; + } + + if (delay != NULL) { + *delay += gif->frames[next].info.delay; + } + + } while (gif->frames[next].info.display == false); + + *frame = next; + return NSGIF_OK; +} + +static inline bool nsgif__animation_complete(int count, int max) +{ + if (max == 0) { + return false; + } + + return (count >= max); +} + +nsgif_error nsgif_reset( + nsgif_t *gif) +{ + gif->info.loop_count = 0; + gif->frame = NSGIF_FRAME_INVALID; + + return NSGIF_OK; +} + +/* exported function documented in nsgif.h */ +nsgif_error nsgif_frame_prepare( + nsgif_t *gif, + nsgif_rect_t *area, + uint32_t *delay_cs, + uint32_t *frame_new) +{ + nsgif_error ret; + nsgif_rect_t rect = { + .x1 = 0, + .y1 = 0, + }; + uint32_t delay = 0; + uint32_t frame = gif->frame; + + if (gif->frame != NSGIF_FRAME_INVALID && + gif->frame < gif->info.frame_count && + gif->frames[gif->frame].info.display) { + rect = gif->frames[gif->frame].info.rect; + } + + if (nsgif__animation_complete( + gif->info.loop_count, + gif->info.loop_max)) { + return NSGIF_ERR_ANIMATION_END; + } + + ret = nsgif__next_displayable_frame(gif, &frame, &delay); + if (ret != NSGIF_OK) { + return ret; + } + + if (gif->frame != NSGIF_FRAME_INVALID && frame < gif->frame) { + gif->info.loop_count++; + } + + if (gif->info.frame_count == 1) { + delay = NSGIF_INFINITE; + + } else if (gif->info.loop_max != 0) { + uint32_t frame_next = frame; + ret = nsgif__next_displayable_frame(gif, &frame_next, NULL); + if (ret != NSGIF_OK) { + return ret; + } + + if (frame_next < frame) { + if (nsgif__animation_complete( + gif->info.loop_count + 1, + gif->info.loop_max)) { + delay = NSGIF_INFINITE; + } + } + } + + gif->frame = frame; + nsgif__redraw_rect_extend(&gif->frames[frame].info.rect, &rect); + + if (delay < gif->delay_min) { + delay = gif->delay_default; + } + + *frame_new = gif->frame; + *delay_cs = delay; + *area = rect; + + return NSGIF_OK; +} + +/* exported function documented in nsgif.h */ +nsgif_error nsgif_frame_decode( + nsgif_t *gif, + uint32_t frame, + nsgif_bitmap_t **bitmap) +{ + uint32_t start_frame; + nsgif_error ret = NSGIF_OK; + + if (frame > gif->info.frame_count) { + return NSGIF_ERR_BAD_FRAME; + } + + if (gif->decoded_frame == frame) { + *bitmap = gif->frame_image; + return NSGIF_OK; + + } else if (gif->decoded_frame >= frame || + gif->decoded_frame == NSGIF_FRAME_INVALID) { + /* Can skip to first frame or restart. */ + start_frame = 0; + } else { + start_frame = nsgif__frame_next( + gif, false, gif->decoded_frame); + } + + for (uint32_t f = start_frame; f <= frame; f++) { + ret = nsgif__process_frame(gif, f, true); + if (ret != NSGIF_OK) { + return ret; + } + } + + *bitmap = gif->frame_image; + return ret; +} + +/* exported function documented in nsgif.h */ +const nsgif_info_t *nsgif_get_info(const nsgif_t *gif) +{ + return &gif->info; +} + +/* exported function documented in nsgif.h */ +const nsgif_frame_info_t *nsgif_get_frame_info( + const nsgif_t *gif, + uint32_t frame) +{ + if (frame > gif->info.frame_count) { + return NULL; + } + + return &gif->frames[frame].info; +} + +/* exported function documented in nsgif.h */ +const char *nsgif_strerror(nsgif_error err) +{ + static const char *const str[] = { + [NSGIF_OK] = "Success", + [NSGIF_ERR_OOM] = "Out of memory", + [NSGIF_ERR_DATA] = "Invalid source data", + [NSGIF_ERR_BAD_FRAME] = "Requested frame does not exist", + [NSGIF_ERR_DATA_FRAME] = "Invalid frame data", + [NSGIF_ERR_FRAME_COUNT] = "Excessive number of frames", + [NSGIF_ERR_END_OF_DATA] = "Insufficient data for first frame", + [NSGIF_ERR_END_OF_FRAME] = "End of data during frame", + [NSGIF_ERR_FRAME_DISPLAY] = "Frame can't be displayed", + [NSGIF_ERR_ANIMATION_END] = "Animation complete", + }; + + if (err >= NSGIF_ARRAY_LEN(str) || str[err] == NULL) { + return "Unknown error"; + } + + return str[err]; +} + +/* exported function documented in nsgif.h */ +const char *nsgif_str_disposal(enum nsgif_disposal disposal) +{ + static const char *const str[] = { + [NSGIF_DISPOSAL_UNSPECIFIED] = "Unspecified", + [NSGIF_DISPOSAL_NONE] = "None", + [NSGIF_DISPOSAL_RESTORE_BG] = "Restore background", + [NSGIF_DISPOSAL_RESTORE_PREV] = "Restore previous", + [NSGIF_DISPOSAL_RESTORE_QUIRK] = "Restore quirk", + }; + + if (disposal >= NSGIF_ARRAY_LEN(str) || str[disposal] == NULL) { + return "Unspecified"; + } + + return str[disposal]; +} diff --git a/libvips/foreign/libnsgif/libnsgif.c b/libvips/foreign/libnsgif/libnsgif.c deleted file mode 100644 index 8bd6950c..00000000 --- a/libvips/foreign/libnsgif/libnsgif.c +++ /dev/null @@ -1,1461 +0,0 @@ -/* - * Copyright 2004 Richard Wilson - * Copyright 2008 Sean Fox - * Copyright 2013-2021 Michael Drake - * - * This file is part of NetSurf's libnsgif, http://www.netsurf-browser.org/ - * Licenced under the MIT License, - * http://www.opensource.org/licenses/mit-license.php - */ - -#include -#include -#include -#include -#include - -#include "lzw.h" -#include "libnsgif.h" - -/** - * - * \file - * \brief GIF image decoder - * - * The GIF format is thoroughly documented; a full description can be found at - * http://www.w3.org/Graphics/GIF/spec-gif89a.txt - * - * \todo Plain text and comment extensions should be implemented. - */ - -/** Maximum colour table size */ -#define GIF_MAX_COLOURS 256 - -/** Internal flag that the colour table needs to be processed */ -#define GIF_PROCESS_COLOURS 0xaa000000 - -/** Internal flag that a frame is invalid/unprocessed */ -#define GIF_INVALID_FRAME -1 - -/** Transparent colour */ -#define GIF_TRANSPARENT_COLOUR 0x00 - -/** No transparency */ -#define GIF_NO_TRANSPARENCY (0xFFFFFFFFu) - -enum gif_disposal { - GIF_DISPOSAL_UNSPECIFIED, - GIF_DISPOSAL_NONE, - GIF_DISPOSAL_RESTORE_BG, - GIF_DISPOSAL_RESTORE_PREV, - GIF_DISPOSAL_RESTORE_QUIRK, /**< Alias for GIF_DISPOSAL_RESTORE_PREV. */ -}; - -/* GIF Flags */ -#define GIF_INTERLACE_MASK 0x40 -#define GIF_COLOUR_TABLE_MASK 0x80 -#define GIF_COLOUR_TABLE_SIZE_MASK 0x07 -#define GIF_EXTENSION_INTRODUCER 0x21 -#define GIF_EXTENSION_GRAPHIC_CONTROL 0xf9 -#define GIF_DISPOSAL_MASK 0x1c -#define GIF_TRANSPARENCY_MASK 0x01 -#define GIF_EXTENSION_COMMENT 0xfe -#define GIF_EXTENSION_PLAIN_TEXT 0x01 -#define GIF_EXTENSION_APPLICATION 0xff -#define GIF_BLOCK_TERMINATOR 0x00 -#define GIF_TRAILER 0x3b - -/** - * Convert an LZW result code to equivalent GIF result code. - * - * \param[in] l_res LZW response code. - * \return GIF result code. - */ -static gif_result gif__error_from_lzw(lzw_result l_res) -{ - static const gif_result g_res[] = { - [LZW_OK] = GIF_OK, - [LZW_OK_EOD] = GIF_END_OF_FRAME, - [LZW_NO_MEM] = GIF_INSUFFICIENT_MEMORY, - [LZW_NO_DATA] = GIF_INSUFFICIENT_DATA, - [LZW_EOI_CODE] = GIF_FRAME_DATA_ERROR, - [LZW_BAD_ICODE] = GIF_FRAME_DATA_ERROR, - [LZW_BAD_CODE] = GIF_FRAME_DATA_ERROR, - }; - assert(l_res != LZW_BAD_PARAM); - assert(l_res != LZW_NO_COLOUR); - return g_res[l_res]; -} - -/** - * Updates the sprite memory size - * - * \param gif The animation context - * \param width The width of the sprite - * \param height The height of the sprite - * \return GIF_INSUFFICIENT_MEMORY for a memory error GIF_OK for success - */ -static gif_result gif__initialise_sprite( - struct gif_animation *gif, - uint32_t width, - uint32_t height) -{ - /* Already allocated? */ - if (gif->frame_image) { - return GIF_OK; - } - - assert(gif->bitmap_callbacks.bitmap_create); - gif->frame_image = gif->bitmap_callbacks.bitmap_create(width, height); - if (gif->frame_image == NULL) { - return GIF_INSUFFICIENT_MEMORY; - } - - return GIF_OK; -} - -/** - * Helper to get the rendering bitmap for a gif. - * - * \param[in] gif The gif object we're decoding. - * \return Client pixel buffer for rendering into. - */ -static inline uint32_t* gif__bitmap_get( - struct gif_animation *gif) -{ - gif_result ret; - - /* Make sure we have a buffer to decode to. */ - ret = gif__initialise_sprite(gif, gif->width, gif->height); - if (ret != GIF_OK) { - return NULL; - } - - /* Get the frame data */ - assert(gif->bitmap_callbacks.bitmap_get_buffer); - return (uint32_t *)gif->bitmap_callbacks.bitmap_get_buffer( - gif->frame_image); -} - -/** - * Helper to tell the client that their bitmap was modified. - * - * \param[in] gif The gif object we're decoding. - */ -static inline void gif__bitmap_modified( - const struct gif_animation *gif) -{ - if (gif->bitmap_callbacks.bitmap_modified) { - gif->bitmap_callbacks.bitmap_modified(gif->frame_image); - } -} - -/** - * Helper to tell the client that whether the bitmap is opaque. - * - * \param[in] gif The gif object we're decoding. - * \param[in] frame The frame that has been decoded. - */ -static inline void gif__bitmap_set_opaque( - const struct gif_animation *gif, - const struct gif_frame *frame) -{ - if (gif->bitmap_callbacks.bitmap_set_opaque) { - gif->bitmap_callbacks.bitmap_set_opaque( - gif->frame_image, frame->opaque); - } -} - -/** - * Helper to get the client to determine if the bitmap is opaque. - * - * \todo: We don't really need to get the client to do this for us. - * - * \param[in] gif The gif object we're decoding. - * \return true if the bitmap is opaque, false otherwise. - */ -static inline bool gif__bitmap_get_opaque( - const struct gif_animation *gif) -{ - if (gif->bitmap_callbacks.bitmap_test_opaque) { - return gif->bitmap_callbacks.bitmap_test_opaque( - gif->frame_image); - } - - return false; -} - -static void gif__record_frame( - struct gif_animation *gif, - const uint32_t *bitmap) -{ - bool need_alloc = gif->prev_frame == NULL; - uint32_t *prev_frame; - - if (gif->decoded_frame == GIF_INVALID_FRAME || - gif->decoded_frame == gif->prev_index) { - /* No frame to copy, or already have this frame recorded. */ - return; - } - - bitmap = gif__bitmap_get(gif); - if (bitmap == NULL) { - return; - } - - if (gif->prev_frame != NULL && - gif->width * gif->height > gif->prev_width * gif->prev_height) { - need_alloc = true; - } - - if (need_alloc) { - prev_frame = realloc(gif->prev_frame, - gif->width * gif->height * 4); - if (prev_frame == NULL) { - return; - } - } else { - prev_frame = gif->prev_frame; - } - - memcpy(prev_frame, bitmap, gif->width * gif->height * 4); - - gif->prev_frame = prev_frame; - gif->prev_width = gif->width; - gif->prev_height = gif->height; - gif->prev_index = gif->decoded_frame; -} - -static gif_result gif__recover_frame( - const struct gif_animation *gif, - uint32_t *bitmap) -{ - const uint32_t *prev_frame = gif->prev_frame; - unsigned height = gif->height < gif->prev_height ? gif->height : gif->prev_height; - unsigned width = gif->width < gif->prev_width ? gif->width : gif->prev_width; - - if (prev_frame == NULL) { - return GIF_FRAME_DATA_ERROR; - } - - for (unsigned y = 0; y < height; y++) { - memcpy(bitmap, prev_frame, width * 4); - - bitmap += gif->width; - prev_frame += gif->prev_width; - } - - return GIF_OK; -} - -/** - * Get the next line for GIF decode. - * - * Note that the step size must be initialised to 24 at the start of the frame - * (when y == 0). This is because of the first two passes of the frame have - * the same step size of 8, and the step size is used to determine the current - * pass. - * - * \param[in] height Frame height in pixels. - * \param[in,out] y Current row, starting from 0, updated on exit. - * \param[in,out] step Current step starting with 24, updated on exit. - * \return true if there is a row to process, false at the end of the frame. - */ -static inline bool gif__deinterlace(uint32_t height, uint32_t *y, uint8_t *step) -{ - *y += *step & 0xf; - - if (*y < height) return true; - - switch (*step) { - case 24: *y = 4; *step = 8; if (*y < height) return true; - /* Fall through. */ - case 8: *y = 2; *step = 4; if (*y < height) return true; - /* Fall through. */ - case 4: *y = 1; *step = 2; if (*y < height) return true; - /* Fall through. */ - default: - break; - } - - return false; -} - -/** - * Get the next line for GIF decode. - * - * \param[in] interlace Non-zero if the frame is not interlaced. - * \param[in] height Frame height in pixels. - * \param[in,out] y Current row, starting from 0, updated on exit. - * \param[in,out] step Current step starting with 24, updated on exit. - * \return true if there is a row to process, false at the end of the frame. - */ -static inline bool gif__next_row(uint32_t interlace, - uint32_t height, uint32_t *y, uint8_t *step) -{ - if (!interlace) { - return (++*y != height); - } else { - return gif__deinterlace(height, y, step); - } -} - -/** - * Get any frame clip adjustment for the image extent. - * - * \param[in] frame_off Frame's X or Y offset. - * \param[in] frame_dim Frame width or height. - * \param[in] image_ext Image width or height constraint. - * \return the amount the frame needs to be clipped to fit the image in given - * dimension. - */ -static inline uint32_t gif__clip( - uint32_t frame_off, - uint32_t frame_dim, - uint32_t image_ext) -{ - uint32_t frame_ext = frame_off + frame_dim; - - if (frame_ext <= image_ext) { - return 0; - } - - return frame_ext - image_ext; -} - -/** - * Perform any jump over decoded data, to accommodate clipped portion of frame. - * - * \param[in,out] skip Number of pixels of data to jump. - * \param[in,out] available Number of pixels of data currently available. - * \param[in,out] pos Position in decoded pixel value data. - */ -static inline void gif__jump_data( - uint32_t *skip, - uint32_t *available, - const uint8_t **pos) -{ - uint32_t jump = (*skip < *available) ? *skip : *available; - - *skip -= jump; - *available -= jump; - *pos += jump; -} - -static gif_result gif__decode_complex( - struct gif_animation *gif, - uint32_t width, - uint32_t height, - uint32_t offset_x, - uint32_t offset_y, - uint32_t interlace, - const uint8_t *data, - uint32_t transparency_index, - uint32_t *restrict frame_data, - uint32_t *restrict colour_table) -{ - lzw_result res; - uint32_t clip_x = gif__clip(offset_x, width, gif->width); - uint32_t clip_y = gif__clip(offset_y, height, gif->height); - const uint8_t *uncompressed; - gif_result ret = GIF_OK; - uint32_t available = 0; - uint8_t step = 24; - uint32_t skip = 0; - uint32_t y = 0; - - if (offset_x >= gif->width || - offset_y >= gif->height) { - return GIF_OK; - } - - width -= clip_x; - height -= clip_y; - - if (width == 0 || height == 0) { - return GIF_OK; - } - - /* Initialise the LZW decoding */ - res = lzw_decode_init(gif->lzw_ctx, data[0], - gif->gif_data, gif->buffer_size, - data + 1 - gif->gif_data); - if (res != LZW_OK) { - return gif__error_from_lzw(res); - } - - do { - uint32_t x; - uint32_t *frame_scanline; - - frame_scanline = frame_data + offset_x + - (y + offset_y) * gif->width; - - x = width; - while (x > 0) { - unsigned row_available; - while (available == 0) { - if (res != LZW_OK) { - /* Unexpected end of frame, try to recover */ - if (res == LZW_OK_EOD) { - ret = GIF_OK; - } else { - ret = gif__error_from_lzw(res); - } - return ret; - } - res = lzw_decode(gif->lzw_ctx, - &uncompressed, &available); - - if (available == 0) { - return GIF_OK; - } - gif__jump_data(&skip, &available, &uncompressed); - } - - row_available = x < available ? x : available; - x -= row_available; - available -= row_available; - if (transparency_index > 0xFF) { - while (row_available-- > 0) { - *frame_scanline++ = - colour_table[*uncompressed++]; - } - } else { - while (row_available-- > 0) { - register uint32_t colour; - colour = *uncompressed++; - if (colour != transparency_index) { - *frame_scanline = - colour_table[colour]; - } - frame_scanline++; - } - } - } - - skip = clip_x; - gif__jump_data(&skip, &available, &uncompressed); - } while (gif__next_row(interlace, height, &y, &step)); - - return ret; -} - -static gif_result gif__decode_simple( - struct gif_animation *gif, - uint32_t height, - uint32_t offset_y, - const uint8_t *data, - uint32_t transparency_index, - uint32_t *restrict frame_data, - uint32_t *restrict colour_table) -{ - uint32_t pixels = gif->width * height; - uint32_t written = 0; - gif_result ret = GIF_OK; - lzw_result res; - - if (offset_y >= gif->height) { - return GIF_OK; - } - - height -= gif__clip(offset_y, height, gif->height); - - if (height == 0) { - return GIF_OK; - } - - /* Initialise the LZW decoding */ - res = lzw_decode_init_map(gif->lzw_ctx, data[0], - transparency_index, colour_table, - gif->gif_data, gif->buffer_size, - data + 1 - gif->gif_data); - if (res != LZW_OK) { - return gif__error_from_lzw(res); - } - - frame_data += (offset_y * gif->width); - - while (pixels > 0) { - res = lzw_decode_map(gif->lzw_ctx, - frame_data, pixels, &written); - pixels -= written; - frame_data += written; - if (res != LZW_OK) { - /* Unexpected end of frame, try to recover */ - if (res == LZW_OK_EOD) { - ret = GIF_OK; - } else { - ret = gif__error_from_lzw(res); - } - break; - } - } - - if (pixels == 0) { - ret = GIF_OK; - } - - return ret; -} - -static inline gif_result gif__decode( - struct gif_animation *gif, - struct gif_frame *frame, - const uint8_t *data, - uint32_t *restrict frame_data) -{ - gif_result ret; - uint32_t offset_x = frame->redraw_x; - uint32_t offset_y = frame->redraw_y; - uint32_t width = frame->redraw_width; - uint32_t height = frame->redraw_height; - uint32_t interlace = frame->flags & GIF_INTERLACE_MASK; - uint32_t transparency_index = frame->transparency_index; - uint32_t *restrict colour_table = gif->colour_table; - - if (interlace == false && width == gif->width && offset_x == 0) { - ret = gif__decode_simple(gif, height, offset_y, - data, transparency_index, - frame_data, colour_table); - } else { - ret = gif__decode_complex(gif, width, height, - offset_x, offset_y, interlace, - data, transparency_index, - frame_data, colour_table); - } - - return ret; -} - -/** - * Restore a GIF to the background colour. - * - * \param[in] gif The gif object we're decoding. - * \param[in] frame The frame to clear, or NULL. - * \param[in] bitmap The bitmap to clear the frame in. - */ -static void gif__restore_bg( - struct gif_animation *gif, - struct gif_frame *frame, - uint32_t *bitmap) -{ - if (frame == NULL) { - memset(bitmap, GIF_TRANSPARENT_COLOUR, - gif->width * gif->height * sizeof(*bitmap)); - } else { - uint32_t offset_x = frame->redraw_x; - uint32_t offset_y = frame->redraw_y; - uint32_t width = frame->redraw_width; - uint32_t height = frame->redraw_height; - - width -= gif__clip(offset_x, width, gif->width); - height -= gif__clip(offset_y, height, gif->height); - - if (frame->display == false || width == 0) { - return; - } - - if (frame->transparency) { - for (uint32_t y = 0; y < height; y++) { - uint32_t *scanline = bitmap + offset_x + - (offset_y + y) * gif->width; - memset(scanline, GIF_TRANSPARENT_COLOUR, - width * sizeof(*bitmap)); - } - } else { - for (uint32_t y = 0; y < height; y++) { - uint32_t *scanline = bitmap + offset_x + - (offset_y + y) * gif->width; - for (uint32_t x = 0; x < width; x++) { - scanline[x] = gif->bg_colour; - } - } - } - } -} - -static gif_result gif__update_bitmap( - struct gif_animation *gif, - struct gif_frame *frame, - const uint8_t *data, - uint32_t frame_idx) -{ - gif_result ret; - uint32_t *bitmap; - - gif->decoded_frame = frame_idx; - - bitmap = gif__bitmap_get(gif); - if (bitmap == NULL) { - return GIF_INSUFFICIENT_MEMORY; - } - - /* Handle any bitmap clearing/restoration required before decoding this - * frame. */ - if (frame_idx == 0 || gif->decoded_frame == GIF_INVALID_FRAME) { - gif__restore_bg(gif, NULL, bitmap); - - } else { - struct gif_frame *prev = &gif->frames[frame_idx - 1]; - - if (prev->disposal_method == GIF_DISPOSAL_RESTORE_BG) { - gif__restore_bg(gif, prev, bitmap); - - } else if (prev->disposal_method == GIF_DISPOSAL_RESTORE_PREV) { - ret = gif__recover_frame(gif, bitmap); - if (ret != GIF_OK) { - gif__restore_bg(gif, prev, bitmap); - } - } - } - - if (frame->disposal_method == GIF_DISPOSAL_RESTORE_PREV) { - /* Store the previous frame for later restoration */ - gif__record_frame(gif, bitmap); - } - - ret = gif__decode(gif, frame, data, bitmap); - - gif__bitmap_modified(gif); - - if (frame->virgin) { - frame->opaque = gif__bitmap_get_opaque(gif); - frame->virgin = false; - } - gif__bitmap_set_opaque(gif, frame); - - return ret; -} - -/** - * Parse the application extension - * - * \param[in] frame The gif object we're decoding. - * \param[in] data The data to decode. - * \param[in] len Byte length of data. - * \return GIF_INSUFFICIENT_DATA if more data is needed, - * GIF_OK for success. - */ -static gif_result gif__parse_extension_graphic_control( - struct gif_frame *frame, - const uint8_t *data, - size_t len) -{ - /* 6-byte Graphic Control Extension is: - * - * +0 CHAR Graphic Control Label - * +1 CHAR Block Size - * +2 CHAR __Packed Fields__ - * 3BITS Reserved - * 3BITS Disposal Method - * 1BIT User Input Flag - * 1BIT Transparent Color Flag - * +3 SHORT Delay Time - * +5 CHAR Transparent Color Index - */ - if (len < 6) { - return GIF_INSUFFICIENT_DATA; - } - - frame->frame_delay = data[3] | (data[4] << 8); - if (data[2] & GIF_TRANSPARENCY_MASK) { - frame->transparency = true; - frame->transparency_index = data[5]; - } - - frame->disposal_method = ((data[2] & GIF_DISPOSAL_MASK) >> 2); - /* I have encountered documentation and GIFs in the - * wild that use 0x04 to restore the previous frame, - * rather than the officially documented 0x03. I - * believe some (older?) software may even actually - * export this way. We handle this as a type of - * "quirks" mode. */ - if (frame->disposal_method == GIF_DISPOSAL_RESTORE_QUIRK) { - frame->disposal_method = GIF_DISPOSAL_RESTORE_PREV; - } - - /* if we are clearing the background then we need to - * redraw enough to cover the previous frame too. */ - frame->redraw_required = - frame->disposal_method == GIF_DISPOSAL_RESTORE_BG || - frame->disposal_method == GIF_DISPOSAL_RESTORE_PREV; - - return GIF_OK; -} - -/** - * Parse the application extension - * - * \param[in] gif The gif object we're decoding. - * \param[in] data The data to decode. - * \param[in] len Byte length of data. - * \return GIF_INSUFFICIENT_DATA if more data is needed, - * GIF_OK for success. - */ -static gif_result gif__parse_extension_application( - struct gif_animation *gif, - const uint8_t *data, - size_t len) -{ - /* 14-byte+ Application Extension is: - * - * +0 CHAR Application Extension Label - * +1 CHAR Block Size - * +2 8CHARS Application Identifier - * +10 3CHARS Appl. Authentication Code - * +13 1-256 Application Data (Data sub-blocks) - */ - if (len < 17) { - return GIF_INSUFFICIENT_DATA; - } - - if ((data[1] == 0x0b) && - (strncmp((const char *)data + 2, "NETSCAPE2.0", 11) == 0) && - (data[13] == 0x03) && (data[14] == 0x01)) { - gif->loop_count = data[15] | (data[16] << 8); - } - - return GIF_OK; -} - -/** - * Parse the frame's extensions - * - * \param[in] gif The gif object we're decoding. - * \param[in] frame The frame to parse extensions for. - * \param[in] pos Current position in data, updated on exit. - * \param[in] decode Whether to decode or skip over the extension. - * \return GIF_INSUFFICIENT_DATA if more data is needed, - * GIF_OK for success. - */ -static gif_result gif__parse_frame_extensions( - struct gif_animation *gif, - struct gif_frame *frame, - const uint8_t **pos, - bool decode) -{ - const uint8_t *gif_data = *pos; - const uint8_t *gif_end = gif->gif_data + gif->buffer_size; - int gif_bytes = gif_end - gif_data; - - /* Initialise the extensions */ - while (gif_bytes > 0 && gif_data[0] == GIF_EXTENSION_INTRODUCER) { - bool block_step = true; - gif_result ret; - - gif_data++; - gif_bytes--; - - if (gif_bytes == 0) { - return GIF_INSUFFICIENT_DATA; - } - - /* Switch on extension label */ - switch (gif_data[0]) { - case GIF_EXTENSION_GRAPHIC_CONTROL: - if (decode) { - ret = gif__parse_extension_graphic_control( - frame, gif_data, gif_bytes); - if (ret != GIF_OK) { - return ret; - } - } - break; - - case GIF_EXTENSION_APPLICATION: - if (decode) { - ret = gif__parse_extension_application( - gif, gif_data, gif_bytes); - if (ret != GIF_OK) { - return ret; - } - } - break; - - case GIF_EXTENSION_COMMENT: - /* Move the pointer to the first data sub-block Skip 1 - * byte for the extension label. */ - ++gif_data; - block_step = false; - break; - - default: - break; - } - - if (block_step) { - /* Move the pointer to the first data sub-block Skip 2 - * bytes for the extension label and size fields Skip - * the extension size itself - */ - if (gif_bytes < 2) { - return GIF_INSUFFICIENT_DATA; - } - gif_data += 2 + gif_data[1]; - } - - /* Repeatedly skip blocks until we get a zero block or run out - * of data. This data is ignored by this gif decoder. */ - while (gif_data < gif_end && gif_data[0] != GIF_BLOCK_TERMINATOR) { - gif_data += gif_data[0] + 1; - if (gif_data >= gif_end) { - return GIF_INSUFFICIENT_DATA; - } - } - gif_data++; - gif_bytes = gif_end - gif_data; - } - - if (gif_data > gif_end) { - gif_data = gif_end; - } - - /* Set buffer position and return */ - *pos = gif_data; - return GIF_OK; -} - -/** - * Parse a GIF Image Descriptor. - * - * The format is: - * - * +0 CHAR Image Separator (0x2c) - * +1 SHORT Image Left Position - * +3 SHORT Image Top Position - * +5 SHORT Width - * +7 SHORT Height - * +9 CHAR __Packed Fields__ - * 1BIT Local Colour Table Flag - * 1BIT Interlace Flag - * 1BIT Sort Flag - * 2BITS Reserved - * 3BITS Size of Local Colour Table - * - * \param[in] gif The gif object we're decoding. - * \param[in] frame The frame to parse an image descriptor for. - * \param[in] pos Current position in data, updated on exit. - * \param[in] decode Whether to decode the image descriptor. - * \return GIF_OK on success, appropriate error otherwise. - */ -static gif_result gif__parse_image_descriptor( - struct gif_animation *gif, - struct gif_frame *frame, - const uint8_t **pos, - bool decode) -{ - const uint8_t *data = *pos; - size_t len = gif->gif_data + gif->buffer_size - data; - enum { - GIF_IMAGE_DESCRIPTOR_LEN = 10u, - GIF_IMAGE_SEPARATOR = 0x2Cu, - }; - - assert(gif != NULL); - assert(frame != NULL); - - if (len < GIF_IMAGE_DESCRIPTOR_LEN) { - return GIF_INSUFFICIENT_DATA; - } - - if (decode) { - unsigned x, y, w, h; - - if (data[0] != GIF_IMAGE_SEPARATOR) { - return GIF_FRAME_DATA_ERROR; - } - - x = data[1] | (data[2] << 8); - y = data[3] | (data[4] << 8); - w = data[5] | (data[6] << 8); - h = data[7] | (data[8] << 8); - frame->flags = data[9]; - - frame->redraw_x = x; - frame->redraw_y = y; - frame->redraw_width = w; - frame->redraw_height = h; - - /* Allow first frame to grow image dimensions. */ - if (gif->frame_count == 0) { - if (x + w > gif->width) { - gif->width = x + w; - } - if (y + h > gif->height) { - gif->height = y + h; - } - } - } - - *pos += GIF_IMAGE_DESCRIPTOR_LEN; - return GIF_OK; -} - -/** - * Extract a GIF colour table into a LibNSGIF colour table buffer. - * - * \param[in] gif The gif object we're decoding. - * \param[in] colour_table The colour table to populate. - * \param[in] colour_table_entries The number of colour table entries. - * \param[in] pos Current position in data, updated on exit. - * \param[in] decode Whether to decode the colour table. - * \return GIF_OK on success, appropriate error otherwise. - */ -static gif_result gif__colour_table_extract( - struct gif_animation *gif, - uint32_t *colour_table, - size_t colour_table_entries, - const uint8_t **pos, - bool decode) -{ - const uint8_t *data = *pos; - size_t len = gif->gif_data + gif->buffer_size - data; - - if (len < colour_table_entries * 3) { - return GIF_INSUFFICIENT_DATA; - } - - if (decode) { - int count = colour_table_entries; - uint8_t *entry = (uint8_t *)colour_table; - - while (count--) { - /* Gif colour map contents are r,g,b. - * - * We want to pack them bytewise into the - * colour table, such that the red component - * is in byte 0 and the alpha component is in - * byte 3. - */ - - *entry++ = *data++; /* r */ - *entry++ = *data++; /* g */ - *entry++ = *data++; /* b */ - *entry++ = 0xff; /* a */ - } - } - - *pos += colour_table_entries * 3; - return GIF_OK; -} - -/** - * Get a frame's colour table. - * - * Sets up gif->colour_table for the frame. - * - * \param[in] gif The gif object we're decoding. - * \param[in] frame The frame to get the colour table for. - * \param[in] pos Current position in data, updated on exit. - * \param[in] decode Whether to decode the colour table. - * \return GIF_OK on success, appropriate error otherwise. - */ -static gif_result gif__parse_colour_table( - struct gif_animation *gif, - struct gif_frame *frame, - const uint8_t **pos, - bool decode) -{ - gif_result ret; - - assert(gif != NULL); - assert(frame != NULL); - - if ((frame->flags & GIF_COLOUR_TABLE_MASK) == 0) { - gif->colour_table = gif->global_colour_table; - return GIF_OK; - } - - ret = gif__colour_table_extract(gif, gif->local_colour_table, - 2 << (frame->flags & GIF_COLOUR_TABLE_SIZE_MASK), - pos, decode); - if (ret != GIF_OK) { - return ret; - } - - gif->colour_table = gif->local_colour_table; - return GIF_OK; -} - -/** - * Parse the image data for a gif frame. - * - * Sets up gif->colour_table for the frame. - * - * \param[in] gif The gif object we're decoding. - * \param[in] frame The frame to parse image data for. - * \param[in] pos Current position in data, updated on exit. - * \param[in] decode Whether to decode the image data. - * \return GIF_OK on success, appropriate error otherwise. - */ -static gif_result gif__parse_image_data( - struct gif_animation *gif, - struct gif_frame *frame, - const uint8_t **pos, - bool decode) -{ - const uint8_t *data = *pos; - size_t len = gif->gif_data + gif->buffer_size - data; - uint32_t frame_idx = frame - gif->frames; - uint8_t minimum_code_size; - gif_result ret; - - assert(gif != NULL); - assert(frame != NULL); - - if (!decode) { - gif->frame_count_partial = frame_idx + 1; - } - - /* Ensure sufficient data remains. A gif trailer or a minimum lzw code - * followed by a gif trailer is treated as OK, although without any - * image data. */ - switch (len) { - default: if (data[0] == GIF_TRAILER) return GIF_OK; - break; - case 2: if (data[1] == GIF_TRAILER) return GIF_OK; - /* Fall through. */ - case 1: if (data[0] == GIF_TRAILER) return GIF_OK; - /* Fall through. */ - case 0: return GIF_INSUFFICIENT_DATA; - } - - minimum_code_size = data[0]; - if (minimum_code_size >= LZW_CODE_MAX) { - return GIF_DATA_ERROR; - } - - if (decode) { - ret = gif__update_bitmap(gif, frame, data, frame_idx); - } else { - uint32_t block_size = 0; - - /* Skip the minimum code size. */ - data++; - len--; - - while (block_size != 1) { - if (len < 1) return GIF_INSUFFICIENT_DATA; - block_size = data[0] + 1; - /* Check if the frame data runs off the end of the file */ - if (block_size > len) { - block_size = len; - return GIF_OK; - } - - len -= block_size; - data += block_size; - } - - gif->frame_count = frame_idx + 1; - gif->frames[frame_idx].display = true; - *pos = data; - - /* Check if we've finished */ - if (len < 1) { - return GIF_INSUFFICIENT_DATA; - } else { - if (data[0] == GIF_TRAILER) { - return GIF_OK; - } - } - - return GIF_WORKING; - } - - return ret; -} - -static struct gif_frame *gif__get_frame( - struct gif_animation *gif, - uint32_t frame_idx) -{ - struct gif_frame *frame; - - if (gif->frame_holders > frame_idx) { - frame = &gif->frames[frame_idx]; - } else { - /* Allocate more memory */ - size_t count = frame_idx + 1; - struct gif_frame *temp; - - temp = realloc(gif->frames, count * sizeof(*frame)); - if (temp == NULL) { - return NULL; - } - gif->frames = temp; - gif->frame_holders = count; - - frame = &gif->frames[frame_idx]; - - frame->transparency = false; - frame->transparency_index = GIF_NO_TRANSPARENCY; - frame->frame_pointer = gif->buffer_position; - frame->redraw_required = false; - frame->disposal_method = 0; - frame->frame_delay = 10; - frame->display = false; - frame->virgin = true; - } - - return frame; -} - -/** - * Attempts to initialise the next frame - * - * \param[in] gif The animation context - * \param[in] frame_idx The frame number to decode. - * \param[in] decode Whether to decode the graphical image data. - * \return error code - * - GIF_INSUFFICIENT_DATA reached unexpected end of source data. - * - GIF_FRAME_DATA_ERROR for GIF frame data error - * - GIF_INSUFFICIENT_MEMORY for insufficient memory to process - * - GIF_DATA_ERROR for GIF error (invalid frame header) - * - GIF_OK for successful decoding - * - GIF_WORKING for successful decoding if more frames are expected -*/ -static gif_result gif__process_frame( - struct gif_animation *gif, - uint32_t frame_idx, - bool decode) -{ - gif_result ret; - const uint8_t *pos; - const uint8_t *end; - struct gif_frame *frame; - - frame = gif__get_frame(gif, frame_idx); - if (frame == NULL) { - return GIF_INSUFFICIENT_MEMORY; - } - - end = gif->gif_data + gif->buffer_size; - - if (decode) { - pos = gif->gif_data + frame->frame_pointer; - - /* Ensure this frame is supposed to be decoded */ - if (frame->display == false) { - return GIF_OK; - } - - /* Ensure the frame is in range to decode */ - if (frame_idx > gif->frame_count_partial) { - return GIF_INSUFFICIENT_DATA; - } - - /* Done if frame is already decoded */ - if ((int)frame_idx == gif->decoded_frame) { - return GIF_OK; - } - } else { - pos = (uint8_t *)(gif->gif_data + gif->buffer_position); - - /* Check if we've finished */ - if (pos < end && pos[0] == GIF_TRAILER) { - return GIF_OK; - } - - /* We could theoretically get some junk data that gives us - * millions of frames, so we ensure that we don't have a - * silly number. */ - if (frame_idx > 4096) { - return GIF_FRAME_DATA_ERROR; - } - } - - /* Initialise any extensions */ - ret = gif__parse_frame_extensions(gif, frame, &pos, !decode); - if (ret != GIF_OK) { - goto cleanup; - } - - ret = gif__parse_image_descriptor(gif, frame, &pos, !decode); - if (ret != GIF_OK) { - goto cleanup; - } - - ret = gif__parse_colour_table(gif, frame, &pos, decode); - if (ret != GIF_OK) { - goto cleanup; - } - - ret = gif__parse_image_data(gif, frame, &pos, decode); - if (ret != GIF_OK) { - goto cleanup; - } - -cleanup: - if (!decode) { - gif->buffer_position = pos - gif->gif_data; - } - - return ret; -} - -/* exported function documented in libnsgif.h */ -void gif_create(gif_animation *gif, gif_bitmap_callback_vt *bitmap_callbacks) -{ - memset(gif, 0, sizeof(gif_animation)); - gif->bitmap_callbacks = *bitmap_callbacks; - gif->decoded_frame = GIF_INVALID_FRAME; - gif->prev_index = GIF_INVALID_FRAME; -} - -/** - * Read GIF header. - * - * 6-byte GIF file header is: - * - * +0 3CHARS Signature ('GIF') - * +3 3CHARS Version ('87a' or '89a') - * - * \param[in] gif The GIF object we're decoding. - * \param[in,out] pos The current buffer position, updated on success. - * \param[in] strict Whether to require a known GIF version. - * \return GIF_OK on success, appropriate error otherwise. - */ -static gif_result gif__parse_header( - struct gif_animation *gif, - const uint8_t **pos, - bool strict) -{ - const uint8_t *data = *pos; - size_t len = gif->gif_data + gif->buffer_size - data; - - if (len < 6) { - return GIF_INSUFFICIENT_DATA; - } - - if (strncmp((const char *) data, "GIF", 3) != 0) { - return GIF_DATA_ERROR; - } - data += 3; - - if (strict == true) { - if ((strncmp((const char *) data, "87a", 3) != 0) && - (strncmp((const char *) data, "89a", 3) != 0)) { - return GIF_DATA_ERROR; - } - } - data += 3; - - *pos = data; - return GIF_OK; -} - -/** - * Read Logical Screen Descriptor. - * - * 7-byte Logical Screen Descriptor is: - * - * +0 SHORT Logical Screen Width - * +2 SHORT Logical Screen Height - * +4 CHAR __Packed Fields__ - * 1BIT Global Colour Table Flag - * 3BITS Colour Resolution - * 1BIT Sort Flag - * 3BITS Size of Global Colour Table - * +5 CHAR Background Colour Index - * +6 CHAR Pixel Aspect Ratio - * - * \param[in] gif The GIF object we're decoding. - * \param[in,out] pos The current buffer position, updated on success. - * \return GIF_OK on success, appropriate error otherwise. - */ -static gif_result gif__parse_logical_screen_descriptor( - struct gif_animation *gif, - const uint8_t **pos) -{ - const uint8_t *data = *pos; - size_t len = gif->gif_data + gif->buffer_size - data; - - if (len < 7) { - return GIF_INSUFFICIENT_DATA; - } - - gif->width = data[0] | (data[1] << 8); - gif->height = data[2] | (data[3] << 8); - gif->global_colours = data[4] & GIF_COLOUR_TABLE_MASK; - gif->colour_table_size = 2 << (data[4] & GIF_COLOUR_TABLE_SIZE_MASK); - gif->bg_index = data[5]; - gif->aspect_ratio = data[6]; - gif->loop_count = 1; - - *pos += 7; - return GIF_OK; -} - -/* exported function documented in libnsgif.h */ -gif_result gif_initialise(gif_animation *gif, size_t size, const uint8_t *data) -{ - const uint8_t *gif_data; - gif_result ret; - - /* Initialize values */ - gif->buffer_size = size; - gif->gif_data = data; - - /* Get our current processing position */ - gif_data = gif->gif_data + gif->buffer_position; - - /* See if we should initialise the GIF */ - if (gif->buffer_position == 0) { - /* We want everything to be NULL before we start so we've no - * chance of freeing bad pointers (paranoia) - */ - gif->frame_image = NULL; - gif->frames = NULL; - gif->frame_holders = 0; - gif->local_colour_table = NULL; - gif->global_colour_table = NULL; - - /* The caller may have been lazy and not reset any values */ - gif->frame_count = 0; - gif->frame_count_partial = 0; - gif->decoded_frame = GIF_INVALID_FRAME; - - ret = gif__parse_header(gif, &gif_data, false); - if (ret != GIF_OK) { - return ret; - } - - ret = gif__parse_logical_screen_descriptor(gif, &gif_data); - if (ret != GIF_OK) { - return ret; - } - - /* Remember we've done this now */ - gif->buffer_position = gif_data - gif->gif_data; - - /* Some broken GIFs report the size as the screen size they - * were created in. As such, we detect for the common cases and - * set the sizes as 0 if they are found which results in the - * GIF being the maximum size of the frames. - */ - if (((gif->width == 640) && (gif->height == 480)) || - ((gif->width == 640) && (gif->height == 512)) || - ((gif->width == 800) && (gif->height == 600)) || - ((gif->width == 1024) && (gif->height == 768)) || - ((gif->width == 1280) && (gif->height == 1024)) || - ((gif->width == 1600) && (gif->height == 1200)) || - ((gif->width == 0) || (gif->height == 0)) || - ((gif->width > 2048) || (gif->height > 2048))) { - gif->width = 1; - gif->height = 1; - } - - /* Allocate some data irrespective of whether we've got any - * colour tables. We always get the maximum size in case a GIF - * is lying to us. It's far better to give the wrong colours - * than to trample over some memory somewhere. - */ - gif->global_colour_table = calloc(GIF_MAX_COLOURS, sizeof(uint32_t)); - gif->local_colour_table = calloc(GIF_MAX_COLOURS, sizeof(uint32_t)); - if ((gif->global_colour_table == NULL) || - (gif->local_colour_table == NULL)) { - gif_finalise(gif); - return GIF_INSUFFICIENT_MEMORY; - } - - /* Set the first colour to a value that will never occur in - * reality so we know if we've processed it - */ - gif->global_colour_table[0] = GIF_PROCESS_COLOURS; - - /* Check if the GIF has no frame data (13-byte header + 1-byte - * termination block) Although generally useless, the GIF - * specification does not expressly prohibit this - */ - if (gif->buffer_size == gif->buffer_position + 1) { - if (gif_data[0] == GIF_TRAILER) { - return GIF_OK; - } - } - } - - /* Do the colour map if we haven't already. As the top byte is always - * 0xff or 0x00 depending on the transparency we know if it's been - * filled in. - */ - if (gif->global_colour_table[0] == GIF_PROCESS_COLOURS) { - /* Check for a global colour map signified by bit 7 */ - if (gif->global_colours) { - ret = gif__colour_table_extract(gif, - gif->global_colour_table, - gif->colour_table_size, - &gif_data, true); - if (ret != GIF_OK) { - return ret; - } - - gif->buffer_position = (gif_data - gif->gif_data); - } else { - /* Create a default colour table with the first two - * colours as black and white - */ - uint32_t *entry = gif->global_colour_table; - - entry[0] = 0x00000000; - /* Force Alpha channel to opaque */ - ((uint8_t *) entry)[3] = 0xff; - - entry[1] = 0xffffffff; - } - - if (gif->global_colours && - gif->bg_index < gif->colour_table_size) { - size_t bg_idx = gif->bg_index; - gif->bg_colour = gif->global_colour_table[bg_idx]; - } else { - gif->bg_colour = gif->global_colour_table[0]; - } - } - - if (gif->lzw_ctx == NULL) { - lzw_result res = lzw_context_create( - (struct lzw_ctx **)&gif->lzw_ctx); - if (res != LZW_OK) { - return gif__error_from_lzw(res); - } - } - - /* Repeatedly try to initialise frames */ - do { - ret = gif__process_frame(gif, gif->frame_count, false); - } while (ret == GIF_WORKING); - - return ret; -} - -/* exported function documented in libnsgif.h */ -gif_result gif_decode_frame(gif_animation *gif, uint32_t frame) -{ - return gif__process_frame(gif, frame, true); -} - -/* exported function documented in libnsgif.h */ -void gif_finalise(gif_animation *gif) -{ - /* Release all our memory blocks */ - if (gif->frame_image) { - assert(gif->bitmap_callbacks.bitmap_destroy); - gif->bitmap_callbacks.bitmap_destroy(gif->frame_image); - } - - gif->frame_image = NULL; - free(gif->frames); - gif->frames = NULL; - free(gif->local_colour_table); - gif->local_colour_table = NULL; - free(gif->global_colour_table); - gif->global_colour_table = NULL; - - free(gif->prev_frame); - gif->prev_frame = NULL; - - lzw_context_destroy(gif->lzw_ctx); - gif->lzw_ctx = NULL; -} diff --git a/libvips/foreign/libnsgif/libnsgif.h b/libvips/foreign/libnsgif/libnsgif.h deleted file mode 100644 index b281034f..00000000 --- a/libvips/foreign/libnsgif/libnsgif.h +++ /dev/null @@ -1,194 +0,0 @@ -/* - * Copyright 2004 Richard Wilson - * Copyright 2008 Sean Fox - * Copyright 2013-2021 Michael Drake - * - * This file is part of NetSurf's libnsgif, http://www.netsurf-browser.org/ - * Licenced under the MIT License, - * http://www.opensource.org/licenses/mit-license.php - */ - -/** - * \file - * Interface to progressive animated GIF file decoding. - */ - -#ifndef _LIBNSGIF_H_ -#define _LIBNSGIF_H_ - -#include -#include - -/* Error return values */ -typedef enum { - GIF_WORKING = 1, - GIF_OK = 0, - GIF_INSUFFICIENT_DATA = -1, - GIF_INSUFFICIENT_FRAME_DATA = GIF_INSUFFICIENT_DATA, - GIF_FRAME_DATA_ERROR = -2, - GIF_DATA_ERROR = -4, - GIF_INSUFFICIENT_MEMORY = -5, - GIF_FRAME_NO_DISPLAY = -6, - GIF_END_OF_FRAME = -7 -} gif_result; - -/** GIF frame data */ -typedef struct gif_frame { - /** whether the frame should be displayed/animated */ - bool display; - /** delay (in cs) before animating the frame */ - uint32_t frame_delay; - - /* Internal members are listed below */ - - /** offset (in bytes) to the GIF frame data */ - uint32_t frame_pointer; - /** whether the frame has previously been used */ - bool virgin; - /** whether the frame is totally opaque */ - bool opaque; - /** whether a full image redraw is required */ - bool redraw_required; - /** how the previous frame should be disposed; affects plotting */ - uint8_t disposal_method; - /** whether we acknowledge transparency */ - bool transparency; - /** the index designating a transparent pixel */ - uint32_t transparency_index; - /** x co-ordinate of redraw rectangle */ - uint32_t redraw_x; - /** y co-ordinate of redraw rectangle */ - uint32_t redraw_y; - /** width of redraw rectangle */ - uint32_t redraw_width; - /** height of redraw rectangle */ - uint32_t redraw_height; - /* Frame flags */ - uint32_t flags; -} gif_frame; - -/* API for Bitmap callbacks */ -typedef void* (*gif_bitmap_cb_create)(int width, int height); -typedef void (*gif_bitmap_cb_destroy)(void *bitmap); -typedef uint8_t* (*gif_bitmap_cb_get_buffer)(void *bitmap); -typedef void (*gif_bitmap_cb_set_opaque)(void *bitmap, bool opaque); -typedef bool (*gif_bitmap_cb_test_opaque)(void *bitmap); -typedef void (*gif_bitmap_cb_modified)(void *bitmap); - -/** Bitmap callbacks function table */ -typedef struct gif_bitmap_callback_vt { - /** Create a bitmap. */ - gif_bitmap_cb_create bitmap_create; - /** Free a bitmap. */ - gif_bitmap_cb_destroy bitmap_destroy; - /** Return a pointer to the pixel data in a bitmap. */ - gif_bitmap_cb_get_buffer bitmap_get_buffer; - - /* Members below are optional */ - - /** Sets whether a bitmap should be plotted opaque. */ - gif_bitmap_cb_set_opaque bitmap_set_opaque; - /** Tests whether a bitmap has an opaque alpha channel. */ - gif_bitmap_cb_test_opaque bitmap_test_opaque; - /** The bitmap image has changed, so flush any persistent cache. */ - gif_bitmap_cb_modified bitmap_modified; -} gif_bitmap_callback_vt; - -/** GIF animation data */ -typedef struct gif_animation { - /** LZW decode context */ - void *lzw_ctx; - /** callbacks for bitmap functions */ - gif_bitmap_callback_vt bitmap_callbacks; - /** pointer to GIF data */ - const uint8_t *gif_data; - /** width of GIF (may increase during decoding) */ - uint32_t width; - /** height of GIF (may increase during decoding) */ - uint32_t height; - /** number of frames decoded */ - uint32_t frame_count; - /** number of frames partially decoded */ - uint32_t frame_count_partial; - /** decoded frames */ - gif_frame *frames; - /** current frame decoded to bitmap */ - int decoded_frame; - /** currently decoded image; stored as bitmap from bitmap_create callback */ - void *frame_image; - /** number of times to loop animation */ - int loop_count; - - /* Internal members are listed below */ - - /** current index into GIF data */ - uint32_t buffer_position; - /** total number of bytes of GIF data available */ - uint32_t buffer_size; - /** current number of frame holders */ - uint32_t frame_holders; - /** background index */ - uint32_t bg_index; - /** background colour */ - uint32_t bg_colour; - /** image aspect ratio (ignored) */ - uint32_t aspect_ratio; - /** size of colour table (in entries) */ - uint32_t colour_table_size; - /** whether the GIF has a global colour table */ - bool global_colours; - /** global colour table */ - uint32_t *global_colour_table; - /** local colour table */ - uint32_t *local_colour_table; - /** current colour table */ - uint32_t *colour_table; - - /** previous frame for GIF_FRAME_RESTORE */ - void *prev_frame; - /** previous frame index */ - int prev_index; - /** previous frame width */ - unsigned prev_width; - /** previous frame height */ - unsigned prev_height; -} gif_animation; - -/** - * Initialises necessary gif_animation members. - */ -void gif_create(gif_animation *gif, gif_bitmap_callback_vt *bitmap_callbacks); - -/** - * Initialises any workspace held by the animation and attempts to decode - * any information that hasn't already been decoded. - * If an error occurs, all previously decoded frames are retained. - * - * \return Error return value. - * - GIF_FRAME_DATA_ERROR for GIF frame data error - * - GIF_INSUFFICIENT_DATA reached unexpected end of source data - * - GIF_INSUFFICIENT_MEMORY for memory error - * - GIF_DATA_ERROR for GIF error - * - GIF_OK for successful decoding - * - GIF_WORKING for successful decoding if more frames are expected - */ -gif_result gif_initialise(gif_animation *gif, size_t size, const uint8_t *data); - -/** - * Decodes a GIF frame. - * - * \return Error return value. - * - GIF_FRAME_DATA_ERROR for GIF frame data error - * - GIF_DATA_ERROR for GIF error (invalid frame header) - * - GIF_INSUFFICIENT_DATA reached unexpected end of source data - * - GIF_INSUFFICIENT_MEMORY for insufficient memory to process - * - GIF_OK for successful decoding - */ -gif_result gif_decode_frame(gif_animation *gif, uint32_t frame); - -/** - * Releases any workspace held by a gif - */ -void gif_finalise(gif_animation *gif); - -#endif diff --git a/libvips/foreign/libnsgif/meson.build b/libvips/foreign/libnsgif/meson.build index 1724a315..7fc9926e 100644 --- a/libvips/foreign/libnsgif/meson.build +++ b/libvips/foreign/libnsgif/meson.build @@ -1,6 +1,6 @@ nsgif_lib = static_library('nsgif', - 'libnsgif.h', - 'libnsgif.c', + 'nsgif.h', + 'gif.c', 'lzw.c', 'lzw.h', ) diff --git a/libvips/foreign/libnsgif/nsgif.h b/libvips/foreign/libnsgif/nsgif.h new file mode 100644 index 00000000..fe11d29c --- /dev/null +++ b/libvips/foreign/libnsgif/nsgif.h @@ -0,0 +1,358 @@ +/* + * Copyright 2004 Richard Wilson + * Copyright 2008 Sean Fox + * Copyright 2013-2022 Michael Drake + * + * This file is part of NetSurf's libnsgif, http://www.netsurf-browser.org/ + * Licenced under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + */ + +/** + * \file + * Interface to progressive animated GIF file decoding. + */ + +#ifndef NSNSGIF_H +#define NSNSGIF_H + +#include +#include +#include + +/** Representation of infinity. */ +#define NSGIF_INFINITE (UINT32_MAX) + +/** + * Opaque type used by LibNSGIF to represent a GIF object in memory. + */ +typedef struct nsgif nsgif_t; + +/** + * LibNSGIF rectangle structure. + * + * * Top left coordinate is `(x0, y0)`. + * * Width is `x1 - x0`. + * * Height is `y1 - y0`. + * * Units are pixels. + */ +typedef struct nsgif_rect { + /** x co-ordinate of redraw rectangle, left */ + uint32_t x0; + /** y co-ordinate of redraw rectangle, top */ + uint32_t y0; + /** x co-ordinate of redraw rectangle, right */ + uint32_t x1; + /** y co-ordinate of redraw rectangle, bottom */ + uint32_t y1; +} nsgif_rect_t; + +/** + * LibNSGIF return codes. + */ +typedef enum { + /** + * Success. + */ + NSGIF_OK, + + /** + * Out of memory error. + */ + NSGIF_ERR_OOM, + + /** + * GIF source data is invalid, and no frames are recoverable. + */ + NSGIF_ERR_DATA, + + /** + * Frame number is not valid. + */ + NSGIF_ERR_BAD_FRAME, + + /** + * GIF source data contained an error in a frame. + */ + NSGIF_ERR_DATA_FRAME, + + /** + * Too many frames. + */ + NSGIF_ERR_FRAME_COUNT, + + /** + * GIF source data ended without one complete frame available. + */ + NSGIF_ERR_END_OF_DATA, + + /** + * GIF source data ended with incomplete frame. + */ + NSGIF_ERR_END_OF_FRAME, + + /** + * The current frame cannot be displayed. + */ + NSGIF_ERR_FRAME_DISPLAY, + + /** + * Indicates an animation is complete, and \ref nsgif_reset must be + * called to restart the animation from the beginning. + */ + NSGIF_ERR_ANIMATION_END, +} nsgif_error; + +/** + * Client bitmap type. + * + * These are client-created and destroyed, via the \ref bitmap callbacks, + * but they are owned by a \ref nsgif_t. + * + * The pixel buffer is is 32bpp, treated as individual bytes in the component + * order RR GG BB AA. For example, a 1x1 image with a single orange pixel would + * be encoded as the following sequence of bytes: 0xff, 0x88, 0x00, 0x00. + */ +typedef void nsgif_bitmap_t; + +/** Bitmap callbacks function table */ +typedef struct nsgif_bitmap_cb_vt { + /** + * Callback to create a bitmap with the given dimensions. + * + * \param[in] width Required bitmap width in pixels. + * \param[in] height Required bitmap height in pixels. + * \return pointer to client's bitmap structure or NULL on error. + */ + nsgif_bitmap_t* (*create)(int width, int height); + + /** + * Callback to free a bitmap. + * + * \param[in] bitmap The bitmap to destroy. + */ + void (*destroy)(nsgif_bitmap_t *bitmap); + + /** + * Get pointer to pixel buffer in a bitmap. + * + * The pixel buffer must be `width * height * sizeof(uint32_t)`. + * Note that the returned pointer to uint8_t must be 4-byte aligned. + * + * \param[in] bitmap The bitmap. + * \return pointer to bitmap's pixel buffer. + */ + uint8_t* (*get_buffer)(nsgif_bitmap_t *bitmap); + + /* The following functions are optional. */ + + /** + * Set whether a bitmap can be plotted opaque. + * + * \param[in] bitmap The bitmap. + * \param[in] opaque Whether the current frame is opaque. + */ + void (*set_opaque)(nsgif_bitmap_t *bitmap, bool opaque); + + /** + * Tests whether a bitmap has an opaque alpha channel. + * + * \param[in] bitmap The bitmap. + * \return true if the bitmap is opaque, false otherwise. + */ + bool (*test_opaque)(nsgif_bitmap_t *bitmap); + + /** + * Bitmap modified notification. + * + * \param[in] bitmap The bitmap. + */ + void (*modified)(nsgif_bitmap_t *bitmap); +} nsgif_bitmap_cb_vt; + +/** + * Convert an error code to a string. + * + * \param[in] err The error code to convert. + * \return String representation of given error code. + */ +const char *nsgif_strerror(nsgif_error err); + +/** + * Create the NSGIF object. + * + * \param[in] bitmap_vt Bitmap operation functions v-table. + * \param[out] gif_out Return \ref nsgif_t object on success. + * + * \return NSGIF_OK on success, or appropriate error otherwise. + */ +nsgif_error nsgif_create( + const nsgif_bitmap_cb_vt *bitmap_vt, + nsgif_t **gif_out); + +/** + * Free a NSGIF object. + * + * \param[in] gif The NSGIF to free. + */ +void nsgif_destroy(nsgif_t *gif); + +/** + * Scan the source image data. + * + * This is used to feed the source data into LibNSGIF. This must be called + * before calling \ref nsgif_frame_decode. + * + * It can be called multiple times with, with increasing sizes. If it is called + * several times, as more data is available (e.g. slow network fetch) the data + * already given to \ref nsgif_data_scan must be provided each time. + * + * For example, if you call \ref nsgif_data_scan with 25 bytes of data, and then + * fetch another 10 bytes, you would need to call \ref nsgif_data_scan with a + * size of 35 bytes, and the whole 35 bytes must be contiguous memory. It is + * safe to `realloc` the source buffer between calls to \ref nsgif_data_scan. + * (The actual data pointer is allowed to be different.) + * + * If an error occurs, all previously scanned frames are retained. + * + * \param[in] gif The \ref nsgif_t object. + * \param[in] size Number of bytes in data. + * \param[in] data Raw source GIF data. + * + * \return NSGIF_OK on success, or appropriate error otherwise. + */ +nsgif_error nsgif_data_scan( + nsgif_t *gif, + size_t size, + const uint8_t *data); + +/** + * Prepare to show a frame. + * + * If this is the last frame of an animation with a finite loop count, the + * returned `delay_cs` will be \ref NSGIF_INFINITE, indicating that the frame + * should be shown forever. + * + * \param[in] gif The \ref nsgif_t object. + * \param[out] area The area in pixels that must be redrawn. + * \param[out] delay_cs Time to wait after frame_new before next frame in cs. + * \param[out] frame_new The frame to decode. + * + * \return NSGIF_OK on success, or appropriate error otherwise. + */ +nsgif_error nsgif_frame_prepare( + nsgif_t *gif, + nsgif_rect_t *area, + uint32_t *delay_cs, + uint32_t *frame_new); + +/** + * Decodes a GIF frame. + * + * \param[in] gif The \ref nsgif_t object. + * \param[in] frame The frame number to decode. + * \param[out] bitmap On success, returns pointer to the client-allocated, + * nsgif-owned client bitmap structure. + * + * \return NSGIF_OK on success, or appropriate error otherwise. + */ +nsgif_error nsgif_frame_decode( + nsgif_t *gif, + uint32_t frame, + nsgif_bitmap_t **bitmap); + +/** + * Reset a GIF animation. + * + * Some animations are only meant to loop N times, and then show the + * final frame forever. This function resets the loop and frame counters, + * so that the animation can be replayed without the overhead of recreating + * the \ref nsgif_t object and rescanning the raw data. + * + * \param[in] gif A \ref nsgif_t object. + * + * \return NSGIF_OK on success, or appropriate error otherwise. + */ +nsgif_error nsgif_reset( + nsgif_t *gif); + +/** + * Information about a GIF. + */ +typedef struct nsgif_info { + /** width of GIF (may increase during decoding) */ + uint32_t width; + /** height of GIF (may increase during decoding) */ + uint32_t height; + /** number of frames decoded */ + uint32_t frame_count; + /** number of times to loop animation */ + int loop_max; + /** number of animation loops so far */ + int loop_count; + /** background colour in same pixel format as \ref nsgif_bitmap_t. */ + uint8_t background[4]; +} nsgif_info_t; + +/** + * Frame disposal method. + * + * Clients do not need to know about this, it is provided purely for dumping + * raw information about GIF frames. + */ +enum nsgif_disposal { + NSGIF_DISPOSAL_UNSPECIFIED, /**< No disposal method specified. */ + NSGIF_DISPOSAL_NONE, /**< Frame remains. */ + NSGIF_DISPOSAL_RESTORE_BG, /**< Clear frame to background colour. */ + NSGIF_DISPOSAL_RESTORE_PREV, /**< Restore previous frame. */ + NSGIF_DISPOSAL_RESTORE_QUIRK, /**< Alias for NSGIF_DISPOSAL_RESTORE_PREV. */ +}; + +/** + * Convert a disposal method to a string. + * + * \param[in] disposal The disposal method to convert. + * \return String representation of given disposal method. + */ +const char *nsgif_str_disposal(enum nsgif_disposal disposal); + +/** + * Information about a GIF frame. + */ +typedef struct nsgif_frame_info { + /** whether the frame should be displayed/animated */ + bool display; + /** whether the frame may have transparency */ + bool transparency; + + /** Disposal method for previous frame; affects plotting */ + uint8_t disposal; + /** delay (in cs) before animating the frame */ + uint32_t delay; + + /** Frame's redraw rectangle. */ + nsgif_rect_t rect; +} nsgif_frame_info_t; + +/** + * Get information about a GIF from an \ref nsgif_t object. + * + * \param[in] gif The \ref nsgif_t object to get info for. + * + * \return The gif info, or NULL on error. + */ +const nsgif_info_t *nsgif_get_info(const nsgif_t *gif); + +/** + * Get information about a GIF from an \ref nsgif_t object. + * + * \param[in] gif The \ref nsgif_t object to get frame info for. + * \param[in] frame The frame number to get info for. + * + * \return The gif frame info, or NULL on error. + */ +const nsgif_frame_info_t *nsgif_get_frame_info( + const nsgif_t *gif, + uint32_t frame); + +#endif diff --git a/libvips/foreign/libnsgif/patches/default-frame-delay.patch b/libvips/foreign/libnsgif/patches/default-frame-delay.patch deleted file mode 100644 index 6e534f05..00000000 --- a/libvips/foreign/libnsgif/patches/default-frame-delay.patch +++ /dev/null @@ -1,11 +0,0 @@ ---- libnsgif.orig.c 2021-12-18 17:58:43.829719505 +0000 -+++ libnsgif.c 2021-12-18 17:58:47.773783438 +0000 -@@ -1003,7 +1003,7 @@ - frame->frame_pointer = gif->buffer_position; - frame->redraw_required = false; - frame->disposal_method = 0; -- frame->frame_delay = 100; -+ frame->frame_delay = 10; - frame->display = false; - frame->virgin = true; - } diff --git a/libvips/foreign/libnsgif/test/cli.c b/libvips/foreign/libnsgif/test/cli.c new file mode 100644 index 00000000..031cd977 --- /dev/null +++ b/libvips/foreign/libnsgif/test/cli.c @@ -0,0 +1,763 @@ +/* + * SPDX-License-Identifier: ISC + * + * Copyright (C) 2021 Michael Drake + */ + +/** + * \file + * \brief Command line argument handling. + */ + +#include +#include +#include +#include +#include + +#include "cli.h" + +/** + * Check whether a CLI argument type should have a numerical value. + * + * \param[in] type An argument type. + * \return true if the argument needs a numerical value, or false otherwise. + */ +static inline bool cli__arg_is_numerical(enum cli_arg_type type) +{ + return (type != CLI_STRING && type != CLI_BOOL); +} + +/** + * Parse a signed integer value from an argument. + * + * \param[in] str String containing value to parse. + * \param[out] i Pointer to place to store parsed value. + * \param[in,out] pos Current position in str, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_value_int( + const char *str, + int64_t *i, + size_t *pos) +{ + long long temp; + char *end = NULL; + + str += *pos; + errno = 0; + temp = strtoll(str, &end, 0); + + if (end == str || errno == ERANGE || + temp > INT64_MAX || temp < INT64_MIN) { + fprintf(stderr, "Failed to parse integer from '%s'\n", str); + return false; + } + + *i = (int64_t)temp; + *pos += (size_t)(end - str); + return true; +} + +/** + * Parse an unsigned integer value from an argument. + * + * \param[in] str String containing value to parse. + * \param[out] u Pointer to place to store parsed value. + * \param[in,out] pos Current position in str, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_value_uint( + const char *str, + uint64_t *u, + size_t *pos) +{ + unsigned long long temp; + char *end = NULL; + + str += *pos; + errno = 0; + temp = strtoull(str, &end, 0); + + if (end == str || errno == ERANGE || temp > UINT64_MAX) { + fprintf(stderr, "Failed to parse unsigned from '%s'\n", str); + return false; + } + + *u = (uint64_t)temp; + *pos += (size_t)(end - str); + return true; +} + +/** + * Parse an enum value from an argument. + * + * \param[in] str String containing value to parse. + * \param[out] e Enum details. + * \param[in,out] pos Current position in str, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_value_enum( + const char *str, + const struct cli_enum *e, + size_t *pos) +{ + str += *pos; + *pos += strlen(str); + + for (const struct cli_str_val *sv = e->desc; sv->str != NULL; sv++) { + if (strcmp(str, sv->str) == 0) { + *e->e = sv->val; + return true; + } + } + + return false; +} + +/** + * Parse a string value from an argument. + * + * \param[in] str String containing value to parse. + * \param[out] s Pointer to place to store parsed value. + * \param[in,out] pos Current position in str, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_value_string( + const char *str, + const char **s, + size_t *pos) +{ + *s = str + *pos; + *pos += strlen(*s); + return true; +} + +/** + * Parse a value from an argument. + * + * \param[in] entry Client command line interface argument specification. + * \param[in] arg Argument to parse a value from. + * \param[in,out] pos Current position in argument, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_value( + const struct cli_table_entry *entry, + const char *arg, + size_t *pos) +{ + switch (entry->t) { + case CLI_CMD: + if (strcmp(arg + *pos, entry->l) == 0) { + *pos += strlen(arg); + return true; + } + return false; + + case CLI_INT: + return cli__parse_value_int(arg, entry->v.i, pos); + + case CLI_UINT: + return cli__parse_value_uint(arg, entry->v.u, pos); + + case CLI_ENUM: + return cli__parse_value_enum(arg, &entry->v.e, pos); + + case CLI_STRING: + return cli__parse_value_string(arg, entry->v.s, pos); + + default: + fprintf(stderr, "Unexpected value for '%s': %s\n", + entry->l, arg); + break; + } + + return false; +} + +/** + * Parse a value from an argument. + * + * \param[in] entry Client command line interface argument specification. + * \param[in] argc Number of command line arguments. + * \param[in] argv String vector containing command line arguments. + * \param[in] arg_pos Current position in argv. + * \param[in,out] pos Current pos in current argument, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_argv_value(const struct cli_table_entry *entry, + int argc, const char **argv, + int arg_pos, size_t *pos) +{ + const char *arg = argv[arg_pos]; + + if (arg_pos >= argc) { + fprintf(stderr, "Value not given for '%s'\n", entry->l); + return false; + } + + return cli__parse_value(entry, arg, pos); +} + +/** + * Check whether a CLI argument is a positional value. + * + * \param[in] entry Client command line interface argument specification. + * \return true if the argument is positional, or false otherwise. + */ +static inline bool cli__entry_is_positional(const struct cli_table_entry *entry) +{ + return entry->p; +} + +/** + * Look up a short argument flag. + * + * \param[in] cli Client command line interface specification. + * \param[in] s Argument flag to look up in client CLI spec. + * \return Client CLI spec entry on success, or NULL otherwise. + */ +static const struct cli_table_entry *cli__lookup_short( + const struct cli_table *cli, char s) +{ + for (size_t i = 0; i < cli->count; i++) { + if (cli__entry_is_positional(&cli->entries[i])) { + continue; + } + if (cli->entries[i].s == s) { + return &cli->entries[i]; + } + } + + fprintf(stderr, "Unknown flag: '%c'\n", s); + return NULL; +} + +/** + * Handle an argument with a type that requires a value. + * + * This can handle the value being in the current argument, optionally split by + * a separator, or in the next argument. + * + * \param[in] entry Client command line interface argument specification. + * \param[in] argc Number of command line arguments. + * \param[in] argv String vector containing command line arguments. + * \param[in,out] arg_pos Current position in argv, updated on exit. + * \param[in] pos Current position in current argument string. + * \param[in] sep Name/value separator character, or '\0' if none. + * \return true on success, or false otherwise. + */ +static bool cli__handle_arg_value(const struct cli_table_entry *entry, + int argc, const char **argv, int *arg_pos, size_t pos, char sep) +{ + const char *arg = argv[*arg_pos]; + size_t orig_pos; + bool ret; + + if (arg[pos] == '\0') { + (*arg_pos)++; + pos = 0; + } else if (arg[pos] == sep) { + pos++; + } else if (cli__arg_is_numerical(entry->t) == false) { + fprintf(stderr, "Separator required for non-numerical value\n"); + return false; + } + + if (isspace(argv[*arg_pos][pos])) { + fprintf(stderr, "Unexpected white space in '%s' " + "for argument '%s'\n", + &argv[*arg_pos][pos], entry->l); + return false; + } + + orig_pos = pos; + ret = cli__parse_argv_value(entry, argc, argv, *arg_pos, &pos); + if (ret != true) { + return ret; + } + + if (argv[*arg_pos][pos] != '\0') { + fprintf(stderr, "Invalid value '%s' for argument '%s'\n", + &argv[*arg_pos][orig_pos], entry->l); + return false; + } + + return true; +} + +/** + * Parse a flags argument. + * + * \param[in] cli Client command line interface specification. + * \param[in] argc Number of command line arguments. + * \param[in] argv String vector containing command line arguments. + * \param[out] arg_pos Current position in argv, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_short(const struct cli_table *cli, + int argc, const char **argv, int *arg_pos) +{ + const char *arg = argv[*arg_pos]; + size_t pos = 1; + + if (arg[0] != '-') { + return false; + } + + while (arg[pos] != '\0') { + const struct cli_table_entry *entry; + + entry = cli__lookup_short(cli, arg[pos]); + if (entry == NULL) { + return false; + } + + if (entry->t == CLI_BOOL) { + *entry->v.b = true; + } else { + return cli__handle_arg_value(entry, argc, argv, + arg_pos, pos + 1, '\0'); + } + + pos++; + } + + return true; +} + +/** + * Look up a long argument name. + * + * \param[in] cli Client command line interface specification. + * \param[in] arg Argument name to look up in cli spec. + * \param[in,out] pos Current position in arg, updated on exit. + * \return Client CLI spec entry on success, or NULL otherwise. + */ +static const struct cli_table_entry *cli__lookup_long( + const struct cli_table *cli, + const char *arg, + size_t *pos) +{ + arg += *pos; + + for (size_t i = 0; i < cli->count; i++) { + if (cli__entry_is_positional(&cli->entries[i]) == false) { + const char *name = cli->entries[i].l; + size_t name_len = strlen(cli->entries[i].l); + + if (strncmp(name, arg, name_len) == 0) { + if (arg[name_len] != '\0' && + arg[name_len] != '=') { + continue; + } + *pos += name_len; + return &cli->entries[i]; + } + } + } + + fprintf(stderr, "Unknown argument: '%s'\n", arg); + return NULL; +} + +/** + * Parse a long argument. + * + * \param[in] cli Client command line interface specification. + * \param[in] argc Number of command line arguments. + * \param[in] argv String vector containing command line arguments. + * \param[out] arg_pos Current position in argv, updated on exit. + * \return true on success, or false otherwise. + */ +static bool cli__parse_long(const struct cli_table *cli, + int argc, const char **argv, int *arg_pos) +{ + const struct cli_table_entry *entry; + const char *arg = argv[*arg_pos]; + size_t pos = 2; + + if (arg[0] != '-' || + arg[1] != '-') { + return false; + } + + entry = cli__lookup_long(cli, arg, &pos); + if (entry == NULL) { + return false; + } + + if (entry->t == CLI_BOOL) { + if (arg[pos] != '\0') { + fprintf(stderr, "Unexpected value for argument '%s'\n", + arg); + return false; + } + *entry->v.b = true; + } else { + bool ret; + + ret = cli__handle_arg_value(entry, argc, argv, + arg_pos, pos, '='); + if (ret != true) { + return ret; + } + } + + return true; +} + +/** + * Parse a positional argument according to the given CLI spec entry. + * + * \param[in] entry Client command line interface argument specification. + * \param[in] arg Argument to parse. + * \return true on success, or false otherwise. + */ +static bool cli__parse_positional_entry( + const struct cli_table_entry *entry, + const char *arg) +{ + size_t pos = 0; + bool ret; + + ret = cli__parse_value(entry, arg, &pos); + if (ret != true) { + return ret; + } else if (arg[pos] != '\0') { + fprintf(stderr, "Failed to parse value '%s' for arg '%s'\n", + arg, entry->l); + return false; + } + + return true; +} + +/** + * Parse a positional argument. + * + * \param[in] cli Client command line interface specification. + * \param[in] arg Argument to parse. + * \param[in] count Number of positional arguments parsed already. + * \return true on success, or false otherwise. + */ +static bool cli__parse_positional(const struct cli_table *cli, + const char *arg, size_t count) +{ + size_t positional = 0; + + for (size_t i = 0; i < cli->count; i++) { + if (cli__entry_is_positional(&cli->entries[i])) { + if (positional == count) { + return cli__parse_positional_entry( + &cli->entries[i], arg); + } + + positional++; + } + } + + fprintf(stderr, "Unexpected positional argument: '%s'\n", arg); + return false; +} + +/** + * Get the string to indicate type of value expected for an argument. + * + * \param[in] type The argument type. + * \return String for value type. + */ +static const char *cli__string_from_type(enum cli_arg_type type) +{ + static const char *const strings[] = { + [CLI_BOOL] = "", + [CLI_INT] = "INT", + [CLI_UINT] = "UINT", + [CLI_ENUM] = "ENUM", + [CLI_STRING] = "STRING", + }; + + if (type >= CLI_ARRAY_LEN(strings) || strings[type] == NULL) { + return ""; + } + + return strings[type]; +} + +/** + * Helper to update a maximum adjusted string length if new values is greater. + * + * \param[in] str String to check. + * \param[in] adjustment Amount to modify length of string by (bytes). + * \param[out] len Returns the maximum of existing and this length. + */ +static void cli__max_len(const char *str, size_t adjustment, size_t *len) +{ + size_t str_len = strlen(str) + adjustment; + + if (str_len > *len) { + *len = str_len; + } +} + +/** + * Count up various properties of the client CLI interface specification. + * + * \param[in] cli Client command line interface specification. + * \param[out] count Returns number of non-positional arguments. + * \param[out] pcount Returns number of positional arguments. + * \param[out] max_len Returns max string length of non-positional arguments. + * \param[out] pmax_len Returns max string length of positional arguments. + * \param[out] phas_desc Returns number of positional args with descriptions. + */ +static void cli__count(const struct cli_table *cli, + size_t *count, + size_t *pcount, + size_t *max_len, + size_t *pmax_len, + size_t *phas_desc) +{ + if (count != NULL) *count = 0; + if (pcount != NULL) *pcount = 0; + if (max_len != NULL) *max_len = 0; + if (pmax_len != NULL) *pmax_len = 0; + if (phas_desc != NULL) *phas_desc = 0; + + for (size_t i = 0; i < cli->count; i++) { + const struct cli_table_entry *entry = &cli->entries[i]; + + if (cli__entry_is_positional(entry)) { + if (pcount != NULL) { + (*pcount)++; + } + if (pmax_len != NULL) { + cli__max_len(entry->l, 0, pmax_len); + } + if (phas_desc != NULL) { + (*phas_desc)++; + } + } else { + if (count != NULL) { + (*count)++; + } + if (max_len != NULL) { + const char *type_str; + size_t type_len; + + type_str = cli__string_from_type(entry->t); + type_len = strlen(type_str); + + cli__max_len(entry->l, type_len, max_len); + } + } + } +} + +static inline bool cli__is_negative(const char *arg) +{ + int64_t i; + size_t pos = 0; + + return cli__parse_value_int(arg, &i, &pos) + && pos == strlen(arg) + && i < 0; +} + +/* Documented in cli.h */ +bool cli_parse(const struct cli_table *cli, int argc, const char **argv) +{ + size_t pos_count = 0; + enum { + ARG_PROG_NAME, + ARG_FIRST, + }; + + for (int i = ARG_FIRST; i < argc; i++) { + const char *arg = argv[i]; + size_t pos_inc = 0; + bool ret; + + if (arg[0] == '-') { + if (arg[1] == '-') { + ret = cli__parse_long(cli, argc, argv, &i); + } else { + ret = cli__parse_short(cli, argc, argv, &i); + if (ret != true) { + if (cli__is_negative(argv[i])) { + pos_inc = 1; + ret = cli__parse_positional( + cli, argv[i], + pos_count); + } + } + } + } else { + pos_inc = 1; + ret = cli__parse_positional(cli, argv[i], pos_count); + } + + if (ret != true) { + return ret; + } + + pos_count += pos_inc; + } + + if (pos_count < cli->min_positional) { + fprintf(stderr, "Insufficient positional arguments found.\n"); + return false; + } + + return true; +} + +/** + * Get terminal width. + * + * \return terminal width in characters. + */ +static size_t cli__terminal_width(void) +{ + return 80; +} + +/** + * Print an entry's description, with a given indent. + * + * The indent is assumed to already be applied for the first line of the + * output by the caller. + * + * \param[in] entry The entry to print the description for. + * \param[in] indent The number of spaces to pad the left margin with. + */ +static void cli__print_description(const struct cli_table_entry *entry, + size_t indent) +{ + size_t terminal_width = cli__terminal_width(); + size_t avail = (indent > terminal_width) ? 0 : terminal_width - indent; + size_t space = avail; + const char *desc = entry->d; + + if (desc != NULL) { + while (*desc != '\0') { + size_t word_len = strcspn(desc, " \n\t"); + if (word_len <= space || space == avail) { + fprintf(stderr, "%*.*s", + (int)word_len, + (int)word_len, desc); + desc += word_len; + if (word_len <= space) { + space -= word_len; + } + if (space > 0) { + fprintf(stderr, " "); + space--; + } + } else { + fprintf(stderr, "\n%*s", (int)indent, ""); + space = avail; + } + desc += strspn(desc, " \n\t"); + } + } + + fprintf(stderr, "\n"); +} + +/* Documented in cli.h */ +void cli_help(const struct cli_table *cli, const char *prog_name) +{ + size_t count; + size_t pcount; + size_t max_len; + size_t pmax_len; + size_t phas_desc; + size_t required = 0; + enum { + ARG_PROG_NAME, + }; + + cli__count(cli, &count, &pcount, &max_len, &pmax_len, &phas_desc); + + fprintf(stderr, "\nUsage: %s", prog_name); + + if (pcount > 0) { + for (size_t i = 0; i < cli->count; i++) { + if (cli__entry_is_positional(&cli->entries[i])) { + const char *punctuation = + (required == cli->min_positional) ? + " [" : " "; + + if (cli->entries[i].t == CLI_CMD) { + fprintf(stderr, "%s%s", punctuation, + cli->entries[i].l); + } else { + fprintf(stderr, "%s<%s>", punctuation, + cli->entries[i].l); + } + required++; + } + } + if (required == pcount && required > cli->min_positional) { + fprintf(stderr, "]"); + } + } + + if (count > 0) { + fprintf(stderr, " [options]"); + } + + fprintf(stderr, "\n\n"); + + if (phas_desc > 0) { + fprintf(stderr, "Where:\n\n"); + + for (size_t i = 0; i < cli->count; i++) { + const struct cli_table_entry *entry = &cli->entries[i]; + + if (entry->d == NULL) { + continue; + } + + if (cli__entry_is_positional(entry)) { + fprintf(stderr, " %*.*s ", + (int)pmax_len, + (int)pmax_len, + entry->l); + cli__print_description(entry, pmax_len + 4); + fprintf(stderr, "\n"); + } + } + } + + if (count > 0) { + fprintf(stderr, "Options:\n\n"); + + for (size_t i = 0; i < cli->count; i++) { + const struct cli_table_entry *entry = &cli->entries[i]; + const char *type_str; + size_t type_len; + size_t arg_len; + + if (cli__entry_is_positional(entry)) { + continue; + } + + if (entry->s != '\0') { + fprintf(stderr, " -%c", entry->s); + } else { + fprintf(stderr, " "); + } + + type_str = cli__string_from_type(entry->t); + type_len = strlen(type_str); + arg_len = strlen(entry->l); + + fprintf(stderr, " --%s %s%*.s ", entry->l, type_str, + (int)(max_len - arg_len - type_len), + ""); + cli__print_description(entry, max_len + 11); + fprintf(stderr, "\n"); + } + } +} diff --git a/libvips/foreign/libnsgif/test/cli.h b/libvips/foreign/libnsgif/test/cli.h new file mode 100644 index 00000000..91db0862 --- /dev/null +++ b/libvips/foreign/libnsgif/test/cli.h @@ -0,0 +1,94 @@ +/* + * SPDX-License-Identifier: ISC + * + * Copyright (C) 2021 Michael Drake + */ + +/** + * \file + * \brief Command line argument handling API. + */ + +#ifndef _PELTAR_CLI_H_ +#define _PELTAR_CLI_H_ + +#include +#include + +/** + * Helper to get element count for an array, + * + * \param[in] _a Array to get number of elements for. + */ +#define CLI_ARRAY_LEN(_a) ((sizeof(_a))/(sizeof(*(_a)))) + +/** + * CLI argument type. + */ +enum cli_arg_type { + CLI_CMD, /**< A sub-command. Must match long argument name. */ + CLI_BOOL, /**< Has no value; presence of flag indicates true. */ + CLI_INT, /**< Has signed integer value. */ + CLI_UINT, /**< Has unsigned integer value. */ + CLI_ENUM, /**< Has enumeration value. */ + CLI_STRING, /**< Has string value. */ +}; + +struct cli_str_val { + const char *str; + int64_t val; +}; + +struct cli_enum { + const struct cli_str_val *desc; + int64_t *e; /**< Location to store \ref CLI_ENUM value. */ +}; + +/** + * Client description for a command line argument. + */ +struct cli_table_entry { + const char *l; /**< Long argument name. */ + const char s; /**< Short flag name. (Non-positional arguments.) */ + bool p; /**< Whether the argument is a positional argument. */ + enum cli_arg_type t; /**< Argument type. */ + union { + bool *b; /**< Location to store \ref CLI_BOOL value. */ + int64_t *i; /**< Location to store \ref CLI_INT value. */ + uint64_t *u; /**< Location to store \ref CLI_UINT value. */ + const char **s; /**< Location to store \ref CLI_STRING value. */ + struct cli_enum e; + } v; /**< Where to store type-specific values. */ + const char *d; /**< Description. */ +}; + +/** + * Client command line interface specification. + */ +struct cli_table { + const struct cli_table_entry *entries; + size_t count; + size_t min_positional; +}; + +/** + * Parse the command line arguments. + * + * \param[in] cli Client command line interface specification. + * \param[in] argc Number of command line arguments. + * \param[in] argv String vector containing command line arguments. + * \return true on success, false on error. + */ +bool cli_parse(const struct cli_table *cli, int argc, const char **argv); + +/** + * Print usage and help output. + * + * Note: Assumes non-Unicode. (One byte per character.) + * + * \param[in] cli Client command line interface specification. + * \param[in] prog_name Program name. + */ +void cli_help(const struct cli_table *cli, const char *prog_name); + +#endif diff --git a/libvips/foreign/libnsgif/test/decode_gif.c b/libvips/foreign/libnsgif/test/decode_gif.c deleted file mode 100644 index dd692d8b..00000000 --- a/libvips/foreign/libnsgif/test/decode_gif.c +++ /dev/null @@ -1,258 +0,0 @@ -/* under libvips, compile with: - * - * gcc -g -Wall decode_gif.c `pkg-config vips --cflags --libs` - */ - -/* - * Copyright 2008 Sean Fox - * Copyright 2008 James Bursa - * - * This file is part of NetSurf's libnsgif, http://www.netsurf-browser.org/ - * Licenced under the MIT License, - * http://www.opensource.org/licenses/mit-license.php - */ - -#include -#include -#include -#include -#include -#include -#include - - -#include -#include "../libnsgif.h" - -#define BYTES_PER_PIXEL 4 -#define MAX_IMAGE_BYTES (48 * 1024 * 1024) - - -static void *bitmap_create(int width, int height) -{ - /* ensure a stupidly large bitmap is not created */ - if (((long long)width * (long long)height) > (MAX_IMAGE_BYTES/BYTES_PER_PIXEL)) { - return NULL; - } - return calloc(width * height, BYTES_PER_PIXEL); -} - - -static void bitmap_set_opaque(void *bitmap, bool opaque) -{ - (void) opaque; /* unused */ - (void) bitmap; /* unused */ - assert(bitmap); -} - - -static bool bitmap_test_opaque(void *bitmap) -{ - (void) bitmap; /* unused */ - assert(bitmap); - return false; -} - - -static unsigned char *bitmap_get_buffer(void *bitmap) -{ - assert(bitmap); - return bitmap; -} - - -static void bitmap_destroy(void *bitmap) -{ - assert(bitmap); - free(bitmap); -} - - -static void bitmap_modified(void *bitmap) -{ - (void) bitmap; /* unused */ - assert(bitmap); - return; -} - -static unsigned char *load_file(const char *path, size_t *data_size) -{ - FILE *fd; - struct stat sb; - unsigned char *buffer; - size_t size; - size_t n; - - fd = fopen(path, "rb"); - if (!fd) { - perror(path); - exit(EXIT_FAILURE); - } - - if (stat(path, &sb)) { - perror(path); - exit(EXIT_FAILURE); - } - size = sb.st_size; - - buffer = malloc(size); - if (!buffer) { - fprintf(stderr, "Unable to allocate %lld bytes\n", - (long long) size); - exit(EXIT_FAILURE); - } - - n = fread(buffer, 1, size, fd); - if (n != size) { - perror(path); - exit(EXIT_FAILURE); - } - - fclose(fd); - - *data_size = size; - return buffer; -} - - -static void warning(const char *context, gif_result code) -{ - fprintf(stderr, "%s failed: ", context); - switch (code) - { - case GIF_INSUFFICIENT_FRAME_DATA: - fprintf(stderr, "GIF_INSUFFICIENT_FRAME_DATA"); - break; - case GIF_FRAME_DATA_ERROR: - fprintf(stderr, "GIF_FRAME_DATA_ERROR"); - break; - case GIF_INSUFFICIENT_DATA: - fprintf(stderr, "GIF_INSUFFICIENT_DATA"); - break; - case GIF_DATA_ERROR: - fprintf(stderr, "GIF_DATA_ERROR"); - break; - case GIF_INSUFFICIENT_MEMORY: - fprintf(stderr, "GIF_INSUFFICIENT_MEMORY"); - break; - default: - fprintf(stderr, "unknown code %i", code); - break; - } - fprintf(stderr, "\n"); -} - -static void write_ppm(FILE* fh, const char *name, gif_animation *gif, - bool no_write) -{ - unsigned int i; - gif_result code; - - if (!no_write) { - fprintf(fh, "P3\n"); - fprintf(fh, "# %s\n", name); - fprintf(fh, "# width %u \n", gif->width); - fprintf(fh, "# height %u \n", gif->height); - fprintf(fh, "# frame_count %u \n", gif->frame_count); - fprintf(fh, "# frame_count_partial %u \n", gif->frame_count_partial); - fprintf(fh, "# loop_count %u \n", gif->loop_count); - fprintf(fh, "%u %u 256\n", gif->width, gif->height * gif->frame_count); - } - - /* decode the frames */ - for (i = 0; i != gif->frame_count; i++) { - unsigned int row, col; - unsigned char *image; - - code = gif_decode_frame(gif, i); - if (code != GIF_OK) - warning("gif_decode_frame", code); - - if (!no_write) { - fprintf(fh, "# frame %u:\n", i); - image = (unsigned char *) gif->frame_image; - for (row = 0; row != gif->height; row++) { - for (col = 0; col != gif->width; col++) { - size_t z = (row * gif->width + col) * 4; - fprintf(fh, "%u %u %u ", - (unsigned char) image[z], - (unsigned char) image[z + 1], - (unsigned char) image[z + 2]); - } - fprintf(fh, "\n"); - } - } - } - -} - -int main(int argc, char *argv[]) -{ - gif_bitmap_callback_vt bitmap_callbacks = { - bitmap_create, - bitmap_destroy, - bitmap_get_buffer, - bitmap_set_opaque, - bitmap_test_opaque, - bitmap_modified - }; - gif_animation gif; - size_t size; - gif_result code; - unsigned char *data; - FILE *outf = stdout; - bool no_write = false; - - if (argc < 2) { - fprintf(stderr, "Usage: %s image.gif [out]\n", argv[0]); - fprintf(stderr, "\n"); - fprintf(stderr, "If [out] is NOWRITE, the gif will be docoded " - "but not output.\n"); - fprintf(stderr, "Otherwise [out] is an output filename.\n"); - fprintf(stderr, "When [out] is unset, output is to stdout.\n"); - - return 1; - } - - if (argc > 2) { - if (strcmp(argv[2], "NOWRITE") == 0) { - no_write = true; - } else { - outf = fopen(argv[2], "w+"); - if (outf == NULL) { - fprintf(stderr, "Unable to open %s for writing\n", argv[2]); - return 2; - } - } - } - - /* create our gif animation */ - gif_create(&gif, &bitmap_callbacks); - - /* load file into memory */ - data = load_file(argv[1], &size); - - /* begin decoding */ - do { - code = gif_initialise(&gif, size, data); - if (code != GIF_OK && code != GIF_WORKING) { - warning("gif_initialise", code); - gif_finalise(&gif); - free(data); - return 1; - } - } while (code != GIF_OK); - - write_ppm(outf, argv[1], &gif, no_write); - - if (argc > 2 && !no_write) { - fclose(outf); - } - - /* clean up */ - gif_finalise(&gif); - free(data); - - return 0; -} - diff --git a/libvips/foreign/libnsgif/test/nsgif.c b/libvips/foreign/libnsgif/test/nsgif.c new file mode 100644 index 00000000..bac90618 --- /dev/null +++ b/libvips/foreign/libnsgif/test/nsgif.c @@ -0,0 +1,310 @@ +/* + * Copyright 2008 Sean Fox + * Copyright 2008 James Bursa + * Copyright 2022 Michael Drake + * + * This file is part of NetSurf's libnsgif, http://www.netsurf-browser.org/ + * Licenced under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "../include/nsgif.h" + +#include "cli.h" +#include "cli.c" + +#define BYTES_PER_PIXEL 4 + +static struct nsgif_options { + const char *file; + const char *ppm; + uint64_t loops; + bool info; +} nsgif_options; + +static const struct cli_table_entry cli_entries[] = { + { + .s = 'm', + .l = "ppm", + .t = CLI_STRING, + .v.s = &nsgif_options.ppm, + .d = "Convert frames to PPM image at given path." + }, + { + .s = 'i', + .l = "info", + .t = CLI_BOOL, + .v.b = &nsgif_options.info, + .d = "Dump GIF info to stdout." + }, + { + .s = 'l', + .l = "loops", + .t = CLI_UINT, + .v.u = &nsgif_options.loops, + .d = "Loop through decoding all frames N times. " + "The default is 1." + }, + { + .p = true, + .l = "FILE", + .t = CLI_STRING, + .v.s = &nsgif_options.file, + .d = "Path to GIF file to load." + }, +}; + +const struct cli_table cli = { + .entries = cli_entries, + .count = (sizeof(cli_entries))/(sizeof(*cli_entries)), + .min_positional = 1, +}; + +static void *bitmap_create(int width, int height) +{ + /* Ensure a stupidly large bitmap is not created */ + if (width > 4096 || height > 4096) { + return NULL; + } + + return calloc(width * height, BYTES_PER_PIXEL); +} + +static unsigned char *bitmap_get_buffer(void *bitmap) +{ + return bitmap; +} + +static void bitmap_destroy(void *bitmap) +{ + free(bitmap); +} + +static uint8_t *load_file(const char *path, size_t *data_size) +{ + FILE *fd; + struct stat sb; + unsigned char *buffer; + size_t size; + size_t n; + + fd = fopen(path, "rb"); + if (!fd) { + perror(path); + exit(EXIT_FAILURE); + } + + if (stat(path, &sb)) { + perror(path); + exit(EXIT_FAILURE); + } + size = sb.st_size; + + buffer = malloc(size); + if (!buffer) { + fprintf(stderr, "Unable to allocate %lld bytes\n", + (long long) size); + exit(EXIT_FAILURE); + } + + n = fread(buffer, 1, size, fd); + if (n != size) { + perror(path); + exit(EXIT_FAILURE); + } + + fclose(fd); + + *data_size = size; + return buffer; +} + +static void warning(const char *context, nsgif_error err) +{ + fprintf(stderr, "%s failed: %s\n", + context, nsgif_strerror(err)); +} + +static void print_gif_info(const nsgif_info_t *info) +{ + fprintf(stdout, "gif:\n"); + fprintf(stdout, " width: %"PRIu32"\n", info->width); + fprintf(stdout, " height: %"PRIu32"\n", info->height); + fprintf(stdout, " max-loops: %"PRIu32"\n", info->loop_max); + fprintf(stdout, " frame-count: %"PRIu32"\n", info->frame_count); + fprintf(stdout, " background:\n"); + fprintf(stdout, " red: 0x%"PRIx8"\n", info->background[0]); + fprintf(stdout, " green: 0x%"PRIx8"\n", info->background[1]); + fprintf(stdout, " blue: 0x%"PRIx8"\n", info->background[2]); + fprintf(stdout, " frames:\n"); +} + +static void print_gif_frame_info(const nsgif_frame_info_t *info) +{ + const char *disposal = nsgif_str_disposal(info->disposal); + + fprintf(stdout, " - disposal-method: %s\n", disposal); + fprintf(stdout, " transparency: %s\n", info->transparency ? "yes" : "no"); + fprintf(stdout, " display: %s\n", info->display ? "yes" : "no"); + fprintf(stdout, " delay: %"PRIu32"\n", info->delay); + fprintf(stdout, " rect:\n"); + fprintf(stdout, " x: %"PRIu32"\n", info->rect.x0); + fprintf(stdout, " y: %"PRIu32"\n", info->rect.y0); + fprintf(stdout, " w: %"PRIu32"\n", info->rect.x1 - info->rect.x0); + fprintf(stdout, " h: %"PRIu32"\n", info->rect.y1 - info->rect.y0); +} + +static void decode(FILE* ppm, const char *name, nsgif_t *gif) +{ + nsgif_error err; + uint32_t frame_prev = 0; + const nsgif_info_t *info; + + info = nsgif_get_info(gif); + + if (ppm != NULL) { + fprintf(ppm, "P3\n"); + fprintf(ppm, "# %s\n", name); + fprintf(ppm, "# width %u \n", info->width); + fprintf(ppm, "# height %u \n", info->height); + fprintf(ppm, "# frame_count %u \n", info->frame_count); + fprintf(ppm, "# loop_max %u \n", info->loop_max); + fprintf(ppm, "%u %u 256\n", info->width, + info->height * info->frame_count); + } + + if (nsgif_options.info == true) { + print_gif_info(info); + } + + /* decode the frames */ + while (true) { + nsgif_bitmap_t *bitmap; + const uint8_t *image; + uint32_t frame_new; + uint32_t delay_cs; + nsgif_rect_t area; + + err = nsgif_frame_prepare(gif, &area, + &delay_cs, &frame_new); + if (err != NSGIF_OK) { + warning("nsgif_frame_prepare", err); + return; + } + + if (frame_new < frame_prev) { + /* Must be an animation that loops. We only care about + * decoding each frame once in this utility. */ + return; + } + frame_prev = frame_new; + + err = nsgif_frame_decode(gif, frame_new, &bitmap); + if (err != NSGIF_OK) { + warning("nsgif_decode_frame", err); + return; + } + + if (nsgif_options.info == true) { + const nsgif_frame_info_t *f_info; + + f_info = nsgif_get_frame_info(gif, frame_new); + assert(f_info != NULL); + print_gif_frame_info(f_info); + } + + if (ppm != NULL) { + fprintf(ppm, "# frame %u:\n", frame_new); + image = (const uint8_t *) bitmap; + for (uint32_t y = 0; y != info->height; y++) { + for (uint32_t x = 0; x != info->width; x++) { + size_t z = (y * info->width + x) * 4; + fprintf(ppm, "%u %u %u ", + image[z], + image[z + 1], + image[z + 2]); + } + fprintf(ppm, "\n"); + } + } + + if (delay_cs == NSGIF_INFINITE) { + /** This frame is the last. */ + return; + } + } +} + +int main(int argc, char *argv[]) +{ + const nsgif_bitmap_cb_vt bitmap_callbacks = { + .create = bitmap_create, + .destroy = bitmap_destroy, + .get_buffer = bitmap_get_buffer, + }; + size_t size; + nsgif_t *gif; + uint8_t *data; + nsgif_error err; + FILE *ppm = NULL; + + /* Override default options with any command line args */ + if (!cli_parse(&cli, argc, (void *)argv)) { + cli_help(&cli, argv[0]); + return EXIT_FAILURE; + } + + if (nsgif_options.ppm != NULL) { + ppm = fopen(nsgif_options.ppm, "w+"); + if (ppm == NULL) { + fprintf(stderr, "Unable to open %s for writing\n", + nsgif_options.ppm); + return EXIT_FAILURE; + } + } + + /* create our gif animation */ + err = nsgif_create(&bitmap_callbacks, &gif); + if (err != NSGIF_OK) { + warning("nsgif_create", err); + return EXIT_FAILURE; + } + + /* load file into memory */ + data = load_file(nsgif_options.file, &size); + + /* Scan the raw data */ + err = nsgif_data_scan(gif, size, data); + if (err != NSGIF_OK) { + warning("nsgif_data_scan", err); + nsgif_destroy(gif); + free(data); + return EXIT_FAILURE; + } + + if (nsgif_options.loops == 0) { + nsgif_options.loops = 1; + } + + for (uint64_t i = 0; i < nsgif_options.loops; i++) { + decode((i == 0) ? ppm : NULL, nsgif_options.file, gif); + } + + if (ppm != NULL) { + fclose(ppm); + } + + /* clean up */ + nsgif_destroy(gif); + free(data); + + return 0; +} diff --git a/libvips/foreign/libnsgif/update.sh b/libvips/foreign/libnsgif/update.sh index dedf6e08..cd05d2be 100755 --- a/libvips/foreign/libnsgif/update.sh +++ b/libvips/foreign/libnsgif/update.sh @@ -7,9 +7,15 @@ set -e git clone git://git.netsurf-browser.org/libnsgif.git echo copying out source files ... -cp libnsgif/src/libnsgif.c . -cp libnsgif/include/libnsgif.h . + +cp libnsgif/README.md README-ns.md + +cp libnsgif/include/nsgif.h . cp libnsgif/src/lzw.[ch] . +cp libnsgif/src/gif.c . + +cp libnsgif/test/cli.[ch] test/ +cp libnsgif/test/nsgif.c test/ if [ -d "patches" ] then diff --git a/libvips/foreign/libnsgif/utils/log.h b/libvips/foreign/libnsgif/utils/log.h deleted file mode 100644 index 1413374c..00000000 --- a/libvips/foreign/libnsgif/utils/log.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright 2003 James Bursa - * Copyright 2004 John Tytgat - * - * This file is part of NetSurf, http://www.netsurf-browser.org/ - * Licenced under the MIT License, - * http://www.opensource.org/licenses/mit-license.php - */ - -#include - -#ifndef _LIBNSGIF_LOG_H_ -#define _LIBNSGIF_LOG_H_ - -#ifdef NDEBUG -# define LOG(x) ((void) 0) -#else -# define LOG(x) do { fprintf(stderr, x), fputc('\n', stderr); } while (0) -#endif /* NDEBUG */ - -#endif /* _LIBNSGIF_LOG_H_ */ diff --git a/libvips/foreign/nsgifload.c b/libvips/foreign/nsgifload.c index 92e6e8fa..4a5c90bd 100644 --- a/libvips/foreign/nsgifload.c +++ b/libvips/foreign/nsgifload.c @@ -71,7 +71,7 @@ #ifdef HAVE_NSGIF -#include +#include #define VIPS_TYPE_FOREIGN_LOAD_GIF (vips_foreign_load_nsgif_get_type()) #define VIPS_FOREIGN_LOAD_GIF( obj ) \ @@ -105,19 +105,19 @@ typedef struct _VipsForeignLoadNsgif { /* The animation created by libnsgif. */ - gif_animation *anim; + nsgif_t *anim; /* The data/size pair we pass to libnsgif. */ unsigned char *data; size_t size; - /* The frame_count, after we have removed undisplayable frames. + /* Information about the current GIF. */ - int frame_count_displayable; + const nsgif_info_t *info; /* Delays between frames (in milliseconds). Array of length - * @frame_count_displayable. + * @info->frame_count. */ int *delay; @@ -137,40 +137,13 @@ G_DEFINE_ABSTRACT_TYPE( VipsForeignLoadNsgif, vips_foreign_load_nsgif, VIPS_TYPE_FOREIGN_LOAD ); static const char * -vips_foreign_load_nsgif_errstr( gif_result result ) +vips_foreign_load_nsgif_errstr( nsgif_error result ) { - switch( result ) { - case GIF_WORKING: - return( _( "Working" ) ); - - case GIF_OK: - return( _( "OK" ) ); - - case GIF_FRAME_DATA_ERROR: - return( _( "GIF frame data error" ) ); - - case GIF_INSUFFICIENT_DATA: - return( _( "Incomplete data" ) ); - - case GIF_DATA_ERROR: - return( _( "GIF header data error" ) ); - - case GIF_INSUFFICIENT_MEMORY: - return( _( "Insuficient memory to process" ) ); - - case GIF_FRAME_NO_DISPLAY: - return( _( "No display" ) ); - - case GIF_END_OF_FRAME: - return( _( "At end of frame" ) ); - - default: - return( _( "Unknown error" ) ); - } + return nsgif_strerror( result ); } static void -vips_foreign_load_nsgif_error( VipsForeignLoadNsgif *gif, gif_result result ) +vips_foreign_load_nsgif_error( VipsForeignLoadNsgif *gif, nsgif_error result ) { VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( gif ); @@ -186,8 +159,7 @@ vips_foreign_load_nsgif_dispose( GObject *gobject ) VIPS_DEBUG_MSG( "vips_foreign_load_nsgif_dispose:\n" ); if( gif->anim ) { - gif_finalise( gif->anim ); - VIPS_FREE( gif->anim ); + nsgif_destroy( gif->anim ); } VIPS_UNREF( gif->source ); VIPS_FREE( gif->delay ); @@ -224,60 +196,45 @@ vips_foreign_load_nsgif_is_a_source( VipsSource *source ) } #ifdef VERBOSE -static const char * -dispose_name( int restore ) -{ - switch( restore ) { - case 1: return( "combine" ); - case 2: return( "clear" ); - case 3: return( "restore" ); - case 4: return( "quirk restore" ); - default: return( "none" ); - } -} static void -print_frame( gif_frame *frame ) +print_frame( const nsgif_frame_info_t *frame ) { + if ( frame == NULL ) + return; + printf( "frame:\n" ); printf( " display = %d\n", frame->display ); - printf( " frame_delay = %d\n", frame->frame_delay ); - printf( " virgin = %d\n", frame->virgin ); - printf( " opaque = %d\n", frame->opaque ); - printf( " redraw_required = %d\n", frame->redraw_required ); - printf( " disposal_method = %d (%s)\n", - frame->disposal_method, - dispose_name( frame->disposal_method ) ); + printf( " delay = %d\n", frame->delay ); +// printf( " opaque = %d\n", frame->opaque ); + printf( " disposal = %d (%s)\n", + frame->disposal, nsgif_str_disposal( frame->disposal ) ); printf( " transparency = %d\n", frame->transparency ); - printf( " transparency_index = %d\n", frame->transparency_index ); - printf( " redraw_x = %d\n", frame->redraw_x ); - printf( " redraw_y = %d\n", frame->redraw_y ); - printf( " redraw_width = %d\n", frame->redraw_width ); - printf( " redraw_height = %d\n", frame->redraw_height ); +// printf( " transparency_index = %d\n", frame->transparency_index ); + printf( " rect.x0 = %u\n", frame->rect.x0 ); + printf( " rect.y0 = %u\n", frame->rect.y0 ); + printf( " rect.x1 = %u\n", frame->rect.x1 ); + printf( " rect.y1 = %u\n", frame->rect.y1 ); } static void -print_animation( gif_animation *anim ) +print_animation( nsgif_t *anim, const nsgif_info_t *info ) { int i; printf( "animation:\n" ); - printf( " width = %d\n", anim->width ); - printf( " height = %d\n", anim->height ); - printf( " frame_count = %d\n", anim->frame_count ); - printf( " frame_count_partial = %d\n", anim->frame_count_partial ); - printf( " decoded_frame = %d\n", anim->decoded_frame ); - printf( " frame_image = %p\n", anim->frame_image ); - printf( " loop_count = %d\n", anim->loop_count ); - printf( " frame_holders = %d\n", anim->frame_holders ); - printf( " colour_table_size = %d\n", anim->colour_table_size ); - printf( " global_colours = %d\n", anim->global_colours ); - printf( " global_colour_table = %p\n", anim->global_colour_table ); - printf( " local_colour_table = %p\n", anim->local_colour_table ); + printf( " width = %d\n", info->width ); + printf( " height = %d\n", info->height ); + printf( " frame_count = %d\n", info->frame_count ); + printf( " loop_count = %d\n", info->loop_count ); +// printf( " colour_table_size = %d\n", anim->colour_table_size ); +// printf( " global_colours = %d\n", anim->global_colours ); +// printf( " global_colour_table = %p\n", anim->global_colour_table ); +// printf( " local_colour_table = %p\n", anim->local_colour_table ); - for( i = 0; i < anim->frame_holders; i++ ) { + for( i = 0; i < info->frame_count; i++ ) { printf( "%d ", i ); - print_frame( &anim->frames[i] ); + print_frame( nsgif_get_frame_info( anim, i ) ); } } #endif /*VERBOSE*/ @@ -286,10 +243,12 @@ static int vips_foreign_load_nsgif_set_header( VipsForeignLoadNsgif *gif, VipsImage *image ) { + double array[3]; + VIPS_DEBUG_MSG( "vips_foreign_load_nsgif_set_header:\n" ); vips_image_init_fields( image, - gif->anim->width, gif->anim->height * gif->n, + gif->info->width, gif->info->height * gif->n, gif->has_transparency ? 4 : 3, VIPS_FORMAT_UCHAR, VIPS_CODING_NONE, VIPS_INTERPRETATION_sRGB, 1.0, 1.0 ); @@ -300,29 +259,19 @@ vips_foreign_load_nsgif_set_header( VipsForeignLoadNsgif *gif, */ if( gif->n > 1 ) vips_image_set_int( image, - VIPS_META_PAGE_HEIGHT, gif->anim->height ); + VIPS_META_PAGE_HEIGHT, gif->info->height ); vips_image_set_int( image, VIPS_META_N_PAGES, - gif->frame_count_displayable ); - vips_image_set_int( image, "loop", gif->anim->loop_count ); + gif->info->frame_count ); + vips_image_set_int( image, "loop", gif->info->loop_max ); + vips_image_set_array_int( image, "delay", - gif->delay, gif->frame_count_displayable ); + gif->delay, gif->info->frame_count ); - if( gif->anim->global_colours && - gif->anim->global_colour_table && - gif->anim->bg_index >= 0 && - gif->anim->bg_index < gif->anim->colour_table_size ) { - int index = gif->anim->bg_index; - unsigned char *entry = (unsigned char *) - &gif->anim->global_colour_table[index]; + array[0] = gif->info->background[0]; + array[1] = gif->info->background[1]; + array[2] = gif->info->background[2]; - double array[3]; - - array[0] = entry[0]; - array[1] = entry[1]; - array[2] = entry[2]; - - vips_image_set_array_double( image, "background", array, 3 ); - } + vips_image_set_array_double( image, "background", array, 3 ); VIPS_SETSTR( image->filename, vips_connection_filename( VIPS_CONNECTION( gif->source ) ) ); @@ -333,8 +282,8 @@ vips_foreign_load_nsgif_set_header( VipsForeignLoadNsgif *gif, * but we want to keep the old behavior untouched! */ vips_image_set_int( image, - "gif-loop", gif->anim->loop_count == 0 ? - 0 : gif->anim->loop_count - 1 ); + "gif-loop", gif->info->loop_max == 0 ? + 0 : gif->info->loop_max - 1 ); /* The deprecated gif-delay field is in centiseconds. */ @@ -359,7 +308,7 @@ vips_foreign_load_nsgif_header( VipsForeignLoad *load ) const void *data; size_t size; - gif_result result; + nsgif_error result; int i; VIPS_DEBUG_MSG( "vips_foreign_load_nsgif_header:\n" ); @@ -371,55 +320,40 @@ vips_foreign_load_nsgif_header( VipsForeignLoad *load ) return( -1 ); vips_source_minimise( gif->source ); - result = gif_initialise( gif->anim, size, (void *) data ); - VIPS_DEBUG_MSG( "gif_initialise() = %d\n", result ); + result = nsgif_data_scan( gif->anim, size, (void *) data ); + VIPS_DEBUG_MSG( "nsgif_data_scan() = %s\n", nsgif_strerror( result ) ); + gif->info = nsgif_get_info(gif->anim); #ifdef VERBOSE - print_animation( gif->anim ); + print_animation( gif->anim, gif->info ); #endif /*VERBOSE*/ - if( result != GIF_OK && - result != GIF_WORKING && - result != GIF_INSUFFICIENT_FRAME_DATA ) { + if( result != NSGIF_OK ) { vips_foreign_load_nsgif_error( gif, result ); return( -1 ); } - else if( result == GIF_INSUFFICIENT_FRAME_DATA && - load->fail_on >= VIPS_FAIL_ON_TRUNCATED ) { - vips_error( class->nickname, "%s", _( "truncated GIF" ) ); - return( -1 ); - } - /* Many GIFs have dead frames at the end. Remove these from our count. - */ - for( i = gif->anim->frame_count - 1; - i >= 0 && !gif->anim->frames[i].display; i-- ) - ; - gif->frame_count_displayable = i + 1; -#ifdef VERBOSE - if( gif->frame_count_displayable != gif->anim->frame_count ) - printf( "vips_foreign_load_nsgif_open: " - "removed %d undisplayable frames\n", - gif->anim->frame_count - gif->frame_count_displayable ); -#endif /*VERBOSE*/ - - if( !gif->frame_count_displayable ) { + if( !gif->info->frame_count ) { vips_error( class->nickname, "%s", _( "no frames in GIF" ) ); return( -1 ); } /* Check for any transparency. */ - for( i = 0; i < gif->frame_count_displayable; i++ ) - if( gif->anim->frames[i].transparency ) { + for( i = 0; i < gif->info->frame_count; i++ ) { + const nsgif_frame_info_t *frame_info; + + frame_info = nsgif_get_frame_info( gif->anim, i ); + if( frame_info != NULL && frame_info->transparency ) { gif->has_transparency = TRUE; break; } + } if( gif->n == -1 ) - gif->n = gif->frame_count_displayable - gif->page; + gif->n = gif->info->frame_count - gif->page; if( gif->page < 0 || gif->n <= 0 || - gif->page + gif->n > gif->frame_count_displayable ) { + gif->page + gif->n > gif->info->frame_count ) { vips_error( class->nickname, "%s", _( "bad page number" ) ); return( -1 ); } @@ -428,12 +362,20 @@ vips_foreign_load_nsgif_header( VipsForeignLoad *load ) */ VIPS_FREE( gif->delay ); if( !(gif->delay = VIPS_ARRAY( NULL, - gif->frame_count_displayable, int )) ) + gif->info->frame_count, int )) ) return( -1 ); - for( i = 0; i < gif->frame_count_displayable; i++ ) - gif->delay[i] = 10 * gif->anim->frames[i].frame_delay; + for( i = 0; i < gif->info->frame_count; i++ ) { + const nsgif_frame_info_t *frame_info; - gif->gif_delay = gif->anim->frames[0].frame_delay; + frame_info = nsgif_get_frame_info( gif->anim, i ); + if ( frame_info == NULL ) { + vips_error( class->nickname, "%s", _( "bad frame" ) ); + return( -1 ); + } + gif->delay[i] = 10 * frame_info->delay; + } + + gif->gif_delay = gif->delay[0] / 10; vips_foreign_load_nsgif_set_header( gif, load->out ); @@ -444,7 +386,9 @@ static int vips_foreign_load_nsgif_generate( VipsRegion *or, void *seq, void *a, void *b, gboolean *stop ) { - VipsRect *r = &or->valid; + int prev_page = -1; + nsgif_bitmap_t *bitmap; + VipsRect *r = &or->valid; VipsForeignLoadNsgif *gif = (VipsForeignLoadNsgif *) a; int y; @@ -457,30 +401,30 @@ vips_foreign_load_nsgif_generate( VipsRegion *or, for( y = 0; y < r->height; y++ ) { /* The page for this output line, and the line number in page. */ - int page = (r->top + y) / gif->anim->height + gif->page; - int line = (r->top + y) % gif->anim->height; + int page = (r->top + y) / gif->info->height + gif->page; + int line = (r->top + y) % gif->info->height; - gif_result result; + nsgif_error result; VipsPel *p, *q; - g_assert( line >= 0 && line < gif->anim->height ); - g_assert( page >= 0 && page < gif->frame_count_displayable ); + g_assert( line >= 0 && line < gif->info->height ); + g_assert( page >= 0 && page < gif->info->frame_count ); - if( gif->anim->decoded_frame != page ) { - result = gif_decode_frame( gif->anim, page ); - VIPS_DEBUG_MSG( " gif_decode_frame(%d) = %d\n", + if( prev_page != page ) { + result = nsgif_frame_decode( gif->anim, page, &bitmap ); + VIPS_DEBUG_MSG( " nsgif_frame_decode(%d) = %d\n", page, result ); - if( result != GIF_OK ) { - vips_foreign_load_nsgif_error( gif, result ); + if( result != NSGIF_OK ) { + vips_foreign_load_nsgif_error( gif, result ); return( -1 ); } #ifdef VERBOSE print_animation( gif->anim ); #endif /*VERBOSE*/ + prev_page = page; } - p = gif->anim->frame_image + - line * gif->anim->width * sizeof( int ); + p = bitmap + line * gif->info->width * sizeof( int ); q = VIPS_REGION_ADDR( or, 0, r->top + y ); if( gif->has_transparency ) memcpy( q, p, VIPS_REGION_SIZEOF_LINE( or ) ); @@ -587,23 +531,6 @@ vips_foreign_load_nsgif_bitmap_create( int width, int height ) return g_malloc0( (gsize) width * height * 4 ); } -static void -vips_foreign_load_nsgif_bitmap_set_opaque( void *bitmap, bool opaque ) -{ - (void) opaque; /* unused */ - (void) bitmap; /* unused */ - g_assert( bitmap ); -} - -static bool -vips_foreign_load_nsgif_bitmap_test_opaque( void *bitmap ) -{ - (void) bitmap; /* unused */ - g_assert( bitmap ); - - return( false ); -} - static unsigned char * vips_foreign_load_nsgif_bitmap_get_buffer( void *bitmap ) { @@ -619,29 +546,24 @@ vips_foreign_load_nsgif_bitmap_destroy( void *bitmap ) g_free( bitmap ); } -static void -vips_foreign_load_nsgif_bitmap_modified( void *bitmap ) -{ - (void) bitmap; /* unused */ - g_assert( bitmap ); - - return; -} - -static gif_bitmap_callback_vt vips_foreign_load_nsgif_bitmap_callbacks = { +static nsgif_bitmap_cb_vt vips_foreign_load_nsgif_bitmap_callbacks = { vips_foreign_load_nsgif_bitmap_create, vips_foreign_load_nsgif_bitmap_destroy, vips_foreign_load_nsgif_bitmap_get_buffer, - vips_foreign_load_nsgif_bitmap_set_opaque, - vips_foreign_load_nsgif_bitmap_test_opaque, - vips_foreign_load_nsgif_bitmap_modified }; static void vips_foreign_load_nsgif_init( VipsForeignLoadNsgif *gif ) { - gif->anim = g_new0( gif_animation, 1 ); - gif_create( gif->anim, &vips_foreign_load_nsgif_bitmap_callbacks ); + nsgif_error result = nsgif_create( + &vips_foreign_load_nsgif_bitmap_callbacks, + &gif->anim ); + if (result != NSGIF_OK) { + VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( gif ); + vips_error( class->nickname, "%s", + nsgif_strerror( result ) ); + return; + } gif->n = 1; }