jof_worker.c

Go to the documentation of this file.

 
#include "jof_worker.h"
 
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "jof_produce.h"
#include "ra8_attributes.h"

typedef enum : uint64_t {
  k_worker_max_input = 256U * 1024U * 1024U, 
  k_worker_tile_h    = 256U,                 
  k_worker_out_mode  = 0644U,                
} worker_limit_t;

typedef enum : uint8_t {
  k_worker_webp_riff_ofs = 0U,  
  k_worker_webp_form_ofs = 8U,  
  k_worker_webp_head_len = 12U, 
  k_worker_webp_tag_len  = 4U,  
} worker_webp_t;

static const uint8_t s_worker_riff[k_worker_webp_tag_len] = {'R', 'I', 'F', 'F'};

static const uint8_t s_worker_webp[k_worker_webp_tag_len] = {'W', 'E', 'B', 'P'};

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

typedef struct {
  int  fd;     
  bool failed; 
} worker_sink_t;

static bool worker_read_all(int fd, uint8_t* buf, size_t len)
{
  size_t done = 0U;
  while (done < len) {
    const ssize_t got = read(fd, buf + done, len - done);
    if (got == 0) {
      return false;
    }
    if (got < 0) {
      if (errno == EINTR) {
        continue;
      }
      return false;
    }
    done += (size_t)got;
  }
  return true;
}

static ra8_err_t worker_sink(void* ctx, const uint8_t* buf, size_t len)
{
  worker_sink_t* s    = (worker_sink_t*)ctx;
  size_t         done = 0U;
  while (done < len) {
    const ssize_t wrote = write(s->fd, buf + done, len - done);
    if (wrote == 0) {
      s->failed = true;
      return k_ra8_fail;
    }
    if (wrote < 0) {
      if (errno == EINTR) {
        continue;
      }
      s->failed = true;
      return k_ra8_fail;
    }
    done += (size_t)wrote;
  }
  return k_ra8_ok;
}

