ra8_rabook_gray4.c

Go to the documentation of this file.

 
#include "ra8_rabook_gray4.h"
 
#include <stdint.h> // ra8-keep-include: `uint32_t` used directly
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h" // ra8-keep-include: `ra8_err_t` used directly
#include "ra8_log.h" // ra8-keep-include: `ra8_log_error` used directly
 
/* -------------------------------------------------------------------------- */
/* Private constants */
/* -------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_fp_shift      = 16U,      
  k_fp_unit       = 0x10000U, 
  k_fp_mask       = 0xFFFFU,  
  k_fp_norm_shift = 32U,      
} ra8_gray4_fp_t;

typedef enum : uint8_t {
  k_nib_shift  = 4U, 
  k_nib_lo_msk = 1U, 
} ra8_gray4_nib_t;
 
static const char* const s_tag = "ra8_rabook_gray4";
 
/* -------------------------------------------------------------------------- */
/* Private helpers */
/* -------------------------------------------------------------------------- */

RA8_INTERNAL
static uint8_t internal_bilinear_sample(const uint8_t* src,
                                        uint16_t       src_w,
                                        uint16_t       src_h,
                                        uint64_t       sx_fp,
                                        uint64_t       sy_fp)
{
  RA8_ASSERT(src != nullptr, "Source pointer must not be null");
  RA8_ASSERT(src_w > 0U, "Source width must be positive");
  RA8_ASSERT(src_h > 0U, "Source height must be positive");
 
  uint16_t sx0 = (uint16_t)(sx_fp >> k_fp_shift);
  uint16_t sy0 = (uint16_t)(sy_fp >> k_fp_shift);
  uint16_t sx1 =
    (uint16_t)((((uint32_t)sx0 + 1U) < (uint32_t)src_w) ? ((uint32_t)sx0 + 1U) : (src_w - 1U));
  uint16_t sy1 =
    (uint16_t)((((uint32_t)sy0 + 1U) < (uint32_t)src_h) ? ((uint32_t)sy0 + 1U) : (src_h - 1U));
  uint64_t fx  = sx_fp & (uint64_t)k_fp_mask;
  uint64_t fy  = sy_fp & (uint64_t)k_fp_mask;
  uint64_t ifx = (uint64_t)k_fp_unit - fx;
  uint64_t ify = (uint64_t)k_fp_unit - fy;
 
  uint64_t p00 = src[((uint32_t)sy0 * src_w) + sx0];
  uint64_t p10 = src[((uint32_t)sy0 * src_w) + sx1];
  uint64_t p01 = src[((uint32_t)sy1 * src_w) + sx0];
  uint64_t p11 = src[((uint32_t)sy1 * src_w) + sx1];
 
  uint64_t val = (p00 * ifx * ify) + (p10 * fx * ify) + (p01 * ifx * fy) + (p11 * fx * fy);
  return (uint8_t)(val >> k_fp_norm_shift);
}

RA8_INTERNAL
static void internal_pack_nibbles(const uint8_t* gray_pixels, uint32_t n_pixels, uint8_t* out)
{
  for (uint32_t i = 0U; i < n_pixels; i++) {
    uint8_t nib = (uint8_t)((gray_pixels[i] + (uint8_t)k_ra8_rabook_gray4_round_half) /
                            (uint8_t)k_ra8_rabook_gray4_quant_div);
    if (nib > (uint8_t)k_ra8_rabook_gray4_nib_max) {
      nib = (uint8_t)k_ra8_rabook_gray4_nib_max;
    }
 
    uint32_t byte_idx = i / k_ra8_rabook_gray4_nib_per_byte;
    if ((i & (uint32_t)k_nib_lo_msk) == 0U) {
      out[byte_idx] = (uint8_t)(nib << k_nib_shift);
    } else {
      out[byte_idx] |= nib;
    }
  }
}
 
/* -------------------------------------------------------------------------- */
/* Public API */
/* -------------------------------------------------------------------------- */
 
