zoom_render.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_gfx_dither.h"
#include "zoom.h"
#include "zoom_internal.h"

static const char* const s_tag = "zoom_render";

typedef enum : uint8_t {
  k_zoom_blit_origin = 0U, 
  k_zoom_blit_native = 1U, 
} zoom_blit_t;

RA8_INTERNAL
static void internal_expand_row(const zoom_view_t* v, const zoom_axis_t* ax, uint8_t* drow)
{
  const int32_t scale = (int32_t)v->scale;
  /* The whole index calculation stays signed and the only conversion is of the
   * axis' own simple `s0` -- a cast of the composite `(anchor + d) / scale` to
   * an unsigned type would change essential type mid-expression (MISRA 10.8)
   * for no benefit: every value here is non-negative by construction. */
  const int32_t base = (int32_t)ax->s0;
  for (int32_t d = ax->d0; d < ax->d1; ++d) {
    const int32_t si = ((v->anchor_x + d) / scale) - base;
    drow[d]          = v->scratch.row[si];
  }
}

RA8_INTERNAL
static ra8_err_t internal_fill_row(zoom_view_t*       v,
                                   const zoom_axis_t* ax,
                                   int32_t            plane_y,
                                   uint8_t*           drow,
                                   int32_t*           cached_sy)
{
  const int32_t scale  = (int32_t)v->scale;
  const int32_t height = (int32_t)v->src.height;
  const int32_t sy     = (plane_y >= 0) ? (plane_y / scale) : -1;
  /* Decision: this destination row shows image only if the plane row lies
   * inside the image. The horizontal span is NOT re-tested here -- it is
   * constant across the frame and ::internal_fill_strip settles it once, which
   * keeps this decision to two conditions that are each independently
   * reachable rather than three where one never varies. */
  const bool covered = (sy >= 0) && (sy < height);
  if (!covered) {
    return k_ra8_ok;
  }
  if (sy != *cached_sy) {
    const ra8_err_t rc =
      v->src.read(v->src.ctx, ax->s0, (uint32_t)sy, ax->count, 1U, v->scratch.row, ax->count);
    if (rc != k_ra8_ok) {
      /* Name the row. The caller only learns that the frame was abandoned, and
       * on a paged source which source row faulted IS the diagnostic. */
      ra8_log_error_val(s_tag, "source read failed at row", (uint32_t)sy);
      *cached_sy = -1;
      return rc;
    }
    *cached_sy = sy;
  }
  internal_expand_row(v, ax, drow);
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fill_strip(zoom_view_t*       v,
                                     const zoom_axis_t* ax,
                                     int32_t            top,
                                     int32_t            rows,
                                     int32_t*           cached_sy)
{
  const size_t stride = (size_t)v->dst.w;
  (void)memset(v->scratch.strip, (int)k_zoom_bg_gray, (size_t)rows * stride);
  if (ax->count == 0U) {
    /* The image misses the viewport horizontally, so every row is letterbox and
     * the background fill above is the whole answer. */
    return k_ra8_ok;
  }
  for (int32_t r = 0; r < rows; ++r) {
    uint8_t* drow = &v->scratch.strip[(size_t)r * stride];
    RA8_RETURN_ON_ERROR(internal_fill_row(v, ax, v->anchor_y + top + r, drow, cached_sy),
                        s_tag,
                        "strip row");
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_emit_strip(zoom_view_t*       v,
                                     const zoom_axis_t* ax,
                                     int32_t            top,
                                     int32_t            rows,
                                     int32_t*           cached_sy)
{
  RA8_RETURN_ON_ERROR(internal_fill_strip(v, ax, top, rows, cached_sy), s_tag, "strip fill");
  uint32_t packed_len = 0U;
  RA8_RETURN_ON_ERROR(ra8_gfx_dither_gray8_to_gray4(v->scratch.strip,
                                                    v->dst.w,
                                                    rows,
                                                    v->anchor_x,
                                                    v->anchor_y + top,
                                                    v->scratch.packed,
                                                    v->scratch.packed_cap,
                                                    &packed_len),
                      s_tag,
                      "strip dither");
  return ra8_gfx_blit_gray4_zoom(v->scratch.packed,
                                 v->dst.w,
                                 rows,
                                 (int32_t)k_zoom_blit_origin,
                                 (int32_t)k_zoom_blit_origin,
                                 v->dst.w,
                                 rows,
                                 (int32_t)k_zoom_blit_native,
                                 v->dst.x,
                                 v->dst.y + top);
}

RA8_INTERNAL
static ra8_err_t internal_render_ready(const zoom_view_t* v)
{
  RA8_CHECK_NULL_PTR(v, s_tag, "view must not be nullptr");
  RA8_CHECK_NULL_PTR(v->src.read, s_tag, "view source seam must not be nullptr");
  if (!v->active) {
    ra8_log_error(s_tag, "render on a closed view");
    return k_ra8_err_invalid_state;
  }
  if (v->strip_rows == 0U) {
    ra8_log_error(s_tag, "view has no strip height; it was not opened properly");
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}
 
ra8_err_t zoom_view_render(zoom_view_t* v)
{
  RA8_RETURN_ON_ERROR(internal_render_ready(v), s_tag, "render preconditions");
 
  zoom_axis_t ax = {};
  priv_zoom_axis(v->anchor_x, v->dst.w, (int32_t)v->scale, (int32_t)v->src.width, &ax);
 
  const int32_t rows_max  = (int32_t)v->strip_rows;
  int32_t       cached_sy = -1;
  for (int32_t top = 0; top < v->dst.h; top += rows_max) {
    int32_t rows = v->dst.h - top;
    if (rows > rows_max) {
      rows = rows_max;
    }
    RA8_RETURN_ON_ERROR(internal_emit_strip(v, &ax, top, rows, &cached_sy), s_tag, "strip emit");
  }
  return k_ra8_ok;
}