mdl_export_jof.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <string.h>
 
#include "jof.h"
#include "jof_produce.h"
#include "mdl_export.h"
#include "mdl_export_internal.h"
#include "ra8_attributes.h"
#include "ra8_err.h"

typedef enum : uint16_t {
  k_jof_band_h = 256, 
} mdl_jof_geom_t;

typedef enum : uint8_t {
  k_jof_webp_riff_ofs   = 0U,  
  k_jof_webp_fourcc_ofs = 8U,  
  k_jof_webp_head_len   = 12U, 
  k_jof_webp_tag_len    = 4U,  
} mdl_jof_webp_t;

typedef enum : uint32_t {
  k_jof_source_cap    = 16U * 1024U * 1024U, 
  k_jof_work_cap      = 16U * 1024U * 1024U, 
  k_jof_webp_work_cap = 64U * 1024U * 1024U, 
} mdl_jof_workspace_t;

static const uint8_t s_jof_webp_riff[k_jof_webp_tag_len] = {'R', 'I', 'F', 'F'};

static const uint8_t s_jof_webp_webp[k_jof_webp_tag_len] = {'W', 'E', 'B', 'P'};

RA8_INTERNAL static bool internal_jof_is_webp(const uint8_t* data, size_t len)
{
  if ((data == nullptr) || (len < (size_t)k_jof_webp_head_len)) {
    return false;
  }
  return (memcmp(&data[k_jof_webp_riff_ofs], s_jof_webp_riff, sizeof(s_jof_webp_riff)) == 0) &&
         (memcmp(&data[k_jof_webp_fourcc_ofs], s_jof_webp_webp, sizeof(s_jof_webp_webp)) == 0);
}

typedef struct {
  const uint8_t* data; 
  size_t         len;  
  size_t         pos;  
} jof_pull_ctx_t;

