reflow_image.c

Go to the documentation of this file.

 
#include "reflow_image.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_img_arena.h"
#include "ra8_log.h"
#include "reflow_svg.h"
#include "stb_image.h"

static const char* const s_tag_img = "ra8_img";

typedef enum : uint8_t {
  k_ra8_img_req_rgb  = 3, 
  k_ra8_img_ch_r     = 0, 
  k_ra8_img_ch_g     = 1, 
  k_ra8_img_ch_b     = 2, 
  k_ra8_img_min_edge = 1, 
} ra8_img_pack_t;

typedef enum : uint8_t {
  k_ra8_img_shift_r = 16, 
  k_ra8_img_shift_g = 8,  
} ra8_img_shift_t;
 
ra8_err_t ra8_img_probe_size(const uint8_t* bytes, size_t len, int32_t* out_w, int32_t* out_h)
{
  RA8_CHECK_NULL_PTR(bytes, s_tag_img, "probe: null bytes");
  RA8_CHECK_NULL_PTR(out_w, s_tag_img, "probe: null out_w");
  RA8_CHECK_NULL_PTR(out_h, s_tag_img, "probe: null out_h");
 
  /* SVG is not a raster: take its intrinsic size from the document (#112). */
  if (ra8_svg_is_svg(bytes, len)) {
    return ra8_svg_size(bytes, len, out_w, out_h);
  }
 
  int x    = 0;
  int y    = 0;
  int comp = 0;
  if (stbi_info_from_memory(bytes, (int)len, &x, &y, &comp) == 0) {
    ra8_log_error(s_tag_img, "probe: stbi_info rejected the header");
    return k_ra8_err_not_supported;
  }
  *out_w = (int32_t)x;
  *out_h = (int32_t)y;
  return k_ra8_ok;
}

RA8_INTERNAL
static void internal_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 sw = 0;
  int32_t sh = 0;
  if (((int64_t)box_w * (int64_t)src_h) <= ((int64_t)box_h * (int64_t)src_w)) {
    /* Width is the tighter constraint: fill the box width. */
    sw = box_w;
    sh = (int32_t)(((int64_t)src_h * (int64_t)box_w) / (int64_t)src_w);
  } else {
    /* Height is the tighter constraint: fill the box height. */
    sh = box_h;
    sw = (int32_t)(((int64_t)src_w * (int64_t)box_h) / (int64_t)src_h);
  }
  *fit_w = (sw < k_ra8_img_min_edge) ? (int32_t)k_ra8_img_min_edge : sw;
  *fit_h = (sh < k_ra8_img_min_edge) ? (int32_t)k_ra8_img_min_edge : sh;
}

RA8_INTERNAL
static ra8_err_t internal_decode_fail(void)
{
  const char* const reason = stbi_failure_reason();
  /*
   * internal_decode_fail() is called only from ra8_img_decode_blit() after
   * stbi_load_from_memory() has already reported a decode failure. stb_image
   * sets its global failure string on every failure path, so stbi_failure_reason()
   * is non-null on every call that reaches here; the (reason == nullptr) arm is
   * unreachable defensive code and cannot give the first condition independent
   * influence.
   */
  /* mcdc-deactivated: stbi sets a reason on every failure, so (reason != nullptr) is always true here. */
  if ((reason != nullptr) && (strstr(reason, "outofmem") != nullptr)) {
    return k_ra8_err_no_mem;
  }
  return k_ra8_err_not_supported;
}

