ra8_fmt_stream_verify.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "jof_produce.h"
#include "ra8_attributes.h"
#include "ra8_fmt_stream.h"

typedef enum : uint32_t {
  k_verify_band_height  = 256U, 
  k_verify_diffs_max    = 8U,   
  k_verify_decimal_max  = 20U,  
  k_verify_decimal      = 10U,  
  k_verify_hex_radix    = 16U,  
  k_verify_ppm_max_text = 5U,   
} verify_const_t;

typedef struct {
  const ra8_fmt_source_t* source; 
  uint64_t                offset; 
} verify_pull_t;

typedef struct {
  const ra8_fmt_jof_verify_requirements_t* need;
  ra8_fmt_jof_verify_workspace_t* work;
  const ra8_fmt_spool_t* ref;
  const ra8_fmt_spool_t* got;
  const jof_info_t* rinfo;
  const jof_info_t* ginfo;
  ra8_fmt_transaction_t* dump;
  const ra8_fmt_sink_t* report;
  uint64_t diffs;
  uint32_t shown;
  bool dump_ok;
} verify_compare_t;

RA8_INTERNAL
static ra8_err_t internal_stable(const ra8_fmt_source_t* source)
{
  return (source->validate == nullptr) ? k_ra8_ok : source->validate(source->ctx, source->size);
}

RA8_INTERNAL
static ra8_err_t internal_pull(void* ctx, uint8_t* bytes, size_t cap, size_t* got)
{
  verify_pull_t* pull = (verify_pull_t*)ctx;
  if ((pull == nullptr) || (got == nullptr) || ((bytes == nullptr) && (cap != 0U))) {
    return k_ra8_err_null_ptr;
  }
  *got = 0U;
  if ((cap == 0U) || (pull->offset >= pull->source->size)) {
    return k_ra8_ok;
  }
  const uint64_t remain = pull->source->size - pull->offset;
  if ((uint64_t)cap > remain) {
    cap = (size_t)remain;
  }
  ra8_err_t rc = pull->source->read_at(pull->source->ctx, pull->offset, bytes, cap, got);
  if ((rc == k_ra8_ok) && (*got <= cap)) {
    pull->offset += *got;
  } else if (rc == k_ra8_ok) {
    rc = k_ra8_err_protocol_error;
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_spool_append(void* ctx, const uint8_t* bytes, size_t len)
{
  ra8_fmt_spool_t* spool = (ra8_fmt_spool_t*)ctx;
  return spool->append(spool->ctx, bytes, len);
}

RA8_INTERNAL
static ra8_err_t internal_produce(const ra8_fmt_source_t*                  source,
                                  const ra8_fmt_jof_verify_requirements_t* need,
                                  uint16_t                                 tile_h,
                                  ra8_fmt_jof_verify_workspace_t*          work,
                                  ra8_fmt_spool_t*                         spool,
                                  jof_info_t*                              info)
{
  verify_pull_t           pull = {.source = source, .offset = 0U};
  const jof_produce_cfg_t cfg  = {
    .pull          = internal_pull,
    .pull_ctx      = &pull,
    .sink          = internal_spool_append,
    .sink_ctx      = spool,
    .tile_w        = need->width,
    .tile_h        = tile_h,
    .codec         = (uint8_t)k_jof_codec_deflate,
    .max_width     = need->width,
    .max_height    = need->height,
    .work          = work->work,
    .work_cap      = work->work_cap,
    .webp_work     = work->webp_work,
    .webp_work_cap = work->webp_work_cap,
  };
  ra8_err_t rc = internal_stable(source);
  if (rc == k_ra8_ok) {
    rc = jof_produce(&cfg, info);
  }
  if (rc == k_ra8_ok) {
    rc = internal_stable(source);
  }
  if (rc == k_ra8_ok) {
    rc = spool->seal(spool->ctx, info->total_size);
  }
  return rc;
}

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_decimal_max];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_verify_decimal));
    value /= k_verify_decimal;
  } while (value != 0U);
  char text[k_verify_decimal_max];
  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 ra8_err_t internal_hex(const ra8_fmt_sink_t* sink, uint8_t value)
{
  static const uint8_t digits[] = "0123456789ABCDEF";
  const uint8_t        text[2]  = {
    digits[value / k_verify_hex_radix],
    digits[value % k_verify_hex_radix],
  };
  return sink->write(sink->ctx, text, sizeof(text));
}

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_geometry(const ra8_fmt_sink_t* report, const jof_info_t* info, const jof_info_t* subject)
{
  ra8_err_t rc = internal_text(report, "verify: ");
  internal_field(report, info->width, "x", &rc);
  internal_field(report, info->height, " bpp=", &rc);
  internal_field(report, info->bpp, " | reference 1 tile | banded ", &rc);
  internal_field(report, subject->tile_count, " tiles of ", &rc);
  internal_field(report, subject->tile_h, " rows\n", &rc);
}

