ra8_fmt_stream_convert.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"
#include "ra8_webp.h"

typedef enum : uint32_t {
  k_convert_band_height    = 256U,  
  k_convert_probe_bytes    = 64U,   
  k_convert_jpeg_soi       = 0xD8U, 
  k_convert_jpeg_eoi       = 0xD9U, 
  k_convert_jpeg_sos       = 0xDAU, 
  k_convert_jpeg_sof0      = 0xC0U, 
  k_convert_jpeg_dht       = 0xC4U, 
  k_convert_jpeg_jpg       = 0xC8U, 
  k_convert_jpeg_dac       = 0xCCU, 
  k_convert_jpeg_rst_lo    = 0xD0U, 
  k_convert_jpeg_rst_hi    = 0xD7U, 
  k_convert_jpeg_tem       = 0x01U, 
  k_convert_marker         = 0xFFU, 
  k_convert_jpeg_8bit      = 8U,    
  k_convert_png_dims_end   = 24U,   
  k_convert_png_w          = 16U,   
  k_convert_png_h          = 20U,   
  k_convert_decimal_max    = 20U,   
  k_convert_decimal_base   = 10U,   
  k_convert_u32_high_shift = 24U,   
  k_convert_jpeg_sof_last  = 0xCFU, 
  k_convert_probe_min      = 12U,   
} convert_const_t;

typedef enum : uint8_t {
  k_convert_png_sig_high = 0x89U, 
  k_convert_png_sig_cr   = 0x0DU, 
  k_convert_png_sig_lf   = 0x0AU, 
  k_convert_png_sig_sub  = 0x1AU, 
} convert_png_signature_t;

typedef enum : uint8_t {
  k_convert_kind_jpeg = 0U, 
  k_convert_kind_png  = 1U, 
  k_convert_kind_webp = 2U, 
} convert_kind_t;

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

RA8_INTERNAL
static ra8_err_t
internal_read_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_convert_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 in_range =
    (marker >= (uint8_t)k_convert_jpeg_sof0) && (marker <= (uint8_t)k_convert_jpeg_sof_last);
  return in_range && (marker != (uint8_t)k_convert_jpeg_dht) &&
         (marker != (uint8_t)k_convert_jpeg_jpg) && (marker != (uint8_t)k_convert_jpeg_dac);
}

