ra8_vfs_compress.c

Go to the documentation of this file.

 
#include "ra8_vfs_compress.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_compress.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_io_vfs.h"

static const char* const s_tag = "ra8_vfs_compress";

RA8_INTERNAL static ra8_err_t internal_ra8_vfs_compress_write_validate(const char*     path,
                                                                       const uint8_t*  src,
                                                                       const void*     scratch,
                                                                       const uint8_t*  blob_buf,
                                                                       const uint32_t* out_blob_len)
{
  RA8_CHECK_NULL_PTR(path, s_tag, "path must not be nullptr");
  RA8_CHECK_NULL_PTR(src, s_tag, "src must not be nullptr");
  RA8_CHECK_NULL_PTR(scratch, s_tag, "scratch must not be nullptr");
  RA8_CHECK_NULL_PTR(blob_buf, s_tag, "blob_buf must not be nullptr");
  RA8_CHECK_NULL_PTR(out_blob_len, s_tag, "out_blob_len must not be nullptr");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_ra8_vfs_compress_store_blob(const char* path, const uint8_t* blob, uint32_t blob_len)
{
  ra8_fs_file_t* f = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(path, k_ra8_fs_mode_write, &f), s_tag, "open write");
  const ra8_err_t we = ra8_fs_write(f, blob, blob_len);
  const ra8_err_t ce = ra8_fs_close(f);
  if (we != k_ra8_ok) {
    return we;
  }
  if (ce != k_ra8_ok) {
    return ce;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_vfs_compress_write(const char*    path,
                                 const uint8_t* src,
                                 uint32_t       src_len,
                                 void*          scratch,
                                 uint32_t       scratch_len,
                                 uint8_t*       blob_buf,
                                 uint32_t       blob_cap,
                                 uint32_t*      out_blob_len)
{
  RA8_RETURN_ON_ERROR(
    internal_ra8_vfs_compress_write_validate(path, src, scratch, blob_buf, out_blob_len),
    s_tag,
    "validate args");
 
  uint32_t blob_len = 0;
  RA8_RETURN_ON_ERROR(
    ra8_compress(src, src_len, blob_buf, blob_cap, scratch, scratch_len, &blob_len),
    s_tag,
    "compress");
 
  RA8_RETURN_ON_ERROR(internal_ra8_vfs_compress_store_blob(path, blob_buf, blob_len),
                      s_tag,
                      "store");
  *out_blob_len = blob_len;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_ra8_vfs_compress_read_validate(const char*     path,
                                                                      const uint8_t*  blob_buf,
                                                                      const uint8_t*  out,
                                                                      const uint32_t* out_len)
{
  RA8_CHECK_NULL_PTR(path, s_tag, "path must not be nullptr");
  RA8_CHECK_NULL_PTR(blob_buf, s_tag, "blob_buf 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");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_ra8_vfs_compress_load_blob(const char* path,
                                                                  uint8_t*    blob_buf,
                                                                  uint32_t    blob_cap,
                                                                  uint32_t*   out_blob_len)
{
  ra8_fs_file_t* f = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(path, k_ra8_fs_mode_read, &f), s_tag, "open read");
  uint32_t        blob_len = 0;
  const ra8_err_t re       = ra8_fs_read(f, blob_buf, blob_cap, &blob_len);
  const ra8_err_t ce       = ra8_fs_close(f);
  if (re != k_ra8_ok) {
    return re;
  }
  if (ce != k_ra8_ok) {
    return ce;
  }
  if (blob_len >= blob_cap) {
    return k_ra8_err_invalid_size;
  }
  *out_blob_len = blob_len;
  return k_ra8_ok;
}
 
ra8_err_t ra8_vfs_compress_read(const char* path,
                                uint8_t*    blob_buf,
                                uint32_t    blob_cap,
                                uint8_t*    out,
                                uint32_t    out_cap,
                                uint32_t*   out_len)
{
  RA8_RETURN_ON_ERROR(internal_ra8_vfs_compress_read_validate(path, blob_buf, out, out_len),
                      s_tag,
                      "validate args");
 
  uint32_t blob_len = 0;
  RA8_RETURN_ON_ERROR(internal_ra8_vfs_compress_load_blob(path, blob_buf, blob_cap, &blob_len),
                      s_tag,
                      "load");
 
  RA8_RETURN_ON_ERROR(ra8_decompress(blob_buf, blob_len, out, out_cap, out_len), s_tag, "inflate");
  return k_ra8_ok;
}