RA8_INTERNAL
static void internal_difference(verify_compare_t* state,
                                uint64_t          x,
                                uint64_t          y,
                                uint8_t           reference,
                                uint8_t           banded)
{
  if (state->shown >= k_verify_diffs_max) {
    return;
  }
  ra8_err_t rc = internal_text(state->report, "  DIFF at pixel (");
  internal_field(state->report, x, ", ", &rc);
  internal_field(state->report, y, "): reference=0x", &rc);
  if (rc == k_ra8_ok) {
    rc = internal_hex(state->report, reference);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(state->report, " banded=0x");
  }
  if (rc == k_ra8_ok) {
    rc = internal_hex(state->report, banded);
  }
  if (rc == k_ra8_ok) {
    (void)internal_text(state->report, "\n");
  }
  state->shown++;
}

RA8_INTERNAL
static void internal_abort_dump(verify_compare_t* state)
{
  if ((state->dump != nullptr) && (state->dump->ops != nullptr) &&
      (state->dump->ops->abort != nullptr)) {
    state->dump->ops->abort(state->dump->ctx);
  }
  state->dump_ok = false;
}

RA8_INTERNAL
static void internal_dump_bytes(verify_compare_t* state, const uint8_t* bytes, size_t len)
{
  if (state->dump_ok && (state->dump != nullptr) &&
      (state->dump->ops->append(state->dump->ctx, bytes, len) != k_ra8_ok)) {
    internal_abort_dump(state);
  }
}

RA8_INTERNAL
static void internal_dump_u64(verify_compare_t* state, uint64_t value)
{
  char   reverse[k_verify_decimal_max];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_verify_decimal));
    value /= k_verify_decimal;
  } while (value != 0U);
  char text[k_verify_decimal_max];
  for (size_t i = 0U; i < count; ++i) {
    text[i] = reverse[count - i - 1U];
  }
  internal_dump_bytes(state, (const uint8_t*)text, count);
}

RA8_INTERNAL
static void internal_dump_header(verify_compare_t* state)
{
  const uint8_t magic[3] = {'P', (state->need->bpp == 1U) ? '5' : '6', '\n'};
  internal_dump_bytes(state, magic, sizeof(magic));
  internal_dump_u64(state, state->need->width);
  internal_dump_bytes(state, (const uint8_t*)" ", 1U);
  internal_dump_u64(state, state->need->height);
  internal_dump_bytes(state, (const uint8_t*)"\n255\n", k_verify_ppm_max_text);
}

RA8_INTERNAL
static void internal_dump_row(verify_compare_t* state, const uint8_t* row)
{
  if ((state->dump == nullptr) || !state->dump_ok) {
    return;
  }
  if (state->need->bpp != 4U) {
    internal_dump_bytes(state, row, state->need->row_bytes);
    return;
  }
  for (uint32_t x = 0U; x < state->need->width; ++x) {
    (void)memcpy(&state->work->row[(size_t)x * 3U], &row[(size_t)x * 4U], 3U);
  }
  internal_dump_bytes(state, state->work->row, (size_t)state->need->width * 3U);
}