static ra8_err_t worker_pull(void* ctx, uint8_t* buf, size_t cap, size_t* got)
{
  worker_pull_t* s = (worker_pull_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;
}

static bool worker_is_webp(const uint8_t* data, size_t len)
{
  if (len < (size_t)k_worker_webp_head_len) {
    return false;
  }
  return (memcmp(&data[k_worker_webp_riff_ofs], s_worker_riff, sizeof(s_worker_riff)) == 0) &&
         (memcmp(&data[k_worker_webp_form_ofs], s_worker_webp, sizeof(s_worker_webp)) == 0);
}

static jof_worker_result_t worker_map_producer(ra8_err_t err)
{
  switch (err) {
    case k_ra8_err_invalid_arg:
    case k_ra8_err_invalid_size:
      return k_jof_worker_geometry;
    case k_ra8_err_no_mem:
      return k_jof_worker_memory;
    default:
      return k_jof_worker_decode;
  }
}

static jof_worker_result_t
worker_read_source(const char* in_path, uint8_t** out_src, size_t* out_len)
{
  const int in_fd = open(in_path, O_RDONLY);
  if (in_fd < 0) {
    return k_jof_worker_input;
  }
  struct stat st;
  if (fstat(in_fd, &st) != 0) {
    (void)close(in_fd);
    return k_jof_worker_input;
  }
  if ((st.st_size <= 0) || ((uint64_t)st.st_size > (uint64_t)k_worker_max_input)) {
    (void)close(in_fd);
    return k_jof_worker_input;
  }
  const size_t src_len = (size_t)st.st_size;
  uint8_t*     src = (uint8_t*)malloc(src_len); /* alloc-allow: bounded probe-sized source image */
  if (src == nullptr) {
    (void)close(in_fd);
    return k_jof_worker_memory;
  }
  if (!worker_read_all(in_fd, src, src_len)) {
    free(src); /* alloc-allow: bounded probe-sized source image */
    (void)close(in_fd);
    return k_jof_worker_input;
  }
  (void)close(in_fd);
  *out_src = src;
  *out_len = src_len;
  return k_jof_worker_ok;
}

static jof_worker_result_t worker_alloc_webp(const uint8_t* src,
                                             size_t         src_len,
                                             uint16_t       w,
                                             uint16_t       h,
                                             uint8_t**      out_webp_work,
                                             size_t*        out_webp_cap)
{
  *out_webp_work = nullptr;
  *out_webp_cap  = 0U;
  if (!worker_is_webp(src, src_len)) {
    return k_jof_worker_ok;
  }
  if (src_len > UINT32_MAX) {
    return k_jof_worker_geometry;
  }
  const uint32_t webp_need = jof_webp_work_bytes(w, h, (uint32_t)src_len);
  if (webp_need == 0U) {
    return k_jof_worker_geometry;
  }
  uint8_t* webp_work =
    (uint8_t*)malloc(webp_need); /* alloc-allow: exact jof_webp_work_bytes arena */
  if (webp_work == nullptr) {
    return k_jof_worker_memory;
  }
  *out_webp_work = webp_work;
  *out_webp_cap  = (size_t)webp_need;
  return k_jof_worker_ok;
}

static jof_worker_result_t worker_produce_to_file(const char*    out_path,
                                                  const uint8_t* src,
                                                  size_t         src_len,
                                                  uint16_t       w,
                                                  uint16_t       h,
                                                  uint16_t       tile_h,
                                                  uint8_t*       work,
                                                  size_t         work_cap,
                                                  uint8_t*       webp_work,
                                                  size_t         webp_work_cap)
{
  const int out_fd = open(out_path, O_WRONLY | O_CREAT | O_TRUNC, (mode_t)k_worker_out_mode);
  if (out_fd < 0) {
    return k_jof_worker_output;
  }
  worker_pull_t           pull = {.data = src, .len = src_len, .pos = 0U};
  worker_sink_t           sink = {.fd = out_fd, .failed = false};
  const jof_produce_cfg_t cfg  = {
    .pull          = worker_pull,
    .pull_ctx      = &pull,
    .sink          = worker_sink,
    .sink_ctx      = &sink,
    .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_work_cap,
  };
  jof_info_t      info       = {};
  const ra8_err_t produce_rc = jof_produce(&cfg, &info);
  const int       close_rc   = close(out_fd);
 
  if ((close_rc != 0) || sink.failed) {
    return k_jof_worker_output;
  }
  if (produce_rc != k_ra8_ok) {
    return worker_map_producer(produce_rc);
  }
  return k_jof_worker_ok;
}
 
RA8_NASA_RULE_3_OK("host-only single-image transcode: three bounded arenas sized by probe")
jof_worker_result_t jof_worker_convert(const char* in_path, const char* out_path)
{
  if ((in_path == nullptr) || (out_path == nullptr)) {
    return k_jof_worker_usage;
  }
  uint8_t*            src     = nullptr;
  size_t              src_len = 0U;
  jof_worker_result_t rc      = worker_read_source(in_path, &src, &src_len);
  if (rc != k_jof_worker_ok) {
    return rc;
  }
  uint16_t w = 0U;
  uint16_t h = 0U;
  if (jof_probe_dims(src, src_len, &w, &h) != k_ra8_ok) {
    free(src); /* alloc-allow: bounded probe-sized source image */
    return k_jof_worker_geometry;
  }
  const uint16_t tile_h   = (h > (uint16_t)k_worker_tile_h) ? (uint16_t)k_worker_tile_h : h;
  const uint32_t work_cap = jof_work_bytes(w, h, w, tile_h);
  if (work_cap == 0U) {
    free(src); /* alloc-allow: bounded probe-sized source image */
    return k_jof_worker_geometry;
  }
  uint8_t* work = (uint8_t*)malloc(work_cap); /* alloc-allow: exact jof_work_bytes arena */
  if (work == nullptr) {
    free(src); /* alloc-allow: bounded probe-sized source image */
    return k_jof_worker_memory;
  }
  uint8_t* webp_work     = nullptr;
  size_t   webp_work_cap = 0U;
  rc                     = worker_alloc_webp(src, src_len, w, h, &webp_work, &webp_work_cap);
  if (rc == k_jof_worker_ok) {
    rc = worker_produce_to_file(out_path,
                                src,
                                src_len,
                                w,
                                h,
                                tile_h,
                                work,
                                (size_t)work_cap,
                                webp_work,
                                webp_work_cap);
  }
  free(webp_work); /* alloc-allow: exact jof_webp_work_bytes arena  */
  free(work);      /* alloc-allow: exact jof_work_bytes arena       */
  free(src);       /* alloc-allow: bounded probe-sized source image */
  if (rc != k_jof_worker_ok) {
    (void)unlink(out_path);
  }
  return rc;
}