ra8_gfx_text.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_gfx_internal.h"

typedef enum : uint32_t {
  k_565_r_mask = 0x1FU, 
  k_565_g_mask = 0x3FU, 
  k_565_b_mask = 0x1FU, 
} gfx_565_mask_t;

typedef enum : uint8_t {
  k_shift_blue  = 0,  
  k_shift_green = 8,  
  k_shift_red   = 16, 
  k_shift_alpha = 24, 
} ra8_gfx_color_shifts_t;

typedef enum : uint32_t {
  k_mask_byte = 0xFFU, 
} ra8_gfx_color_masks_t;

typedef enum : uint8_t {
  k_565_r_shift_in  = 3,  
  k_565_g_shift_in  = 2,  
  k_565_b_shift_in  = 3,  
  k_565_r_shift_out = 11, 
  k_565_g_shift_out = 5,  
} ra8_gfx_565_t;

typedef enum : uint8_t {
  k_idx_r      = 0, 
  k_idx_g      = 1, 
  k_idx_b      = 2, 
  k_idx_argb_b = 0, 
  k_idx_argb_g = 1, 
  k_idx_argb_r = 2, 
  k_idx_argb_a = 3, 
} ra8_gfx_byte_idx_t;

typedef enum : uint8_t {
  k_glyph_bits_per_byte = 8, 
  k_glyph_msb_index     = 7, 
} ra8_gfx_glyph_bits_t;

typedef enum : uint8_t {
  k_rgb565_bpp = 2, 
} ra8_gfx_rgb565_bpp_t;

ra8_gfx_state_t g_gfx_text_state = {.format = k_ra8_gfx_format_rgb565};
 
/* ------------------------------------------------------------------ */
/* Helpers */
/* ------------------------------------------------------------------ */

RA8_INTERNAL
static inline uint8_t internal_color_r(uint32_t color)
{
  return (uint8_t)((color >> k_shift_red) & k_mask_byte);
}

RA8_INTERNAL
static inline uint8_t internal_color_g(uint32_t color)
{
  return (uint8_t)((color >> k_shift_green) & k_mask_byte);
}

RA8_INTERNAL
static inline uint8_t internal_color_b(uint32_t color)
{
  return (uint8_t)((color >> k_shift_blue) & k_mask_byte);
}

RA8_INTERNAL
static inline uint8_t internal_color_a(uint32_t color)
{
  return (uint8_t)((color >> k_shift_alpha) & k_mask_byte);
}

uint16_t priv_gfx_text_pack_565(uint32_t color)
{
  const uint16_t r = (uint16_t)(internal_color_r(color) >> k_565_r_shift_in);
  const uint16_t g = (uint16_t)(internal_color_g(color) >> k_565_g_shift_in);
  const uint16_t b = (uint16_t)(internal_color_b(color) >> k_565_b_shift_in);
  return (uint16_t)((r << k_565_r_shift_out) | (g << k_565_g_shift_out) | b);
}

RA8_INTERNAL
static inline uint8_t internal_bpp(ra8_gfx_format_t format)
{
  return (uint8_t)format;
}

RA8_INTERNAL
static inline bool internal_format_ok(ra8_gfx_format_t f)
{
  return (f == k_ra8_gfx_format_rgb565) || (f == k_ra8_gfx_format_rgb888) ||
         (f == k_ra8_gfx_format_argb8888);
}

RA8_INTERNAL
static void internal_put_pixel(uint8_t*         dst,
                               size_t           stride,
                               ra8_gfx_format_t format,
                               size_t           x,
                               size_t           y,
                               uint32_t         color)
{
  uint8_t* p = dst + (y * stride) + (x * (size_t)internal_bpp(format));
  switch (format) {
    case k_ra8_gfx_format_rgb565: {
      const uint16_t v = priv_gfx_text_pack_565(color);
      p[k_idx_r]       = (uint8_t)(v & k_mask_byte);
      p[k_idx_g]       = (uint8_t)((v >> k_glyph_bits_per_byte) & k_mask_byte);
      break;
    }
    case k_ra8_gfx_format_rgb888: {
      p[k_idx_r] = internal_color_r(color);
      p[k_idx_g] = internal_color_g(color);
      p[k_idx_b] = internal_color_b(color);
      break;
    }
    case k_ra8_gfx_format_argb8888: {
      p[k_idx_argb_b] = internal_color_b(color);
      p[k_idx_argb_g] = internal_color_g(color);
      p[k_idx_argb_r] = internal_color_r(color);
      p[k_idx_argb_a] = internal_color_a(color);
      break;
    }
  }
}

