ra8_fmt_portable_verify.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_host_spool_internal.h"
#include "ra8_fmt_portable_main_internal.h"
#include "ra8_fmt_stream.h"

typedef enum : uint32_t {
  k_verify_cli_ok      = 0U,         
  k_verify_cli_fail    = 1U,         
  k_verify_cli_input   = 268435456U, 
  k_verify_cli_align   = 16U,        
  k_verify_cli_digits  = 20U,        
  k_verify_cli_decimal = 10U,        
} verify_cli_const_t;

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

typedef struct {
  size_t producer; 
  size_t webp;     
  size_t scratch;  
  size_t row;      
  size_t total;    
} verify_layout_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_verify_cli_digits];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_verify_cli_decimal));
    value /= k_verify_cli_decimal;
  } while (value != 0U);
  char text[k_verify_cli_digits];
  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* sink, const char* prefix, ra8_err_t status)
{
  ra8_err_t rc = internal_text(sink, prefix);
  internal_field(sink, status, ")\n", &rc);
}

RA8_INTERNAL
static bool internal_parse(int argc, char** argv, verify_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* out)
{
  const size_t mask = (size_t)k_verify_cli_align - 1U;
  if (value > (SIZE_MAX - mask)) {
    return false;
  }
  *out = (value + mask) & ~mask;
  return true;
}

RA8_INTERNAL
static bool internal_add(size_t offset, size_t bytes, size_t* next)
{
  size_t aligned = 0U;
  if (!internal_align(offset, &aligned) || (bytes > (SIZE_MAX - aligned))) {
    return false;
  }
  *next = aligned + bytes;
  return true;
}

RA8_INTERNAL
static bool internal_layout(const ra8_fmt_jof_verify_requirements_t* need, verify_layout_t* layout)
{
  *layout             = (verify_layout_t){};
  layout->producer    = (need->reference_work_bytes > need->banded_work_bytes)
                          ? need->reference_work_bytes
                          : need->banded_work_bytes;
  size_t producer_end = 0U;
  if (!internal_align(layout->producer, &layout->webp) ||
      !internal_add(layout->webp, need->webp_work_bytes, &producer_end)) {
    return false;
  }
  size_t scratch_end = 0U;
  size_t compare_end = 0U;
  if (!internal_align(need->band_tile_bytes, &layout->scratch) ||
      !internal_add(layout->scratch, need->scratch_bytes, &scratch_end) ||
      !internal_align(scratch_end, &layout->row) ||
      !internal_add(layout->row, need->row_bytes, &compare_end)) {
    return false;
  }
  layout->total = (producer_end > compare_end) ? producer_end : compare_end;
  return true;
}

RA8_INTERNAL
static void internal_capacity(const ra8_fmt_sink_t*                    errors,
                              const ra8_fmt_jof_verify_requirements_t* need,
                              const verify_layout_t*                   layout,
                              size_t                                   supplied)
{
  ra8_err_t rc = internal_text(errors, "ra8_fmt: JOF verify workspace too small: required ");
  internal_field(errors, layout->total, " supplied ", &rc);
  internal_field(errors, supplied, " (producer ", &rc);
  internal_field(errors, layout->producer, ", webp ", &rc);
  internal_field(errors, need->webp_work_bytes, ", band ", &rc);
  internal_field(errors, need->band_tile_bytes, ", scratch ", &rc);
  internal_field(errors, need->scratch_bytes, ", row ", &rc);
  internal_field(errors, need->row_bytes, ")\n", &rc);
}

RA8_INTERNAL
static ra8_err_t internal_failed_append(void* ctx, const uint8_t* bytes, size_t len)
{
  (void)ctx;
  (void)bytes;
  (void)len;
  return k_ra8_fail;
}

RA8_INTERNAL
static ra8_err_t internal_failed_commit(void* ctx)
{
  (void)ctx;
  return k_ra8_fail;
}

RA8_INTERNAL
static void internal_failed_abort(void* ctx)
{
  (void)ctx;
}
 
static const ra8_fmt_transaction_ops_t s_failed_transaction_ops = {
  .append = internal_failed_append,
  .commit = internal_failed_commit,
  .abort  = internal_failed_abort,
};

