jof_png_chunk.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "jof_internal.h"
#include "jof_png_internal.h"
#include "ra8_attributes.h"
#include "ra8_err.h"

RA8_PRIV ra8_err_t priv_jof_png_pull_exact(ra8_png_state_t* st, uint8_t* buf, uint32_t len)
{
  uint32_t done = 0U;
  while (done < len) {
    size_t          got = 0U;
    const ra8_err_t err = st->pull(st->pull_ctx, &buf[done], (size_t)(len - done), &got);
    if (err != k_ra8_ok) {
      return err;
    }
    if (got == 0U) {
      return k_ra8_err_protocol_error;
    }
    done += (uint32_t)got;
  }
  return k_ra8_ok;
}

RA8_PRIV ra8_err_t priv_jof_png_skip(ra8_png_state_t* st, uint32_t len)
{
  uint8_t  scratch[k_ra8_png_skip_chunk];
  uint32_t left = len;
  while (left > 0U) {
    const uint32_t take =
      (left < (uint32_t)k_ra8_png_skip_chunk) ? left : (uint32_t)k_ra8_png_skip_chunk;
    const ra8_err_t err = priv_jof_png_pull_exact(st, scratch, take);
    if (err != k_ra8_ok) {
      return err;
    }
    left -= take;
  }
  return k_ra8_ok;
}

