ra8_fmt_stream_inspect.c

Go to the documentation of this file.

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

typedef enum : uint32_t {
  k_fmt_text_dec_digits  = 20U,   
  k_fmt_text_hex_digits  = 16U,   
  k_fmt_text_hex_row     = 16U,   
  k_fmt_text_dec_radix   = 10U,   
  k_fmt_text_nibble      = 4U,    
  k_fmt_text_nibble_mask = 15U,   
  k_fmt_text_max_rows    = 4096U, 
  k_fmt_text_col_width   = 10U,   
  k_fmt_text_ascii_low   = 32U,   
  k_fmt_text_ascii_high  = 126U,  
} fmt_text_const_t;

RA8_INTERNAL
static ra8_err_t internal_put(const ra8_fmt_sink_t* report, const uint8_t* bytes, size_t len)
{
  return report->write(report->ctx, bytes, len);
}

RA8_INTERNAL
static ra8_err_t internal_text(const ra8_fmt_sink_t* report, const char* text)
{
  size_t len = 0U;
  while (text[len] != '\0') {
    len++;
  }
  return internal_put(report, (const uint8_t*)text, len);
}

RA8_INTERNAL
static ra8_err_t internal_char(const ra8_fmt_sink_t* report, char value)
{
  const uint8_t byte = (uint8_t)value;
  return internal_put(report, &byte, 1U);
}

