sh_image.c

Go to the documentation of this file.

#include "ra8_check.h"
#include "ra8_gfx.h"
#include "sh_app.h"

typedef enum : uint32_t {
  k_sh_nib_sh    = 4U,    
  k_sh_two       = 2U,    
  k_sh_img_max_w = 2048U, 
} sh_img_const_t;

static uint8_t s_sh_gray8_row[k_sh_img_max_w];

static uint8_t
  s_sh_loupe[((k_sh_loupe_w / k_sh_loupe_zoom) * (k_sh_loupe_h / k_sh_loupe_zoom)) / k_sh_two];
 
static_assert((k_sh_loupe_w % k_sh_loupe_zoom) == 0U, "loupe width must be a multiple of zoom");
static_assert((k_sh_loupe_h % k_sh_loupe_zoom) == 0U, "loupe height must be a multiple of zoom");

static bool sh_gray4_fetch_row(const book_src_t* src, const book_image_t* img, uint32_t sy)
{
  return book_src_image_rect(src,
                             img,
                             0U,
                             sy,
                             (uint32_t)img->width,
                             1U,
                             s_sh_gray8_row,
                             (uint32_t)img->width) == k_ra8_ok;
}

static void sh_fit_box(int32_t  src_w,
                       int32_t  src_h,
                       int32_t  box_w,
                       int32_t  box_h,
                       int32_t* fit_w,
                       int32_t* fit_h)
{
  int32_t fw = box_w;
  int32_t fh = (src_w > 0) ? ((box_w * src_h) / src_w) : box_h;
  if (fh > box_h) {
    fh = box_h;
    fw = (src_h > 0) ? ((box_h * src_w) / src_h) : box_w;
  }
  *fit_w = (fw < 1) ? 1 : fw;
  *fit_h = (fh < 1) ? 1 : fh;
}

static bool sh_gray4_image(const book_src_t* src, uint32_t img_idx, book_image_t* out_img)
{
  if (book_src_image(src, img_idx, out_img) != k_ra8_ok) {
    return false;
  }
  if (out_img->format != (uint8_t)k_book_image_gray4) {
    return false;
  }
  if ((out_img->width == 0U) || (out_img->height == 0U)) {
    return false;
  }
  return (uint32_t)out_img->width <= (uint32_t)k_sh_img_max_w;
}

static int32_t sh_clampi(int32_t v, int32_t lo, int32_t hi)
{
  const int32_t x = (v < lo) ? lo : v;
  return (x > hi) ? hi : x;
}

static void sh_loupe_pack(int32_t j, int32_t i, int32_t w, uint8_t g8)
{
  const size_t  flat = ((size_t)j * (size_t)w) + (size_t)i;
  const uint8_t nib  = (uint8_t)(g8 >> k_sh_nib_sh);
  const size_t  bi   = flat >> 1U;
  if ((flat & 1U) == 0U) {
    s_sh_loupe[bi] = (uint8_t)(nib << k_sh_nib_sh); /* even flat: high nibble (clears low) */
  } else {
    s_sh_loupe[bi] = (uint8_t)(s_sh_loupe[bi] | nib); /* odd flat: OR in the low nibble */
  }
}

static bool sh_loupe_stage(const book_src_t*   src,
                           const book_image_t* img,
                           int32_t             sx,
                           int32_t             sy,
                           int32_t             w,
                           int32_t             h)
{
  for (int32_t j = 0; j < h; ++j) {
    if (book_src_image_rect(src,
                            img,
                            (uint32_t)sx,
                            (uint32_t)(sy + j),
                            (uint32_t)w,
                            1U,
                            s_sh_gray8_row,
                            (uint32_t)w) != k_ra8_ok) {
      return false;
    }
    for (int32_t i = 0; i < w; ++i) {
      sh_loupe_pack(j, i, w, s_sh_gray8_row[i]);
    }
  }
  return true;
}

