ra8_jpeg_sw_stream.c

Go to the documentation of this file.

 
#include <stddef.h>
#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_internal.h"
#include "ra8_log.h"

static const char* s_tag = "JPEG_SW";

typedef enum : uint16_t {
  k_ra8_jpeg_stream_max_markers = 1024U, 
  k_ra8_jpeg_stream_soi_bytes   = 2U,    
  k_ra8_jpeg_stream_gray_ch     = 1U,    
  k_ra8_jpeg_stream_rgb_ch      = 3U,    
} ra8_jpeg_stream_const_t;

typedef struct {
  ra8_jpeg_sw_pull_fn pull;     
  void*               pull_ctx; 
  uint8_t*            win;      
  uint32_t            win_cap;  
  uint32_t            win_len;  
  uint8_t             eof;      
 
  ra8_jpeg_sw_rows_fn on_rows; 
  void*               cb_ctx;  
 
  uint8_t* stripe;     
  uint32_t stripe_cap; 
  uint8_t  channels;   
  uint16_t mcu_w;      
  uint16_t mcu_h;      
  uint16_t mcus_x;     
  uint16_t mcus_y;     
 
  ra8_jpeg_dec_ctx_t dec; 
} ra8_jpeg_stream_state_t;

static ra8_jpeg_stream_state_t s_js;

