ra8_jpeg_sw_encode.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_jpeg_sw.h"
#include "ra8_jpeg_sw_encode_internal.h"
#include "ra8_jpeg_sw_internal.h"
#include "ra8_log.h"

static const char* s_tag = "JPEG_SW";
 
/* ------------------------------------------------------------------ */
/* Encoder quantization reference tables (T.81 Annex K.1) */
/* ------------------------------------------------------------------ */

static const uint8_t s_quant_luma[64] = {
  16, 11,  10,  16, 24, 40, 51, 61, 12,  12,  14,  19,  26, 58, 60, 55,  14,  13,  16,  24, 40, 57,
  69, 56,  14,  17, 22, 29, 51, 87, 80,  62,  18,  22,  37, 56, 68, 109, 103, 77,  24,  35, 55, 64,
  81, 104, 113, 92, 49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98,  112, 100, 103, 99,
};

static const uint8_t s_quant_chroma[64] = {
  17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99,
  99, 99, 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
};
 
/* ------------------------------------------------------------------ */
/* Forward DCT (encoder) */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static void internal_fwd_dct_1d_norm(const int32_t* in, int32_t* out)
{
  for (uint8_t k = 0U; k < (uint8_t)k_ra8_jpeg_block_dim; k++) {
    int64_t s = 0;
    for (uint8_t n = 0U; n < (uint8_t)k_ra8_jpeg_block_dim; n++) {
      s += (int64_t)in[n] * (int64_t)s_dct_cos_q14[k][n];
    }
    /* s is Q14*Q0 = Q14; multiply by Q14 weight -> Q28; round to Q0. */
    int64_t r =
      ((s * (int64_t)s_dct_w_q14[k]) + (1LL << k_jpeg_idct_p1_bias_sh)) >> k_jpeg_idct_p1_sh;
    out[k] = (int32_t)r;
  }
}

RA8_INTERNAL static void internal_fdct8x8(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_fwd_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_fwd_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];
    }
  }
}
 
/* ------------------------------------------------------------------ */
/* Quantization */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static uint16_t internal_enc_quality_scale(uint8_t q)
{
  if (q < (uint8_t)k_ra8_jpeg_quality_pivot) {
    return (uint16_t)(k_jpeg_q_scale_low / q);
  }
  return (uint16_t)(k_jpeg_q_scale_high - (2U * (uint16_t)q));
}

RA8_INTERNAL static void internal_enc_scale_qtab(const uint8_t* base, uint8_t* dst, uint16_t scale)
{
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_jpeg_block_size; i++) {
    uint32_t t = (((uint32_t)base[i] * (uint32_t)scale) + k_jpeg_q_round_bias) / k_jpeg_q_percent;
    if (t < 1U) {
      t = 1U;
    } else if (t > (uint32_t)k_ra8_jpeg_pixel_max) {
      t = (uint32_t)k_ra8_jpeg_pixel_max;
    }
    dst[i] = (uint8_t)t;
  }
}

RA8_INTERNAL static uint8_t internal_enc_bits_needed(int32_t v)
{
  uint32_t a = (v < 0) ? (uint32_t)(-v) : (uint32_t)v;
  uint8_t  n = 0U;
  while (a != 0U) {
    a >>= 1U;
    n++;
  }
  return n;
}

RA8_INTERNAL static int32_t internal_enc_quantize(int32_t v, uint8_t qv)
{
  int32_t q = (int32_t)qv;
  if (q == 0) {
    q = 1;
  }
  if (v < 0) {
    int32_t a = -v + (q >> 1);
    return -(a / q);
  }
  return (v + (q >> 1)) / q;
}
 
/* ------------------------------------------------------------------ */
/* Per-block Huffman emission */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static void internal_enc_block_ac(ra8_jpeg_enc_ctx_t* e,
                                               const int32_t*      z,
                                               const uint16_t*     ac_codes,
                                               const uint8_t*      ac_sizes)
{
  uint8_t run = 0U;
  for (uint8_t k = 1U; k < (uint8_t)k_ra8_jpeg_block_size; k++) {
    if (z[k] == 0) {
      run++;
      continue;
    }
    while (run >= 16U) {
      /* ZRL = 0xF0. */
      priv_jpeg_sw_enc_put_bits(e,
                                (uint32_t)ac_codes[k_jpeg_zrl_symbol],
                                ac_sizes[k_jpeg_zrl_symbol]);
      run = (uint8_t)(run - 16U);
    }
    uint8_t mb  = internal_enc_bits_needed(z[k]);
    uint8_t sym = (uint8_t)((run << k_ra8_jpeg_nibble_shift) | mb);
    priv_jpeg_sw_enc_put_bits(e, (uint32_t)ac_codes[sym], ac_sizes[sym]);
    int32_t v = (z[k] < 0) ? (z[k] - 1) : z[k];
    priv_jpeg_sw_enc_put_bits(e, (uint32_t)v & ((1U << mb) - 1U), mb);
    run = 0U;
  }
  if (run > 0U) {
    /* EOB = 0x00. */
    priv_jpeg_sw_enc_put_bits(e, (uint32_t)ac_codes[0U], ac_sizes[0U]);
  }
}