RA8_INTERNAL
static uint32_t
internal_get_pixel(const uint8_t* src, size_t stride, ra8_gfx_format_t format, size_t x, size_t y)
{
  const uint8_t* p = src + (y * stride) + (x * (size_t)internal_bpp(format));
  switch (format) {
    case k_ra8_gfx_format_rgb565: {
      const uint16_t v = (uint16_t)(p[k_idx_r] | ((uint16_t)p[k_idx_g] << k_glyph_bits_per_byte));
      const uint32_t r = ((uint32_t)(v >> k_565_r_shift_out) & k_565_r_mask) << k_565_r_shift_in;
      const uint32_t g = ((uint32_t)(v >> k_565_g_shift_out) & k_565_g_mask) << k_565_g_shift_in;
      const uint32_t b = ((uint32_t)v & k_565_b_mask) << k_565_b_shift_in;
      return (r << k_shift_red) | (g << k_shift_green) | (b << k_shift_blue);
    }
    case k_ra8_gfx_format_rgb888: {
      const uint32_t r = p[k_idx_r];
      const uint32_t g = p[k_idx_g];
      const uint32_t b = p[k_idx_b];
      return (r << k_shift_red) | (g << k_shift_green) | (b << k_shift_blue);
    }
    case k_ra8_gfx_format_argb8888: {
      const uint32_t bb = p[k_idx_argb_b];
      const uint32_t gg = p[k_idx_argb_g];
      const uint32_t rr = p[k_idx_argb_r];
      const uint32_t aa = p[k_idx_argb_a];
      return (aa << k_shift_alpha) | (rr << k_shift_red) | (gg << k_shift_green) | bb;
    }
  }
  return 0U;
}

void priv_gfx_text_plot(int32_t x, int32_t y, uint32_t color)
{
  /* The clip rectangle is always within the framebuffer, so this single test
   * enforces both the clip and the framebuffer bounds. With the default clip
   * (0,0,width,height) it is identical to a plain bounds check. */
  if ((x < g_gfx_text_state.clip_x0) || (y < g_gfx_text_state.clip_y0)) {
    return;
  }
  if ((x >= g_gfx_text_state.clip_x1) || (y >= g_gfx_text_state.clip_y1)) {
    return;
  }
  internal_put_pixel(g_gfx_text_state.fb,
                     (size_t)g_gfx_text_state.width * (size_t)g_gfx_text_state.bpp,
                     g_gfx_text_state.format,
                     (size_t)x,
                     (size_t)y,
                     color);
}

RA8_INTERNAL
static inline void internal_fill_565(uint8_t* p, size_t count, uint8_t lo, uint8_t hi)
{
  if (lo == hi) {
    /* Symmetric packed colour (e.g. white paper 0xFFFF, black 0x0000): every
     * byte of the run is the same value, so the optimised libc memset replaces
     * the byte loop. Byte-identical -- both write `lo` to every byte. This is the
     * common full-screen clear, so it is the hot path. */
    (void)memset(p, (int)lo, count * (size_t)k_rgb565_bpp);
    return;
  }
  for (size_t i = 0; i < count; i++) {
    *p++ = lo;
    *p++ = hi;
  }
}

