jof_produce_webp.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "jof_internal.h"
#include "jof_produce.h"
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_webp.h"
#include "ra8_webp_arena.h"

typedef enum : uint32_t {
  k_jof_webp_bpp           = 4U,                 
  k_jof_webp_scratch_mult  = 2U,                 
  k_jof_webp_scratch_slack = 1U * 1024U * 1024U, 
} jof_webp_const_t;
 
uint32_t jof_webp_work_bytes(uint16_t max_width, uint16_t max_height, uint32_t max_src_bytes)
{
  if ((max_width == 0U) || ((uint32_t)max_width > (uint32_t)k_ra8_webp_max_dim) ||
      (max_height == 0U) || ((uint32_t)max_height > (uint32_t)k_ra8_webp_max_dim) ||
      (max_src_bytes == 0U)) {
    return 0U;
  }
  const uint64_t frame = (uint64_t)max_width * (uint64_t)max_height * (uint64_t)k_jof_webp_bpp;
  const uint64_t scratch =
    ((uint64_t)k_jof_webp_scratch_mult * frame) + (uint64_t)k_jof_webp_scratch_slack;
  const uint64_t total = (uint64_t)max_src_bytes + frame + scratch + (uint64_t)k_jof_carve_slack;
  if (total > (uint64_t)UINT32_MAX) {
    return 0U;
  }
  return (uint32_t)total;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_webp_pull_all(jof_prefix_pull_t* pfx, uint8_t* dst, size_t cap, size_t* out_len)
{
  size_t len = 0U;
  while (len < cap) {
    size_t          got = 0U;
    const ra8_err_t err = priv_jof_prefix_pull(pfx, &dst[len], cap - len, &got);
    if (err != k_ra8_ok) {
      return err;
    }
    if (got == 0U) {
      *out_len = len;
      return k_ra8_ok;
    }
    len += got;
  }
  /* The arena filled without hitting end of stream: the source is at least as
   * large as the whole arena, so there is no room for the frame + scratch. */
  return k_ra8_err_invalid_size;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_webp_feed(jof_prod_state_t* st, const uint8_t* frame, uint16_t w, uint16_t h)
{
  const uint32_t stride = (uint32_t)w * (uint32_t)k_jof_webp_bpp;
  const uint32_t th     = (uint32_t)st->cfg->tile_h;
  uint32_t       y      = 0U;
  while (y < (uint32_t)h) {
    const uint32_t  nrows = (((uint32_t)h - y) < th) ? ((uint32_t)h - y) : th;
    const ra8_err_t err   = priv_jof_on_rows(st,
                                             &frame[(size_t)y * (size_t)stride],
                                             w,
                                             (uint16_t)y,
                                             (uint16_t)nrows,
                                             (uint8_t)k_jof_webp_bpp);
    if (err != k_ra8_ok) {
      return err;
    }
    y += nrows;
  }
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_jof_webp_transcode(jof_prod_state_t* st, jof_prefix_pull_t* pfx)
{
  uint8_t* const arena = st->cfg->webp_work;
  if (arena == nullptr) {
    return k_ra8_err_not_supported; /* WebP source but no whole-frame arena */
  }
  const size_t acap    = st->cfg->webp_work_cap;
  size_t       src_len = 0U;
  ra8_err_t    err     = internal_webp_pull_all(pfx, arena, acap, &src_len);
  if (err != k_ra8_ok) {
    return err;
  }
  uint32_t w = 0U;
  uint32_t h = 0U;
  err        = ra8_webp_get_info(arena, src_len, &w, &h);
  if (err != k_ra8_ok) {
    return err;
  }
  err = priv_jof_on_geom(st, (uint16_t)w, (uint16_t)h, (uint8_t)k_jof_webp_bpp);
  if (err != k_ra8_ok) {
    return err;
  }
  const size_t   mask    = (size_t)k_jof_bump_align - 1U;
  const size_t   used    = (src_len + mask) & ~mask;
  const uint64_t frame64 = (uint64_t)w * (uint64_t)h * (uint64_t)k_jof_webp_bpp;
  if ((used >= acap) || (frame64 >= ((uint64_t)acap - (uint64_t)used))) {
    return k_ra8_err_invalid_size; /* no room for frame + at least some scratch */
  }
  const size_t     frame_n = (size_t)frame64;
  uint8_t* const   frame   = &arena[used];
  const size_t     scr_off = used + frame_n;
  ra8_webp_arena_t wa = {.base = &arena[scr_off], .cap = acap - scr_off, .offset = 0U, .live = 0U};
  err                 = ra8_webp_decode_rgba(arena,
                                             src_len,
                                             &wa,
                                             frame,
                                             (size_t)w * (size_t)k_jof_webp_bpp,
                                             frame_n,
                                             nullptr,
                                             nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_webp_feed(st, frame, (uint16_t)w, (uint16_t)h);
}