ra8_fmt_portable_convert.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
 
#include "ra8_attributes.h"
#include "ra8_fmt_host_fd_internal.h"
#include "ra8_fmt_portable_main_internal.h"
#include "ra8_fmt_stream.h"

typedef enum : uint32_t {
  k_convert_cli_ok      = 0U,         
  k_convert_cli_fail    = 1U,         
  k_convert_cli_usage   = 2U,         
  k_convert_cli_input   = 268435456U, 
  k_convert_cli_decimal = 20U,        
  k_convert_cli_radix   = 10U,        
  k_convert_cli_align   = 16U,        
} convert_cli_const_t;

typedef struct {
  const char* input;  
  const char* output; 
  const char* format; 
} convert_cli_args_t;

RA8_INTERNAL
static ra8_err_t internal_text(const ra8_fmt_sink_t* sink, const char* text)
{
  return sink->write(sink->ctx, (const uint8_t*)text, strlen(text));
}

RA8_INTERNAL
static ra8_err_t internal_u64(const ra8_fmt_sink_t* sink, uint64_t value)
{
  char   reverse[k_convert_cli_decimal];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_convert_cli_radix));
    value /= k_convert_cli_radix;
  } while (value != 0U);
  char text[k_convert_cli_decimal];
  for (size_t i = 0U; i < count; ++i) {
    text[i] = reverse[count - i - 1U];
  }
  return sink->write(sink->ctx, (const uint8_t*)text, count);
}

RA8_INTERNAL
static void
internal_field(const ra8_fmt_sink_t* sink, uint64_t value, const char* suffix, ra8_err_t* status)
{
  if (*status == k_ra8_ok) {
    *status = internal_u64(sink, value);
  }
  if (*status == k_ra8_ok) {
    *status = internal_text(sink, suffix);
  }
}

RA8_INTERNAL
static void internal_status(const ra8_fmt_sink_t* errors, const char* prefix, ra8_err_t status)
{
  ra8_err_t rc = internal_text(errors, prefix);
  if (rc == k_ra8_ok) {
    rc = internal_u64(errors, (uint64_t)status);
  }
  if (rc == k_ra8_ok) {
    (void)internal_text(errors, ")\n");
  }
}

