ra8_compress.c

Go to the documentation of this file.

 
#include "ra8_compress.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "miniz.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"

static const char* const s_tag = "ra8_compress";

typedef struct {
  uint8_t* out;      
  uint32_t cap;      
  uint32_t len;      
  uint8_t  overflow; 
} compress_ctx_t;

RA8_INTERNAL static mz_bool internal_compress_put(const void* buf, int len, void* user)
{
  compress_ctx_t* c = (compress_ctx_t*)user;
  const uint32_t  n = (uint32_t)len;
  if (n > (c->cap - c->len)) {
    c->overflow = 1U;
    return MZ_FALSE;
  }
  (void)memcpy(&c->out[c->len], buf, (size_t)n);
  c->len += n;
  return MZ_TRUE;
}

RA8_INTERNAL static ra8_err_t internal_ra8_compress_validate(const uint8_t*  src,
                                                             const uint8_t*  out,
                                                             const void*     scratch,
                                                             uint32_t        scratch_len,
                                                             const uint32_t* out_len)
{
  RA8_CHECK_NULL_PTR(src, s_tag, "src must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  RA8_CHECK_NULL_PTR(scratch, s_tag, "scratch must not be nullptr");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len must not be nullptr");
  if (scratch_len < (uint32_t)k_ra8_compress_scratch_bytes) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_ra8_compress_drive(tdefl_compressor* d,
                                                          compress_ctx_t*   ctx,
                                                          const uint8_t*    src,
                                                          uint32_t          src_len,
                                                          int               flags,
                                                          uint32_t*         out_len)
{
  if (tdefl_init(d, internal_compress_put, ctx, flags) != TDEFL_STATUS_OKAY) {
    return k_ra8_fail;
  }
  const tdefl_status st = tdefl_compress_buffer(d, src, (size_t)src_len, TDEFL_FINISH);
  if (ctx->overflow != 0U) {
    return k_ra8_err_no_mem;
  }
  if (st != TDEFL_STATUS_DONE) {
    return k_ra8_fail;
  }
  *out_len = ctx->len;
  return k_ra8_ok;
}
 
ra8_err_t ra8_compress(const uint8_t* src,
                       uint32_t       src_len,
                       uint8_t*       out,
                       uint32_t       out_cap,
                       void*          scratch,
                       uint32_t       scratch_len,
                       uint32_t*      out_len)
{
  const ra8_err_t vr = internal_ra8_compress_validate(src, out, scratch, scratch_len, out_len);
  if (vr != k_ra8_ok) {
    return vr;
  }
  tdefl_compressor* d   = (tdefl_compressor*)scratch;
  compress_ctx_t    ctx = {.out = out, .cap = out_cap, .len = 0, .overflow = 0};
  return internal_ra8_compress_drive(d, &ctx, src, src_len, (int)TDEFL_DEFAULT_MAX_PROBES, out_len);
}
 
ra8_err_t ra8_compress_zlib(const uint8_t* src,
                            uint32_t       src_len,
                            uint8_t*       out,
                            uint32_t       out_cap,
                            void*          scratch,
                            uint32_t       scratch_len,
                            uint32_t*      out_len)
{
  const ra8_err_t vr = internal_ra8_compress_validate(src, out, scratch, scratch_len, out_len);
  if (vr != k_ra8_ok) {
    return vr;
  }
  tdefl_compressor* d     = (tdefl_compressor*)scratch;
  compress_ctx_t    ctx   = {.out = out, .cap = out_cap, .len = 0, .overflow = 0};
  const int         flags = (int)TDEFL_DEFAULT_MAX_PROBES | (int)TDEFL_WRITE_ZLIB_HEADER;
  return internal_ra8_compress_drive(d, &ctx, src, src_len, flags, out_len);
}
 
ra8_err_t ra8_decompress(const uint8_t* src,
                         uint32_t       src_len,
                         uint8_t*       out,
                         uint32_t       out_cap,
                         uint32_t*      out_len)
{
  RA8_CHECK_NULL_PTR(src, s_tag, "src must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len must not be nullptr");
  const size_t n =
    tinfl_decompress_mem_to_mem((void*)out, (size_t)out_cap, src, (size_t)src_len, 0);
  if (n == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED) {
    return k_ra8_err_no_mem;
  }
  *out_len = (uint32_t)n;
  return k_ra8_ok;
}