jof_audit.c

Go to the documentation of this file.

 
#include "jof_audit.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"

typedef enum : uint32_t {
  k_jof_audit_fnv_basis    = 2166136261U, 
  k_jof_audit_fnv_prime    = 16777619U,   
  k_jof_audit_u32_b3_shift = 24U,         
} jof_audit_hash_t;

typedef struct internal_span_t {
  uintptr_t begin; 
  uintptr_t end;   
} internal_span_t;

RA8_INTERNAL static ra8_err_t
internal_read_exact(jof_pread_fn pread, void* ctx, uint64_t offset, uint8_t* buf, size_t len)
{
  size_t          got = 0U;
  const ra8_err_t rc  = pread(ctx, offset, buf, len, &got);
  if (rc != k_ra8_ok) {
    return rc;
  }
  return (got == len) ? k_ra8_ok : k_ra8_err_validation_failed;
}

RA8_INTERNAL static uint32_t internal_rd_u32(const uint8_t* p)
{
  return (uint32_t)p[0] | ((uint32_t)p[1] << 8U) | ((uint32_t)p[2] << 16U) |
         ((uint32_t)p[3] << k_jof_audit_u32_b3_shift);
}

RA8_INTERNAL static uint32_t internal_hash(const uint8_t* bytes, size_t len, bool* out_uniform)
{
  uint32_t h       = (uint32_t)k_jof_audit_fnv_basis;
  bool     uniform = true;
  for (size_t i = 0U; i < len; ++i) {
    if (i != 0U) {
      if (bytes[i] != bytes[0]) {
        uniform = false;
      }
    }
    h ^= (uint32_t)bytes[i];
    h *= (uint32_t)k_jof_audit_fnv_prime;
  }
  *out_uniform = uniform;
  return h;
}

RA8_INTERNAL static ra8_err_t internal_make_span(const void* ptr, size_t len, internal_span_t* out)
{
  if (len == 0U) {
    *out = (internal_span_t){};
    return k_ra8_ok;
  }
  if (ptr == nullptr) {
    return k_ra8_err_null_ptr;
  }
  uintptr_t begin = 0U;
  static_assert(sizeof(begin) == sizeof(ptr), "uintptr_t must preserve a pointer representation");
  (void)memcpy((void*)&begin, (const void*)&ptr, sizeof(begin));
  if (len > (size_t)(UINTPTR_MAX - begin)) {
    return k_ra8_err_invalid_size;
  }
  *out = (internal_span_t){.begin = begin, .end = begin + (uintptr_t)len};
  return k_ra8_ok;
}

RA8_INTERNAL static bool internal_spans_overlap(const internal_span_t* left,
                                                const internal_span_t* right)
{
  if (left->begin >= right->end) {
    return false;
  }
  return right->begin < left->end;
}

RA8_INTERNAL static bool internal_any_workspace_overlap(const internal_span_t* workspace,
                                                        const internal_span_t* records,
                                                        const internal_span_t* tile,
                                                        const internal_span_t* scratch,
                                                        const internal_span_t* result)
{
  if (internal_spans_overlap(workspace, records)) {
    return true;
  }
  if (internal_spans_overlap(workspace, tile)) {
    return true;
  }
  if (internal_spans_overlap(workspace, scratch)) {
    return true;
  }
  if (internal_spans_overlap(workspace, result)) {
    return true;
  }
  if (internal_spans_overlap(records, tile)) {
    return true;
  }
  if (internal_spans_overlap(records, scratch)) {
    return true;
  }
  if (internal_spans_overlap(records, result)) {
    return true;
  }
  if (internal_spans_overlap(tile, scratch)) {
    return true;
  }
  if (internal_spans_overlap(tile, result)) {
    return true;
  }
  return internal_spans_overlap(scratch, result);
}
 