static void sh_loupe_chrome(int32_t dst_x, int32_t dst_y)
{
  const ra8_ui_rect_t r = {.x = dst_x,
                           .y = dst_y,
                           .w = (int32_t)k_sh_loupe_w,
                           .h = (int32_t)k_sh_loupe_h};
  sh_border(r, (uint32_t)k_sh_col_ink, (int32_t)k_sh_loupe_border);
}
 
ra8_err_t sh_image_decode_gray8(const book_src_t* src,
                                uint32_t          img_idx,
                                uint8_t*          out,
                                int32_t           box_w,
                                int32_t           box_h,
                                int32_t*          out_w,
                                int32_t*          out_h)
{
  RA8_CHECK_NULL_PTR(src, "sh_image", "decode: null src");
  RA8_CHECK_NULL_PTR(out, "sh_image", "decode: null out");
  book_image_t img = {};
  if (!sh_gray4_image(src, img_idx, &img) || (box_w <= 0) || (box_h <= 0)) {
    return k_ra8_err_invalid_arg;
  }
  int32_t fw = 0;
  int32_t fh = 0;
  sh_fit_box((int32_t)img.width, (int32_t)img.height, box_w, box_h, &fw, &fh);
  uint32_t last_sy = UINT32_MAX;
  for (int32_t dy = 0; dy < fh; ++dy) {
    const uint32_t sy = (uint32_t)((dy * (int32_t)img.height) / fh);
    if ((sy != last_sy) && !sh_gray4_fetch_row(src, &img, sy)) {
      return k_ra8_err_invalid_arg;
    }
    last_sy = sy;
    for (int32_t dx = 0; dx < fw; ++dx) {
      const uint32_t sx   = (uint32_t)((dx * (int32_t)img.width) / fw);
      out[(dy * fw) + dx] = s_sh_gray8_row[sx];
    }
  }
  *out_w = fw;
  *out_h = fh;
  return k_ra8_ok;
}
 
void sh_image_blit_gray8(const uint8_t* src, int32_t w, int32_t h, int32_t dst_x, int32_t dst_y)
{
  if ((src == nullptr) || (w <= 0) || (h <= 0)) {
    return;
  }
  /* One clipped row-loop in ra8_gfx instead of a per-pixel ra8_gfx_pixel chain. */
  (void)ra8_gfx_blit_gray8(src, w, h, dst_x, dst_y);
}

static uint8_t s_sh_cover_row[k_sh_fb_w];
 
ra8_err_t sh_image_blit_cover(const book_src_t* src,
                              uint32_t          img_idx,
                              int32_t           dst_x,
                              int32_t           dst_y,
                              int32_t           box_w,
                              int32_t           box_h,
                              int32_t*          out_w,
                              int32_t*          out_h)
{
  RA8_CHECK_NULL_PTR(src, "sh_image", "cover: null src");
  book_image_t img = {};
  if (!sh_gray4_image(src, img_idx, &img) || (box_w <= 0) || (box_h <= 0)) {
    return k_ra8_err_invalid_arg;
  }
  int32_t fw = 0;
  int32_t fh = 0;
  sh_fit_box((int32_t)img.width, (int32_t)img.height, box_w, box_h, &fw, &fh);
  const int32_t ox = dst_x + ((box_w - fw) / (int32_t)k_sh_two);
  const int32_t oy = dst_y + ((box_h - fh) / (int32_t)k_sh_two);
  /* Read one unpacked gray8 source row via the library, nearest-neighbour scale
   * it into a gray8 row, then blit that row in a single clipped pass -- the same
   * pixels the resident per-pixel loop wrote, far fewer calls. */
  const int32_t rw      = (fw < (int32_t)k_sh_fb_w) ? fw : (int32_t)k_sh_fb_w;
  uint32_t      last_sy = UINT32_MAX;
  for (int32_t dy = 0; dy < fh; ++dy) {
    const uint32_t sy = (uint32_t)((dy * (int32_t)img.height) / fh);
    if ((sy != last_sy) && !sh_gray4_fetch_row(src, &img, sy)) {
      return k_ra8_err_invalid_arg;
    }
    last_sy = sy;
    for (int32_t dx = 0; dx < rw; ++dx) {
      const uint32_t sx          = (uint32_t)((dx * (int32_t)img.width) / fw);
      s_sh_cover_row[(size_t)dx] = s_sh_gray8_row[sx];
    }
    (void)ra8_gfx_blit_gray8(s_sh_cover_row, rw, 1, ox, oy + dy);
  }
  if (out_w != nullptr) {
    *out_w = fw;
  }
  if (out_h != nullptr) {
    *out_h = fh;
  }
  return k_ra8_ok;
}
 