RA8_INTERNAL
static ra8_err_t internal_u64(const ra8_fmt_sink_t* report, uint64_t value, uint32_t width)
{
  char     digits[k_fmt_text_dec_digits];
  uint32_t count = 0U;
  do {
    digits[count++] = (char)('0' + (char)(value % k_fmt_text_dec_radix));
    value /= k_fmt_text_dec_radix;
  } while (value != 0U);
  ra8_err_t rc = k_ra8_ok;
  for (uint32_t i = count; (i < width) && (rc == k_ra8_ok); ++i) {
    rc = internal_char(report, ' ');
  }
  while ((count != 0U) && (rc == k_ra8_ok)) {
    rc = internal_char(report, digits[--count]);
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_hex(const ra8_fmt_sink_t* report, uint64_t value, uint32_t width)
{
  static const char s_digits[] = "0123456789ABCDEF";
  char              text[k_fmt_text_hex_digits];
  if (width > (uint32_t)sizeof(text)) {
    return k_ra8_err_invalid_size;
  }
  for (uint32_t i = 0U; i < width; ++i) {
    const uint32_t shift = (width - i - 1U) * k_fmt_text_nibble;
    text[i]              = s_digits[(value >> shift) & k_fmt_text_nibble_mask];
  }
  return internal_put(report, (const uint8_t*)text, width);
}

RA8_INTERNAL
static ra8_err_t internal_value_line(const ra8_fmt_sink_t* report,
                                     const char*           label,
                                     uint64_t              value,
                                     const char*           suffix)
{
  ra8_err_t rc = internal_text(report, label);
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, value, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, suffix);
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t
internal_read_exact(const ra8_fmt_source_t* source, uint64_t offset, uint8_t* bytes, size_t len)
{
  size_t          got = 0U;
  const ra8_err_t rc  = source->read_at(source->ctx, offset, bytes, len, &got);
  if (rc != k_ra8_ok) {
    return rc;
  }
  return (got == len) ? k_ra8_ok : k_ra8_err_validation_failed;
}

RA8_INTERNAL
static ra8_err_t internal_hex_dump_header(const ra8_fmt_sink_t* report,
                                          const char*           label,
                                          uint64_t              offset,
                                          size_t                len)
{
  ra8_err_t rc = internal_text(report, label);
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " (");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, len, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " bytes at +");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, offset, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, "):\n");
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_hex_dump_row(const ra8_fmt_sink_t* report,
                                       uint64_t              offset,
                                       const uint8_t*        row,
                                       size_t                count)
{
  ra8_err_t rc = internal_text(report, "  ");
  if (rc == k_ra8_ok) {
    rc = internal_hex(report, offset, 8U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, "  ");
  }
  for (size_t i = 0U; (i < (size_t)k_fmt_text_hex_row) && (rc == k_ra8_ok); ++i) {
    if (i < count) {
      rc = internal_hex(report, row[i], 2U);
      if (rc == k_ra8_ok) {
        rc = internal_char(report, ' ');
      }
    } else {
      rc = internal_text(report, "   ");
    }
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " |");
  }
  for (size_t i = 0U; (i < count) && (rc == k_ra8_ok); ++i) {
    const bool printable =
      (row[i] >= (uint8_t)k_fmt_text_ascii_low) && (row[i] <= (uint8_t)k_fmt_text_ascii_high);
    rc = internal_char(report, (char)(printable ? (char)row[i] : '.'));
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, "|\n");
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_hex_dump(const ra8_fmt_source_t* source,
                                   const ra8_fmt_sink_t*   report,
                                   const char*             label,
                                   uint64_t                offset,
                                   size_t                  len)
{
  ra8_err_t rc = internal_hex_dump_header(report, label, offset, len);
  uint8_t   row[k_fmt_text_hex_row];
  size_t    done = 0U;
  while ((done < len) && (rc == k_ra8_ok)) {
    size_t count = len - done;
    if (count > sizeof(row)) {
      count = sizeof(row);
    }
    rc = internal_read_exact(source, offset + done, row, count);
    if (rc == k_ra8_ok) {
      rc = internal_hex_dump_row(report, offset + done, row, count);
    }
    done += count;
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_dimensions(const jof_info_t* info, const ra8_fmt_sink_t* report)
{
  ra8_err_t rc = internal_text(report, "  image      : ");
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, info->width, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " x ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, info->height, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " px\n  tile       : ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, info->tile_w, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " x ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, info->tile_h, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " px\n  grid       : ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, info->tile_cols, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " cols x ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, info->tile_rows, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " rows\n");
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_geometry(const ra8_fmt_source_t* source,
                                   const jof_info_t*       info,
                                   const ra8_fmt_sink_t*   report)
{
  ra8_err_t rc = internal_text(report, "JOF atlas: ");
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, source->size, 0U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " bytes\n");
  }
  if (rc == k_ra8_ok) {
    rc = internal_dimensions(info, report);
  }
  if (rc == k_ra8_ok) {
    rc = internal_value_line(report, "  bpp        : ", info->bpp, "\n");
  }
  if (rc == k_ra8_ok) {
    rc = internal_value_line(report, "  codec      : ", info->codec, " (");
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report,
                       (info->codec == (uint8_t)k_jof_codec_deflate) ? "deflate)\n" : "raw)\n");
  }
  if (rc == k_ra8_ok) {
    rc = internal_value_line(report, "  tile_count : ", info->tile_count, "\n");
  }
  if (rc == k_ra8_ok) {
    rc = internal_value_line(report, "  index_off  : ", info->index_off, "\n");
  }
  if (rc == k_ra8_ok) {
    rc = internal_value_line(report, "  total_size : ", info->total_size, "\n  longstrip  : ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report,
                       (info->tile_w == info->width) ? "YES (tile_w == width)\n"
                                                     : "NO (tile_w != width)\n");
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t
internal_table_row(const ra8_fmt_sink_t* report, uint32_t index, const jof_audit_record_t* record)
{
  ra8_err_t rc = internal_u64(report, index, 8U);
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, record->offset, k_fmt_text_col_width);
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, record->length, k_fmt_text_col_width);
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, record->payload, k_fmt_text_col_width);
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, record->width, 6U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_u64(report, record->height, 6U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, "   ");
  }
  if (rc == k_ra8_ok) {
    rc = internal_hex(report, record->content_hash, 8U);
  }
  if (rc == k_ra8_ok) {
    rc = internal_char(report, '\n');
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t
internal_table(const jof_audit_record_t* records, uint32_t count, const ra8_fmt_sink_t* report)
{
  ra8_err_t rc =
    internal_text(report, "  tile      offset    length   payload   tw    th   hash\n");
  uint32_t shown = count;
  if (shown > k_fmt_text_max_rows) {
    shown = k_fmt_text_max_rows;
  }
  for (uint32_t i = 0U; (i < shown) && (rc == k_ra8_ok); ++i) {
    rc = internal_table_row(report, i, &records[i]);
  }
  if ((shown < count) && (rc == k_ra8_ok)) {
    rc = internal_text(report, "  ... ");
  }
  if ((shown < count) && (rc == k_ra8_ok)) {
    rc = internal_u64(report, count - shown, 0U);
  }
  if ((shown < count) && (rc == k_ra8_ok)) {
    rc = internal_text(report, " more tiles elided\n");
  }
  return rc;
}
 
ra8_err_t ra8_fmt_jof_inspect_stream(const ra8_fmt_source_t*                source,
                                     bool                                   verbose,
                                     const ra8_fmt_jof_inspect_workspace_t* workspace,
                                     const ra8_fmt_sink_t*                  report)
{
  if ((source == nullptr) || (source->read_at == nullptr) || (workspace == nullptr) ||
      (report == nullptr) || (report->write == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  jof_audit_workspace_t audit_workspace = {.records     = workspace->records,
                                           .record_cap  = workspace->record_cap,
                                           .tile        = workspace->tile,
                                           .tile_cap    = workspace->tile_cap,
                                           .scratch     = workspace->scratch,
                                           .scratch_cap = workspace->scratch_cap};
  jof_audit_result_t    result          = {};
  const ra8_err_t       audit_rc =
    jof_audit(source->read_at, source->ctx, source->size, &audit_workspace, &result);
  if ((audit_rc != k_ra8_ok) && (audit_rc != k_ra8_err_validation_failed)) {
    return audit_rc;
  }
  ra8_err_t rc = internal_geometry(source, &result.info, report);
  if (verbose && (rc == k_ra8_ok)) {
    rc = internal_hex_dump(source, report, "header", 0U, (size_t)k_jof_hdr_bytes);
  }
  if (verbose && (rc == k_ra8_ok)) {
    rc = internal_hex_dump(source,
                           report,
                           "footer",
                           source->size - (uint64_t)k_jof_footer_bytes,
                           (size_t)k_jof_footer_bytes);
  }
  if (verbose && (rc == k_ra8_ok)) {
    rc = internal_table(workspace->records, result.info.tile_count, report);
  }
  if ((result.duplicate_candidates != 0U) && (rc == k_ra8_ok)) {
    rc = internal_value_line(report,
                             "  duplicate hash candidates: ",
                             result.duplicate_candidates,
                             " (diagnostic only)\n");
  }
  if (rc == k_ra8_ok) {
    const char* verdict = "verdict: INVALID (see anomalies above)\n";
    if ((audit_rc == k_ra8_ok) && (result.duplicate_candidates == 0U)) {
      verdict = "verdict: VALID (coverage exact, no duplicate tiles)\n";
    } else if (audit_rc == k_ra8_ok) {
      verdict = "verdict: VALID (coverage exact; duplicate hashes are diagnostic)\n";
    }
    rc = internal_text(report, verdict);
  }
  return (rc == k_ra8_ok) ? audit_rc : rc;
}