#include <stdlib.h>
#include <string.h>
#include "heatshrink_decoder.h"

Include dependency graph for heatshrink_decoder.c:

Data Structures
struct	output_info

Macros
#define	LOG(...) /* no-op */

#define	ASSERT(X) /* no-op */

#define	NO_BITS ((uint32_t)-1)

#define	BACKREF_COUNT_BITS(HSD) (HEATSHRINK_DECODER_LOOKAHEAD_BITS(HSD))

#define	BACKREF_INDEX_BITS(HSD) (HEATSHRINK_DECODER_WINDOW_BITS(HSD))

Enumerations
enum	HSD_state { HSDS_EMPTY, HSDS_INPUT_AVAILABLE, HSDS_YIELD_LITERAL, HSDS_BACKREF_INDEX_MSB, HSDS_BACKREF_INDEX_LSB, HSDS_BACKREF_COUNT_MSB, HSDS_BACKREF_COUNT_LSB, HSDS_YIELD_BACKREF, HSDS_CHECK_FOR_MORE_INPUT }

Functions
static uint32_t	get_bits (heatshrink_decoder *hsd, uint8_t count)

static void	push_byte (heatshrink_decoder hsd, output_info oi, uint8_t byte)

heatshrink_decoder *	heatshrink_decoder_alloc (uint16_t input_buffer_size, uint8_t window_sz2, uint8_t lookahead_sz2)

void	heatshrink_decoder_free (heatshrink_decoder *hsd)

void	heatshrink_decoder_reset (heatshrink_decoder *hsd)

HSD_sink_res	heatshrink_decoder_sink (heatshrink_decoder hsd, uint8_t in_buf, size_t size, size_t *input_size)

static HSD_state	st_input_available (heatshrink_decoder *hsd)

static HSD_state	st_yield_literal (heatshrink_decoder hsd, output_info oi)

static HSD_state	st_backref_index_msb (heatshrink_decoder *hsd)

static HSD_state	st_backref_index_lsb (heatshrink_decoder *hsd)

static HSD_state	st_backref_count_msb (heatshrink_decoder *hsd)

static HSD_state	st_backref_count_lsb (heatshrink_decoder *hsd)

static HSD_state	st_yield_backref (heatshrink_decoder hsd, output_info oi)

static HSD_state	st_check_for_input (heatshrink_decoder *hsd)

HSD_poll_res	heatshrink_decoder_poll (heatshrink_decoder hsd, uint8_t out_buf, size_t out_buf_size, size_t *output_size)

HSD_finish_res	heatshrink_decoder_finish (heatshrink_decoder *hsd)

Macro Definition Documentation

◆ ASSERT

#define ASSERT ( X ) /* no-op */

Definition at line 35 of file heatshrink_decoder.c.

Referenced by st_backref_count_msb(), st_backref_index_msb(), and st_yield_backref().

◆ BACKREF_COUNT_BITS

#define BACKREF_COUNT_BITS ( HSD ) (HEATSHRINK_DECODER_LOOKAHEAD_BITS(HSD))

Definition at line 128 of file heatshrink_decoder.c.

Referenced by st_backref_count_lsb(), st_backref_count_msb(), st_backref_index_lsb(), and st_yield_backref().

◆ BACKREF_INDEX_BITS

#define BACKREF_INDEX_BITS ( HSD ) (HEATSHRINK_DECODER_WINDOW_BITS(HSD))

Definition at line 129 of file heatshrink_decoder.c.

Referenced by st_backref_index_lsb(), and st_backref_index_msb().

◆ LOG

#define LOG ( ... ) /* no-op */

Definition at line 34 of file heatshrink_decoder.c.

Referenced by get_bits(), heatshrink_decoder_alloc(), heatshrink_decoder_poll(), heatshrink_decoder_sink(), push_byte(), st_backref_count_lsb(), st_backref_count_msb(), st_backref_index_lsb(), st_backref_index_msb(), st_yield_backref(), and st_yield_literal().

◆ NO_BITS

#define NO_BITS ((uint32_t)-1)

Definition at line 44 of file heatshrink_decoder.c.

Referenced by get_bits(), st_backref_count_lsb(), st_backref_count_msb(), st_backref_index_lsb(), st_backref_index_msb(), and st_yield_literal().

Enumeration Type Documentation

◆ HSD_state

enum HSD_state

Enumerator
HSDS_EMPTY
HSDS_INPUT_AVAILABLE
HSDS_YIELD_LITERAL
HSDS_BACKREF_INDEX_MSB
HSDS_BACKREF_INDEX_LSB
HSDS_BACKREF_COUNT_MSB
HSDS_BACKREF_COUNT_LSB
HSDS_YIELD_BACKREF
HSDS_CHECK_FOR_MORE_INPUT

Definition at line 6 of file heatshrink_decoder.c.

              {
     HSDS_EMPTY,                 /* no input to process */
     HSDS_INPUT_AVAILABLE,       /* new input, completely unprocessed */
     HSDS_YIELD_LITERAL,         /* ready to yield literal byte */
     HSDS_BACKREF_INDEX_MSB,     /* most significant byte of index */
     HSDS_BACKREF_INDEX_LSB,     /* least significant byte of index */
     HSDS_BACKREF_COUNT_MSB,     /* most significant byte of count */
     HSDS_BACKREF_COUNT_LSB,     /* least significant byte of count */
     HSDS_YIELD_BACKREF,         /* ready to yield back-reference */
     HSDS_CHECK_FOR_MORE_INPUT,  /* check if input is exhausted */
 } HSD_state;

Function Documentation

◆ get_bits()

static uint32_t get_bits	(	heatshrink_decoder *	hsd,
		uint8_t	count
	)

static

Definition at line 305 of file heatshrink_decoder.c.

References heatshrink_decoder::bit_accumulator, heatshrink_decoder::bit_index, heatshrink_decoder::buffers, heatshrink_decoder::current_byte, heatshrink_decoder::input_index, heatshrink_decoder::input_size, LOG, and NO_BITS.

Referenced by st_backref_count_lsb(), st_backref_count_msb(), st_backref_index_lsb(), st_backref_index_msb(), st_input_available(), and st_yield_literal().

                                                                  {
     int i;
     if (count > 31) { return NO_BITS; }
     LOG("-- popping %u bit(s)\n", count);
 
     /* If we aren't able to get COUNT bits, suspend immediately, because we
      * don't track how many bits of COUNT we've accumulated before suspend. */
     if (hsd->input_size == 0) {
         if (hsd->bit_index < (1 << (count - 1))) { return NO_BITS; }
     }
 
     for (i = 0; i < count; i++) {
         if (hsd->bit_index == 0x00) {
             if (hsd->input_size == 0) {
                 LOG("  -- out of bits, suspending w/ accumulator of %u (0x%02x)\n",
                     hsd->bit_accumulator, hsd->bit_accumulator);
                 return NO_BITS;
             }
             hsd->current_byte = hsd->buffers[hsd->input_index++];
             LOG("  -- pulled byte 0x%02x\n", hsd->current_byte);
             if (hsd->input_index == hsd->input_size) {
                 hsd->input_index = 0; /* input is exhausted */
                 hsd->input_size = 0;
             }
             hsd->bit_index = 0x80;
         }
         hsd->bit_accumulator <<= 1;
         if (hsd->current_byte & hsd->bit_index) {
             hsd->bit_accumulator |= 0x01;
             if (0) {
                 LOG("  -- got 1, accumulator 0x%04x, bit_index 0x%02x\n",
                 hsd->bit_accumulator, hsd->bit_index);
             }
         } else {
             if (0) {
                 LOG("  -- got 0, accumulator 0x%04x, bit_index 0x%02x\n",
                 hsd->bit_accumulator, hsd->bit_index);
             }
         }
         hsd->bit_index >>= 1;
     }
 
     uint32_t res = 0;
     res = hsd->bit_accumulator;
     hsd->bit_accumulator = 0x00000000;
     if (count > 1) { LOG("  -- accumulated %08x\n", res); }
     return res;
 }

Here is the caller graph for this function:

◆ heatshrink_decoder_alloc()

heatshrink_decoder* heatshrink_decoder_alloc	(	uint16_t	input_buffer_size,
		uint8_t	window_sz2,
		uint8_t	lookahead_sz2
	)

Definition at line 51 of file heatshrink_decoder.c.

References heatshrink_decoder_reset(), HEATSHRINK_MALLOC, HEATSHRINK_MAX_WINDOW_BITS, HEATSHRINK_MIN_LOOKAHEAD_BITS, HEATSHRINK_MIN_WINDOW_BITS, hsd, heatshrink_decoder::input_buffer_size, LOG, heatshrink_decoder::lookahead_sz2, NULL, and heatshrink_decoder::window_sz2.

                                                                     {
     if ((window_sz2 < HEATSHRINK_MIN_WINDOW_BITS) ||
         (window_sz2 > HEATSHRINK_MAX_WINDOW_BITS) ||
         (input_buffer_size == 0) ||
         (lookahead_sz2 < HEATSHRINK_MIN_LOOKAHEAD_BITS) ||
         (lookahead_sz2 > window_sz2)) {
         return NULL;
     }
     size_t buffers_sz = (1 << window_sz2) + input_buffer_size;
     size_t sz = sizeof(heatshrink_decoder) + buffers_sz;
     heatshrink_decoder *hsd = HEATSHRINK_MALLOC(sz);
     if (hsd == NULL) { return NULL; }
     hsd->input_buffer_size = input_buffer_size;
     hsd->window_sz2 = window_sz2;
     hsd->lookahead_sz2 = lookahead_sz2;
     heatshrink_decoder_reset(hsd);
     LOG("-- allocated decoder with buffer size of %zu (%zu + %u + %u)\n",
         sz, sizeof(heatshrink_decoder), (1 << window_sz2), input_buffer_size);
     return hsd;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ heatshrink_decoder_finish()

HSD_finish_res heatshrink_decoder_finish ( heatshrink_decoder * hsd )

Definition at line 354 of file heatshrink_decoder.c.

References HSDR_FINISH_DONE, HSDR_FINISH_ERROR_NULL, HSDR_FINISH_MORE, HSDS_BACKREF_COUNT_LSB, HSDS_BACKREF_COUNT_MSB, HSDS_BACKREF_INDEX_LSB, HSDS_BACKREF_INDEX_MSB, HSDS_EMPTY, HSDS_YIELD_LITERAL, heatshrink_decoder::input_size, NULL, and heatshrink_decoder::state.

Referenced by compress_and_expand_and_check(), decode(), decoder_finish_should_note_when_done(), decoder_finish_should_reject_null_input(), decoder_poll_should_expand_short_literal_and_backref_when_fed_input_byte_by_byte(), decoder_should_not_get_stuck_with_finish_yielding_MORE_but_0_bytes_output_from_poll(), decoder_sink_read(), and espFsRead().

                                                                   {
     if (hsd == NULL) { return HSDR_FINISH_ERROR_NULL; }
     switch (hsd->state) {
     case HSDS_EMPTY:
         return HSDR_FINISH_DONE;
 
     /* If we want to finish with no input, but are in these states, it's
      * because the 0-bit padding to the last byte looks like a backref
      * marker bit followed by all 0s for index and count bits. */
     case HSDS_BACKREF_INDEX_LSB:
     case HSDS_BACKREF_INDEX_MSB:
     case HSDS_BACKREF_COUNT_LSB:
     case HSDS_BACKREF_COUNT_MSB:
         return hsd->input_size == 0 ? HSDR_FINISH_DONE : HSDR_FINISH_MORE;
 
     /* If the output stream is padded with 0xFFs (possibly due to being in
      * flash memory), also explicitly check the input size rather than
      * uselessly returning MORE but yielding 0 bytes when polling. */
     case HSDS_YIELD_LITERAL:
         return hsd->input_size == 0 ? HSDR_FINISH_DONE : HSDR_FINISH_MORE;
 
     default:
         return HSDR_FINISH_MORE;
     }
 }

Here is the caller graph for this function:

◆ heatshrink_decoder_free()

void heatshrink_decoder_free ( heatshrink_decoder * hsd )

Definition at line 74 of file heatshrink_decoder.c.

References HEATSHRINK_FREE, heatshrink_decoder::input_buffer_size, and heatshrink_decoder::window_sz2.

                                                       {
     size_t buffers_sz = (1 << hsd->window_sz2) + hsd->input_buffer_size;
     size_t sz = sizeof(heatshrink_decoder) + buffers_sz;
     HEATSHRINK_FREE(hsd, sz);
     (void)sz;   /* may not be used by free */
 }

Here is the caller graph for this function:

◆ heatshrink_decoder_poll()

HSD_poll_res heatshrink_decoder_poll	(	heatshrink_decoder *	hsd,
		uint8_t *	out_buf,
		size_t	out_buf_size,
		size_t *	output_size
	)

Definition at line 143 of file heatshrink_decoder.c.

References output_info::buf, output_info::buf_size, HSDR_POLL_EMPTY, HSDR_POLL_ERROR_NULL, HSDR_POLL_ERROR_UNKNOWN, HSDR_POLL_MORE, HSDS_BACKREF_COUNT_LSB, HSDS_BACKREF_COUNT_MSB, HSDS_BACKREF_INDEX_LSB, HSDS_BACKREF_INDEX_MSB, HSDS_CHECK_FOR_MORE_INPUT, HSDS_EMPTY, HSDS_INPUT_AVAILABLE, HSDS_YIELD_BACKREF, HSDS_YIELD_LITERAL, heatshrink_decoder::input_size, LOG, NULL, output_info::output_size, st_backref_count_lsb(), st_backref_count_msb(), st_backref_index_lsb(), st_backref_index_msb(), st_check_for_input(), st_input_available(), st_yield_backref(), st_yield_literal(), and heatshrink_decoder::state.

                                                                     {
     if ((hsd == NULL) || (out_buf == NULL) || (output_size == NULL)) {
         return HSDR_POLL_ERROR_NULL;
     }
     *output_size = 0;
 
     output_info oi;
     oi.buf = out_buf;
     oi.buf_size = out_buf_size;
     oi.output_size = output_size;
 
     while (1) {
         LOG("-- poll, state is %d (%s), input_size %d\n",
             hsd->state, state_names[hsd->state], hsd->input_size);
         uint8_t in_state = hsd->state;
         switch (in_state) {
         case HSDS_EMPTY:
             return HSDR_POLL_EMPTY;
         case HSDS_INPUT_AVAILABLE:
             hsd->state = st_input_available(hsd);
             break;
         case HSDS_YIELD_LITERAL:
             hsd->state = st_yield_literal(hsd, &oi);
             break;
         case HSDS_BACKREF_INDEX_MSB:
             hsd->state = st_backref_index_msb(hsd);
             break;
         case HSDS_BACKREF_INDEX_LSB:
             hsd->state = st_backref_index_lsb(hsd);
             break;
         case HSDS_BACKREF_COUNT_MSB:
             hsd->state = st_backref_count_msb(hsd);
             break;
         case HSDS_BACKREF_COUNT_LSB:
             hsd->state = st_backref_count_lsb(hsd);
             break;
         case HSDS_YIELD_BACKREF:
             hsd->state = st_yield_backref(hsd, &oi);
             break;
         case HSDS_CHECK_FOR_MORE_INPUT:
             hsd->state = st_check_for_input(hsd);
             break;
         default:
             return HSDR_POLL_ERROR_UNKNOWN;
         }
         
         /* If the current state cannot advance, check if input or output
          * buffer are exhausted. */
         if (hsd->state == in_state) {
             if (*output_size == out_buf_size) { return HSDR_POLL_MORE; }
             return HSDR_POLL_EMPTY;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ heatshrink_decoder_reset()

void heatshrink_decoder_reset ( heatshrink_decoder * hsd )

Definition at line 82 of file heatshrink_decoder.c.

References heatshrink_decoder::bit_accumulator, heatshrink_decoder::bit_index, heatshrink_decoder::buffers, heatshrink_decoder::current_byte, heatshrink_decoder::head_index, HEATSHRINK_DECODER_INPUT_BUFFER_SIZE, HEATSHRINK_DECODER_WINDOW_BITS, HSDS_EMPTY, heatshrink_decoder::input_index, heatshrink_decoder::input_size, memset, heatshrink_decoder::output_count, heatshrink_decoder::output_index, and heatshrink_decoder::state.

Referenced by compress_and_expand_and_check(), decoder_should_not_get_stuck_with_finish_yielding_MORE_but_0_bytes_output_from_poll(), and heatshrink_decoder_alloc().

                                                        {
     size_t buf_sz = 1 << HEATSHRINK_DECODER_WINDOW_BITS(hsd);
     size_t input_sz = HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd);
     memset(hsd->buffers, 0, buf_sz + input_sz);
     hsd->state = HSDS_EMPTY;
     hsd->input_size = 0;
     hsd->input_index = 0;
     hsd->bit_index = 0x00;
     hsd->current_byte = 0x00;
     hsd->output_count = 0;
     hsd->output_index = 0;
     hsd->head_index = 0;
     hsd->bit_accumulator = 0x00000000;
 }

Here is the caller graph for this function:

◆ heatshrink_decoder_sink()

HSD_sink_res heatshrink_decoder_sink	(	heatshrink_decoder *	hsd,
		uint8_t *	in_buf,
		size_t	size,
		size_t *	input_size
	)

Definition at line 98 of file heatshrink_decoder.c.

References heatshrink_decoder::buffers, HEATSHRINK_DECODER_INPUT_BUFFER_SIZE, HSDR_SINK_ERROR_NULL, HSDR_SINK_FULL, HSDR_SINK_OK, HSDS_EMPTY, HSDS_INPUT_AVAILABLE, heatshrink_decoder::input_index, heatshrink_decoder::input_size, LOG, memcpy, NULL, and heatshrink_decoder::state.

Referenced by compress_and_expand_and_check(), data_with_simple_repetition_should_match_with_absurdly_tiny_buffers(), data_without_duplication_should_match_with_absurdly_tiny_buffers(), decoder_finish_should_note_when_done(), decoder_poll_should_expand_short_literal(), decoder_poll_should_expand_short_literal_and_backref(), decoder_poll_should_expand_short_literal_and_backref_when_fed_input_byte_by_byte(), decoder_poll_should_expand_short_self_overlapping_backref(), decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_backref_expansion(), decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_literal_expansion(), decoder_should_not_get_stuck_with_finish_yielding_MORE_but_0_bytes_output_from_poll(), decoder_sink_read(), decoder_sink_should_reject_excessively_large_input(), decoder_sink_should_reject_null_count_pointer(), decoder_sink_should_reject_null_hsd_pointer(), decoder_sink_should_reject_null_input_pointer(), decoder_sink_should_sink_data_when_preconditions_hold(), and espFsRead().

                                                           {
     if ((hsd == NULL) || (in_buf == NULL) || (input_size == NULL)) {
         return HSDR_SINK_ERROR_NULL;
     }
 
     size_t rem = HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd) - hsd->input_size;
     if (rem == 0) {
         *input_size = 0;
         return HSDR_SINK_FULL;
     }
 
     size = rem < size ? rem : size;
     LOG("-- sinking %zd bytes\n", size);
     /* copy into input buffer (at head of buffers) */
     memcpy(&hsd->buffers[hsd->input_size], in_buf, size);
     hsd->input_size += size;
     if (hsd->state == HSDS_EMPTY) {
         hsd->state = HSDS_INPUT_AVAILABLE;
         hsd->input_index = 0;
     }
     *input_size = size;
     return HSDR_SINK_OK;
 }

Here is the caller graph for this function:

◆ push_byte()

static void push_byte	(	heatshrink_decoder *	hsd,
		output_info *	oi,
		uint8_t	byte
	)

static

Definition at line 380 of file heatshrink_decoder.c.

References output_info::buf, isprint, LOG, and output_info::output_size.

Referenced by st_yield_backref(), and st_yield_literal().

                                                                               {
     LOG(" -- pushing byte: 0x%02x ('%c')\n", byte, isprint(byte) ? byte : '.');
     oi->buf[(*oi->output_size)++] = byte;
     (void)hsd;
 }

Here is the caller graph for this function:

◆ st_backref_count_lsb()

static HSD_state st_backref_count_lsb ( heatshrink_decoder * hsd )

static

Definition at line 263 of file heatshrink_decoder.c.

References BACKREF_COUNT_BITS, get_bits(), HSDS_BACKREF_COUNT_LSB, HSDS_YIELD_BACKREF, LOG, NO_BITS, and heatshrink_decoder::output_count.

Referenced by heatshrink_decoder_poll().

                                                                {
     uint8_t br_bit_ct = BACKREF_COUNT_BITS(hsd);
     uint32_t bits = get_bits(hsd, br_bit_ct < 8 ? br_bit_ct : 8);
     LOG("-- backref count (lsb), got 0x%04x (+1)\n", bits);
     if (bits == NO_BITS) { return HSDS_BACKREF_COUNT_LSB; }
     hsd->output_count |= bits;
     hsd->output_count++;
     return HSDS_YIELD_BACKREF;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ st_backref_count_msb()

static HSD_state st_backref_count_msb ( heatshrink_decoder * hsd )

static

Definition at line 253 of file heatshrink_decoder.c.

References ASSERT, BACKREF_COUNT_BITS, get_bits(), HSDS_BACKREF_COUNT_LSB, HSDS_BACKREF_COUNT_MSB, LOG, NO_BITS, and heatshrink_decoder::output_count.

Referenced by heatshrink_decoder_poll().

                                                                {
     uint8_t br_bit_ct = BACKREF_COUNT_BITS(hsd);
     ASSERT(br_bit_ct > 8);
     uint32_t bits = get_bits(hsd, br_bit_ct - 8);
     LOG("-- backref count (msb), got 0x%04x (+1)\n", bits);
     if (bits == NO_BITS) { return HSDS_BACKREF_COUNT_MSB; }
     hsd->output_count = bits << 8;
     return HSDS_BACKREF_COUNT_LSB;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ st_backref_index_lsb()

static HSD_state st_backref_index_lsb ( heatshrink_decoder * hsd )

static

Definition at line 241 of file heatshrink_decoder.c.

References BACKREF_COUNT_BITS, BACKREF_INDEX_BITS, get_bits(), HSDS_BACKREF_COUNT_LSB, HSDS_BACKREF_COUNT_MSB, HSDS_BACKREF_INDEX_LSB, LOG, NO_BITS, heatshrink_decoder::output_count, and heatshrink_decoder::output_index.

Referenced by heatshrink_decoder_poll().

                                                                {
     uint8_t bit_ct = BACKREF_INDEX_BITS(hsd);
     uint32_t bits = get_bits(hsd, bit_ct < 8 ? bit_ct : 8);
     LOG("-- backref index (lsb), got 0x%04x (+1)\n", bits);
     if (bits == NO_BITS) { return HSDS_BACKREF_INDEX_LSB; }
     hsd->output_index |= bits;
     hsd->output_index++;
     uint8_t br_bit_ct = BACKREF_COUNT_BITS(hsd);
     hsd->output_count = 0;
     return (br_bit_ct > 8) ? HSDS_BACKREF_COUNT_MSB : HSDS_BACKREF_COUNT_LSB;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ st_backref_index_msb()

static HSD_state st_backref_index_msb ( heatshrink_decoder * hsd )

static

Definition at line 231 of file heatshrink_decoder.c.

References ASSERT, BACKREF_INDEX_BITS, get_bits(), HSDS_BACKREF_INDEX_LSB, HSDS_BACKREF_INDEX_MSB, LOG, NO_BITS, and heatshrink_decoder::output_index.

Referenced by heatshrink_decoder_poll().

                                                                {
     uint8_t bit_ct = BACKREF_INDEX_BITS(hsd);
     ASSERT(bit_ct > 8);
     uint32_t bits = get_bits(hsd, bit_ct - 8);
     LOG("-- backref index (msb), got 0x%04x (+1)\n", bits);
     if (bits == NO_BITS) { return HSDS_BACKREF_INDEX_MSB; }
     hsd->output_index = bits << 8;
     return HSDS_BACKREF_INDEX_LSB;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ st_check_for_input()

static HSD_state st_check_for_input ( heatshrink_decoder * hsd )

static

Definition at line 299 of file heatshrink_decoder.c.

References HSDS_EMPTY, HSDS_INPUT_AVAILABLE, and heatshrink_decoder::input_size.

Referenced by heatshrink_decoder_poll().

                                                              {
     return (hsd->input_size == 0) ? HSDS_EMPTY : HSDS_INPUT_AVAILABLE;
 }

Here is the caller graph for this function:

◆ st_input_available()

static HSD_state st_input_available ( heatshrink_decoder * hsd )

static

Definition at line 199 of file heatshrink_decoder.c.

References get_bits(), HEATSHRINK_DECODER_WINDOW_BITS, HSDS_BACKREF_INDEX_LSB, HSDS_BACKREF_INDEX_MSB, HSDS_YIELD_LITERAL, and heatshrink_decoder::output_index.

Referenced by heatshrink_decoder_poll().

                                                              {
     uint32_t bits = get_bits(hsd, 1);  // get tag bit
     if (bits) {
         return HSDS_YIELD_LITERAL;
     } else if (HEATSHRINK_DECODER_WINDOW_BITS(hsd) > 8) {
         return HSDS_BACKREF_INDEX_MSB;
     } else {
         hsd->output_index = 0;
         return HSDS_BACKREF_INDEX_LSB;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ st_yield_backref()

static HSD_state st_yield_backref	(	heatshrink_decoder *	hsd,
		output_info *	oi
	)

static

Definition at line 273 of file heatshrink_decoder.c.

References ASSERT, BACKREF_COUNT_BITS, output_info::buf_size, heatshrink_decoder::buffers, heatshrink_decoder::head_index, HEATSHRINK_DECODER_INPUT_BUFFER_SIZE, HEATSHRINK_DECODER_WINDOW_BITS, HSDS_CHECK_FOR_MORE_INPUT, HSDS_YIELD_BACKREF, LOG, heatshrink_decoder::output_count, heatshrink_decoder::output_index, output_info::output_size, and push_byte().

Referenced by heatshrink_decoder_poll().

                          {
     size_t count = oi->buf_size - *oi->output_size;
     size_t i;
     if (count > 0) {
         if (hsd->output_count < count) count = hsd->output_count;
         uint8_t *buf = &hsd->buffers[HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd)];
         uint16_t mask = (1 << HEATSHRINK_DECODER_WINDOW_BITS(hsd)) - 1;
         uint16_t neg_offset = hsd->output_index;
         LOG("-- emitting %zu bytes from -%u bytes back\n", count, neg_offset);
         ASSERT(neg_offset < mask + 1);
         ASSERT(count <= 1 << BACKREF_COUNT_BITS(hsd));
 
         for (i=0; i<count; i++) {
             uint8_t c = buf[(hsd->head_index - neg_offset) & mask];
             push_byte(hsd, oi, c);
             buf[hsd->head_index & mask] = c;
             hsd->head_index++;
             LOG("  -- ++ 0x%02x\n", c);
         }
         hsd->output_count -= count;
         if (hsd->output_count == 0) { return HSDS_CHECK_FOR_MORE_INPUT; }
     }
     return HSDS_YIELD_BACKREF;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ st_yield_literal()

static HSD_state st_yield_literal	(	heatshrink_decoder *	hsd,
		output_info *	oi
	)

static

Definition at line 211 of file heatshrink_decoder.c.

References output_info::buf_size, heatshrink_decoder::buffers, get_bits(), heatshrink_decoder::head_index, HEATSHRINK_DECODER_INPUT_BUFFER_SIZE, HEATSHRINK_DECODER_WINDOW_BITS, HSDS_CHECK_FOR_MORE_INPUT, HSDS_YIELD_LITERAL, isprint, LOG, NO_BITS, output_info::output_size, and push_byte().

Referenced by heatshrink_decoder_poll().

                          {
     /* Emit a repeated section from the window buffer, and add it (again)
      * to the window buffer. (Note that the repetition can include
      * itself.)*/
     if (*oi->output_size < oi->buf_size) {
         uint32_t byte = get_bits(hsd, 8);
         if (byte == NO_BITS) { return HSDS_YIELD_LITERAL; } /* out of input */
         uint8_t *buf = &hsd->buffers[HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(hsd)];
         uint16_t mask = (1 << HEATSHRINK_DECODER_WINDOW_BITS(hsd))  - 1;
         uint8_t c = byte & 0xFF;
         LOG("-- emitting literal byte 0x%02x ('%c')\n", c, isprint(c) ? c : '.');
         buf[hsd->head_index++ & mask] = c;
         push_byte(hsd, oi, c);
         return HSDS_CHECK_FOR_MORE_INPUT;
     } else {
         return HSDS_YIELD_LITERAL;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Enumerations

Functions

Macro Definition Documentation

◆ ASSERT

◆ BACKREF_COUNT_BITS

◆ BACKREF_INDEX_BITS

◆ LOG

◆ NO_BITS

Enumeration Type Documentation

◆ HSD_state

Function Documentation

◆ get_bits()

◆ heatshrink_decoder_alloc()

◆ heatshrink_decoder_finish()

◆ heatshrink_decoder_free()

◆ heatshrink_decoder_poll()

◆ heatshrink_decoder_reset()

◆ heatshrink_decoder_sink()

◆ push_byte()

◆ st_backref_count_lsb()

◆ st_backref_count_msb()

◆ st_backref_index_lsb()

◆ st_backref_index_msb()

◆ st_check_for_input()

◆ st_input_available()

◆ st_yield_backref()

◆ st_yield_literal()