ra8_err_t sh_image_loupe(const book_src_t* src,
                         uint32_t          img_idx,
                         int32_t           src_cx,
                         int32_t           src_cy,
                         int32_t           dst_x,
                         int32_t           dst_y)
{
  RA8_CHECK_NULL_PTR(src, "sh_image", "loupe: null src");
  book_image_t img = {};
  if (!sh_gray4_image(src, img_idx, &img)) {
    return k_ra8_err_invalid_arg;
  }
  /* Sample a FULL-RESOLUTION window (never scale-to-fit) and magnify it 1:1. The
   * window shrinks to the image if a small source cannot fill the lens. */
  const int32_t sub_w = (int32_t)k_sh_loupe_w / (int32_t)k_sh_loupe_zoom;
  const int32_t sub_h = (int32_t)k_sh_loupe_h / (int32_t)k_sh_loupe_zoom;
  const int32_t w     = ((int32_t)img.width < sub_w) ? (int32_t)img.width : sub_w;
  const int32_t h     = ((int32_t)img.height < sub_h) ? (int32_t)img.height : sub_h;
  const int32_t sx    = sh_clampi(src_cx - (w / (int32_t)k_sh_two), 0, (int32_t)img.width - w);
  const int32_t sy    = sh_clampi(src_cy - (h / (int32_t)k_sh_two), 0, (int32_t)img.height - h);
  if (!sh_loupe_stage(src, &img, sx, sy, w, h)) {
    return k_ra8_err_invalid_arg;
  }
  /* Confine the magnified blit to the lens window so nothing spills, then frame. */
  (void)ra8_gfx_set_clip(dst_x, dst_y, (int32_t)k_sh_loupe_w, (int32_t)k_sh_loupe_h);
  (void)
    ra8_gfx_blit_gray4_zoom(s_sh_loupe, w, h, 0, 0, w, h, (int32_t)k_sh_loupe_zoom, dst_x, dst_y);
  (void)ra8_gfx_reset_clip();
  sh_loupe_chrome(dst_x, dst_y);
  return k_ra8_ok;
}
 
bool sh_image_loupe_map(const book_src_t* src,
                        uint32_t          img_idx,
                        int32_t           box_x,
                        int32_t           box_y,
                        int32_t           box_w,
                        int32_t           box_h,
                        int32_t           px,
                        int32_t           py,
                        int32_t*          out_cx,
                        int32_t*          out_cy)
{
  if ((src == nullptr) || (out_cx == nullptr) || (out_cy == nullptr)) {
    return false;
  }
  book_image_t img = {};
  if (!sh_gray4_image(src, img_idx, &img) || (box_w <= 0) || (box_h <= 0)) {
    return false;
  }
  int32_t fw = 0;
  int32_t fh = 0;
  sh_fit_box((int32_t)img.width, (int32_t)img.height, box_w, box_h, &fw, &fh);
  const int32_t ox     = box_x + ((box_w - fw) / (int32_t)k_sh_two);
  const int32_t oy     = box_y + ((box_h - fh) / (int32_t)k_sh_two);
  const bool    inside = (px >= ox) && (px < (ox + fw)) && (py >= oy) && (py < (oy + fh));
  if (!inside) {
    return false;
  }
  *out_cx = ((px - ox) * (int32_t)img.width) / fw;
  *out_cy = ((py - oy) * (int32_t)img.height) / fh;
  return true;
}