RA8_INTERNAL
static void internal_bind(ra8_fmt_cli_workspace_t*                 root,
                          const ra8_fmt_jof_verify_requirements_t* need,
                          const verify_layout_t*                   layout,
                          ra8_fmt_jof_verify_workspace_t*          out)
{
  *out = (ra8_fmt_jof_verify_workspace_t){
    .work          = root->bytes,
    .work_cap      = (uint32_t)layout->producer,
    .webp_work     = (need->webp_work_bytes == 0U) ? nullptr : &root->bytes[layout->webp],
    .webp_work_cap = need->webp_work_bytes,
    .band_tile     = root->bytes,
    .band_tile_cap = need->band_tile_bytes,
    .scratch       = &root->bytes[layout->scratch],
    .scratch_cap   = need->scratch_bytes,
    .row           = &root->bytes[layout->row],
    .row_cap       = need->row_bytes,
  };
}

RA8_INTERNAL
static void internal_cleanup(ra8_fmt_host_source_t* ref,
                             ra8_fmt_host_source_t* got,
                             ra8_fmt_host_spool_t*  ref_spool,
                             ra8_fmt_host_spool_t*  got_spool)
{
  priv_fmt_host_spool_close(ref_spool);
  priv_fmt_host_spool_close(got_spool);
  priv_fmt_host_source_close(ref);
  priv_fmt_host_source_close(got);
}

RA8_INTERNAL
static ra8_err_t internal_run(const ra8_fmt_host_source_t*             ref,
                              const ra8_fmt_host_source_t*             got,
                              const ra8_fmt_jof_verify_requirements_t* need,
                              ra8_fmt_jof_verify_workspace_t*          work,
                              ra8_fmt_spool_t*                         ref_spool,
                              ra8_fmt_spool_t*                         got_spool,
                              ra8_fmt_transaction_t*                   dump,
                              const char*                              dump_name,
                              const ra8_fmt_sink_t*                    report)
{
  return ra8_fmt_jof_verify_stream(&ref->source,
                                   &got->source,
                                   need,
                                   work,
                                   ref_spool,
                                   got_spool,
                                   dump,
                                   dump_name,
                                   report);
}

RA8_INTERNAL
static int internal_execute(const verify_cli_args_t*                 args,
                            ra8_fmt_cli_workspace_t*                 workspace,
                            ra8_fmt_host_source_t*                   ref_source,
                            ra8_fmt_host_source_t*                   got_source,
                            const ra8_fmt_jof_verify_requirements_t* need,
                            const verify_layout_t*                   layout,
                            const ra8_fmt_sink_t*                    errors,
                            const ra8_fmt_sink_t*                    report)
{
  ra8_fmt_host_spool_t ref_host_spool = {.fd = -1};
  ra8_fmt_host_spool_t got_host_spool = {.fd = -1};
  ra8_fmt_spool_t      ref_spool      = {};
  ra8_fmt_spool_t      got_spool      = {};
  ra8_err_t            rc = priv_fmt_host_spool_open(args->input, &ref_host_spool, &ref_spool);
  if (rc == k_ra8_ok) {
    rc = priv_fmt_host_spool_open(args->input, &got_host_spool, &got_spool);
  }
  if (rc != k_ra8_ok) {
    internal_status(errors, "ra8_fmt: cannot create verify spool (rc=", rc);
    internal_cleanup(ref_source, got_source, &ref_host_spool, &got_host_spool);
    return (int)k_verify_cli_fail;
  }
  ra8_fmt_host_transaction_t host_dump = {.parent_fd = -1, .stage_fd = -1};
  ra8_fmt_transaction_t      dump      = {};
  ra8_fmt_transaction_t*     dump_ptr  = nullptr;
  if (args->output != nullptr) {
    rc = priv_fmt_host_transaction_begin(args->output, &host_dump, &dump);
    if (rc != k_ra8_ok) {
      dump = (ra8_fmt_transaction_t){.ops = &s_failed_transaction_ops, .ctx = nullptr};
    }
    dump_ptr = &dump;
  }
  ra8_fmt_jof_verify_workspace_t work;
  internal_bind(workspace, need, layout, &work);
  rc = internal_run(ref_source,
                    got_source,
                    need,
                    &work,
                    &ref_spool,
                    &got_spool,
                    dump_ptr,
                    args->output,
                    report);
  if (host_dump.active) {
    dump.ops->abort(dump.ctx);
  }
  internal_cleanup(ref_source, got_source, &ref_host_spool, &got_host_spool);
  return (rc == k_ra8_ok) ? (int)k_verify_cli_ok : (int)k_verify_cli_fail;
}