RA8_INTERNAL
static ra8_err_t internal_preflight(const ra8_fmt_spool_t*          spool,
                                    const jof_info_t*               info,
                                    ra8_fmt_jof_verify_workspace_t* work,
                                    bool                            reference)
{
  uint8_t* const buffer = reference ? work->row : work->band_tile;
  const uint32_t cap    = reference ? work->row_cap : work->band_tile_cap;
  for (uint16_t y = 0U; y < info->tile_rows; ++y) {
    uint16_t        out_w = 0U;
    uint16_t        out_h = 0U;
    const ra8_err_t rc    = jof_read_tile(spool->read_at,
                                          spool->ctx,
                                          info,
                                          0U,
                                          y,
                                          work->scratch,
                                          work->scratch_cap,
                                          buffer,
                                          cap,
                                          &out_w,
                                          &out_h);
    if ((rc != k_ra8_ok) || (out_w != info->width) || (reference && (out_h != 1U))) {
      return (rc == k_ra8_ok) ? k_ra8_err_validation_failed : rc;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static void internal_compare_row(verify_compare_t* state, const uint8_t* band_row, uint16_t y)
{
  for (uint32_t i = 0U; i < state->need->row_bytes; ++i) {
    if (state->work->row[i] != band_row[i]) {
      state->diffs++;
      internal_difference(state,
                          (uint64_t)(i / state->need->bpp),
                          y,
                          state->work->row[i],
                          band_row[i]);
    }
  }
  internal_dump_row(state, band_row);
}

RA8_INTERNAL
static ra8_err_t internal_compare(verify_compare_t* state)
{
  if (state->dump != nullptr) {
    state->dump_ok = true;
    internal_dump_header(state);
  }
  uint16_t global_y = 0U;
  for (uint16_t band_y = 0U; band_y < state->ginfo->tile_rows; ++band_y) {
    uint16_t  band_w = 0U;
    uint16_t  band_h = 0U;
    ra8_err_t rc     = jof_read_tile(state->got->read_at,
                                     state->got->ctx,
                                     state->ginfo,
                                     0U,
                                     band_y,
                                     state->work->scratch,
                                     state->work->scratch_cap,
                                     state->work->band_tile,
                                     state->work->band_tile_cap,
                                     &band_w,
                                     &band_h);
    if ((rc != k_ra8_ok) || (band_w != state->need->width)) {
      return (rc == k_ra8_ok) ? k_ra8_err_validation_failed : rc;
    }
    for (uint16_t row = 0U; row < band_h; ++row) {
      uint16_t ref_w = 0U;
      uint16_t ref_h = 0U;
      rc             = jof_read_tile(state->ref->read_at,
                                     state->ref->ctx,
                                     state->rinfo,
                                     0U,
                                     global_y,
                                     state->work->scratch,
                                     state->work->scratch_cap,
                                     state->work->row,
                                     state->work->row_cap,
                                     &ref_w,
                                     &ref_h);
      if ((rc != k_ra8_ok) || (ref_w != state->need->width) || (ref_h != 1U)) {
        return (rc == k_ra8_ok) ? k_ra8_err_validation_failed : rc;
      }
      const uint8_t* band_row = &state->work->band_tile[(size_t)row * state->need->row_bytes];
      internal_compare_row(state, band_row, global_y++);
    }
  }
  return (global_y == state->need->height) ? k_ra8_ok : k_ra8_err_validation_failed;
}

RA8_INTERNAL
static bool internal_info(const jof_info_t*                        info,
                          const ra8_fmt_jof_verify_requirements_t* need,
                          uint16_t                                 tile_h)
{
  const uint16_t rows = (uint16_t)(((uint32_t)need->height + tile_h - 1U) / tile_h);
  return (info->width == need->width) && (info->height == need->height) &&
         (info->tile_w == need->width) && (info->tile_h == tile_h) && (info->tile_cols == 1U) &&
         (info->tile_rows == rows) && (info->tile_count == rows) && (info->bpp == need->bpp) &&
         (info->codec == (uint8_t)k_jof_codec_deflate);
}

RA8_INTERNAL
static void internal_phase_error(const ra8_fmt_sink_t* report, const char* prefix, ra8_err_t status)
{
  ra8_err_t rc = internal_text(report, prefix);
  internal_field(report, status, ")\n", &rc);
}

RA8_INTERNAL
static void internal_finish_dump(verify_compare_t* state, const char* dump_name)
{
  if (state->dump == nullptr) {
    return;
  }
  if (state->dump_ok && (state->dump->ops->commit(state->dump->ctx) != k_ra8_ok)) {
    internal_abort_dump(state);
  }
  ra8_err_t rc = internal_text(state->report, "  wrote reassembled raster to ");
  if (rc == k_ra8_ok) {
    rc = internal_text(state->report, dump_name);
  }
  if (rc == k_ra8_ok) {
    (void)internal_text(state->report, state->dump_ok ? " (ok)\n" : " (FAILED)\n");
  }
}

RA8_INTERNAL
static void internal_verdict(const ra8_fmt_sink_t* report, uint64_t diffs)
{
  ra8_err_t rc = internal_text(report, "verdict: ");
  if (rc == k_ra8_ok) {
    rc = internal_text(report,
                       (diffs == 0U) ? "ROUND-TRIP EXACT -- the produced file is correct"
                                     : "MISMATCH");
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " (");
  }
  internal_field(report, diffs, " differing bytes)\n", &rc);
}

RA8_INTERNAL
static ra8_err_t internal_check(const ra8_fmt_source_t*                  reference_source,
                                const ra8_fmt_source_t*                  banded_source,
                                const ra8_fmt_jof_verify_requirements_t* need,
                                const ra8_fmt_jof_verify_workspace_t*    work,
                                const ra8_fmt_spool_t*                   ref_spool,
                                const ra8_fmt_spool_t*                   got_spool,
                                const ra8_fmt_sink_t*                    report)
{
  if ((reference_source == nullptr) || (banded_source == nullptr) ||
      (reference_source->read_at == nullptr) || (banded_source->read_at == nullptr) ||
      (reference_source->ctx == banded_source->ctx) || (need == nullptr) || (work == nullptr) ||
      (ref_spool == nullptr) || (got_spool == nullptr) || (ref_spool->read_at == nullptr) ||
      (ref_spool->append == nullptr) || (ref_spool->seal == nullptr) ||
      (got_spool->read_at == nullptr) || (got_spool->append == nullptr) ||
      (got_spool->seal == nullptr) || (ref_spool->ctx == got_spool->ctx) || (report == nullptr) ||
      (report->write == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  const uint32_t producer = (need->reference_work_bytes > need->banded_work_bytes)
                              ? need->reference_work_bytes
                              : need->banded_work_bytes;
  const bool     webp_bad =
    (need->webp_work_bytes != 0U) &&
    ((work->webp_work == nullptr) || (work->webp_work_cap < need->webp_work_bytes));
  if ((work->work == nullptr) || (work->work_cap < producer) || webp_bad ||
      (work->band_tile == nullptr) || (work->band_tile_cap < need->band_tile_bytes) ||
      (work->scratch == nullptr) || (work->scratch_cap < need->scratch_bytes) ||
      (work->row == nullptr) || (work->row_cap < need->row_bytes)) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}

typedef struct {
  jof_info_t reference; 
  jof_info_t banded;    
} verify_atlases_t;

RA8_INTERNAL
static void internal_abort_transaction(ra8_fmt_transaction_t* dump)
{
  if ((dump != nullptr) && (dump->ops != nullptr) && (dump->ops->abort != nullptr)) {
    dump->ops->abort(dump->ctx);
  }
}

RA8_INTERNAL
static ra8_err_t internal_accept(const ra8_fmt_spool_t*                   spool,
                                 const ra8_fmt_jof_verify_requirements_t* need,
                                 ra8_fmt_jof_verify_workspace_t*          work,
                                 bool                                     reference,
                                 jof_info_t*                              info)
{
  const uint16_t tile_h = reference ? 1U : need->band_height;
  ra8_err_t      rc     = jof_parse(spool->read_at, spool->ctx, info->total_size, info);
  if ((rc == k_ra8_ok) && !internal_info(info, need, tile_h)) {
    rc = k_ra8_err_validation_failed;
  }
  if (rc == k_ra8_ok) {
    rc = internal_preflight(spool, info, work, reference);
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_prepare(const ra8_fmt_source_t*                  reference_source,
                                  const ra8_fmt_source_t*                  banded_source,
                                  const ra8_fmt_jof_verify_requirements_t* need,
                                  ra8_fmt_jof_verify_workspace_t*          work,
                                  ra8_fmt_spool_t*                         reference_spool,
                                  ra8_fmt_spool_t*                         banded_spool,
                                  const ra8_fmt_sink_t*                    report,
                                  verify_atlases_t*                        atlases)
{
  ra8_err_t rc =
    internal_produce(reference_source, need, 1U, work, reference_spool, &atlases->reference);
  if (rc == k_ra8_ok) {
    rc = internal_accept(reference_spool, need, work, true, &atlases->reference);
  }
  if (rc != k_ra8_ok) {
    internal_phase_error(report, "verify: reference encode failed (rc=", rc);
    return rc;
  }
  rc =
    internal_produce(banded_source, need, need->band_height, work, banded_spool, &atlases->banded);
  if (rc == k_ra8_ok) {
    rc = internal_accept(banded_spool, need, work, false, &atlases->banded);
  }
  if (rc != k_ra8_ok) {
    internal_phase_error(report, "verify: banded encode failed (rc=", rc);
  }
  return rc;
}
 
ra8_err_t ra8_fmt_jof_verify_stream(const ra8_fmt_source_t*                  reference_source,
                                    const ra8_fmt_source_t*                  banded_source,
                                    const ra8_fmt_jof_verify_requirements_t* requirements,
                                    ra8_fmt_jof_verify_workspace_t*          workspace,
                                    ra8_fmt_spool_t*                         reference_spool,
                                    ra8_fmt_spool_t*                         banded_spool,
                                    ra8_fmt_transaction_t*                   dump,
                                    const char*                              dump_name,
                                    const ra8_fmt_sink_t*                    report)
{
  ra8_err_t  rc = internal_check(reference_source,
                                 banded_source,
                                 requirements,
                                 workspace,
                                 reference_spool,
                                 banded_spool,
                                 report);
  const bool dump_bad =
    (dump != nullptr) &&
    ((dump->ops == nullptr) || (dump->ops->append == nullptr) || (dump->ops->commit == nullptr) ||
     (dump->ops->abort == nullptr) || (dump_name == nullptr));
  if ((rc != k_ra8_ok) || dump_bad) {
    return (rc == k_ra8_ok) ? k_ra8_err_null_ptr : rc;
  }
  verify_atlases_t atlases = {};
  rc                       = internal_prepare(reference_source,
                                              banded_source,
                                              requirements,
                                              workspace,
                                              reference_spool,
                                              banded_spool,
                                              report,
                                              &atlases);
  if (rc != k_ra8_ok) {
    internal_abort_transaction(dump);
    return rc;
  }
  internal_geometry(report, &atlases.reference, &atlases.banded);
  verify_compare_t compare = {
    .need    = requirements,
    .work    = workspace,
    .ref     = reference_spool,
    .got     = banded_spool,
    .rinfo   = &atlases.reference,
    .ginfo   = &atlases.banded,
    .dump    = dump,
    .report  = report,
    .dump_ok = dump != nullptr,
  };
  rc = internal_compare(&compare);
  if (rc == k_ra8_ok) {
    rc = internal_stable(reference_source);
  }
  if (rc == k_ra8_ok) {
    rc = internal_stable(banded_source);
  }
  if (rc != k_ra8_ok) {
    internal_abort_dump(&compare);
    return rc;
  }
  internal_finish_dump(&compare, dump_name);
  internal_verdict(report, compare.diffs);
  return (compare.diffs == 0U) ? k_ra8_ok : k_ra8_err_validation_failed;
}