ra8_gfx_dither.c

Go to the documentation of this file.

 
#include "ra8_gfx_dither.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_gfx_dither_mask_internal.h"
#include "ra8_gfx_internal.h"
#include "ra8_log.h"
 
/* The runtime index arithmetic assumes the generated mask is exactly one
 * mask_dim x mask_dim texture; assert it here so a regenerate that changed the
 * geometry cannot silently mis-index. */
static_assert(sizeof(s_ra8_gfx_dither_mask) == (size_t)k_ra8_gfx_dither_mask_len,
              "blue-noise mask must be mask_dim * mask_dim bytes");
static_assert((int)k_ra8_gfx_dither_mask_index_mask == (int)k_ra8_gfx_dither_mask_dim - 1,
              "toroidal index bitmask must be mask_dim - 1");

RA8_INTERNAL
static uint32_t internal_mask_index(int32_t x, int32_t y)
{
  const uint32_t mx = (uint32_t)x & (uint32_t)k_ra8_gfx_dither_mask_index_mask;
  const uint32_t my = (uint32_t)y & (uint32_t)k_ra8_gfx_dither_mask_index_mask;
  return (my * (uint32_t)k_ra8_gfx_dither_mask_dim) + mx;
}

RA8_INTERNAL
static uint8_t internal_quantise(uint8_t gray8, uint8_t thr)
{
  const uint8_t base  = (uint8_t)(gray8 / (uint8_t)k_ra8_gfx_dither_step);
  const uint8_t rem   = (uint8_t)(gray8 - (uint8_t)(base * (uint8_t)k_ra8_gfx_dither_step));
  uint8_t       level = base;
  if (((uint32_t)thr * (uint32_t)k_ra8_gfx_dither_step) <
      ((uint32_t)rem * (uint32_t)k_ra8_gfx_dither_byte_levels)) {
    level = (uint8_t)(level + 1U);
  }
  return level;
}

RA8_INTERNAL
static uint32_t internal_level_to_color(uint8_t level)
{
  const uint32_t g    = (uint32_t)level;
  const uint32_t gray = (g << (uint32_t)k_ra8_gfx_dither_nib_shift) | g;
  return (gray << (uint32_t)k_ra8_gfx_dither_rgb_r_shift) |
         (gray << (uint32_t)k_ra8_gfx_dither_rgb_g_shift) | gray;
}

RA8_INTERNAL
static void
internal_pack_tile(const uint8_t* src, int32_t w, int32_t h, int32_t ox, int32_t oy, uint8_t* out)
{
  for (int32_t row = 0; row < h; ++row) {
    for (int32_t col = 0; col < w; ++col) {
      const uint32_t i = ((uint32_t)row * (uint32_t)w) + (uint32_t)col;
      const uint8_t  level =
        internal_quantise(src[i], s_ra8_gfx_dither_mask[internal_mask_index(ox + col, oy + row)]);
      const uint32_t byte_idx = i / (uint32_t)k_ra8_gfx_dither_ppb;
      if ((i & 1U) == 0U) {
        out[byte_idx] = (uint8_t)(level << (uint8_t)k_ra8_gfx_dither_nib_shift);
      } else {
        out[byte_idx] = (uint8_t)(out[byte_idx] | level);
      }
    }
  }
}
 
uint8_t ra8_gfx_dither_gray4_level(uint8_t gray8, int32_t x, int32_t y)
{
  return internal_quantise(gray8, s_ra8_gfx_dither_mask[internal_mask_index(x, y)]);
}
 
ra8_err_t ra8_gfx_dither_gray8_to_gray4(const uint8_t* src,
                                        int32_t        w,
                                        int32_t        h,
                                        int32_t        origin_x,
                                        int32_t        origin_y,
                                        uint8_t*       out,
                                        uint32_t       out_cap,
                                        uint32_t*      out_size)
{
  static const char* const k_tag = "ra8_gfx_dither";
  RA8_CHECK_NULL_PTR(src, k_tag, "src");
  RA8_CHECK_NULL_PTR(out, k_tag, "out");
  RA8_CHECK_NULL_PTR(out_size, k_tag, "out_size");
 
  if ((w <= 0) || (h <= 0)) {
    ra8_log_error(k_tag, "w or h is non-positive");
    return k_ra8_err_invalid_arg;
  }
 
  const uint32_t n_pixels = (uint32_t)w * (uint32_t)h;
  const uint32_t n_bytes  = (n_pixels + 1U) / (uint32_t)k_ra8_gfx_dither_ppb;
  if (out_cap < n_bytes) {
    ra8_log_error(k_tag, "output buffer too small");
    return k_ra8_err_no_mem;
  }
 
  internal_pack_tile(src, w, h, origin_x, origin_y, out);
  *out_size = n_bytes;
  return k_ra8_ok;
}
 
ra8_err_t
ra8_gfx_blit_gray8_dither(const uint8_t* src, int32_t w, int32_t h, int32_t dst_x, int32_t dst_y)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  if ((src == nullptr) || (w <= 0) || (h <= 0)) {
    return k_ra8_err_invalid_arg;
  }
 
  for (int32_t row = 0; row < h; ++row) {
    for (int32_t col = 0; col < w; ++col) {
      const uint8_t level =
        internal_quantise(src[((size_t)row * (size_t)w) + (size_t)col],
                          s_ra8_gfx_dither_mask[internal_mask_index(dst_x + col, dst_y + row)]);
      priv_gfx_text_plot(dst_x + col, dst_y + row, internal_level_to_color(level));
    }
  }
  return k_ra8_ok;
}