RA8_INTERNAL
static void internal_fill_rect_565(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{
  /* Clip against the active clip rectangle (which is itself within the
   * framebuffer), so this is both the on-screen clip and the dirty-region clip.
   * With the default full-framebuffer clip it reduces to min/max against the
   * framebuffer, i.e. byte-identical to the unclipped fill. */
  const int32_t cl = g_gfx_text_state.clip_x0;
  const int32_t ct = g_gfx_text_state.clip_y0;
  const int32_t cr = g_gfx_text_state.clip_x1;
  const int32_t cb = g_gfx_text_state.clip_y1;
  const int32_t x0 = (x >= cl) ? x : cl;
  const int32_t y0 = (y >= ct) ? y : ct;
  /* Right/bottom edges in 64-bit so x+w / y+h cannot overflow int32 for a
   * pathological caller; then clamped to the clip. */
  const int64_t xr = (int64_t)x + (int64_t)w;
  const int64_t yr = (int64_t)y + (int64_t)h;
  const int32_t x1 = (xr < (int64_t)cr) ? (int32_t)xr : cr;
  const int32_t y1 = (yr < (int64_t)cb) ? (int32_t)yr : cb;
  if ((x1 <= x0) || (y1 <= y0)) {
    return; /* fully clipped -- nothing to fill. */
  }
  const uint16_t v      = priv_gfx_text_pack_565(color);
  const uint8_t  lo     = (uint8_t)(v & (uint16_t)k_mask_byte);
  const uint8_t  hi     = (uint8_t)((v >> k_glyph_bits_per_byte) & (uint16_t)k_mask_byte);
  const size_t   bpp    = (size_t)g_gfx_text_state.bpp;
  const size_t   stride = (size_t)g_gfx_text_state.width * bpp;
  const size_t   count  = (size_t)(x1 - x0);
  for (int32_t row = y0; row < y1; row++) {
    internal_fill_565(g_gfx_text_state.fb + ((size_t)row * stride) + ((size_t)x0 * bpp),
                      count,
                      lo,
                      hi);
  }
}

RA8_INTERNAL
static void internal_fill_rect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{
  if (g_gfx_text_state.format == k_ra8_gfx_format_rgb565) {
    internal_fill_rect_565(x, y, w, h, color);
    return;
  }
  for (int32_t row = 0; row < h; row++) {
    for (int32_t col = 0; col < w; col++) {
      priv_gfx_text_plot(x + col, y + row, color);
    }
  }
}

RA8_INTERNAL
static void internal_rect_outline(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{
  for (int32_t col = 0; col < w; col++) {
    priv_gfx_text_plot(x + col, y, color);
    priv_gfx_text_plot(x + col, y + h - 1, color);
  }
  for (int32_t row = 0; row < h; row++) {
    priv_gfx_text_plot(x, y + row, color);
    priv_gfx_text_plot(x + w - 1, y + row, color);
  }
}
 
/* ------------------------------------------------------------------ */
/* Public API */
/* ------------------------------------------------------------------ */
 
ra8_err_t ra8_gfx_init(void* fb, uint16_t width, uint16_t height, ra8_gfx_format_t format)
{
  if (fb == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if ((width < k_ra8_gfx_min_dim) || (width > k_ra8_gfx_max_dim)) {
    return k_ra8_err_invalid_arg;
  }
  if ((height < k_ra8_gfx_min_dim) || (height > k_ra8_gfx_max_dim)) {
    return k_ra8_err_invalid_arg;
  }
  if (!internal_format_ok(format)) {
    return k_ra8_err_invalid_arg;
  }
  g_gfx_text_state.fb          = (uint8_t*)fb;
  g_gfx_text_state.width       = width;
  g_gfx_text_state.height      = height;
  g_gfx_text_state.format      = format;
  g_gfx_text_state.bpp         = internal_bpp(format);
  g_gfx_text_state.clip_x0     = 0;
  g_gfx_text_state.clip_y0     = 0;
  g_gfx_text_state.clip_x1     = (int32_t)width; /* default clip = whole framebuffer. */
  g_gfx_text_state.clip_y1     = (int32_t)height;
  g_gfx_text_state.initialized = true;
  return k_ra8_ok;
}
 
ra8_err_t ra8_gfx_clear(uint32_t color)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  /* "Clear" fills the active clip region (the whole framebuffer by default).
   * For RGB565 this is the span-fill path -- pack once, memset each row when the
   * bytes are symmetric -- restricted to the clip, so an incremental repaint
   * only touches the damaged area. With the default clip the rect is the whole
   * framebuffer and the bytes written are identical to the old contiguous fill. */
  if (g_gfx_text_state.format == k_ra8_gfx_format_rgb565) {
    internal_fill_rect_565(0,
                           0,
                           (int32_t)g_gfx_text_state.width,
                           (int32_t)g_gfx_text_state.height,
                           color);
    return k_ra8_ok;
  }
  for (int32_t y = g_gfx_text_state.clip_y0; y < g_gfx_text_state.clip_y1; y++) {
    for (int32_t x = g_gfx_text_state.clip_x0; x < g_gfx_text_state.clip_x1; x++) {
      internal_put_pixel(g_gfx_text_state.fb,
                         (size_t)g_gfx_text_state.width * (size_t)g_gfx_text_state.bpp,
                         g_gfx_text_state.format,
                         (size_t)x,
                         (size_t)y,
                         color);
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_gfx_set_clip(int32_t x, int32_t y, int32_t w, int32_t h)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  const int32_t fbw = (int32_t)g_gfx_text_state.width;
  const int32_t fbh = (int32_t)g_gfx_text_state.height;
  /* Clamp the top-left into [0, fb]; the bottom-right into [top-left, fb]. The
   * edges are computed in 64-bit so x+w / y+h cannot overflow int32, and a
   * non-positive size or fully off-screen rect collapses to an empty clip
   * (x1==x0 or y1==y0), which makes every subsequent draw a no-op. */
  int32_t x0 = (x > 0) ? x : 0;
  int32_t y0 = (y > 0) ? y : 0;
  if (x0 > fbw) {
    x0 = fbw;
  }
  if (y0 > fbh) {
    y0 = fbh;
  }
  const int64_t xr = (int64_t)x + (int64_t)w;
  const int64_t yr = (int64_t)y + (int64_t)h;
  int32_t       x1 = (xr < (int64_t)fbw) ? (int32_t)xr : fbw;
  int32_t       y1 = (yr < (int64_t)fbh) ? (int32_t)yr : fbh;
  if (x1 < x0) {
    x1 = x0;
  }
  if (y1 < y0) {
    y1 = y0;
  }
  g_gfx_text_state.clip_x0 = x0;
  g_gfx_text_state.clip_y0 = y0;
  g_gfx_text_state.clip_x1 = x1;
  g_gfx_text_state.clip_y1 = y1;
  return k_ra8_ok;
}
 
ra8_err_t ra8_gfx_reset_clip(void)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  g_gfx_text_state.clip_x0 = 0;
  g_gfx_text_state.clip_y0 = 0;
  g_gfx_text_state.clip_x1 = (int32_t)g_gfx_text_state.width;
  g_gfx_text_state.clip_y1 = (int32_t)g_gfx_text_state.height;
  return k_ra8_ok;
}
 
ra8_err_t ra8_gfx_pixel(int32_t x, int32_t y, uint32_t color)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  if ((x < 0) || (y < 0) || (x >= (int32_t)g_gfx_text_state.width) ||
      (y >= (int32_t)g_gfx_text_state.height)) {
    return k_ra8_err_range_check_failed;
  }
  priv_gfx_text_plot(x, y, color);
  return k_ra8_ok;
}

RA8_INTERNAL
static inline uint32_t internal_gray_to_color(uint32_t g)
{
  return (g << (uint32_t)k_shift_red) | (g << (uint32_t)k_shift_green) |
         (g << (uint32_t)k_shift_blue);
}

RA8_INTERNAL
static void internal_blit_gray8_565(const uint8_t* src,
                                    int32_t        w,
                                    int32_t        dst_x,
                                    int32_t        dst_y,
                                    int32_t        x0,
                                    int32_t        y0,
                                    int32_t        x1,
                                    int32_t        y1)
{
  const size_t stride = (size_t)g_gfx_text_state.width * (size_t)g_gfx_text_state.bpp;
  for (int32_t y = y0; y < y1; ++y) {
    uint8_t* p = g_gfx_text_state.fb + ((size_t)y * stride) + ((size_t)x0 * (size_t)k_rgb565_bpp);
    const uint8_t* s = src + ((size_t)(y - dst_y) * (size_t)w) + (size_t)(x0 - dst_x);
    for (int32_t x = x0; x < x1; ++x) {
      const uint16_t v = priv_gfx_text_pack_565(internal_gray_to_color((uint32_t)*s));
      p[k_idx_r]       = (uint8_t)(v & k_mask_byte);
      p[k_idx_g]       = (uint8_t)((v >> k_glyph_bits_per_byte) & k_mask_byte);
      p += k_rgb565_bpp;
      ++s;
    }
  }
}

RA8_INTERNAL
static void
internal_blit_gray8_slow(const uint8_t* src, int32_t w, int32_t h, int32_t dx, int32_t dy)
{
  for (int32_t y = 0; y < h; ++y) {
    for (int32_t x = 0; x < w; ++x) {
      priv_gfx_text_plot(dx + x,
                         dy + y,
                         internal_gray_to_color(src[((size_t)y * (size_t)w) + (size_t)x]));
    }
  }
}
 
ra8_err_t ra8_gfx_blit_gray8(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;
  }
  /* Non-panel formats keep the exact per-pixel path; the RGB565 panel resolves
   * the clip once and runs a tight row loop. */
  if (g_gfx_text_state.format != k_ra8_gfx_format_rgb565) {
    internal_blit_gray8_slow(src, w, h, dst_x, dst_y);
    return k_ra8_ok;
  }
  /* Clip the block to the clip rectangle ONCE (always within the framebuffer). */
  const int32_t x0 = (dst_x > g_gfx_text_state.clip_x0) ? dst_x : g_gfx_text_state.clip_x0;
  const int32_t y0 = (dst_y > g_gfx_text_state.clip_y0) ? dst_y : g_gfx_text_state.clip_y0;
  const int32_t x1 =
    ((dst_x + w) < g_gfx_text_state.clip_x1) ? (dst_x + w) : g_gfx_text_state.clip_x1;
  const int32_t y1 =
    ((dst_y + h) < g_gfx_text_state.clip_y1) ? (dst_y + h) : g_gfx_text_state.clip_y1;
  if ((x0 < x1) && (y0 < y1)) {
    internal_blit_gray8_565(src, w, dst_x, dst_y, x0, y0, x1, y1);
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_gfx_line(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  /* Bresenham. */
  int32_t       dx  = (x1 >= x0) ? (x1 - x0) : (x0 - x1);
  int32_t       dy  = (y1 >= y0) ? -(y1 - y0) : -(y0 - y1);
  const int32_t sx  = (x0 < x1) ? 1 : -1;
  const int32_t sy  = (y0 < y1) ? 1 : -1;
  int32_t       err = dx + dy;
  int32_t       x   = x0;
  int32_t       y   = y0;
  /* Bound the iteration count statically (NASA Rule 2). */
  const int32_t max_iters = (int32_t)(k_ra8_gfx_max_dim * 2);
  for (int32_t i = 0; i < max_iters; i++) {
    priv_gfx_text_plot(x, y, color);
    if ((x == x1) && (y == y1)) {
      break;
    }
    const int32_t e2 = err * 2;
    if (e2 >= dy) {
      err += dy;
      x += sx;
    }
    if (e2 <= dx) {
      err += dx;
      y += sy;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_gfx_rect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color, bool filled)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  if ((w <= 0) || (h <= 0)) {
    return k_ra8_ok;
  }
  if (filled) {
    internal_fill_rect(x, y, w, h, color);
  } else {
    internal_rect_outline(x, y, w, h, color);
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static void
internal_circle_outline_step(int32_t cx, int32_t cy, int32_t x, int32_t y, uint32_t color)
{
  priv_gfx_text_plot(cx + x, cy + y, color);
  priv_gfx_text_plot(cx - x, cy + y, color);
  priv_gfx_text_plot(cx + x, cy - y, color);
  priv_gfx_text_plot(cx - x, cy - y, color);
  priv_gfx_text_plot(cx + y, cy + x, color);
  priv_gfx_text_plot(cx - y, cy + x, color);
  priv_gfx_text_plot(cx + y, cy - x, color);
  priv_gfx_text_plot(cx - y, cy - x, color);
}

RA8_INTERNAL
static void
internal_circle_filled_step(int32_t cx, int32_t cy, int32_t x, int32_t y, uint32_t color)
{
  for (int32_t col = -x; col <= x; col++) {
    priv_gfx_text_plot(cx + col, cy + y, color);
    priv_gfx_text_plot(cx + col, cy - y, color);
  }
  for (int32_t col = -y; col <= y; col++) {
    priv_gfx_text_plot(cx + col, cy + x, color);
    priv_gfx_text_plot(cx + col, cy - x, color);
  }
}
 
ra8_err_t ra8_gfx_circle(int32_t cx, int32_t cy, int32_t r, uint32_t color, bool filled)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  if (r < 0) {
    return k_ra8_err_invalid_arg;
  }
  /* Midpoint circle algorithm. */
  int32_t x   = r;
  int32_t y   = 0;
  int32_t err = 1 - r;
  /* Static loop bound. */
  const int32_t max_iters = (int32_t)k_ra8_gfx_max_dim;
  for (int32_t i = 0; i < max_iters; i++) {
    if (filled) {
      internal_circle_filled_step(cx, cy, x, y, color);
    } else {
      internal_circle_outline_step(cx, cy, x, y, color);
    }
    if (x <= y) {
      break;
    }
    y++;
    if (err < 0) {
      err += (2 * y) + 1;
    } else {
      x--;
      err += (2 * (y - x)) + 1;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_gfx_blit(const void*      src_buf,
                       uint16_t         src_w,
                       uint16_t         src_h,
                       ra8_gfx_format_t src_format,
                       int32_t          dst_x,
                       int32_t          dst_y)
{
  if (src_buf == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  if ((src_w == 0) || (src_h == 0) || !internal_format_ok(src_format)) {
    return k_ra8_err_invalid_arg;
  }
  const uint8_t* src        = (const uint8_t*)src_buf;
  const size_t   src_stride = (size_t)src_w * (size_t)internal_bpp(src_format);
  for (uint32_t row = 0; row < src_h; row++) {
    for (uint32_t col = 0; col < src_w; col++) {
      const uint32_t color = internal_get_pixel(src, src_stride, src_format, col, row);
      priv_gfx_text_plot(dst_x + (int32_t)col, dst_y + (int32_t)row, color);
    }
  }
  return k_ra8_ok;
}