reflow_layout_image.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "reflow.h"
#include "reflow_image.h"
#include "reflow_internal.h"
#include "reflow_layout_internal.h"
#include "stb_truetype.h"

RA8_INTERNAL
static bool internal_apply_image_placeholder(reflow_t* engine, priv_cursor_t* cur)
{
  const int32_t advance     = (int32_t)k_priv_image_placeholder_px;
  const int32_t right_limit = (int32_t)engine->viewport_w - (int32_t)k_reflow_margin_px;
  if (priv_reflow_internal_right_overflow_break(cur->x,
                                                advance,
                                                right_limit,
                                                cur->line_has_content)) {
    if (!priv_reflow_layout_newline(engine, cur, false)) {
      return false;
    }
  }
  cur->x += advance;
  cur->line_has_content = 1U;
  return true;
}

RA8_INTERNAL
static bool internal_page_has_content(const reflow_t* engine, const priv_cursor_t* cur)
{
  return (engine->glyph_count > cur->page_first_glyph) ||
         (engine->image_box_count > cur->page_first_image);
}

RA8_INTERNAL
static void internal_image_fit(int32_t  iw,
                               int32_t  ih,
                               int32_t  col_w,
                               int32_t  avail_h,
                               int32_t* out_w,
                               int32_t* out_h)
{
  int32_t bw = (iw < col_w) ? iw : col_w;
  int32_t bh = (int32_t)(((int64_t)ih * (int64_t)bw) / (int64_t)iw);
  if (bh > avail_h) {
    bh = avail_h;
    bw = (int32_t)(((int64_t)iw * (int64_t)bh) / (int64_t)ih);
  }
  *out_w = (bw < 1) ? 1 : bw;
  *out_h = (bh < 1) ? 1 : bh;
}

RA8_INTERNAL
static bool internal_image_resolve_size(reflow_t*             engine,
                                        const reflow_token_t* tok,
                                        int32_t*              out_w,
                                        int32_t*              out_h)
{
  const char*    href  = (const char*)&engine->text_pool[tok->text_off];
  const uint8_t* bytes = nullptr;
  size_t         blen  = 0U;
  if (engine->img_loader(engine->img_loader_ctx, href, tok->text_len, &bytes, &blen) != k_ra8_ok) {
    return false;
  }
  int32_t iw = 0;
  int32_t ih = 0;
  if ((ra8_img_probe_size(bytes, blen, &iw, &ih) != k_ra8_ok) || (iw <= 0) || (ih <= 0)) {
    return false;
  }
  const int32_t col_w   = (int32_t)engine->viewport_w - (2 * (int32_t)k_reflow_margin_px);
  const int32_t avail_h = (int32_t)engine->viewport_h - (2 * (int32_t)k_reflow_margin_px);
  if ((col_w < 1) || (avail_h < 1)) {
    return false;
  }
  internal_image_fit(iw, ih, col_w, avail_h, out_w, out_h);
  return true;
}

RA8_INTERNAL
static void internal_image_record(reflow_t*             engine,
                                  priv_cursor_t*        cur,
                                  const reflow_token_t* tok,
                                  int32_t               bw,
                                  int32_t               bh)
{
  reflow_image_box_t* box = &engine->image_boxes[engine->image_box_count];
  box->x                  = (int32_t)k_reflow_margin_px;
  box->y                  = cur->y;
  box->w                  = bw;
  box->h                  = bh;
  box->src_off            = tok->text_off;
  box->src_len            = tok->text_len;
  box->page_index         = engine->page_count;
  box->reserved           = 0U;
  engine->image_box_count++;
 
  cur->y += bh + (int32_t)k_reflow_paragraph_gap_px;
  cur->line_top         = cur->y;
  cur->x                = (int32_t)k_reflow_margin_px + (int32_t)cur->indent_px;
  cur->line_has_content = 0U;
}

RA8_INTERNAL
static bool internal_place_image(reflow_t* engine, priv_cursor_t* cur, const reflow_token_t* tok)
{
  if (engine->image_box_count >= (uint32_t)k_reflow_max_images) {
    return false;
  }
  int32_t bw = 0;
  int32_t bh = 0;
  if (!internal_image_resolve_size(engine, tok, &bw, &bh)) {
    return false;
  }
  /* Block-level: drop below the current line, then page-break if needed. */
  if (cur->line_has_content != 0U) {
    if (!priv_reflow_layout_newline(engine, cur, false)) {
      return false;
    }
  }
  const int32_t bottom_limit = (int32_t)engine->viewport_h - (int32_t)k_reflow_margin_px;
  if (((cur->y + bh) > bottom_limit) && internal_page_has_content(engine, cur)) {
    if (!priv_reflow_layout_finish_page(engine, cur)) {
      return false;
    }
  }
  internal_image_record(engine, cur, tok, bw, bh);
  /* mcdc-deactivated: internal_image_record incremented image_box_count immediately above, so internal_page_has_content is invariantly true here; its false arm is unreachable once an image box has been recorded on the current page. */
  if (((cur->y + (int32_t)cur->line_height_px) > bottom_limit) &&
      internal_page_has_content(engine, cur)) {
    if (!priv_reflow_layout_finish_page(engine, cur)) {
      return false;
    }
  }
  return true;
}
 
bool priv_reflow_layout_apply_image(reflow_t* engine, priv_cursor_t* cur, const reflow_token_t* tok)
{
  if ((engine->img_loader != nullptr) && (engine->img_arena != nullptr) && (tok->text_len > 0U)) {
    if (internal_place_image(engine, cur, tok)) {
      return true;
    }
    /* Resolution / pool overflow: fall back to the placeholder advance. */
  }
  return internal_apply_image_placeholder(engine, cur);
}