RA8_INTERNAL
static ra8_err_t
internal_jpeg_marker(const ra8_fmt_source_t* source, uint64_t* offset, uint8_t* marker)
{
  uint8_t byte = 0U;
  do {
    const ra8_err_t rc = internal_read_exact(source, (*offset)++, &byte, 1U);
    if (rc != k_ra8_ok) {
      return rc;
    }
  } while (byte != (uint8_t)k_convert_marker);
  do {
    const ra8_err_t rc = internal_read_exact(source, (*offset)++, &byte, 1U);
    if (rc != k_ra8_ok) {
      return rc;
    }
  } while (byte == (uint8_t)k_convert_marker);
  if (byte == 0U) {
    return k_ra8_err_protocol_error;
  }
  *marker = byte;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_jpeg_sof0(const ra8_fmt_source_t* source,
                                    uint64_t                payload,
                                    uint16_t                segment_len,
                                    uint16_t*               out_w,
                                    uint16_t*               out_h)
{
  uint8_t fields[5U];
  if (segment_len < 8U) {
    return k_ra8_err_protocol_error;
  }
  ra8_err_t rc = internal_read_exact(source, payload, fields, sizeof(fields));
  if (rc != k_ra8_ok) {
    return rc;
  }
  const uint16_t height = internal_be16(&fields[1]);
  const uint16_t width  = internal_be16(&fields[3]);
  if (fields[0] != (uint8_t)k_convert_jpeg_8bit) {
    return k_ra8_err_not_supported;
  }
  if ((width == 0U) || (height == 0U) || ((uint32_t)width > (uint32_t)k_jof_max_dim) ||
      ((uint32_t)height > (uint32_t)k_jof_max_dim)) {
    return k_ra8_err_invalid_size;
  }
  *out_w = width;
  *out_h = height;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_jpeg_dims(const ra8_fmt_source_t* source, uint16_t* out_w, uint16_t* out_h)
{
  uint64_t offset = 2U;
  while (offset < source->size) {
    uint8_t   marker = 0U;
    ra8_err_t rc     = internal_jpeg_marker(source, &offset, &marker);
    if (rc != k_ra8_ok) {
      return rc;
    }
    const bool standalone =
      (marker == (uint8_t)k_convert_jpeg_soi) || (marker == (uint8_t)k_convert_jpeg_tem) ||
      ((marker >= (uint8_t)k_convert_jpeg_rst_lo) && (marker <= (uint8_t)k_convert_jpeg_rst_hi));
    if (standalone) {
      continue;
    }
    if ((marker == (uint8_t)k_convert_jpeg_eoi) || (marker == (uint8_t)k_convert_jpeg_sos)) {
      return k_ra8_err_protocol_error;
    }
    uint8_t length_bytes[2U];
    rc = internal_read_exact(source, offset, length_bytes, sizeof(length_bytes));
    if (rc != k_ra8_ok) {
      return rc;
    }
    const uint16_t segment_len = internal_be16(length_bytes);
    if (segment_len < 2U) {
      return k_ra8_err_protocol_error;
    }
    if (internal_is_sof(marker)) {
      return (marker == (uint8_t)k_convert_jpeg_sof0)
               ? internal_jpeg_sof0(source, offset + 2U, segment_len, out_w, out_h)
               : k_ra8_err_not_supported;
    }
    offset += segment_len;
    if (offset > source->size) {
      return k_ra8_err_protocol_error;
    }
  }
  return k_ra8_err_protocol_error;
}

RA8_INTERNAL
static ra8_err_t
internal_png_dims(const uint8_t prefix[k_convert_png_dims_end], uint16_t* out_w, uint16_t* out_h)
{
  const uint32_t width  = internal_be32(&prefix[k_convert_png_w]);
  const uint32_t height = internal_be32(&prefix[k_convert_png_h]);
  if ((width == 0U) || (height == 0U) || (width > (uint32_t)k_jof_max_dim) ||
      (height > (uint32_t)k_jof_max_dim)) {
    return k_ra8_err_invalid_size;
  }
  *out_w = (uint16_t)width;
  *out_h = (uint16_t)height;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_probe(const ra8_fmt_source_t* source,
                                convert_kind_t*         kind,
                                uint16_t*               out_w,
                                uint16_t*               out_h)
{
  static const uint8_t png_magic[8U] = {k_convert_png_sig_high,
                                        'P',
                                        'N',
                                        'G',
                                        k_convert_png_sig_cr,
                                        k_convert_png_sig_lf,
                                        k_convert_png_sig_sub,
                                        k_convert_png_sig_lf};
  uint8_t              prefix[k_convert_probe_bytes];
  size_t               count = sizeof(prefix);
  if (source->size < (uint64_t)count) {
    count = (size_t)source->size;
  }
  if (count < k_convert_probe_min) {
    return k_ra8_err_not_supported;
  }
  ra8_err_t rc = internal_read_exact(source, 0U, prefix, count);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if ((prefix[0] == (uint8_t)k_convert_marker) && (prefix[1] == (uint8_t)k_convert_jpeg_soi)) {
    *kind = k_convert_kind_jpeg;
    return internal_jpeg_dims(source, out_w, out_h);
  }
  if (memcmp(prefix, png_magic, sizeof(png_magic)) == 0) {
    if (count < (size_t)k_convert_png_dims_end) {
      return k_ra8_err_not_supported;
    }
    *kind = k_convert_kind_png;
    return internal_png_dims(prefix, out_w, out_h);
  }
  if ((memcmp(prefix, "RIFF", 4U) == 0) && (memcmp(&prefix[8], "WEBP", 4U) == 0)) {
    uint32_t width  = 0U;
    uint32_t height = 0U;
    rc              = ra8_webp_get_info(prefix, count, &width, &height);
    if (rc != k_ra8_ok) {
      return rc;
    }
    if ((width == 0U) || (height == 0U) || (width > (uint32_t)k_jof_max_dim) ||
        (height > (uint32_t)k_jof_max_dim)) {
      return k_ra8_err_invalid_size;
    }
    *kind  = k_convert_kind_webp;
    *out_w = (uint16_t)width;
    *out_h = (uint16_t)height;
    return k_ra8_ok;
  }
  return k_ra8_err_not_supported;
}

RA8_INTERNAL
static ra8_err_t internal_pull(void* ctx, uint8_t* bytes, size_t cap, size_t* got)
{
  convert_pull_t* pull = (convert_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;
  }
  uint64_t remain = pull->source->size - pull->offset;
  if ((uint64_t)cap > remain) {
    cap = (size_t)remain;
  }
  const 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) {
    return k_ra8_err_protocol_error;
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_append(void* ctx, const uint8_t* bytes, size_t len)
{
  ra8_fmt_transaction_t* transaction = (ra8_fmt_transaction_t*)ctx;
  return transaction->ops->append(transaction->ctx, bytes, len);
}

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

RA8_INTERNAL
static ra8_err_t internal_text(const ra8_fmt_sink_t* report, const char* text)
{
  return report->write(report->ctx, (const uint8_t*)text, strlen(text));
}

RA8_INTERNAL
static ra8_err_t internal_u64(const ra8_fmt_sink_t* report, uint64_t value)
{
  char   reverse[k_convert_decimal_max];
  size_t count = 0U;
  do {
    reverse[count++] = (char)('0' + (char)(value % k_convert_decimal_base));
    value /= k_convert_decimal_base;
  } while (value != 0U);
  char text[k_convert_decimal_max];
  for (size_t i = 0U; i < count; ++i) {
    text[i] = reverse[count - i - 1U];
  }
  return report->write(report->ctx, (const uint8_t*)text, count);
}

RA8_INTERNAL
static void
internal_field(const ra8_fmt_sink_t* report, uint64_t value, const char* suffix, ra8_err_t* status)
{
  if (*status == k_ra8_ok) {
    *status = internal_u64(report, value);
  }
  if (*status == k_ra8_ok) {
    *status = internal_text(report, suffix);
  }
}

RA8_INTERNAL
static ra8_err_t
internal_report(const ra8_fmt_sink_t* report, const jof_info_t* info, const char* output_name)
{
  ra8_err_t rc = internal_text(report, "convert: ");
  internal_field(report, info->width, "x", &rc);
  internal_field(report, info->height, " bpp=", &rc);
  internal_field(report, info->bpp, " band=", &rc);
  internal_field(report, info->tile_h, " tiles=", &rc);
  internal_field(report, info->tile_count, " -> ", &rc);
  if (rc == k_ra8_ok) {
    rc = internal_text(report, output_name);
  }
  if (rc == k_ra8_ok) {
    rc = internal_text(report, " (");
  }
  internal_field(report, info->total_size, " bytes)\n", &rc);
  return rc;
}
 
ra8_err_t ra8_fmt_jof_convert_requirements(const ra8_fmt_source_t*             source,
                                           ra8_fmt_jof_convert_requirements_t* out)
{
  if ((source == nullptr) || (source->read_at == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out                = (ra8_fmt_jof_convert_requirements_t){};
  convert_kind_t kind = k_convert_kind_jpeg;
  ra8_err_t      rc   = internal_probe(source, &kind, &out->width, &out->height);
  if (rc != k_ra8_ok) {
    return rc;
  }
  out->tile_width = out->width;
  out->tile_height =
    (out->height < (uint16_t)k_convert_band_height) ? out->height : (uint16_t)k_convert_band_height;
  out->work_bytes = jof_work_bytes(out->width, out->height, out->tile_width, out->tile_height);
  if (out->work_bytes == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (kind == k_convert_kind_webp) {
    if (source->size > (uint64_t)UINT32_MAX) {
      return k_ra8_err_invalid_size;
    }
    out->webp_work_bytes = jof_webp_work_bytes(out->width, out->height, (uint32_t)source->size);
    if (out->webp_work_bytes == 0U) {
      return k_ra8_err_invalid_size;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_fmt_jof_convert_stream(const ra8_fmt_source_t*                   source,
                                     const ra8_fmt_jof_convert_requirements_t* requirements,
                                     const ra8_fmt_jof_convert_workspace_t*    workspace,
                                     ra8_fmt_transaction_t*                    transaction,
                                     const ra8_fmt_sink_t*                     report,
                                     const char*                               output_name)
{
  if ((source == nullptr) || (source->read_at == nullptr) || (requirements == nullptr) ||
      (workspace == nullptr) || (transaction == nullptr) || (transaction->ops == nullptr) ||
      (transaction->ops->append == nullptr) || (transaction->ops->commit == nullptr) ||
      (transaction->ops->abort == nullptr) || (report == nullptr) || (report->write == nullptr) ||
      (output_name == nullptr)) {
    internal_abort(transaction);
    return k_ra8_err_null_ptr;
  }
  const bool webp_missing = (requirements->webp_work_bytes != 0U) &&
                            ((workspace->webp_work == nullptr) ||
                             (workspace->webp_work_cap < requirements->webp_work_bytes));
  if ((workspace->work == nullptr) || (workspace->work_cap < requirements->work_bytes) ||
      webp_missing) {
    internal_abort(transaction);
    return k_ra8_err_invalid_size;
  }
  convert_pull_t          pull = {.source = source, .offset = 0U};
  const jof_produce_cfg_t cfg  = {
    .pull          = internal_pull,
    .pull_ctx      = &pull,
    .sink          = internal_append,
    .sink_ctx      = transaction,
    .tile_w        = requirements->tile_width,
    .tile_h        = requirements->tile_height,
    .codec         = (uint8_t)k_jof_codec_deflate,
    .max_width     = requirements->width,
    .max_height    = requirements->height,
    .work          = workspace->work,
    .work_cap      = workspace->work_cap,
    .webp_work     = workspace->webp_work,
    .webp_work_cap = workspace->webp_work_cap,
  };
  jof_info_t info = {};
  ra8_err_t  rc   = jof_produce(&cfg, &info);
  if (rc != k_ra8_ok) {
    internal_abort(transaction);
    return rc;
  }
  rc = transaction->ops->commit(transaction->ctx);
  if (rc != k_ra8_ok) {
    internal_abort(transaction);
    return rc;
  }
  return internal_report(report, &info, output_name);
}