RA8_INTERNAL static ra8_err_t internal_jof_pull(void* ctx, uint8_t* buf, size_t cap, size_t* got)
{
  jof_pull_ctx_t* s = (jof_pull_ctx_t*)ctx;
  size_t          n = s->len - s->pos;
  if (n > cap) {
    n = cap;
  }
  memcpy(buf, s->data + s->pos, n);
  s->pos += n;
  *got = n;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_jof_sink(void* ctx, const uint8_t* buf, size_t len)
{
  if (len > UINT32_MAX) {
    return k_ra8_err_invalid_size;
  }
  return priv_mdl_export_output_write((mdl_export_output_t*)ctx, buf, (uint32_t)len);
}

RA8_INTERNAL static ra8_err_t internal_jof_carve_webp(const uint8_t*          src,
                                                      size_t                  slen,
                                                      uint16_t                w,
                                                      uint16_t                h,
                                                      uint8_t**               out_work,
                                                      size_t*                 out_cap,
                                                      mdl_export_workspace_t* ws)
{
  *out_work = nullptr;
  *out_cap  = 0U;
  if (!internal_jof_is_webp(src, slen)) {
    return k_ra8_ok;
  }
  const uint32_t need = jof_webp_work_bytes(w, h, (uint32_t)slen);
  if ((need == 0U) || ((size_t)need > (size_t)k_jof_webp_work_cap)) {
    return k_ra8_err_invalid_size;
  }
  uint8_t* mem = (uint8_t*)mdl_export_workspace_take(ws, (size_t)need, 16U);
  if (mem == nullptr) {
    return k_ra8_err_invalid_size;
  }
  *out_work = mem;
  *out_cap  = (size_t)need;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_jof_produce_page(const uint8_t*          src,
                                                        size_t                  slen,
                                                        uint16_t                w,
                                                        uint16_t                h,
                                                        uint16_t                tile_h,
                                                        uint32_t                work_cap,
                                                        mdl_export_output_t*    output,
                                                        mdl_export_workspace_t* ws)
{
  if ((size_t)work_cap > (size_t)k_jof_work_cap) {
    return k_ra8_err_invalid_size;
  }
  uint8_t* work = (uint8_t*)mdl_export_workspace_take(ws, (size_t)work_cap, 16U);
  if (work == nullptr) {
    return k_ra8_err_invalid_size;
  }
  uint8_t*        webp_work = nullptr;
  size_t          webp_cap  = 0U;
  const ra8_err_t carve_rc  = internal_jof_carve_webp(src, slen, w, h, &webp_work, &webp_cap, ws);
  if (carve_rc != k_ra8_ok) {
    return carve_rc;
  }
  jof_pull_ctx_t    pull = {.data = src, .len = slen, .pos = 0U};
  jof_produce_cfg_t cfg  = {.pull          = internal_jof_pull,
                            .pull_ctx      = &pull,
                            .sink          = internal_jof_sink,
                            .sink_ctx      = output,
                            .tile_w        = w,
                            .tile_h        = tile_h,
                            .codec         = (uint8_t)k_jof_codec_deflate,
                            .max_width     = w,
                            .max_height    = h,
                            .work          = work,
                            .work_cap      = work_cap,
                            .webp_work     = webp_work,
                            .webp_work_cap = webp_cap};
  jof_info_t        info = {};
  const ra8_err_t   rc   = jof_produce(&cfg, &info);
  return rc;
}

RA8_INTERNAL static ra8_err_t internal_jof_load_source(mdl_storage_t*          storage,
                                                       const char*             in_path,
                                                       mdl_export_workspace_t* ws,
                                                       uint8_t**               out_src,
                                                       size_t*                 out_slen)
{
  fw_fs_stat_t stat = {};
  ra8_err_t    rc   = fw_fs_stat(&storage->fs->names, in_path, &stat);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (!stat.exists) {
    return k_ra8_err_not_found;
  }
  if ((stat.type != k_fw_fs_node_file) || (stat.size_bytes == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  if (stat.size_bytes > (uint64_t)k_jof_source_cap) {
    return k_ra8_err_invalid_size;
  }
  uint8_t* src = (uint8_t*)mdl_export_workspace_take(ws, (size_t)stat.size_bytes, 16U);
  if (src == nullptr) {
    return k_ra8_err_invalid_size;
  }
  rc = priv_mdl_export_source_slurp(storage, in_path, src, (size_t)stat.size_bytes, out_slen);
  if (rc != k_ra8_ok) {
    return rc;
  }
  *out_src = src;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_jof_one(mdl_storage_t*          storage,
                                               const char*             in_path,
                                               const char*             out_path,
                                               mdl_export_workspace_t* ws)
{
  uint8_t*  src  = nullptr;
  size_t    slen = 0U;
  ra8_err_t rc   = internal_jof_load_source(storage, in_path, ws, &src, &slen);
  if (rc != k_ra8_ok) {
    return rc;
  }
  uint16_t w = 0U;
  uint16_t h = 0U;
  /* Probe through the producer's own dispatch, so every format the producer can
   * decode (JPEG, PNG, WebP) is a format this exporter can size and write. */
  if (jof_probe_dims(src, slen, &w, &h) != k_ra8_ok) {
    return k_ra8_err_not_supported;
  }
  const uint16_t tile_h   = (h < (uint16_t)k_jof_band_h) ? h : (uint16_t)k_jof_band_h;
  const uint32_t work_cap = jof_work_bytes(w, h, w, tile_h);
  if (work_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  /* Produce into the storage transaction's borrowed stage; canonical
   * validation must pass before the transaction publishes this page. */
  mdl_export_output_t output = {};
  rc = priv_mdl_export_output_begin(&output, storage, out_path, k_mdl_format_jof);
  if (rc == k_ra8_ok) {
    rc = internal_jof_produce_page(src, slen, w, h, tile_h, work_cap, &output, ws);
  }
  if ((rc != k_ra8_ok) && output.writer.transaction.active) {
    const ra8_err_t aborted = priv_mdl_export_output_abort(&output);
    return (aborted == k_ra8_ok) ? rc : aborted;
  }
  bool published = false;
  return (rc == k_ra8_ok) ? priv_mdl_export_output_commit(&output, ws, &published) : rc;
}
 
RA8_PRIV ra8_err_t priv_mdl_export_jof(mdl_storage_t*          storage,
                                       const char*             dir,
                                       const char              names[][k_name_max],
                                       size_t                  count,
                                       mdl_export_workspace_t* ws)
{
  const size_t page_mark = ws->used;
  ra8_err_t    rc        = k_ra8_ok;
  for (size_t i = 0U; (rc == k_ra8_ok) && (i < count); ++i) {
    char in_path[k_fw_fs_path_cap];
    char stem[k_name_max];
    char out_path[k_fw_fs_path_cap];
    rc = priv_mdl_export_path_join(in_path, sizeof(in_path), dir, names[i]);
    memcpy(stem, names[i], k_name_max);
    char* dot = strrchr(stem, '.');
    if (dot != nullptr) {
      *dot = '\0';
    }
    char      output_leaf[k_name_max];
    const int written = snprintf(output_leaf, sizeof(output_leaf), "%s.jof", stem);
    if ((rc == k_ra8_ok) && priv_mdl_export_snprintf_fit(written, sizeof(output_leaf))) {
      rc = priv_mdl_export_path_join(out_path, sizeof(out_path), dir, output_leaf);
    } else if (rc == k_ra8_ok) {
      rc = k_ra8_err_invalid_size;
    }
    ws->used = page_mark;
    if (rc == k_ra8_ok) {
      rc = internal_jof_one(storage, in_path, out_path, ws);
    }
  }
  return rc;
}