nsgif_data_scan()

nsgif_error fl::third_party::nsgif_data_scan	(	nsgif_t *	gif,
		fl::size	size,
		const fl::u8 *	data )

Scan the source image data.

This is used to feed the source data into LibNSGIF. This must be called before calling 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 nsgif_data_scan must be provided each time.

Once all the data has been provided, call nsgif_data_complete.

For example, if you call nsgif_data_scan with 25 bytes of data, and then fetch another 10 bytes, you would need to call 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 nsgif_data_scan. (The actual data pointer is allowed to be different.)

If an error occurs, all previously scanned frames are retained.

Note that an error returned from this function is purely informational. So long as at least one frame is available, you can display frames.

Parameters

[in]	gif	The nsgif_t object.
[in]	size	Number of bytes in data.
[in]	data	Raw source GIF data.

Returns

NSGIF_OK on success, or appropriate error otherwise.

Definition at line 1616 of file gif.cpp.hpp.

{
    const fl::u8 *nsgif_data;
    nsgif_error ret;
    fl::u32 frames;
 
    if (gif->data_complete) {
        return NSGIF_ERR_DATA_COMPLETE;
    }
 
    /* 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 = nullptr;
        gif->frames = nullptr;
        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->info.global_palette) {
            fl::size remaining = gif->buf + gif->buf_len - nsgif_data;
            fl::size used;
 
            ret = nsgif__colour_table_extract(
                    gif->global_colour_table,
                    &gif->colour_layout,
                    gif->colour_table_size,
                    nsgif_data, remaining, &used, true);
            if (ret != NSGIF_OK) {
                return ret;
            }
 
            nsgif_data += used;
            gif->buf_pos = (nsgif_data - gif->buf);
        } else {
            /* Create a default colour table with the first two
             * colours as black and white. */
            fl::u8 *entry = (fl::u8 *)gif->global_colour_table;
 
            /* Black */
            entry[gif->colour_layout.r] = 0x00;
            entry[gif->colour_layout.g] = 0x00;
            entry[gif->colour_layout.b] = 0x00;
            entry[gif->colour_layout.a] = 0xFF;
 
            entry += sizeof(fl::u32);
 
            /* White */
            entry[gif->colour_layout.r] = 0xFF;
            entry[gif->colour_layout.g] = 0xFF;
            entry[gif->colour_layout.b] = 0xFF;
            entry[gif->colour_layout.a] = 0xFF;
 
            gif->colour_table_size = 2;
        }
 
        if (gif->info.global_palette &&
            gif->bg_index < gif->colour_table_size) {
            fl::size bg_idx = gif->bg_index;
            gif->info.background = gif->global_colour_table[bg_idx];
        } else {
            gif->info.background = gif->global_colour_table[0];
        }
    }
 
    if (gif->lzw_ctx == nullptr) {
        struct lzw_ctx *lzw_ctx_ptr = nullptr;
        lzw_result res = lzw_context_create(&lzw_ctx_ptr);
        gif->lzw_ctx = lzw_ctx_ptr;
        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;
}

References FL_NOEXCEPT, lzw_context_create(), LZW_OK, nsgif__colour_table_extract(), nsgif__error_from_lzw(), nsgif__parse_header(), nsgif__parse_logical_screen_descriptor(), nsgif__process_frame(), NSGIF_ERR_DATA_COMPLETE, NSGIF_ERR_END_OF_DATA, NSGIF_FRAME_INVALID, NSGIF_OK, NSGIF_PROCESS_COLOURS, and NSGIF_TRAILER.

Referenced by fl::third_party::SoftwareGifDecoder::loadMoreData().

Here is the call graph for this function:

Here is the caller graph for this function: