heatshrink_decoder.h File Reference

#include <stdint.h>
#include <stddef.h>
#include "heatshrink_common.h"
#include "heatshrink_config.h"

Go to the source code of this file.

Classes
struct	heatshrink_decoder

Macros
#define	HEATSHRINK_DECODER_INPUT_BUFFER_SIZE(_)   HEATSHRINK_STATIC_INPUT_BUFFER_SIZE
#define	HEATSHRINK_DECODER_WINDOW_BITS(_)   (HEATSHRINK_STATIC_WINDOW_BITS)
#define	HEATSHRINK_DECODER_LOOKAHEAD_BITS(BUF)   (HEATSHRINK_STATIC_LOOKAHEAD_BITS)

Enumerations
enum	HSD_sink_res { HSDR_SINK_OK, HSDR_SINK_FULL, HSDR_SINK_ERROR_NULL =-1 }
enum	HSD_poll_res { HSDR_POLL_EMPTY, HSDR_POLL_MORE, HSDR_POLL_ERROR_NULL =-1, HSDR_POLL_ERROR_UNKNOWN =-2 }
enum	HSD_finish_res { HSDR_FINISH_DONE, HSDR_FINISH_MORE, HSDR_FINISH_ERROR_NULL =-1 }

Functions
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)
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

HEATSHRINK_DECODER_INPUT_BUFFER_SIZE

#define HEATSHRINK_DECODER_INPUT_BUFFER_SIZE

(

_

)

HEATSHRINK_STATIC_INPUT_BUFFER_SIZE

HEATSHRINK_DECODER_WINDOW_BITS

#define HEATSHRINK_DECODER_WINDOW_BITS

(

_

)

(HEATSHRINK_STATIC_WINDOW_BITS)

HEATSHRINK_DECODER_LOOKAHEAD_BITS

#define HEATSHRINK_DECODER_LOOKAHEAD_BITS

(

BUF

)

(HEATSHRINK_STATIC_LOOKAHEAD_BITS)

Enumeration Type Documentation

HSD_sink_res

enum HSD_sink_res

libs/heatshrink/heatshrink_decoder.h

Enumerator
HSDR_SINK_OK
HSDR_SINK_FULL
HSDR_SINK_ERROR_NULL

             {
  HSDR_SINK_OK,               /* data sunk, ready to poll */
  HSDR_SINK_FULL,             /* out of space in internal buffer */
  HSDR_SINK_ERROR_NULL=-1,    /* NULL argument */
} HSD_sink_res;

HSD_poll_res

enum HSD_poll_res

Enumerator
HSDR_POLL_EMPTY
HSDR_POLL_MORE
HSDR_POLL_ERROR_NULL
HSDR_POLL_ERROR_UNKNOWN

             {
  HSDR_POLL_EMPTY,            /* input exhausted */
  HSDR_POLL_MORE,             /* more data remaining, call again w/ fresh output buffer */
  HSDR_POLL_ERROR_NULL=-1,    /* NULL arguments */
  HSDR_POLL_ERROR_UNKNOWN=-2,
} HSD_poll_res;

HSD_finish_res

enum HSD_finish_res

Enumerator
HSDR_FINISH_DONE
HSDR_FINISH_MORE
HSDR_FINISH_ERROR_NULL

             {
  HSDR_FINISH_DONE,           /* output is done */
  HSDR_FINISH_MORE,           /* more output remains */
  HSDR_FINISH_ERROR_NULL=-1,  /* NULL arguments */
} HSD_finish_res;

Function Documentation

heatshrink_decoder_reset()

void heatshrink_decoder_reset

(

heatshrink_decoder *

hsd

)

                                                       {
  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_TAG_BIT;
  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;
}

heatshrink_decoder_sink()

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

                                                    {
  if (hsd == nullptr || in_buf == nullptr || input_size == nullptr)
    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;
  *input_size = size;
  return HSDR_SINK_OK;
}

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
	)

                                                                                                                          {
  if (hsd == nullptr || out_buf == nullptr || output_size == nullptr)
    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_TAG_BIT:
        hsd->state = st_tag_bit(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;
      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)
      return (*output_size == out_buf_size) ? HSDR_POLL_MORE : HSDR_POLL_EMPTY;
  }

Here is the call graph for this function:

heatshrink_decoder_finish()

HSD_finish_res heatshrink_decoder_finish

(

heatshrink_decoder *

hsd

)

                                                                  {
  if (hsd == nullptr) { return HSDR_FINISH_ERROR_NULL; }
  switch (hsd->state) {
    case HSDS_TAG_BIT:
      return hsd->input_size == 0 ? HSDR_FINISH_DONE : HSDR_FINISH_MORE;
 
    /* 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;
  }