lzw__read_code()

static lzw_result fl::third_party::lzw__read_code ( struct lzw_read_ctx * ctx, fl::u16 code_size, fl::u16 * code_out )

inlinestatic

Get the next LZW code of given size from the raw input data.

Reads codes from the input data stream coping with GIF data sub-blocks.

Parameters

[in]	ctx	LZW reading context, updated.
[in]	code_size	Size of LZW code to get from data.
[out]	code_out	Returns an LZW code on success.

Returns

LZW_OK or LZW_OK_EOD on success, appropriate error otherwise.

Definition at line 167 of file lzw.cpp.hpp.

{
    fl::u32 code = 0;
    fl::u32 current_bit = ctx->sb_bit & 0x7;
 
    if (ctx->sb_bit + 24 <= ctx->sb_bit_count) {
        /* Fast path: read three bytes from this sub-block */
        const fl::u8 *data = ctx->sb_data + (ctx->sb_bit >> 3);
        code |= static_cast<fl::u32>(*data++) <<  0;
        code |= static_cast<fl::u32>(*data++) <<  8;
        code |= static_cast<fl::u32>(*data)   << 16;
        ctx->sb_bit += code_size;
    } else {
        /* Slow path: code spans sub-blocks */
        fl::u8 byte_advance = (current_bit + code_size) >> 3;
        fl::u8 byte = 0;
        fl::u8 bits_remaining_0 = (code_size < (8u - current_bit)) ?
                code_size : (8u - current_bit);
        fl::u8 bits_remaining_1 = code_size - bits_remaining_0;
        fl::u8 bits_used[3] = {
            bits_remaining_0,
            (fl::u8)(bits_remaining_1 < 8 ? bits_remaining_1 : 8),
            (fl::u8)(bits_remaining_1 - 8),
        };
 
        FL_ASSERT(byte_advance <= 2, "Byte advance too large");
 
        while (true) {
            const fl::u8 *data = ctx->sb_data;
            lzw_result res;
 
            /* Get any data from end of this sub-block */
            while (byte <= byte_advance &&
                    ctx->sb_bit < ctx->sb_bit_count) {
                code |= data[ctx->sb_bit >> 3] << (byte << 3);
                ctx->sb_bit += bits_used[byte];
                byte++;
            }
 
            /* Check if we have all we need */
            if (byte > byte_advance) {
                break;
            }
 
            /* Move to next sub-block */
            res = lzw__block_advance(ctx);
            if (res != LZW_OK) {
                return res;
            }
        }
    }
 
    *code_out = (code >> current_bit) & ((1 << code_size) - 1);
    return LZW_OK;
}

References FL_ASSERT, FL_NOEXCEPT, lzw__block_advance(), and LZW_OK.

Referenced by lzw__decode(), and lzw__handle_clear().

Here is the call graph for this function:

Here is the caller graph for this function: