ra8_jpeg_sw.c

Go to the documentation of this file.

 
#include "ra8_jpeg_sw.h"
 
#include <stdint.h> // ra8-keep-include: `uint8_t` used directly
 
#include "ra8_attributes.h" // ra8-keep-include: `RA8_INTERNAL` and `RA8_PRIV` used directly
#include "ra8_check.h"
#include "ra8_err.h" // ra8-keep-include: `ra8_err_t` used directly
#include "ra8_jpeg_sw_internal.h"

static const char* s_tag = "JPEG_SW";
 
#ifdef __ARM_FEATURE_MVE
#include <arm_mve.h>
#endif
 
/* ------------------------------------------------------------------ */
/* Bit reader (decoder-side) */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static void internal_br_fill(ra8_jpeg_bitreader_t* br)
{
  while (br->nbits <= k_jpeg_reservoir_lo && !br->had_eoi) {
    if (br->pos >= br->len) {
      br->had_eoi = 1U;
      return;
    }
    uint8_t b = br->buf[br->pos];
    br->pos++;
    if (b == (uint8_t)k_ra8_jpeg_marker_byte) {
      if (br->pos >= br->len) {
        br->had_eoi = 1U;
        return;
      }
      uint8_t s = br->buf[br->pos];
      br->pos++;
      if (s != 0U) {
        /* A real marker; rewind so caller can inspect. */
        br->pos -= 2U;
        br->had_eoi = 1U;
        return;
      }
      /* Stuffed 0xFF byte. */
    }
    br->acc   = (br->acc << k_ra8_jpeg_byte_shift) | (uint32_t)b;
    br->nbits = (uint8_t)(br->nbits + k_ra8_jpeg_byte_shift);
  }
}

RA8_PRIV int32_t priv_jpeg_sw_br_get_bits(ra8_jpeg_bitreader_t* br, uint8_t n)
{
  if (n == 0U) {
    return 0;
  }
  if (br->nbits < n) {
    internal_br_fill(br);
    if (br->nbits < n) {
      return -1;
    }
  }
  uint32_t v = (br->acc >> (br->nbits - n)) & ((1U << n) - 1U);
  br->nbits  = (uint8_t)(br->nbits - n);
  br->acc &= (br->nbits == 0U) ? 0U : ((1U << br->nbits) - 1U);
  return (int32_t)v;
}
 
/* ------------------------------------------------------------------ */
/* Huffman tables */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static void internal_htab_build_lookup(ra8_jpeg_htab_t* h)
{
  uint16_t j = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_jpeg_huff_lengths; i++) {
    if (h->bits[i] == 0U) {
      h->maxcode[i] = -1;
    } else {
      h->valptr[i]  = j;
      h->mincode[i] = (int32_t)h->huffcode[j];
      j             = (uint16_t)((j + h->bits[i]) - 1U);
      h->maxcode[i] = (int32_t)h->huffcode[j];
      j++;
    }
  }
}
 
RA8_PRIV void priv_jpeg_sw_htab_build(ra8_jpeg_htab_t* h)
{
  /* T.81 Annex C, "Generation of size table" + "Generation of code
   * table". */
  uint16_t k = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_jpeg_huff_lengths; i++) {
    for (uint8_t j = 0U; j < h->bits[i]; j++) {
      h->huffsize[k] = (uint8_t)(i + 1U);
      k++;
    }
  }
  h->huffsize[k] = 0U;
  h->total       = k;
 
  uint16_t code = 0U;
  uint8_t  si   = (k > 0U) ? h->huffsize[0] : 0U;
  uint16_t kk   = 0U;
  while (h->huffsize[kk] != 0U) {
    while (h->huffsize[kk] == si) {
      h->huffcode[kk] = code;
      code++;
      kk++;
    }
    if (h->huffsize[kk] == 0U) {
      break;
    }
    do {
      code = (uint16_t)(code << 1U);
      si++;
    } while (h->huffsize[kk] != si);
  }
 
  /* T.81 Annex F.2.2.3 mincode/maxcode/valptr build. */
  internal_htab_build_lookup(h);
}

RA8_PRIV int32_t priv_jpeg_sw_htab_decode(ra8_jpeg_bitreader_t* br, const ra8_jpeg_htab_t* h)
{
  internal_br_fill(br);
  if (br->nbits == 0U) {
    return -1;
  }
  /* Single-bit greedy lookup per F.2.2.3 "Decoder code-length
   * algorithm". */
  int32_t code = priv_jpeg_sw_br_get_bits(br, 1U);
  /* After br->nbits == 0 guard above, br->nbits >= 1; br_get_bits(br, 1)
   * with nbits >= 1 always returns 0 or 1 without invoking internal_br_fill, so
   * code < 0 is unreachable on any host input. */
  if (code < 0) {
    return -1; /* GCOVR_EXCL_LINE -- internal_br_receive(nbits>=1) returns 0 or 1 */
  }
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_jpeg_huff_lengths; i++) {
    if (code <= h->maxcode[i]) {
      uint16_t j = (uint16_t)(h->valptr[i] + (uint16_t)(code - h->mincode[i]));
      if (j >= h->total) {
        return -1;
      }
      return (int32_t)h->vals[j];
    }
    int32_t bit = priv_jpeg_sw_br_get_bits(br, 1U);
    if (bit < 0) {
      return -1;
    }
    code = (code << 1) | bit;
  }
  return -1;
}

RA8_PRIV int32_t priv_jpeg_sw_huff_extend(int32_t v, uint8_t n)
{
  if (n == 0U) {
    return 0;
  }
  int32_t vt = 1 << (n - 1U);
  if (v < vt) {
    v += ((int32_t)((uint32_t)-1 << n)) + 1;
  }
  return v;
}
 
/* ------------------------------------------------------------------ */
/* Inverse DCT (decoder) */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static void internal_inv_dct_1d_norm(const int32_t* in, int32_t* out)
{
  for (uint8_t n = 0U; n < (uint8_t)k_ra8_jpeg_block_dim; n++) {
    int64_t s = 0;
    for (uint8_t k = 0U; k < (uint8_t)k_ra8_jpeg_block_dim; k++) {
      int64_t v = (int64_t)in[k] * (int64_t)s_dct_w_q14[k];
      s += (v * (int64_t)s_dct_cos_q14[k][n]) >> k_jpeg_q14_shift;
    }
    int64_t r = (s + (1LL << k_jpeg_idct_p2_bias_sh)) >> k_jpeg_q14_shift;
    out[n]    = (int32_t)r;
  }
}
 
/* Full 8x8 inverse DCT, in place -- see surrounding code and HUM citations. */
RA8_PRIV void priv_jpeg_sw_idct8x8(int32_t* block)
{
  int32_t tmp[(uint32_t)k_ra8_jpeg_block_size];
  int32_t row[(uint32_t)k_ra8_jpeg_block_dim];
  int32_t col[(uint32_t)k_ra8_jpeg_block_dim];
  int32_t out[(uint32_t)k_ra8_jpeg_block_dim];
  for (uint8_t r = 0U; r < (uint8_t)k_ra8_jpeg_block_dim; r++) {
    for (uint8_t c = 0U; c < (uint8_t)k_ra8_jpeg_block_dim; c++) {
      row[c] = block[(r * (uint8_t)k_ra8_jpeg_block_dim) + c];
    }
    internal_inv_dct_1d_norm(row, out);
    for (uint8_t c = 0U; c < (uint8_t)k_ra8_jpeg_block_dim; c++) {
      tmp[(r * (uint8_t)k_ra8_jpeg_block_dim) + c] = out[c];
    }
  }
  for (uint8_t c = 0U; c < (uint8_t)k_ra8_jpeg_block_dim; c++) {
    for (uint8_t r = 0U; r < (uint8_t)k_ra8_jpeg_block_dim; r++) {
      col[r] = tmp[(r * (uint8_t)k_ra8_jpeg_block_dim) + c];
    }
    internal_inv_dct_1d_norm(col, out);
    for (uint8_t r = 0U; r < (uint8_t)k_ra8_jpeg_block_dim; r++) {
      block[(r * (uint8_t)k_ra8_jpeg_block_dim) + c] = out[r];
    }
  }
}
 
/* ------------------------------------------------------------------ */
/* Colour conversion (YCbCr -> RGB) */
/* ------------------------------------------------------------------ */

RA8_PRIV void priv_jpeg_sw_ycc_to_rgb(int32_t  y,
                                      int32_t  cb,
                                      int32_t  cr,
                                      uint8_t* out_r,
                                      uint8_t* out_g,
                                      uint8_t* out_b)
{
  cb -= (int32_t)k_ra8_jpeg_level_offset;
  cr -= (int32_t)k_ra8_jpeg_level_offset;
  int32_t r = y + (((int32_t)k_ra8_jpeg_cr_r * cr) >> k_ra8_jpeg_yuv_shift);
  int32_t g = y + ((((int32_t)k_ra8_jpeg_cb_g * cb) + ((int32_t)k_ra8_jpeg_cr_g * cr)) >>
                   k_ra8_jpeg_yuv_shift);
  int32_t b = y + (((int32_t)k_ra8_jpeg_cb_b * cb) >> k_ra8_jpeg_yuv_shift);
  *out_r    = internal_clamp_u8(r);
  *out_g    = internal_clamp_u8(g);
  *out_b    = internal_clamp_u8(b);
}
 