RA8_INTERNAL static ra8_err_t internal_open_and_size(const verify_cli_args_t* args,
                                                     size_t                   workspace_bytes,
                                                     ra8_fmt_host_source_t*   ref_source,
                                                     ra8_fmt_host_source_t*   got_source,
                                                     ra8_fmt_jof_verify_requirements_t* need,
                                                     verify_layout_t*                   layout,
                                                     const ra8_fmt_sink_t*              errors,
                                                     const ra8_fmt_sink_t*              report)
{
  ra8_err_t rc = priv_fmt_host_source_open(args->input, k_verify_cli_input, ref_source);
  if (rc == k_ra8_ok) {
    rc = priv_fmt_host_source_open(args->input, k_verify_cli_input, got_source);
  }
  if ((rc == k_ra8_ok) && (!priv_fmt_host_sources_same(ref_source, got_source) ||
                           (priv_fmt_host_source_unchanged(ref_source) != k_ra8_ok) ||
                           (priv_fmt_host_source_unchanged(got_source) != k_ra8_ok))) {
    rc = k_ra8_err_validation_failed;
  }
  if (rc != k_ra8_ok) {
    internal_status(errors, "ra8_fmt: cannot open verify input (rc=", rc);
    internal_cleanup(ref_source, got_source, nullptr, nullptr);
    return rc;
  }
  rc               = ra8_fmt_jof_verify_requirements(&ref_source->source, need);
  const bool sized = (rc == k_ra8_ok) && internal_layout(need, layout);
  if ((rc == k_ra8_ok) && (!sized || (layout->total > workspace_bytes))) {
    internal_capacity(errors, need, layout, workspace_bytes);
    rc = k_ra8_err_invalid_size;
  }
  if (rc != k_ra8_ok) {
    internal_status(report, "verify: cannot read source dimensions (rc=", rc);
    internal_cleanup(ref_source, got_source, nullptr, nullptr);
  }
  return rc;
}
 
RA8_PRIV int priv_fmt_try_portable_verify(int                      argc,
                                          char**                   argv,
                                          ra8_fmt_cli_workspace_t* workspace,
                                          bool*                    handled)
{
  if ((handled == nullptr) || (workspace == nullptr)) {
    return (int)k_verify_cli_fail;
  }
  *handled = false;
  if ((argc < 2) || (strcmp(argv[1], "verify") != 0)) {
    return (int)k_verify_cli_ok;
  }
  verify_cli_args_t args = {};
  if (!internal_parse(argc, argv, &args) || (args.format == nullptr) ||
      (strcmp(args.format, "jof") != 0) || (args.input == nullptr)) {
    return (int)k_verify_cli_ok;
  }
  *handled                                       = true;
  ra8_fmt_host_fd_sink_t            error_state  = {.fd = STDERR_FILENO};
  ra8_fmt_host_fd_sink_t            report_state = {.fd = STDOUT_FILENO};
  const ra8_fmt_sink_t              errors       = priv_fmt_host_fd_sink(&error_state);
  const ra8_fmt_sink_t              report       = priv_fmt_host_fd_sink(&report_state);
  ra8_fmt_host_source_t             ref_source   = {.fd = -1};
  ra8_fmt_host_source_t             got_source   = {.fd = -1};
  ra8_fmt_jof_verify_requirements_t need         = {};
  verify_layout_t                   layout       = {};
  const ra8_err_t                   rc           = internal_open_and_size(&args,
                                                                          sizeof(workspace->bytes),
                                                                          &ref_source,
                                                                          &got_source,
                                                                          &need,
                                                                          &layout,
                                                                          &errors,
                                                                          &report);
  if (rc != k_ra8_ok) {
    return (int)k_verify_cli_fail;
  }
  return internal_execute(&args,
                          workspace,
                          &ref_source,
                          &got_source,
                          &need,
                          &layout,
                          &errors,
                          &report);
}