ra8_fmt_stream_verify_plan.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_png_head         = 26U,         
  k_verify_png_chunks       = 33U,         
  k_verify_png_trns         = 0x74524E53U, 
  k_verify_png_idat         = 0x49444154U, 
  k_verify_jpeg_sof0        = 0xC0U,       
  k_verify_jpeg_dht         = 0xC4U,       
  k_verify_jpeg_jpg         = 0xC8U,       
  k_verify_jpeg_dac         = 0xCCU,       
  k_verify_jpeg_marker      = 0xFFU,       
  k_verify_jpeg_soi         = 0xD8U,       
  k_verify_jpeg_sof_last    = 0xCFU,       
  k_verify_u32_high_shift   = 24U,         
  k_verify_jpeg_components  = 7U,          
  k_verify_png_chunk_record = 12U,         
  k_verify_png_color_type   = 25U,         
  k_verify_fourcc_bytes     = 4U,          
  k_verify_webp_form_offset = 8U,          
} verify_plan_const_t;

typedef enum : uint8_t {
  k_verify_png_sig_high = 0x89U, 
  k_verify_png_sig_cr   = 0x0DU, 
  k_verify_png_sig_lf   = 0x0AU, 
  k_verify_png_sig_sub  = 0x1AU, 
} verify_png_signature_t;