RA8_PRIV ra8_err_t priv_jof_png_chunk_hdr(ra8_png_state_t* st,
                                          uint32_t*        out_len,
                                          uint32_t*        out_type)
{
  uint8_t         hdr[k_ra8_png_chunk_hdr] = {};
  const ra8_err_t err                      = priv_jof_png_pull_exact(st, hdr, sizeof(hdr));
  if (err != k_ra8_ok) {
    return err;
  }
  const uint32_t len  = ((uint32_t)hdr[0] << k_ra8_png_be_sh24) |
                        ((uint32_t)hdr[1] << k_ra8_png_be_sh16) |
                        ((uint32_t)hdr[2] << k_ra8_png_be_sh8) | (uint32_t)hdr[3];
  const uint32_t type = ((uint32_t)hdr[4] << k_ra8_png_be_sh24) |
                        ((uint32_t)hdr[5] << k_ra8_png_be_sh16) |
                        ((uint32_t)hdr[6] << k_ra8_png_be_sh8) | (uint32_t)hdr[7];
  if (len > (uint32_t)k_ra8_png_max_len) {
    return k_ra8_err_protocol_error;
  }
  *out_len  = len;
  *out_type = type;
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static uint8_t internal_png_src_channels(uint8_t color_type)
{
  switch (color_type) {
    case k_ra8_png_color_gray:
      return (uint8_t)k_ra8_png_ch_1;
    case k_ra8_png_color_rgb:
      return (uint8_t)k_ra8_png_ch_3;
    case k_ra8_png_color_pal:
      return (uint8_t)k_ra8_png_ch_1;
    case k_ra8_png_color_ga:
      return (uint8_t)k_ra8_png_ch_2;
    case k_ra8_png_color_rgba:
      return (uint8_t)k_ra8_png_ch_4;
    default:
      return 0U;
  }
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_png_check_ihdr(ra8_png_state_t* st, const uint8_t* ihdr, uint16_t max_w, uint16_t max_h)
{
  const uint32_t w32 = ((uint32_t)ihdr[0] << k_ra8_png_be_sh24) |
                       ((uint32_t)ihdr[1] << k_ra8_png_be_sh16) |
                       ((uint32_t)ihdr[2] << k_ra8_png_be_sh8) | (uint32_t)ihdr[3];
  const uint32_t h32 = ((uint32_t)ihdr[4] << k_ra8_png_be_sh24) |
                       ((uint32_t)ihdr[5] << k_ra8_png_be_sh16) |
                       ((uint32_t)ihdr[6] << k_ra8_png_be_sh8) | (uint32_t)ihdr[7];
  if ((w32 == 0U) || (w32 > (uint32_t)max_w)) {
    return k_ra8_err_invalid_size;
  }
  if ((h32 == 0U) || (h32 > (uint32_t)max_h)) {
    return k_ra8_err_invalid_size;
  }
  if (ihdr[k_ra8_png_ihdr_ofs_depth] != (uint8_t)k_ra8_png_depth_8) {
    return k_ra8_err_not_supported;
  }
  st->src_ch = internal_png_src_channels(ihdr[k_ra8_png_ihdr_ofs_color]);
  if (st->src_ch == 0U) {
    return k_ra8_err_not_supported;
  }
  if (ihdr[k_ra8_png_ihdr_ofs_compress] != 0U) {
    return k_ra8_err_not_supported;
  }
  if (ihdr[k_ra8_png_ihdr_ofs_filter] != 0U) {
    return k_ra8_err_not_supported;
  }
  if (ihdr[k_ra8_png_ihdr_ofs_interlace] != 0U) {
    return k_ra8_err_not_supported; /* Adam7 breaks streaming; fail closed */
  }
  st->w          = (uint16_t)w32;
  st->h          = (uint16_t)h32;
  st->color_type = ihdr[k_ra8_png_ihdr_ofs_color];
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_png_parse_ihdr(ra8_png_state_t* st, uint16_t max_w, uint16_t max_h)
{
  uint32_t  len  = 0U;
  uint32_t  type = 0U;
  ra8_err_t err  = priv_jof_png_chunk_hdr(st, &len, &type);
  if (err != k_ra8_ok) {
    return err;
  }
  if ((type != (uint32_t)k_ra8_png_type_ihdr) || (len != (uint32_t)k_ra8_png_ihdr_len)) {
    return k_ra8_err_protocol_error;
  }
  uint8_t ihdr[k_ra8_png_ihdr_len] = {};
  err                              = priv_jof_png_pull_exact(st, ihdr, sizeof(ihdr));
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_png_check_ihdr(st, ihdr, max_w, max_h);
  if (err != k_ra8_ok) {
    return err;
  }
  return priv_jof_png_skip(st, (uint32_t)k_ra8_png_crc_bytes);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_png_parse_plte(ra8_png_state_t* st, uint32_t len)
{
  if ((len == 0U) || ((len % (uint32_t)k_ra8_png_ch_3) != 0U) ||
      (len > (uint32_t)k_ra8_png_plte_max) || (st->has_plte != 0U)) {
    return k_ra8_err_validation_failed;
  }
  const ra8_err_t err = priv_jof_png_pull_exact(st, st->palette, len);
  if (err != k_ra8_ok) {
    return err;
  }
  st->plte_count = (uint16_t)(len / (uint32_t)k_ra8_png_ch_3);
  st->has_plte   = 1U;
  return priv_jof_png_skip(st, (uint32_t)k_ra8_png_crc_bytes);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_png_parse_trns(ra8_png_state_t* st, uint32_t len)
{
  if (st->color_type != (uint8_t)k_ra8_png_color_pal) {
    return k_ra8_err_not_supported;
  }
  if ((len > (uint32_t)k_ra8_png_trns_max) || (st->has_plte == 0U) || (st->has_trns != 0U)) {
    return k_ra8_err_validation_failed;
  }
  const ra8_err_t err = priv_jof_png_pull_exact(st, st->trns, len);
  if (err != k_ra8_ok) {
    return err;
  }
  st->trns_count = (uint16_t)len;
  st->has_trns   = 1U;
  return priv_jof_png_skip(st, (uint32_t)k_ra8_png_crc_bytes);
}

RA8_PRIV ra8_err_t priv_jof_png_prologue(ra8_png_state_t* st, uint16_t max_w, uint16_t max_h)
{
  static const uint8_t s_png_sig[k_ra8_png_sig_bytes] = {k_ra8_png_sig_high,
                                                         'P',
                                                         'N',
                                                         'G',
                                                         k_ra8_png_sig_cr,
                                                         k_ra8_png_sig_lf,
                                                         k_ra8_png_sig_sub,
                                                         k_ra8_png_sig_lf};
  uint8_t              sig[k_ra8_png_sig_bytes]       = {};
  const ra8_err_t      err = priv_jof_png_pull_exact(st, sig, sizeof(sig));
  if (err != k_ra8_ok) {
    return err;
  }
  if (memcmp(sig, s_png_sig, sizeof(sig)) != 0) {
    return k_ra8_err_protocol_error;
  }
  return internal_png_parse_ihdr(st, max_w, max_h);
}

RA8_PRIV ra8_err_t priv_jof_png_pre_idat(ra8_png_state_t* st, uint32_t len, uint32_t type)
{
  if (type == (uint32_t)k_ra8_png_type_plte) {
    return internal_png_parse_plte(st, len);
  }
  if (type == (uint32_t)k_ra8_png_type_trns) {
    return internal_png_parse_trns(st, len);
  }
  if (type == (uint32_t)k_ra8_png_type_iend) {
    return k_ra8_err_protocol_error; /* IEND before any IDAT */
  }
  return priv_jof_png_skip(st, len + (uint32_t)k_ra8_png_crc_bytes);
}

RA8_PRIV ra8_err_t priv_jof_png_finish(ra8_png_state_t* st)
{
  uint32_t len  = st->pending_len;
  uint32_t type = st->pending_type;
  if (st->pending_valid == 0U) {
    ra8_err_t err = priv_jof_png_skip(st, (uint32_t)k_ra8_png_crc_bytes); /* last IDAT's CRC */
    if (err != k_ra8_ok) {
      return err;
    }
    err = priv_jof_png_chunk_hdr(st, &len, &type);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  for (uint32_t guard = 0U; guard < (uint32_t)k_ra8_png_max_chunks; guard++) {
    if (type == (uint32_t)k_ra8_png_type_iend) {
      return k_ra8_ok;
    }
    if (type == (uint32_t)k_ra8_png_type_idat) {
      return k_ra8_err_protocol_error; /* IDAT after the stream completed */
    }
    ra8_err_t err = priv_jof_png_skip(st, len + (uint32_t)k_ra8_png_crc_bytes);
    if (err != k_ra8_ok) {
      return err;
    }
    err = priv_jof_png_chunk_hdr(st, &len, &type);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_err_protocol_error;
}