RA8_INTERNAL
static void internal_blit_scaled(const uint8_t* pixels,
                                 int32_t        src_w,
                                 int32_t        src_h,
                                 int32_t        fit_w,
                                 int32_t        fit_h,
                                 int32_t        dst_x,
                                 int32_t        dst_y)
{
  for (int32_t dy = 0; dy < fit_h; dy++) {
    const int32_t map_y = (int32_t)(((int64_t)dy * (int64_t)src_h) / (int64_t)fit_h);
    for (int32_t dx = 0; dx < fit_w; dx++) {
      const int32_t map_x = (int32_t)(((int64_t)dx * (int64_t)src_w) / (int64_t)fit_w);
      const size_t  idx =
        (((size_t)map_y * (size_t)src_w) + (size_t)map_x) * (size_t)k_ra8_img_req_rgb;
      const uint32_t color = ((uint32_t)pixels[idx + (size_t)k_ra8_img_ch_r] << k_ra8_img_shift_r) |
                             ((uint32_t)pixels[idx + (size_t)k_ra8_img_ch_g] << k_ra8_img_shift_g) |
                             (uint32_t)pixels[idx + (size_t)k_ra8_img_ch_b];
      (void)ra8_gfx_pixel(dst_x + dx, dst_y + dy, color);
    }
  }
}

RA8_INTERNAL
static void internal_arena_release(ra8_img_arena_t* arena)
{
  ra8_img_arena_unbind();
  arena->offset = 0U;
  arena->live   = 0U;
}

ra8_err_t ra8_img_decode_blit(ra8_img_arena_t* arena,
                              const uint8_t*   bytes,
                              size_t           len,
                              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(arena, s_tag_img, "blit: null arena");
  RA8_CHECK_NULL_PTR(bytes, s_tag_img, "blit: null bytes");
  if ((len == 0U) || (box_w < (int32_t)k_ra8_img_min_edge) ||
      (box_h < (int32_t)k_ra8_img_min_edge)) {
    ra8_log_error(s_tag_img, "blit: empty input or box");
    return k_ra8_err_invalid_arg;
  }
 
  ra8_img_arena_bind(arena); /* resets the arena to empty */
  int sx   = 0;
  int sy   = 0;
  int comp = 0;
  /* The stb call stays on one line so the no-alloc audit
     (scripts/checks/check_no_dynamic_alloc.py) finds its opt-out on the flagged
     call line; clang-format would otherwise wrap it across many lines. */
  // clang-format off: the allocation opt-out comment must stay on the flagged call line.
  uint8_t* const pixels = stbi_load_from_memory(bytes, (int)len, &sx, &sy, &comp, (int)k_ra8_img_req_rgb); /* alloc-allow: stb is backed by the fixed ra8_img_arena (zero-heap), not malloc */
  // clang-format on
  /*
   * stbi_load_from_memory() returns a non-null pixel pointer only when it
   * decoded a bitmap of at least 1x1 (it rejects zero-dimension images with a
   * null return). So whenever pixels != nullptr, sx >= 1 and sy >= 1: the
   * (sx <= 0) and (sy <= 0) guards are defensive belt-and-suspenders that can
   * only be true when pixels == nullptr already made the decision true. Neither
   * can be flipped independently, so full MC/DC of this decision is unreachable.
   */
  /* mcdc-deactivated: stbi guarantees sx,sy >= 1 when pixels != nullptr; sx/sy guards are unreachable. */
  if ((pixels == nullptr) || (sx <= 0) || (sy <= 0)) {
    const ra8_err_t err = internal_decode_fail();
    internal_arena_release(arena);
    ra8_log_error(s_tag_img, "blit: decode failed");
    return err;
  }
 
  int32_t fit_w = 0;
  int32_t fit_h = 0;
  internal_fit_box((int32_t)sx, (int32_t)sy, box_w, box_h, &fit_w, &fit_h);
  internal_blit_scaled(pixels, (int32_t)sx, (int32_t)sy, fit_w, fit_h, dst_x, dst_y);
  // clang-format off: the allocation opt-out comment must stay on the flagged call line.
  stbi_image_free(pixels); /* alloc-allow: ra8_img_arena-backed (zero-heap), not malloc */
  // clang-format on
  internal_arena_release(arena);
 
  if (out_w != nullptr) {
    *out_w = fit_w;
  }
  if (out_h != nullptr) {
    *out_h = fit_h;
  }
  return k_ra8_ok;
}