ra8_jpeg_sw_internal.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
 
/* ------------------------------------------------------------------ */
/* Shared constants and look-up tables */
/* ------------------------------------------------------------------ */

typedef enum : uint16_t {
  k_jpeg_byte_mask    = 0xFFU, 
  k_jpeg_nibble_mask  = 0xFU,  
  k_jpeg_reservoir_lo = 24U,   
  k_jpeg_sof_dims_off = 5U,    
  k_jpeg_mcu_align    = 15U,   
  k_jpeg_zrl_symbol   = 0xF0U, 
} jpeg_misc_t;

typedef enum : uint8_t {
  k_jpeg_idct_p1_bias_sh = 27U, 
  k_jpeg_idct_p1_sh      = 28U, 
  k_jpeg_idct_p2_bias_sh = 13U, 
  k_jpeg_q14_shift       = 14U, 
  k_jpeg_ycc_q15_shift   = 14U, 
} jpeg_dsp_shift_t;

typedef enum : int16_t {
  k_cr_r_q15 = 22970,  
  k_cb_b_q15 = 29032,  
  k_cb_g_q15 = -5638,  
  k_cr_g_q15 = -11700, 
} jpeg_ycc_coeff_t;

typedef enum : uint16_t {
  k_jpeg_marker_sof_lo = 0xFFC0U, 
  k_jpeg_marker_sof1   = 0xFFC1U, 
  k_jpeg_marker_sof_hi = 0xFFCFU, 
  k_jpeg_marker_jpg    = 0xFFC8U, 
  k_jpeg_marker_ff00   = 0xFF00U, 
} jpeg_marker_range_t;

typedef enum : uint16_t {
  k_jpeg_q_scale_low  = 5000U, 
  k_jpeg_q_scale_high = 200U,  
  k_jpeg_q_round_bias = 50U,   
  k_jpeg_q_percent    = 100U,  
  k_jpeg_sof_seg_len  = 17U,   
  k_jpeg_sos_seg_len  = 12U,   
  k_jpeg_spectral_end = 63U,   
} jpeg_enc_t;

typedef enum : uint8_t {
  k_jpeg_samp_2x2       = 0x22U, 
  k_jpeg_samp_1x1       = 0x11U, 
  k_jpeg_dht_ac_chroma  = 0x11U, 
  k_jpeg_sos_sel_chroma = 0x11U, 
} jpeg_enc_field_t;

typedef enum : uint16_t {
  k_ra8_jpeg_marker_soi    = 0xFFD8U,              
  k_ra8_jpeg_marker_eoi    = 0xFFD9U,              
  k_ra8_jpeg_marker_sos    = 0xFFDAU,              
  k_ra8_jpeg_marker_dqt    = 0xFFDBU,              
  k_ra8_jpeg_marker_dht    = 0xFFC4U,              
  k_ra8_jpeg_marker_dri    = 0xFFDDU,              
  k_ra8_jpeg_marker_sof0   = 0xFFC0U,              
  k_ra8_jpeg_marker_sof1   = 0xFFC1U,              
  k_ra8_jpeg_marker_sof2   = 0xFFC2U,              
  k_ra8_jpeg_marker_sof3   = 0xFFC3U,              
  k_ra8_jpeg_marker_app0   = 0xFFE0U,              
  k_ra8_jpeg_marker_com    = 0xFFFEU,              
  k_ra8_jpeg_marker_rst0   = 0xFFD0U,              
  k_ra8_jpeg_marker_rst7   = 0xFFD7U,              
  k_ra8_jpeg_marker_pad    = 0xFF00U,              
  k_ra8_jpeg_marker_sof_lo = 0xFFC0U,              
  k_ra8_jpeg_marker_sof_hi = k_jpeg_marker_sof_hi, 
  k_ra8_jpeg_marker_dac    = 0xFFC8U,              
  k_ra8_jpeg_marker_high   = 0xFF00U,              
} ra8_jpeg_marker_t;

typedef enum : uint16_t {
  k_ra8_jpeg_block_dim    = 8U,    
  k_ra8_jpeg_block_size   = 64U,   
  k_ra8_jpeg_max_comps    = 3U,    
  k_ra8_jpeg_mcu_max_dim  = 16U,   
  k_ra8_jpeg_huff_classes = 2U,    
  k_ra8_jpeg_huff_ids     = 2U,    
  k_ra8_jpeg_huff_max     = 256U,  
  k_ra8_jpeg_marker_byte  = 0xFFU, 
  k_ra8_jpeg_quant_tabs   = 2U,    
  k_ra8_jpeg_enc_max_w    = 1024U, 
  k_ra8_jpeg_min_jpeg_len = 4U,    
  k_ra8_jpeg_garbage_len  = 5U,    
  k_ra8_jpeg_mcu_align    = 15U,   
  k_ra8_jpeg_sof0_min_len = 8U,    
  k_ra8_jpeg_dht_hdr      = 1U,    
  k_ra8_jpeg_sof0_hdr_len = 17U,   
  k_ra8_jpeg_sos_len      = 12U,   
  k_ra8_jpeg_app0_len     = 16U,   
  k_ra8_jpeg_eob_band_max = 63U,   
} ra8_jpeg_const_t;