RA8_INTERNAL
static ra8_err_t
internal_exact(const ra8_fmt_source_t* source, uint64_t offset, uint8_t* bytes, size_t len)
{
  if ((offset > source->size) || ((uint64_t)len > (source->size - offset))) {
    return k_ra8_err_protocol_error;
  }
  size_t done = 0U;
  while (done < len) {
    size_t          got = 0U;
    const ra8_err_t rc =
      source->read_at(source->ctx, offset + done, &bytes[done], len - done, &got);
    if (rc != k_ra8_ok) {
      return rc;
    }
    if ((got == 0U) || (got > (len - done))) {
      return k_ra8_err_protocol_error;
    }
    done += got;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static uint16_t internal_be16(const uint8_t bytes[2])
{
  return (uint16_t)(((uint16_t)bytes[0] << 8U) | bytes[1]);
}

RA8_INTERNAL
static uint32_t internal_be32(const uint8_t bytes[4])
{
  return ((uint32_t)bytes[0] << k_verify_u32_high_shift) | ((uint32_t)bytes[1] << 16U) |
         ((uint32_t)bytes[2] << 8U) | bytes[3];
}

RA8_INTERNAL
static bool internal_is_sof(uint8_t marker)
{
  const bool range =
    (marker >= (uint8_t)k_verify_jpeg_sof0) && (marker <= (uint8_t)k_verify_jpeg_sof_last);
  return range && (marker != (uint8_t)k_verify_jpeg_dht) &&
         (marker != (uint8_t)k_verify_jpeg_jpg) && (marker != (uint8_t)k_verify_jpeg_dac);
}

RA8_INTERNAL
static ra8_err_t internal_jpeg_bpp(const ra8_fmt_source_t* source, uint8_t* bpp)
{
  uint64_t offset = 2U;
  while (offset < source->size) {
    uint8_t byte = 0U;
    do {
      ra8_err_t rc = internal_exact(source, offset++, &byte, 1U);
      if (rc != k_ra8_ok) {
        return rc;
      }
    } while (byte != (uint8_t)k_verify_jpeg_marker);
    do {
      ra8_err_t rc = internal_exact(source, offset++, &byte, 1U);
      if (rc != k_ra8_ok) {
        return rc;
      }
    } while (byte == (uint8_t)k_verify_jpeg_marker);
    uint8_t   length_bytes[2];
    ra8_err_t rc = internal_exact(source, offset, length_bytes, sizeof(length_bytes));
    if (rc != k_ra8_ok) {
      return rc;
    }
    const uint16_t segment = internal_be16(length_bytes);
    if (segment < 2U) {
      return k_ra8_err_protocol_error;
    }
    if (internal_is_sof(byte)) {
      uint8_t components = 0U;
      rc = internal_exact(source, offset + k_verify_jpeg_components, &components, 1U);
      if (rc != k_ra8_ok) {
        return rc;
      }
      if ((components != 1U) && (components != 3U)) {
        return k_ra8_err_not_supported;
      }
      *bpp = components;
      return k_ra8_ok;
    }
    offset += segment;
  }
  return k_ra8_err_protocol_error;
}

RA8_INTERNAL
static ra8_err_t internal_png_bpp(const ra8_fmt_source_t* source, uint8_t color_type, uint8_t* bpp)
{
  if (color_type == 0U) {
    *bpp = 1U;
    return k_ra8_ok;
  }
  if ((color_type == 4U) || (color_type == 6U)) {
    *bpp = 4U;
    return k_ra8_ok;
  }
  if (color_type == 2U) {
    *bpp = 3U;
    return k_ra8_ok;
  }
  if (color_type != 3U) {
    return k_ra8_err_not_supported;
  }
  uint64_t offset = k_verify_png_chunks;
  *bpp            = 3U;
  while ((offset + k_verify_png_chunk_record) <= source->size) {
    uint8_t   chunk[8];
    ra8_err_t rc = internal_exact(source, offset, chunk, sizeof(chunk));
    if (rc != k_ra8_ok) {
      return rc;
    }
    const uint32_t length = internal_be32(chunk);
    const uint32_t type   = internal_be32(&chunk[4]);
    if ((uint64_t)length > (source->size - offset - k_verify_png_chunk_record)) {
      return k_ra8_err_protocol_error;
    }
    if (type == k_verify_png_trns) {
      *bpp = 4U;
    }
    if (type == k_verify_png_idat) {
      return k_ra8_ok;
    }
    offset += k_verify_png_chunk_record + length;
  }
  return k_ra8_err_protocol_error;
}

RA8_INTERNAL
static ra8_err_t internal_bpp(const ra8_fmt_source_t* source, uint8_t* bpp)
{
  uint8_t   head[k_verify_png_head];
  ra8_err_t rc = internal_exact(source, 0U, head, sizeof(head));
  if (rc != k_ra8_ok) {
    return rc;
  }
  if ((head[0] == (uint8_t)k_verify_jpeg_marker) && (head[1] == (uint8_t)k_verify_jpeg_soi)) {
    return internal_jpeg_bpp(source, bpp);
  }
  static const uint8_t png[8] = {k_verify_png_sig_high,
                                 'P',
                                 'N',
                                 'G',
                                 k_verify_png_sig_cr,
                                 k_verify_png_sig_lf,
                                 k_verify_png_sig_sub,
                                 k_verify_png_sig_lf};
  if (memcmp(head, png, sizeof(png)) == 0) {
    return internal_png_bpp(source, head[k_verify_png_color_type], bpp);
  }
  /* Compared as unsigned octet runs rather than as null-terminated strings:
   * a fourCC is a fixed four-byte field with no terminator, and `head` is a
   * uint8_t buffer, so both memcmp operands stay essentially unsigned. */
  static const uint8_t riff[k_verify_fourcc_bytes] = {'R', 'I', 'F', 'F'};
  static const uint8_t webp[k_verify_fourcc_bytes] = {'W', 'E', 'B', 'P'};
  if ((memcmp(head, riff, sizeof(riff)) == 0) &&
      (memcmp(&head[k_verify_webp_form_offset], webp, sizeof(webp)) == 0)) {
    *bpp = 4U;
    return k_ra8_ok;
  }
  return k_ra8_err_not_supported;
}

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_err_t ra8_fmt_jof_verify_requirements(const ra8_fmt_source_t*            source,
                                          ra8_fmt_jof_verify_requirements_t* out)
{
  if ((source == nullptr) || (source->read_at == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out                                       = (ra8_fmt_jof_verify_requirements_t){};
  ra8_fmt_jof_convert_requirements_t convert = {};
  ra8_err_t                          rc      = ra8_fmt_jof_convert_requirements(source, &convert);
  if (rc != k_ra8_ok) {
    return rc;
  }
  rc = internal_bpp(source, &out->bpp);
  if (rc != k_ra8_ok) {
    return rc;
  }
  out->width                = convert.width;
  out->height               = convert.height;
  out->band_height          = convert.tile_height;
  out->reference_work_bytes = jof_work_bytes(out->width, out->height, out->width, 1U);
  out->banded_work_bytes    = convert.work_bytes;
  out->webp_work_bytes      = convert.webp_work_bytes;
  const uint64_t row        = (uint64_t)out->width * out->bpp;
  const uint64_t band       = row * out->band_height;
  if ((out->reference_work_bytes == 0U) || (band > UINT32_MAX)) {
    return k_ra8_err_invalid_size;
  }
  out->row_bytes       = (uint32_t)row;
  out->band_tile_bytes = (uint32_t)band;
  out->scratch_bytes   = jof_stored_bound(out->band_tile_bytes);
  return internal_stable(source);
}