RA8_INTERNAL
static bool internal_parse(int argc, char** argv, convert_cli_args_t* args)
{
  for (int i = 2; i < argc; ++i) {
    if ((strcmp(argv[i], "--format") == 0) && ((i + 1) < argc)) {
      args->format = argv[++i];
    } else if ((strcmp(argv[i], "--in") == 0) && ((i + 1) < argc)) {
      args->input = argv[++i];
    } else if ((strcmp(argv[i], "--out") == 0) && ((i + 1) < argc)) {
      args->output = argv[++i];
    } else if ((strcmp(argv[i], "--verbose") == 0) || (strcmp(argv[i], "-v") == 0)) {
      continue;
    } else if ((argv[i][0] != '-') && (args->input == nullptr)) {
      args->input = argv[i];
    } else {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static bool internal_align(size_t value, size_t* aligned)
{
  const size_t mask = (size_t)k_convert_cli_align - 1U;
  if (value > (SIZE_MAX - mask)) {
    return false;
  }
  *aligned = (value + mask) & ~mask;
  return true;
}

RA8_INTERNAL
static bool internal_high_water(const ra8_fmt_jof_convert_requirements_t* requirements,
                                size_t*                                   webp_offset,
                                size_t*                                   total)
{
  if (!internal_align(requirements->work_bytes, webp_offset)) {
    return false;
  }
  if ((size_t)requirements->webp_work_bytes > (SIZE_MAX - *webp_offset)) {
    return false;
  }
  *total = *webp_offset + requirements->webp_work_bytes;
  return true;
}

RA8_INTERNAL
static void internal_capacity(const ra8_fmt_sink_t*                     errors,
                              const ra8_fmt_jof_convert_requirements_t* requirements,
                              size_t                                    required,
                              size_t                                    supplied)
{
  ra8_err_t rc = internal_text(errors, "ra8_fmt: JOF convert workspace too small: required ");
  internal_field(errors, required, " supplied ", &rc);
  internal_field(errors, supplied, " (work ", &rc);
  internal_field(errors, requirements->work_bytes, ", webp ", &rc);
  internal_field(errors, requirements->webp_work_bytes, ")\n", &rc);
}

RA8_INTERNAL
static ra8_err_t internal_size_input(const ra8_fmt_source_t*             source,
                                     size_t                              arena_cap,
                                     const ra8_fmt_sink_t*               errors,
                                     ra8_fmt_jof_convert_requirements_t* requirements,
                                     size_t*                             webp_offset,
                                     size_t*                             high_water,
                                     bool*                               sized)
{
  ra8_err_t rc = ra8_fmt_jof_convert_requirements(source, requirements);
  *sized       = (rc == k_ra8_ok) && internal_high_water(requirements, webp_offset, high_water);
  if ((rc == k_ra8_ok) && (!*sized || (*high_water > arena_cap))) {
    internal_capacity(errors, requirements, *sized ? *high_water : SIZE_MAX, arena_cap);
    rc = k_ra8_err_invalid_size;
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_run(const ra8_fmt_source_t*                   source,
                              const char*                               output,
                              const ra8_fmt_jof_convert_requirements_t* requirements,
                              uint8_t*                                  arena,
                              size_t                                    webp_offset,
                              const ra8_fmt_sink_t*                     report)
{
  ra8_fmt_host_transaction_t host_transaction;
  ra8_fmt_transaction_t      transaction;
  ra8_err_t rc = priv_fmt_host_transaction_begin(output, &host_transaction, &transaction);
  if (rc != k_ra8_ok) {
    return rc;
  }
  ra8_fmt_jof_convert_workspace_t workspace = {
    .work          = arena,
    .work_cap      = requirements->work_bytes,
    .webp_work     = (requirements->webp_work_bytes == 0U) ? nullptr : &arena[webp_offset],
    .webp_work_cap = requirements->webp_work_bytes,
  };
  rc = ra8_fmt_jof_convert_stream(source, requirements, &workspace, &transaction, report, output);
  return rc;
}

RA8_INTERNAL
static void internal_report_run_failure(const ra8_fmt_sink_t* errors,
                                        ra8_err_t             rc,
                                        bool                  sized,
                                        size_t                high_water,
                                        size_t                arena_cap)
{
  if (rc == k_ra8_ok) {
    return;
  }
  if (sized && (high_water <= arena_cap)) {
    internal_status(errors, "ra8_fmt: JOF convert failed (rc=", rc);
  } else if (!sized) {
    internal_status(errors, "ra8_fmt: cannot size JOF convert (rc=", rc);
  }
}
 
RA8_PRIV int priv_fmt_try_portable_convert(int      argc,
                                           char**   argv,
                                           uint8_t* arena,
                                           size_t   arena_cap,
                                           bool*    handled)
{
  if ((handled == nullptr) || (arena == nullptr)) {
    return (int)k_convert_cli_fail;
  }
  *handled = false;
  if ((argc < 2) || (strcmp(argv[1], "convert") != 0)) {
    return (int)k_convert_cli_ok;
  }
  convert_cli_args_t args = {};
  if (!internal_parse(argc, argv, &args) || (args.format == nullptr) ||
      (strcmp(args.format, "jof") != 0)) {
    return (int)k_convert_cli_ok;
  }
  *handled                           = true;
  ra8_fmt_host_fd_sink_t error_state = {.fd = STDERR_FILENO};
  const ra8_fmt_sink_t   errors      = priv_fmt_host_fd_sink(&error_state);
  if ((args.input == nullptr) || (args.output == nullptr)) {
    (void)internal_text(&errors, "ra8_fmt: JOF convert needs --in and --out\n");
    return (int)k_convert_cli_usage;
  }
  ra8_fmt_host_source_t source = {.fd = -1};
  ra8_err_t             rc = priv_fmt_host_source_open(args.input, k_convert_cli_input, &source);
  if (rc != k_ra8_ok) {
    internal_status(&errors, "ra8_fmt: cannot open convert input (rc=", rc);
    return (int)k_convert_cli_fail;
  }
  ra8_fmt_jof_convert_requirements_t requirements = {};
  size_t                             webp_offset  = 0U;
  size_t                             high_water   = 0U;
  bool                               sized        = false;
  rc                                              = internal_size_input(&source.source,
                                                                        arena_cap,
                                                                        &errors,
                                                                        &requirements,
                                                                        &webp_offset,
                                                                        &high_water,
                                                                        &sized);
  ra8_fmt_host_fd_sink_t output_state             = {.fd = STDOUT_FILENO};
  const ra8_fmt_sink_t   report                   = priv_fmt_host_fd_sink(&output_state);
  if (rc == k_ra8_ok) {
    rc = internal_run(&source.source, args.output, &requirements, arena, webp_offset, &report);
  }
  priv_fmt_host_source_close(&source);
  internal_report_run_failure(&errors, rc, sized, high_water, arena_cap);
  return (rc == k_ra8_ok) ? (int)k_convert_cli_ok : (int)k_convert_cli_fail;
}