void ra8_rabook_gray4_output_dims(uint16_t  src_w,
                                  uint16_t  src_h,
                                  uint16_t  max_edge,
                                  uint16_t* out_w,
                                  uint16_t* out_h)
{
  if ((out_w == nullptr) || (out_h == nullptr)) {
    return;
  }
 
  if ((src_w == 0U) || (src_h == 0U) || (max_edge == 0U)) {
    *out_w = 0U;
    *out_h = 0U;
    return;
  }
 
  uint16_t longer = (src_w >= src_h) ? src_w : src_h;
  if (longer <= max_edge) {
    *out_w = src_w;
    *out_h = src_h;
    return;
  }
 
  uint32_t half_longer = (uint32_t)longer / 2U;
  *out_w               = (uint16_t)((((uint32_t)src_w * max_edge) + half_longer) / longer);
  *out_h               = (uint16_t)((((uint32_t)src_h * max_edge) + half_longer) / longer);
 
  if (*out_w == 0U) {
    *out_w = 1U;
  }
  if (*out_h == 0U) {
    *out_h = 1U;
  }
}
 
ra8_err_t ra8_rabook_gray4_downscale(const uint8_t* src,
                                     uint16_t       src_w,
                                     uint16_t       src_h,
                                     uint8_t*       dst,
                                     uint16_t       dst_w,
                                     uint16_t       dst_h)
{
  RA8_CHECK_NULL_PTR(src, s_tag, "src");
  RA8_CHECK_NULL_PTR(dst, s_tag, "dst");
 
  if ((dst_w == 0U) || (dst_h == 0U)) {
    ra8_log_error(s_tag, "dst_w or dst_h is zero");
    return k_ra8_err_invalid_arg;
  }
 
  if ((src_w == 0U) || (src_h == 0U)) {
    (void)memset(dst, 0, (size_t)dst_w * (size_t)dst_h);
    return k_ra8_ok;
  }
 
  uint64_t x_step = ((uint64_t)src_w << k_fp_shift) / dst_w;
  uint64_t y_step = ((uint64_t)src_h << k_fp_shift) / dst_h;
 
  for (uint16_t dy = 0U; dy < dst_h; dy++) {
    uint64_t sy_fp = (uint64_t)dy * y_step;
 
    for (uint16_t dx = 0U; dx < dst_w; dx++) {
      uint64_t sx_fp                   = (uint64_t)dx * x_step;
      dst[((uint32_t)dy * dst_w) + dx] = internal_bilinear_sample(src, src_w, src_h, sx_fp, sy_fp);
    }
  }
 
  return k_ra8_ok;
}
 
ra8_err_t ra8_rabook_gray4_encode(const uint8_t* gray_pixels,
                                  uint16_t       w,
                                  uint16_t       h,
                                  uint8_t*       out,
                                  uint32_t       out_cap,
                                  uint32_t*      out_size)
{
  RA8_CHECK_NULL_PTR(gray_pixels, s_tag, "gray_pixels");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
  RA8_CHECK_NULL_PTR(out_size, s_tag, "out_size");
 
  uint32_t n_pixels = (uint32_t)w * h;
  uint32_t n_bytes  = (n_pixels + 1U) / k_ra8_rabook_gray4_nib_per_byte;
 
  if (n_pixels == 0U) {
    *out_size = 0U;
    return k_ra8_ok;
  }
 
  if (out_cap < n_bytes) {
    ra8_log_error(s_tag, "output buffer too small");
    return k_ra8_err_no_mem;
  }
 
  (void)memset(out, 0, n_bytes);
  internal_pack_nibbles(gray_pixels, n_pixels, out);
 
  *out_size = n_bytes;
  return k_ra8_ok;
}
 
ra8_err_t ra8_rabook_gray8_encode(const uint8_t* gray_pixels,
                                  uint16_t       w,
                                  uint16_t       h,
                                  uint8_t*       out,
                                  uint32_t       out_cap,
                                  uint32_t*      out_size)
{
  RA8_CHECK_NULL_PTR(gray_pixels, s_tag, "gray_pixels");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
  RA8_CHECK_NULL_PTR(out_size, s_tag, "out_size");
 
  uint32_t n_bytes = (uint32_t)w * h;
 
  if (n_bytes == 0U) {
    *out_size = 0U;
    return k_ra8_ok;
  }
 
  if (out_cap < n_bytes) {
    ra8_log_error(s_tag, "output buffer too small");
    return k_ra8_err_no_mem;
  }
 
  (void)memcpy(out, gray_pixels, n_bytes);
 
  *out_size = n_bytes;
  return k_ra8_ok;
}