typedef enum : uint8_t {
  k_ra8_jpeg_byte_shift     = 8U,    
  k_ra8_jpeg_nibble_shift   = 4U,    
  k_ra8_jpeg_nibble_mask    = 0x0FU, 
  k_ra8_jpeg_signbit_pos    = 7U,    
  k_ra8_jpeg_signbit_pos16  = 15U,   
  k_ra8_jpeg_level_offset   = 128U,  
  k_ra8_jpeg_pixel_max      = 255U,  
  k_ra8_jpeg_quality_pivot  = 50U,   
  k_ra8_jpeg_huff_lengths   = 16U,   
  k_ra8_jpeg_zrl_runlen     = 16U,   
  k_ra8_jpeg_zrl_symbol     = 0xF0U, 
  k_ra8_jpeg_eob_runlen     = 0xFU,  
  k_ra8_jpeg_dht_dc_class   = 0U,    
  k_ra8_jpeg_dht_ac_class   = 0x10U, 
  k_ra8_jpeg_y_sampling_420 = 0x22U, 
  k_ra8_jpeg_c_sampling     = 0x11U, 
  k_ra8_jpeg_be_byte_mask   = 0xFFU, 
  k_ra8_jpeg_yuv_shift      = 16U,   
  k_ra8_jpeg_rgb_components = 3U,    
} ra8_jpeg_shift_t;

typedef enum : int32_t {
  k_ra8_jpeg_yr   = 19595,  
  k_ra8_jpeg_yg   = 38470,  
  k_ra8_jpeg_yb   = 7471,   
  k_ra8_jpeg_cbr  = -11059, 
  k_ra8_jpeg_cbg  = -21709, 
  k_ra8_jpeg_cbb  = 32768,  
  k_ra8_jpeg_crr  = 32768,  
  k_ra8_jpeg_crg  = -27439, 
  k_ra8_jpeg_crb  = -5329,  
  k_ra8_jpeg_cr_r = 91881,  
  k_ra8_jpeg_cb_b = 116130, 
  k_ra8_jpeg_cr_g = -46802, 
  k_ra8_jpeg_cb_g = -22554, 
} ra8_jpeg_color_coef_t;

static const uint8_t s_zigzag[64] = {
  0,  1,  8,  16, 9,  2,  3,  10, 17, 24, 32, 25, 18, 11, 4,  5,  12, 19, 26, 33, 40, 48,
  41, 34, 27, 20, 13, 6,  7,  14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23,
  30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
};

static const int32_t s_dct_cos_q14[8][8] = {
  {16384, 16384, 16384, 16384, 16384, 16384, 16384, 16384},
  {16069, 13623, 9102, 3196, -3196, -9102, -13623, -16069},
  {15137, 6270, -6270, -15137, -15137, -6270, 6270, 15137},
  {13623, -3196, -16069, -9102, 9102, 16069, 3196, -13623},
  {11585, -11585, -11585, 11585, 11585, -11585, -11585, 11585},
  {9102, -16069, 3196, 13623, -13623, -3196, 16069, -9102},
  {6270, -15137, 15137, -6270, -6270, 15137, -15137, 6270},
  {3196, -9102, 13623, -16069, 16069, -13623, 9102, -3196},
};

static const int32_t s_dct_w_q14[8] = {
  /* sqrt(2/8) = 0.5; * (1/sqrt(2)) for k=0 -> 0.3536068; * 16384 = 5793. */
  5793,
  /* sqrt(2/8) = 0.5; * 16384 = 8192 (k=1..7). */
  8192,
  8192,
  8192,
  8192,
  8192,
  8192,
  8192,
};
 
/* ------------------------------------------------------------------ */
/* Inline byte / pixel helpers */
/* ------------------------------------------------------------------ */

RA8_INTERNAL static inline uint8_t internal_clamp_u8(int32_t v)
{
  if (v < 0) {
    return 0U;
  }
  if (v > (int32_t)k_ra8_jpeg_pixel_max) {
    return (uint8_t)k_ra8_jpeg_pixel_max;
  }
  return (uint8_t)v;
}

RA8_INTERNAL static inline uint16_t internal_read_be16(const uint8_t* p)
{
  return (uint16_t)(((uint16_t)p[0] << k_ra8_jpeg_byte_shift) | (uint16_t)p[1]);
}

RA8_INTERNAL static inline void internal_write_be16(uint8_t* p, uint16_t v)
{
  p[0] = (uint8_t)(v >> k_ra8_jpeg_byte_shift);
  p[1] = (uint8_t)(v & k_jpeg_byte_mask);
}
 
/* ------------------------------------------------------------------ */
/* Shared entropy / DSP primitive types */
/* ------------------------------------------------------------------ */

typedef struct {
  const uint8_t* buf;     
  uint32_t       len;     
  uint32_t       pos;     
  uint32_t       acc;     
  uint8_t        nbits;   
  uint8_t        had_eoi; 
} ra8_jpeg_bitreader_t;