RA8_INTERNAL static void internal_enc_block(ra8_jpeg_enc_ctx_t* e,
                                            const int32_t*      spatial,
                                            const uint8_t*      qtab,
                                            uint8_t             comp_idx,
                                            const uint16_t*     dc_codes,
                                            const uint8_t*      dc_sizes,
                                            const uint16_t*     ac_codes,
                                            const uint8_t*      ac_sizes)
{
  int32_t blk[(uint32_t)k_ra8_jpeg_block_size];
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_jpeg_block_size; i++) {
    blk[i] = spatial[i];
  }
  internal_fdct8x8(blk);
 
  /* Quantize in zig-zag order. */
  int32_t z[(uint32_t)k_ra8_jpeg_block_size];
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_jpeg_block_size; i++) {
    z[i] = internal_enc_quantize(blk[s_zigzag[i]], qtab[s_zigzag[i]]);
  }
 
  /* DC differential. */
  int32_t diff         = z[0] - e->dc_pred[comp_idx];
  e->dc_pred[comp_idx] = z[0];
  uint8_t nb           = internal_enc_bits_needed(diff);
  priv_jpeg_sw_enc_put_bits(e, (uint32_t)dc_codes[nb], dc_sizes[nb]);
  if (nb != 0U) {
    int32_t v = (diff < 0) ? (diff - 1) : diff;
    priv_jpeg_sw_enc_put_bits(e, (uint32_t)v & ((1U << nb) - 1U), nb);
  }
 
  /* AC. */
  internal_enc_block_ac(e, z, ac_codes, ac_sizes);
}
 
/* ------------------------------------------------------------------ */
/* RGB -> YCbCr conversion and block sampling */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static void
internal_enc_rgb_to_ycc_row(const uint8_t* rgb, uint16_t n, int32_t* y, int32_t* cb, int32_t* cr)
{
  for (uint16_t i = 0U; i < n; i++) {
    uint32_t px = (uint32_t)i * (uint32_t)k_ra8_jpeg_rgb_components;
    int32_t  r  = (int32_t)rgb[px];
    int32_t  g  = (int32_t)rgb[px + 1U];
    int32_t  b  = (int32_t)rgb[px + 2U];
    y[i]        = (((int32_t)k_ra8_jpeg_yr * r) + ((int32_t)k_ra8_jpeg_yg * g) +
                   ((int32_t)k_ra8_jpeg_yb * b)) >>
                  k_ra8_jpeg_yuv_shift;
    cb[i]       = ((((int32_t)k_ra8_jpeg_cbr * r) + ((int32_t)k_ra8_jpeg_cbg * g) +
                    ((int32_t)k_ra8_jpeg_cbb * b)) >>
                   k_ra8_jpeg_yuv_shift) +
                  (int32_t)k_ra8_jpeg_level_offset;
    cr[i]       = ((((int32_t)k_ra8_jpeg_crr * r) + ((int32_t)k_ra8_jpeg_crg * g) +
                    ((int32_t)k_ra8_jpeg_crb * b)) >>
                   k_ra8_jpeg_yuv_shift) +
                  (int32_t)k_ra8_jpeg_level_offset;
  }
}

RA8_INTERNAL static void internal_enc_sample_y_block(const int32_t* yplane,
                                                     uint16_t       plane_w,
                                                     uint16_t       plane_h,
                                                     uint16_t       x0,
                                                     uint16_t       y0,
                                                     int32_t*       out)
{
  for (uint8_t r = 0U; r < (uint8_t)k_ra8_jpeg_block_dim; r++) {
    uint16_t sy = (uint16_t)(y0 + r);
    if (sy >= plane_h) {
      sy = (uint16_t)(plane_h - 1U);
    }
    for (uint8_t c = 0U; c < (uint8_t)k_ra8_jpeg_block_dim; c++) {
      uint16_t sx = (uint16_t)(x0 + c);
      if (sx >= plane_w) {
        sx = (uint16_t)(plane_w - 1U);
      }
      out[(r * (uint8_t)k_ra8_jpeg_block_dim) + c] =
        yplane[((uint32_t)sy * plane_w) + sx] - (int32_t)k_ra8_jpeg_level_offset;
    }
  }
}

