ra8_camera_codec_jpeg_sw.c

Go to the documentation of this file.

 
#include "ra8_camera_codec_jpeg_sw.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_camera_internal.h"
#include "ra8_err.h"
#include "ra8_jpeg_sw.h"

typedef enum : int32_t {
  k_camera_jpeg_luma_black = 16,  
  k_camera_jpeg_chroma_mid = 128, 
  k_camera_jpeg_luma_scale = 298, 
  k_camera_jpeg_red_cr     = 409, 
  k_camera_jpeg_green_cb   = 100, 
  k_camera_jpeg_green_cr   = 208, 
  k_camera_jpeg_blue_cb    = 516, 
  k_camera_jpeg_rounding   = 128, 
  k_camera_jpeg_shift      = 8,   
  k_camera_jpeg_u8_max     = 255, 
} camera_jpeg_color_t;

RA8_INTERNAL static uint8_t internal_jpeg_sw_clamp(int32_t component)
{
  if (component < 0) {
    return 0U;
  }
  if (component > (int32_t)k_camera_jpeg_u8_max) {
    return (uint8_t)k_camera_jpeg_u8_max;
  }
  return (uint8_t)component;
}

RA8_INTERNAL static void
internal_jpeg_sw_ycbcr_to_rgb(uint8_t y, uint8_t cb, uint8_t cr, uint8_t* output)
{
  int32_t luma = (int32_t)y - (int32_t)k_camera_jpeg_luma_black;
  if (luma < 0) {
    luma = 0;
  }
  const int32_t blue_delta = (int32_t)cb - (int32_t)k_camera_jpeg_chroma_mid;
  const int32_t red_delta  = (int32_t)cr - (int32_t)k_camera_jpeg_chroma_mid;
  output[0]                = internal_jpeg_sw_clamp(((int32_t)k_camera_jpeg_luma_scale * luma +
                                                     (int32_t)k_camera_jpeg_red_cr * red_delta +
                                                     (int32_t)k_camera_jpeg_rounding) >>
                                                    (int32_t)k_camera_jpeg_shift);
  output[1]                = internal_jpeg_sw_clamp(
    ((int32_t)k_camera_jpeg_luma_scale * luma - (int32_t)k_camera_jpeg_green_cb * blue_delta -
     (int32_t)k_camera_jpeg_green_cr * red_delta + (int32_t)k_camera_jpeg_rounding) >>
    (int32_t)k_camera_jpeg_shift);
  output[2] = internal_jpeg_sw_clamp(((int32_t)k_camera_jpeg_luma_scale * luma +
                                      (int32_t)k_camera_jpeg_blue_cb * blue_delta +
                                      (int32_t)k_camera_jpeg_rounding) >>
                                     (int32_t)k_camera_jpeg_shift);
}

RA8_INTERNAL static void
internal_jpeg_sw_read_rgb(const ra8_camera_frame_t* input, uint32_t x, uint32_t y, uint8_t* output)
{
  const uint32_t row = y * input->stride_bytes;
  if (input->format == k_ra8_camera_format_rgb888) {
    const uint32_t offset = row + (x * 3U);
    output[0]             = input->data[offset];
    output[1]             = input->data[offset + 1U];
    output[2]             = input->data[offset + 2U];
    return;
  }
  const uint32_t pair = row + ((x & ~1U) * 2U);
  const uint32_t yoff = ((x & 1U) == 0U) ? 1U : 3U;
  internal_jpeg_sw_ycbcr_to_rgb(input->data[pair + yoff],
                                input->data[pair],
                                input->data[pair + 2U],
                                output);
}

RA8_INTERNAL static void internal_jpeg_sw_prepare_rgb(const ra8_camera_codec_jpeg_sw_state_t* state,
                                                      const ra8_camera_frame_t*               input)
{
  const uint32_t out_width  = (uint32_t)state->cfg.output_width;
  const uint32_t out_height = (uint32_t)state->cfg.output_height;
  for (uint32_t y = 0U; y < out_height; y += 1U) {
    const uint32_t source_y = (y * (uint32_t)input->height) / out_height;
    for (uint32_t x = 0U; x < out_width; x += 1U) {
      const uint32_t source_x = (x * (uint32_t)input->width) / out_width;
      internal_jpeg_sw_read_rgb(input,
                                source_x,
                                source_y,
                                &state->cfg.rgb_workspace[(((size_t)y * out_width) + x) * 3U]);
    }
  }
}

RA8_INTERNAL static ra8_err_t internal_jpeg_sw_encode(void*                      ctx,
                                                      const ra8_camera_frame_t*  input,
                                                      const ra8_camera_buffer_t* output_buffer,
                                                      ra8_camera_frame_t*        out_frame)
{
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (input == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (output_buffer == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (out_frame == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (output_buffer->data == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (output_buffer->capacity == 0U) {
    return k_ra8_err_null_ptr;
  }
  if (input->format != k_ra8_camera_format_rgb888) {
    if (input->format != k_ra8_camera_format_uyvy422) {
      return k_ra8_err_not_supported;
    }
  }
  const ra8_camera_codec_jpeg_sw_state_t* state = (const ra8_camera_codec_jpeg_sw_state_t*)ctx;
  internal_jpeg_sw_prepare_rgb(state, input);
  uint32_t        produced = 0U;
  const ra8_err_t encoded  = ra8_jpeg_sw_encode(state->cfg.rgb_workspace,
                                                state->cfg.output_width,
                                                state->cfg.output_height,
                                                state->cfg.quality,
                                                output_buffer->data,
                                                output_buffer->capacity,
                                                &produced);
  if (encoded != k_ra8_ok) {
    return encoded;
  }
  *out_frame = (ra8_camera_frame_t){
    .data         = output_buffer->data,
    .bytes        = produced,
    .stride_bytes = 0U,
    .width        = state->cfg.output_width,
    .height       = state->cfg.output_height,
    .format       = k_ra8_camera_format_jpeg,
  };
  return k_ra8_ok;
}

static const ra8_camera_codec_iface_t s_jpeg_sw_codec_iface = {
  .encode = internal_jpeg_sw_encode,
};
 
ra8_err_t ra8_camera_codec_jpeg_sw_init(ra8_camera_codec_t*                   codec,
                                        ra8_camera_codec_jpeg_sw_state_t*     state,
                                        const ra8_camera_codec_jpeg_sw_cfg_t* cfg)
{
  if (codec == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (state == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (cfg == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (cfg->rgb_workspace == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (cfg->quality < (uint8_t)k_ra8_jpeg_sw_quality_min) {
    return k_ra8_err_invalid_arg;
  }
  if (cfg->quality > (uint8_t)k_ra8_jpeg_sw_quality_max) {
    return k_ra8_err_invalid_arg;
  }
  if (cfg->output_width == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (cfg->output_height == 0U) {
    return k_ra8_err_invalid_arg;
  }
  const uint32_t row_bytes = (uint32_t)cfg->output_width * 3U;
  if ((uint32_t)cfg->output_height > (UINT32_MAX / row_bytes)) {
    return k_ra8_err_invalid_size;
  }
  if (cfg->rgb_workspace_capacity < (row_bytes * (uint32_t)cfg->output_height)) {
    return k_ra8_err_invalid_size;
  }
  state->cfg   = *cfg;
  codec->iface = &s_jpeg_sw_codec_iface;
  codec->ctx   = state;
  return k_ra8_ok;
}