typedef struct {
  uint8_t  bits[k_ra8_jpeg_huff_lengths];    
  uint8_t  vals[k_ra8_jpeg_huff_max];        
  uint16_t huffcode[k_ra8_jpeg_huff_max];    
  uint8_t  huffsize[k_ra8_jpeg_huff_max];    
  int32_t  mincode[k_ra8_jpeg_huff_lengths]; 
  int32_t  maxcode[k_ra8_jpeg_huff_lengths]; 
  uint16_t valptr[k_ra8_jpeg_huff_lengths];  
  uint16_t total;                            
} ra8_jpeg_htab_t;
 
/* ------------------------------------------------------------------ */
/* Decode-primitive prototypes (defined in ra8_jpeg_sw.c, called from */
/* the parser unit ra8_jpeg_sw_decode.c) */
/* ------------------------------------------------------------------ */

RA8_PRIV int32_t priv_jpeg_sw_br_get_bits(ra8_jpeg_bitreader_t* br, uint8_t n);

RA8_PRIV void priv_jpeg_sw_htab_build(ra8_jpeg_htab_t* h);

RA8_PRIV int32_t priv_jpeg_sw_htab_decode(ra8_jpeg_bitreader_t* br, const ra8_jpeg_htab_t* h);

RA8_PRIV int32_t priv_jpeg_sw_huff_extend(int32_t v, uint8_t n);

RA8_PRIV void priv_jpeg_sw_idct8x8(int32_t* block);

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);
 
/* ------------------------------------------------------------------ */
/* Decoder context + marker/scan primitives (defined in */
/* ra8_jpeg_sw_decode.c, shared with the streaming driver */
/* ra8_jpeg_sw_stream.c) */
/* ------------------------------------------------------------------ */

typedef struct {
  const uint8_t* src;     
  uint32_t       src_len; 
  uint32_t       cursor;  
 
  uint16_t width;  
  uint16_t height; 
  uint8_t  ncomp;  
  uint8_t  hmax;   
  uint8_t  vmax;   
 
  /* Per-component info (T.81 sec B.2.2). */
  uint8_t comp_id[k_ra8_jpeg_max_comps];      
  uint8_t comp_h[k_ra8_jpeg_max_comps];       
  uint8_t comp_v[k_ra8_jpeg_max_comps];       
  uint8_t comp_qid[k_ra8_jpeg_max_comps];     
  uint8_t comp_dc_id[k_ra8_jpeg_max_comps];   
  uint8_t comp_ac_id[k_ra8_jpeg_max_comps];   
  int32_t comp_dc_pred[k_ra8_jpeg_max_comps]; 
 
  uint16_t        qtab[k_ra8_jpeg_quant_tabs][k_ra8_jpeg_block_size]; 
  ra8_jpeg_htab_t hdc[k_ra8_jpeg_huff_ids];                           
  ra8_jpeg_htab_t hac[k_ra8_jpeg_huff_ids];                           
} ra8_jpeg_dec_ctx_t;

typedef enum : uint8_t {
  k_ra8_jpeg_dec_continue = 0U, 
  k_ra8_jpeg_dec_scan     = 1U, 
  k_ra8_jpeg_dec_eoi      = 2U, 
} ra8_jpeg_dec_marker_action_t;

RA8_PRIV ra8_err_t priv_jpeg_sw_skip_segment(ra8_jpeg_dec_ctx_t* d);

RA8_PRIV ra8_err_t priv_jpeg_sw_parse_dqt(ra8_jpeg_dec_ctx_t* d);

RA8_PRIV ra8_err_t priv_jpeg_sw_parse_dht(ra8_jpeg_dec_ctx_t* d);

RA8_PRIV ra8_err_t priv_jpeg_sw_parse_sof0(ra8_jpeg_dec_ctx_t* d);

RA8_PRIV ra8_err_t priv_jpeg_sw_parse_sos(ra8_jpeg_dec_ctx_t* d);

RA8_PRIV ra8_err_t priv_jpeg_sw_block(ra8_jpeg_dec_ctx_t*   d,
                                      ra8_jpeg_bitreader_t* br,
                                      uint8_t               ci,
                                      int32_t*              outblk);

RA8_PRIV void priv_jpeg_sw_idct_into(int32_t* coeffs, uint8_t* tile);

RA8_PRIV ra8_err_t priv_jpeg_sw_mcu_y(ra8_jpeg_dec_ctx_t*   d,
                                      ra8_jpeg_bitreader_t* br,
                                      uint8_t*              y_tile,
                                      uint16_t              mcu_w_px);

RA8_PRIV ra8_err_t priv_jpeg_sw_mcu_chroma(ra8_jpeg_dec_ctx_t*   d,
                                           ra8_jpeg_bitreader_t* br,
                                           uint8_t*              cb_tile,
                                           uint8_t*              cr_tile);

RA8_PRIV ra8_err_t priv_jpeg_sw_dispatch(ra8_jpeg_dec_ctx_t*           d,
                                         bool*                         got_sof,
                                         ra8_jpeg_dec_marker_action_t* action);