ra8_err_t jof_audit_requirements(jof_pread_fn              pread,
                                 void*                     pread_ctx,
                                 uint64_t                  total_size,
                                 jof_audit_requirements_t* out)
{
  if (pread == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  jof_info_t      info = {};
  const ra8_err_t rc   = jof_parse(pread, pread_ctx, total_size, &info);
  if (rc != k_ra8_ok) {
    return rc;
  }
  const uint64_t tile64 = (uint64_t)info.tile_w * (uint64_t)info.tile_h * (uint64_t)info.bpp;
  if (tile64 > UINT32_MAX) {
    return k_ra8_err_invalid_size;
  }
  const uint32_t                 tile      = (uint32_t)tile64;
  const jof_audit_requirements_t candidate = {
    .record_count  = info.tile_count,
    .tile_bytes    = tile,
    .scratch_bytes = (info.codec == (uint8_t)k_jof_codec_deflate) ? jof_stored_bound(tile) : 0U,
  };
  if (candidate.tile_bytes == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (info.codec == (uint8_t)k_jof_codec_deflate) {
    if (candidate.scratch_bytes == 0U) {
      return k_ra8_err_invalid_size;
    }
  }
  *out = candidate;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_check_workspace_spans(const jof_audit_workspace_t*    ws,
                                                             const jof_audit_requirements_t* need,
                                                             const jof_audit_result_t*       out,
                                                             size_t record_bytes)
{
  internal_span_t workspace_span = {};
  internal_span_t record_span    = {};
  internal_span_t tile_span      = {};
  internal_span_t scratch_span   = {};
  internal_span_t result_span    = {};
  ra8_err_t       rc             = internal_make_span(ws, sizeof(*ws), &workspace_span);
  if (rc == k_ra8_ok) {
    rc = internal_make_span(ws->records, record_bytes, &record_span);
  }
  if (rc == k_ra8_ok) {
    rc = internal_make_span(ws->tile, need->tile_bytes, &tile_span);
  }
  if (rc == k_ra8_ok) {
    rc = internal_make_span(ws->scratch, need->scratch_bytes, &scratch_span);
  }
  if (rc == k_ra8_ok) {
    rc = internal_make_span(out, sizeof(*out), &result_span);
  }
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (internal_any_workspace_overlap(&workspace_span,
                                     &record_span,
                                     &tile_span,
                                     &scratch_span,
                                     &result_span)) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_check_workspace(const jof_audit_workspace_t*    ws,
                                                       const jof_audit_requirements_t* need,
                                                       const jof_audit_result_t*       out)
{
  if (ws == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ws->records == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ws->tile == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (need->scratch_bytes != 0U) {
    if (ws->scratch == nullptr) {
      return k_ra8_err_null_ptr;
    }
  }
  if (ws->record_cap < need->record_count) {
    return k_ra8_err_invalid_size;
  }
  if (ws->tile_cap < need->tile_bytes) {
    return k_ra8_err_invalid_size;
  }
  if (ws->scratch_cap < need->scratch_bytes) {
    return k_ra8_err_invalid_size;
  }
  const size_t record_bytes = (size_t)need->record_count * sizeof(*ws->records);
  if (need->record_count != 0U) {
    if ((record_bytes / sizeof(*ws->records)) != (size_t)need->record_count) {
      return k_ra8_err_invalid_size;
    }
  }
  return internal_check_workspace_spans(ws, need, out, record_bytes);
}

RA8_INTERNAL static uint32_t internal_duplicate_count(const jof_audit_record_t* records,
                                                      uint32_t                  count,
                                                      const jof_audit_record_t* item)
{
  if (item->uniform) {
    return 0U;
  }
  uint32_t matches = 0U;
  for (uint32_t i = 0U; i < count; ++i) {
    if (records[i].uniform) {
      continue;
    }
    if (records[i].payload != item->payload) {
      continue;
    }
    if (records[i].content_hash != item->content_hash) {
      continue;
    }
    matches++;
  }
  return matches;
}

typedef struct internal_audit_context_t {
  jof_pread_fn           pread;           
  void*                  pread_ctx;       
  jof_audit_workspace_t* workspace;       
  jof_audit_result_t*    candidate;       
  uint32_t               expected_offset; 
} internal_audit_context_t;

RA8_INTERNAL
static ra8_err_t internal_audit_tile(internal_audit_context_t* context, uint32_t index_number)
{
  uint8_t        index[k_jof_index_entry] = {};
  const uint64_t index_at                 = (uint64_t)context->candidate->info.index_off +
                                            ((uint64_t)index_number * (uint64_t)k_jof_index_entry);
  ra8_err_t      rc =
    internal_read_exact(context->pread, context->pread_ctx, index_at, index, sizeof(index));
  if (rc != k_ra8_ok) {
    return rc;
  }
  jof_audit_record_t* const record = &context->workspace->records[index_number];
  *record                          = (jof_audit_record_t){
    .offset = internal_rd_u32(&index[k_jof_idx_ofs_offset]),
    .length = internal_rd_u32(&index[k_jof_idx_ofs_length]),
  };
  if (record->offset != context->expected_offset) {
    context->candidate->coverage_errors++;
  }
  const uint64_t next = (uint64_t)record->offset + (uint64_t)record->length;
  if (next > UINT32_MAX) {
    return k_ra8_err_validation_failed;
  }
  context->expected_offset = (uint32_t)next;
 
  const uint16_t tx = (uint16_t)(index_number % (uint32_t)context->candidate->info.tile_cols);
  const uint16_t ty = (uint16_t)(index_number / (uint32_t)context->candidate->info.tile_cols);
  rc                = jof_read_tile(context->pread,
                                    context->pread_ctx,
                                    &context->candidate->info,
                                    tx,
                                    ty,
                                    context->workspace->scratch,
                                    context->workspace->scratch_cap,
                                    context->workspace->tile,
                                    context->workspace->tile_cap,
                                    &record->width,
                                    &record->height);
  if (rc != k_ra8_ok) {
    return rc;
  }
  record->payload =
    (uint32_t)record->width * (uint32_t)record->height * (uint32_t)context->candidate->info.bpp;
  uint16_t want_w = 0U;
  uint16_t want_h = 0U;
  rc              = jof_tile_dims(&context->candidate->info, tx, ty, &want_w, &want_h);
  if (rc != k_ra8_ok) {
    return rc;
  }
  bool geometry_error = record->width != want_w;
  if (record->height != want_h) {
    geometry_error = true;
  }
  if (geometry_error) {
    context->candidate->geometry_errors++;
  }
  record->content_hash = internal_hash(context->workspace->tile, record->payload, &record->uniform);
  context->candidate->duplicate_candidates +=
    internal_duplicate_count(context->workspace->records, index_number, record);
  context->candidate->decoded_tiles++;
  return k_ra8_ok;
}
 
ra8_err_t jof_audit(jof_pread_fn           pread,
                    void*                  pread_ctx,
                    uint64_t               total_size,
                    jof_audit_workspace_t* workspace,
                    jof_audit_result_t*    out)
{
  if (pread == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  jof_audit_requirements_t need = {};
  ra8_err_t                rc   = jof_audit_requirements(pread, pread_ctx, total_size, &need);
  if (rc != k_ra8_ok) {
    return rc;
  }
  rc = internal_check_workspace(workspace, &need, out);
  if (rc != k_ra8_ok) {
    return rc;
  }
  jof_audit_result_t candidate = {};
  rc                           = jof_parse(pread, pread_ctx, total_size, &candidate.info);
  if (rc != k_ra8_ok) {
    return rc;
  }
 
  internal_audit_context_t context = {.pread           = pread,
                                      .pread_ctx       = pread_ctx,
                                      .workspace       = workspace,
                                      .candidate       = &candidate,
                                      .expected_offset = (uint32_t)k_jof_hdr_bytes};
  for (uint32_t i = 0U; i < candidate.info.tile_count; ++i) {
    rc = internal_audit_tile(&context, i);
    if (rc != k_ra8_ok) {
      return rc;
    }
  }
  if (context.expected_offset != candidate.info.index_off) {
    candidate.coverage_errors++;
  }
  *out = candidate;
  if (candidate.coverage_errors != 0U) {
    return k_ra8_err_validation_failed;
  }
  if (candidate.geometry_errors != 0U) {
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}