RA8_INTERNAL static ra8_err_t internal_js_refill(ra8_jpeg_stream_state_t* st)
{
  while ((st->eof == 0U) && (st->win_len < st->win_cap)) {
    size_t          got = 0U;
    const ra8_err_t err =
      st->pull(st->pull_ctx, &st->win[st->win_len], (size_t)(st->win_cap - st->win_len), &got);
    if (err != k_ra8_ok) {
      return err;
    }
    if (got == 0U) {
      st->eof = 1U;
    } else {
      st->win_len += (uint32_t)got;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_js_slide(ra8_jpeg_stream_state_t* st, uint32_t consumed)
{
  if (consumed > 0U) {
    (void)memmove(st->win, &st->win[consumed], (size_t)(st->win_len - consumed));
    st->win_len -= consumed;
  }
  return internal_js_refill(st);
}

RA8_INTERNAL static ra8_err_t internal_js_bind_geometry(ra8_jpeg_stream_state_t* st,
                                                        ra8_jpeg_sw_geom_fn      on_geom)
{
  const ra8_jpeg_dec_ctx_t* d = &st->dec;
  st->channels =
    (d->ncomp == 1U) ? (uint8_t)k_ra8_jpeg_stream_gray_ch : (uint8_t)k_ra8_jpeg_stream_rgb_ch;
  st->mcu_w  = (uint16_t)((uint16_t)k_ra8_jpeg_block_dim * d->hmax);
  st->mcu_h  = (uint16_t)((uint16_t)k_ra8_jpeg_block_dim * d->vmax);
  st->mcus_x = (uint16_t)((d->width + st->mcu_w - 1U) / st->mcu_w);
  st->mcus_y = (uint16_t)((d->height + st->mcu_h - 1U) / st->mcu_h);
 
  uint8_t*        stripe     = nullptr;
  uint32_t        stripe_cap = 0U;
  const ra8_err_t err =
    on_geom(st->cb_ctx, d->width, d->height, st->channels, st->mcu_h, &stripe, &stripe_cap);
  if (err != k_ra8_ok) {
    return err;
  }
  RA8_CHECK_NULL_PTR(stripe, s_tag, "geometry callback supplied a NULL stripe");
  const uint32_t need = (uint32_t)d->width * (uint32_t)st->mcu_h * (uint32_t)st->channels;
  if (stripe_cap < need) {
    return k_ra8_err_invalid_size;
  }
  st->stripe     = stripe;
  st->stripe_cap = stripe_cap;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_js_parse_markers(ra8_jpeg_stream_state_t* st,
                                                        ra8_jpeg_sw_geom_fn      on_geom,
                                                        uint32_t*                out_scan_pos)
{
  bool got_sof   = false;
  bool geom_done = false;
  for (uint16_t iter = 0U; iter < (uint16_t)k_ra8_jpeg_stream_max_markers; iter++) {
    if (st->win_len == 0U) {
      return k_ra8_err_protocol_error; /* stream ended before SOS */
    }
    st->dec.src                         = st->win;
    st->dec.src_len                     = st->win_len;
    st->dec.cursor                      = 0U;
    ra8_jpeg_dec_marker_action_t action = k_ra8_jpeg_dec_continue;
    ra8_err_t                    err    = priv_jpeg_sw_dispatch(&st->dec, &got_sof, &action);
    if (err != k_ra8_ok) {
      return err;
    }
    if (got_sof && !geom_done) {
      err = internal_js_bind_geometry(st, on_geom);
      if (err != k_ra8_ok) {
        return err;
      }
      geom_done = true;
    }
    if (action == k_ra8_jpeg_dec_scan) {
      *out_scan_pos = st->dec.cursor;
      return k_ra8_ok;
    }
    if (action == k_ra8_jpeg_dec_eoi) {
      return k_ra8_err_protocol_error; /* EOI before any scan */
    }
    err = internal_js_slide(st, st->dec.cursor);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_err_protocol_error; /* marker budget exhausted (hostile stream) */
}

RA8_INTERNAL static void internal_js_emit_mcu(const ra8_jpeg_stream_state_t* st,
                                              const uint8_t*                 y_tile,
                                              const uint8_t*                 cb_tile,
                                              const uint8_t*                 cr_tile,
                                              uint16_t                       mx,
                                              uint16_t                       rows)
{
  const ra8_jpeg_dec_ctx_t* d      = &st->dec;
  const uint32_t            stride = (uint32_t)d->width * (uint32_t)st->channels;
  for (uint16_t r = 0U; r < rows; r++) {
    for (uint16_t c = 0U; c < st->mcu_w; c++) {
      const uint32_t px = ((uint32_t)mx * (uint32_t)st->mcu_w) + (uint32_t)c;
      if (px >= (uint32_t)d->width) {
        break;
      }
      const int32_t y = (int32_t)y_tile[((uint32_t)r * (uint32_t)st->mcu_w) + (uint32_t)c];
      if (st->channels == (uint8_t)k_ra8_jpeg_stream_gray_ch) {
        st->stripe[((uint32_t)r * stride) + px] = (uint8_t)y;
        continue;
      }
      const uint16_t cx  = (uint16_t)(c / d->hmax);
      const uint16_t cy  = (uint16_t)(r / d->vmax);
      const int32_t  cb  = (int32_t)cb_tile[((uint32_t)cy * (uint32_t)k_ra8_jpeg_block_dim) + cx];
      const int32_t  cr  = (int32_t)cr_tile[((uint32_t)cy * (uint32_t)k_ra8_jpeg_block_dim) + cx];
      const uint32_t idx = ((uint32_t)r * stride) + (px * (uint32_t)st->channels);
      priv_jpeg_sw_ycc_to_rgb(y,
                              cb,
                              cr,
                              &st->stripe[idx],
                              &st->stripe[idx + 1U],
                              &st->stripe[idx + 2U]);
    }
  }
}

RA8_INTERNAL static ra8_err_t internal_js_scan_margin(ra8_jpeg_stream_state_t* st,
                                                      ra8_jpeg_bitreader_t*    br)
{
  if ((st->eof == 0U) && ((st->win_len - br->pos) < (uint32_t)k_ra8_jpeg_sw_stream_scan_margin)) {
    const uint32_t  shift = br->pos;
    const ra8_err_t err   = internal_js_slide(st, shift);
    if (err != k_ra8_ok) {
      return err;
    }
    br->pos = 0U;
    br->len = st->win_len;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_js_decode_mcu(ra8_jpeg_stream_state_t* st,
                                                     ra8_jpeg_bitreader_t*    br,
                                                     uint8_t*                 y_tile,
                                                     uint8_t*                 cb_tile,
                                                     uint8_t*                 cr_tile,
                                                     uint16_t                 mx,
                                                     uint16_t                 rows)
{
  ra8_err_t err = internal_js_scan_margin(st, br);
  if (err != k_ra8_ok) {
    return err;
  }
  err = priv_jpeg_sw_mcu_y(&st->dec, br, y_tile, st->mcu_w);
  if (err != k_ra8_ok) {
    return err;
  }
  if (st->dec.ncomp == 3U) {
    err = priv_jpeg_sw_mcu_chroma(&st->dec, br, cb_tile, cr_tile);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  internal_js_emit_mcu(st, y_tile, cb_tile, cr_tile, mx, rows);
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_js_scan(ra8_jpeg_stream_state_t* st, uint32_t scan_pos)
{
  ra8_jpeg_dec_ctx_t*  d  = &st->dec;
  ra8_jpeg_bitreader_t br = {
    .buf     = st->win,
    .len     = st->win_len,
    .pos     = scan_pos,
    .acc     = 0U,
    .nbits   = 0U,
    .had_eoi = 0U,
  };
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_jpeg_max_comps; i++) {
    d->comp_dc_pred[i] = 0;
  }
  uint8_t y_tile[(uint32_t)k_ra8_jpeg_mcu_max_dim * (uint32_t)k_ra8_jpeg_mcu_max_dim] = {};
  uint8_t cb_tile[(uint32_t)k_ra8_jpeg_block_size]                                    = {};
  uint8_t cr_tile[(uint32_t)k_ra8_jpeg_block_size]                                    = {};
 
  for (uint16_t my = 0U; my < st->mcus_y; my++) {
    const uint32_t y0   = (uint32_t)my * (uint32_t)st->mcu_h;
    const uint32_t left = (uint32_t)d->height - y0;
    const uint16_t rows = (uint16_t)((left < (uint32_t)st->mcu_h) ? left : (uint32_t)st->mcu_h);
    for (uint16_t mx = 0U; mx < st->mcus_x; mx++) {
      const ra8_err_t err = internal_js_decode_mcu(st, &br, y_tile, cb_tile, cr_tile, mx, rows);
      if (err != k_ra8_ok) {
        return err;
      }
    }
    const ra8_err_t err =
      st->on_rows(st->cb_ctx, st->stripe, d->width, (uint16_t)y0, rows, st->channels);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_js_begin(ra8_jpeg_stream_state_t* st,
                                                ra8_jpeg_sw_pull_fn      pull,
                                                void*                    pull_ctx,
                                                uint8_t*                 window,
                                                uint32_t                 window_cap,
                                                ra8_jpeg_sw_rows_fn      on_rows,
                                                void*                    cb_ctx)
{
  (void)memset(st, 0, sizeof(*st));
  st->pull      = pull;
  st->pull_ctx  = pull_ctx;
  st->win       = window;
  st->win_cap   = window_cap;
  st->on_rows   = on_rows;
  st->cb_ctx    = cb_ctx;
  ra8_err_t err = internal_js_refill(st);
  if (err != k_ra8_ok) {
    return err;
  }
  if (st->win_len < (uint32_t)k_ra8_jpeg_stream_soi_bytes) {
    return k_ra8_err_invalid_size;
  }
  if (internal_read_be16(st->win) != (uint16_t)k_ra8_jpeg_marker_soi) {
    return k_ra8_err_protocol_error;
  }
  return internal_js_slide(st, (uint32_t)k_ra8_jpeg_stream_soi_bytes);
}
 
ra8_err_t ra8_jpeg_sw_decode_stripes(ra8_jpeg_sw_pull_fn pull,
                                     void*               pull_ctx,
                                     uint8_t*            window,
                                     uint32_t            window_cap,
                                     ra8_jpeg_sw_geom_fn on_geom,
                                     ra8_jpeg_sw_rows_fn on_rows,
                                     void*               cb_ctx)
{
  RA8_CHECK_NULL_PTR(pull, s_tag, "pull must not be nullptr");
  RA8_CHECK_NULL_PTR(window, s_tag, "window must not be nullptr");
  RA8_CHECK_NULL_PTR(on_geom, s_tag, "on_geom must not be nullptr");
  RA8_CHECK_NULL_PTR(on_rows, s_tag, "on_rows must not be nullptr");
  if (window_cap < (uint32_t)k_ra8_jpeg_sw_stream_min_window) {
    return k_ra8_err_invalid_size;
  }
  ra8_jpeg_stream_state_t* st = &s_js;
  ra8_err_t err = internal_js_begin(st, pull, pull_ctx, window, window_cap, on_rows, cb_ctx);
  if (err != k_ra8_ok) {
    return err;
  }
  uint32_t scan_pos = 0U;
  err               = internal_js_parse_markers(st, on_geom, &scan_pos);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_js_scan(st, scan_pos);
}