/* ------------------------------------------------------------------ */
/* Public API: get_dimensions */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static ra8_err_t
internal_dims_next_marker(const uint8_t* jpeg_buf, uint32_t jpeg_len, uint32_t* i, uint16_t* out_mk)
{
  if (jpeg_buf[*i] != (uint8_t)k_ra8_jpeg_marker_byte) {
    return k_ra8_err_protocol_error;
  }
  /* Skip pad bytes. */
  while (*i < jpeg_len && jpeg_buf[*i] == (uint8_t)k_ra8_jpeg_marker_byte) {
    (*i)++;
  }
  if (*i >= jpeg_len) {
    return k_ra8_err_protocol_error;
  }
  uint8_t m = jpeg_buf[*i];
  *out_mk   = (uint16_t)(((uint16_t)k_jpeg_byte_mask << k_ra8_jpeg_byte_shift) | m);
  (*i)++;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_dims_parse_sof0(const uint8_t* jpeg_buf,
                                                       uint32_t       i,
                                                       uint16_t       seglen,
                                                       uint16_t*      out_w,
                                                       uint16_t*      out_h)
{
  if (seglen < 8U) {
    return k_ra8_err_protocol_error;
  }
  uint8_t precision = jpeg_buf[i + 2U];
  if (precision != 8U) {
    return k_ra8_err_not_supported;
  }
  *out_h = internal_read_be16(&jpeg_buf[i + 3U]);
  *out_w = internal_read_be16(&jpeg_buf[i + k_jpeg_sof_dims_off]);
  if (*out_w == 0U || *out_h == 0U) {
    return k_ra8_err_protocol_error;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_dims_step(const uint8_t* jpeg_buf,
                                                 uint32_t       jpeg_len,
                                                 uint32_t*      i,
                                                 bool*          done,
                                                 uint16_t*      out_w,
                                                 uint16_t*      out_h)
{
  uint16_t  mk = 0U;
  ra8_err_t e  = internal_dims_next_marker(jpeg_buf, jpeg_len, i, &mk);
  if (e != k_ra8_ok) {
    return e;
  }
  if (mk == (uint16_t)k_ra8_jpeg_marker_soi || mk == (uint16_t)k_ra8_jpeg_marker_eoi) {
    return k_ra8_ok;
  }
  if (*i + 2U > jpeg_len) {
    return k_ra8_err_protocol_error;
  }
  uint16_t seglen = internal_read_be16(&jpeg_buf[*i]);
  if (seglen < 2U || (uint32_t)seglen > jpeg_len - *i) {
    return k_ra8_err_protocol_error;
  }
  if (mk == (uint16_t)k_ra8_jpeg_marker_sof0) {
    e = internal_dims_parse_sof0(jpeg_buf, *i, seglen, out_w, out_h);
    if (e == k_ra8_ok) {
      *done = true;
    }
    return e;
  }
  if (mk >= k_jpeg_marker_sof_lo && mk <= k_jpeg_marker_sof_hi &&
      mk != (uint16_t)k_ra8_jpeg_marker_dht && mk != k_jpeg_marker_jpg) {
    return k_ra8_err_not_supported;
  }
  *i += seglen;
  return k_ra8_ok;
}
 
ra8_err_t ra8_jpeg_sw_get_dimensions(const uint8_t* jpeg_buf,
                                     uint32_t       jpeg_len,
                                     uint16_t*      out_w,
                                     uint16_t*      out_h)
{
  RA8_CHECK_NULL_PTR(jpeg_buf, s_tag, "jpeg_buf is NULL");
  RA8_CHECK_NULL_PTR(out_w, s_tag, "out_w is NULL");
  RA8_CHECK_NULL_PTR(out_h, s_tag, "out_h is NULL");
  if (jpeg_len < 4U) {
    return k_ra8_err_invalid_size;
  }
  if (internal_read_be16(jpeg_buf) != (uint16_t)k_ra8_jpeg_marker_soi) {
    return k_ra8_err_protocol_error;
  }
  uint32_t i = 2U;
  while (i + 4U <= jpeg_len) {
    bool      done = false;
    ra8_err_t e    = internal_dims_step(jpeg_buf, jpeg_len, &i, &done, out_w, out_h);
    if (e != k_ra8_ok) {
      return e;
    }
    if (done) {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_protocol_error;
}