ra8_gfx_blit_gray4.c

Go to the documentation of this file.

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

typedef enum : uint32_t {
  k_ra8_g4_nib_lo   = 0x0FU, 
  k_ra8_g4_nib_sh   = 4U,    
  k_ra8_g4_rgb_g_sh = 8U,    
  k_ra8_g4_rgb_r_sh = 16U,   
} ra8_gfx_g4_const_t;

RA8_INTERNAL
static uint32_t internal_gray4_color(const uint8_t* src, int32_t src_w, int32_t x, int32_t y)
{
  const size_t  flat = ((size_t)y * (size_t)src_w) + (size_t)x;
  const uint8_t byte = src[flat >> 1U];
  const uint8_t nib =
    ((flat & 1U) != 0U) ? (uint8_t)(byte & k_ra8_g4_nib_lo) : (uint8_t)(byte >> k_ra8_g4_nib_sh);
  const uint8_t g8 = (uint8_t)((nib << k_ra8_g4_nib_sh) | nib);
  return ((uint32_t)g8 << k_ra8_g4_rgb_r_sh) | ((uint32_t)g8 << k_ra8_g4_rgb_g_sh) | (uint32_t)g8;
}

RA8_INTERNAL
static void internal_gray4_block(int32_t bx, int32_t by, int32_t zoom, uint32_t color)
{
  for (int32_t dy = 0; dy < zoom; ++dy) {
    for (int32_t dx = 0; dx < zoom; ++dx) {
      priv_gfx_text_plot(bx + dx, by + dy, color);
    }
  }
}
 
ra8_err_t ra8_gfx_blit_gray4_zoom(const uint8_t* src,
                                  int32_t        src_w,
                                  int32_t        src_h,
                                  int32_t        sx,
                                  int32_t        sy,
                                  int32_t        sw,
                                  int32_t        sh,
                                  int32_t        zoom,
                                  int32_t        dst_x,
                                  int32_t        dst_y)
{
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  if (src == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if (zoom <= 0) {
    return k_ra8_err_invalid_arg;
  }
  if ((src_w <= 0) || (src_h <= 0)) {
    return k_ra8_err_invalid_arg;
  }
  /* Clamp the sampled window to the source image bounds; an off-image edge draws
   * only the in-image portion at its natural (dst + offset*zoom) position. A
   * non-positive sw/sh collapses the range, so nothing is drawn. */
  const int32_t x_lo = (sx > 0) ? sx : 0;
  const int32_t y_lo = (sy > 0) ? sy : 0;
  const int32_t x_hi = ((sx + sw) < src_w) ? (sx + sw) : src_w;
  const int32_t y_hi = ((sy + sh) < src_h) ? (sy + sh) : src_h;
  for (int32_t py = y_lo; py < y_hi; ++py) {
    const int32_t by = dst_y + ((py - sy) * zoom);
    for (int32_t px = x_lo; px < x_hi; ++px) {
      internal_gray4_block(dst_x + ((px - sx) * zoom),
                           by,
                           zoom,
                           internal_gray4_color(src, src_w, px, py));
    }
  }
  return k_ra8_ok;
}