RA8_INTERNAL static int32_t internal_enc_avg_2x2(const int32_t* cplane,
                                                 uint16_t       plane_w,
                                                 uint16_t       plane_h,
                                                 uint16_t       sx,
                                                 uint16_t       sy)
{
  int32_t s = 0;
  uint8_t n = 0U;
  for (uint8_t dy = 0U; dy < 2U; dy++) {
    for (uint8_t dx = 0U; dx < 2U; dx++) {
      uint16_t yy = (uint16_t)(sy + dy);
      uint16_t xx = (uint16_t)(sx + dx);
      if (yy >= plane_h) {
        yy = (uint16_t)(plane_h - 1U);
      }
      if (xx >= plane_w) {
        xx = (uint16_t)(plane_w - 1U);
      }
      s += cplane[((uint32_t)yy * plane_w) + xx];
      n++;
    }
  }
  return s / (int32_t)n;
}

RA8_INTERNAL static void internal_enc_sample_c_block_420(const int32_t* cplane,
                                                         uint16_t       plane_w,
                                                         uint16_t       plane_h,
                                                         uint16_t       x0,
                                                         uint16_t       y0,
                                                         int32_t*       out)
{
  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++) {
      uint16_t sy = (uint16_t)(y0 + (r * 2U));
      uint16_t sx = (uint16_t)(x0 + (c * 2U));
      out[(r * (uint8_t)k_ra8_jpeg_block_dim) + c] =
        internal_enc_avg_2x2(cplane, plane_w, plane_h, sx, sy) - (int32_t)k_ra8_jpeg_level_offset;
    }
  }
}

RA8_INTERNAL static void internal_enc_convert_strip_to_ycc(const uint8_t* rgb,
                                                           uint16_t       w,
                                                           uint16_t       h,
                                                           uint16_t       pad_w,
                                                           uint16_t       mby,
                                                           int32_t*       y_strip,
                                                           int32_t*       cb_strip,
                                                           int32_t*       cr_strip,
                                                           uint8_t*       tmp_rgb)
{
  for (uint8_t r = 0U; r < 16U; r++) {
    uint16_t src_y = mby + r;
    if (src_y >= h) {
      src_y = (uint16_t)(h - 1U);
    }
    for (uint16_t c = 0U; c < pad_w; c++) {
      uint16_t src_x = c;
      if (src_x >= w) {
        src_x = (uint16_t)(w - 1U);
      }
      uint32_t sidx =
        (((uint32_t)src_y * (uint32_t)w) + (uint32_t)src_x) * (uint32_t)k_ra8_jpeg_rgb_components;
      uint32_t didx      = (uint32_t)c * (uint32_t)k_ra8_jpeg_rgb_components;
      tmp_rgb[didx]      = rgb[sidx + 0U];
      tmp_rgb[didx + 1U] = rgb[sidx + 1U];
      tmp_rgb[didx + 2U] = rgb[sidx + 2U];
    }
    internal_enc_rgb_to_ycc_row(tmp_rgb,
                                pad_w,
                                &y_strip[(size_t)r * pad_w],
                                &cb_strip[(size_t)r * pad_w],
                                &cr_strip[(size_t)r * pad_w]);
  }
}

RA8_INTERNAL static void internal_enc_encode_mcu_row(ra8_jpeg_enc_ctx_t* e,
                                                     uint16_t            pad_w,
                                                     const int32_t*      y_strip,
                                                     const int32_t*      cb_strip,
                                                     const int32_t*      cr_strip)
{
  for (uint16_t mbx = 0U; mbx < pad_w; mbx = (uint16_t)(mbx + 16U)) {
    int32_t blk[(uint32_t)k_ra8_jpeg_block_size];
    /* 4 luma blocks: (0,0) (0,8) (8,0) (8,8). */
    for (uint8_t by = 0U; by < 2U; by++) {
      for (uint8_t bx = 0U; bx < 2U; bx++) {
        internal_enc_sample_y_block(y_strip,
                                    pad_w,
                                    16U,
                                    (uint16_t)(mbx + (bx * 8U)),
                                    (uint16_t)(by * 8U),
                                    blk);
        internal_enc_block(e,
                           blk,
                           e->qy,
                           0U,
                           e->code_dc_l,
                           e->size_dc_l,
                           e->code_ac_l,
                           e->size_ac_l);
      }
    }
    internal_enc_sample_c_block_420(cb_strip, pad_w, 16U, mbx, 0U, blk);
    internal_enc_block(e, blk, e->qc, 1U, e->code_dc_c, e->size_dc_c, e->code_ac_c, e->size_ac_c);
    internal_enc_sample_c_block_420(cr_strip, pad_w, 16U, mbx, 0U, blk);
    internal_enc_block(e, blk, e->qc, 2U, e->code_dc_c, e->size_dc_c, e->code_ac_c, e->size_ac_c);
  }
}
 
/* ------------------------------------------------------------------ */
/* Top-level driver and public API */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static ra8_err_t
internal_enc_run(ra8_jpeg_enc_ctx_t* e, const uint8_t* rgb, uint16_t w, uint16_t h, uint8_t quality)
{
  /* Build quantization tables. */
  uint16_t qs = internal_enc_quality_scale(quality);
  internal_enc_scale_qtab(s_quant_luma, e->qy, qs);
  internal_enc_scale_qtab(s_quant_chroma, e->qc, qs);
 
  /* Build Huffman code tables from K.3.3 BITS/VALUES. */
  uint16_t total_dc_l;
  uint16_t total_ac_l;
  uint16_t total_dc_c;
  uint16_t total_ac_c;
  priv_jpeg_sw_enc_build_huff(e, &total_dc_l, &total_ac_l, &total_dc_c, &total_ac_c);
 
  priv_jpeg_sw_enc_headers(e, w, h, total_dc_l, total_ac_l, total_dc_c, total_ac_c);
 
  /* Convert source rows to YCbCr 16-row strips. Static buffers
   * keep the host stack small while still respecting NASA Rule 3
   * (no heap). The encoder is single-threaded, so file-scope
   * sharing is safe. */
  uint16_t pad_w = (uint16_t)((w + k_jpeg_mcu_align) & ~k_jpeg_mcu_align);
  uint16_t pad_h = (uint16_t)((h + k_jpeg_mcu_align) & ~k_jpeg_mcu_align);
  if ((uint32_t)pad_w > (uint32_t)k_ra8_jpeg_enc_max_w) {
    return k_ra8_err_invalid_arg;
  }
  static int32_t s_y_strip[16U * (uint32_t)k_ra8_jpeg_enc_max_w];
  static int32_t s_cb_strip[16U * (uint32_t)k_ra8_jpeg_enc_max_w];
  static int32_t s_cr_strip[16U * (uint32_t)k_ra8_jpeg_enc_max_w];
  static uint8_t s_tmp_rgb[3U * (uint32_t)k_ra8_jpeg_enc_max_w];
 
  for (uint16_t mby = 0U; mby < pad_h; mby = (uint16_t)(mby + 16U)) {
    internal_enc_convert_strip_to_ycc(rgb,
                                      w,
                                      h,
                                      pad_w,
                                      mby,
                                      s_y_strip,
                                      s_cb_strip,
                                      s_cr_strip,
                                      s_tmp_rgb);
    internal_enc_encode_mcu_row(e, pad_w, s_y_strip, s_cb_strip, s_cr_strip);
  }
 
  priv_jpeg_sw_enc_flush_bits(e);
  priv_jpeg_sw_enc_emit_u16(e, (uint16_t)k_ra8_jpeg_marker_eoi);
 
  if (e->overflow) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_jpeg_sw_encode(const uint8_t* rgb_buf,
                             uint16_t       width,
                             uint16_t       height,
                             uint8_t        quality,
                             uint8_t*       out_buf,
                             uint32_t       out_buf_len,
                             uint32_t*      out_len)
{
  RA8_CHECK_NULL_PTR(rgb_buf, s_tag, "rgb_buf is NULL");
  RA8_CHECK_NULL_PTR(out_buf, s_tag, "out_buf is NULL");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len is NULL");
  *out_len = 0U;
  if (width == 0U || height == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (quality < (uint8_t)k_ra8_jpeg_sw_quality_min ||
      quality > (uint8_t)k_ra8_jpeg_sw_quality_max) {
    return k_ra8_err_invalid_arg;
  }
 
  /* Encoder context contains 2KiB of Huffman code/size LUTs; allocate
   * static to avoid the project's stack-usage budget firing. */
  static ra8_jpeg_enc_ctx_t s_e;
  ra8_jpeg_enc_ctx_t*       e = &s_e;
  memset(e, 0, sizeof(*e));
  e->dst = out_buf;
  e->cap = out_buf_len;
 
  ra8_err_t err = internal_enc_run(e, rgb_buf, width, height, quality);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_len = e->pos;
  return k_ra8_ok;
}