main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "book.h"
#include "font_fixture.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"
#include "rabook_fixture.h"
#include "rabook_gray8_fixture.h"
#include "reflow.h"

typedef enum : uint32_t {
  k_erb_fb_w        = 128U,        
  k_erb_fb_h        = 160U,        
  k_erb_font_px     = 16U,         
  k_erb_ink         = 0xFF101010U, 
  k_erb_link_col    = 0xFF2A52BEU, 
  k_erb_bg          = 0xF4F0E8U,   
  k_erb_xhtml_cap   = 2048U,       
  k_erb_uart_baud   = 115200U,     
  k_erb_fnv_offset  = 2166136261U, 
  k_erb_fnv_prime   = 16777619U,   
  k_erb_hex_nibbles = 8U,          
  k_erb_nibble_bits = 4U,          
  k_erb_nibble_mask = 0x0FU,       
  k_erb_dec_ten     = 10U,         
} erb_consts_t;

static uint16_t s_framebuffer[(size_t)k_erb_fb_h * (size_t)k_erb_fb_w];

static reflow_t s_engine;

static char s_xhtml[k_erb_xhtml_cap];
 
static const uint8_t k_msg_boot[] = "ereader-rabook-hil: boot\r\n";
static const uint8_t k_msg_fail[] = "ereader-rabook-hil: FAIL init\r\n";
static const uint8_t k_msg_berr[] = "ereader-rabook-hil: FAIL book\r\n";
static const uint8_t k_msg_lerr[] = "ereader-rabook-hil: FAIL layout\r\n";
static const uint8_t k_msg_pre[]  = "ereader-rabook-hil: chapters=";
static const uint8_t k_msg_ch[]   = " ch";
static const uint8_t k_msg_p[]    = " p=";
static const uint8_t k_msg_crc[]  = " crc=";
static const uint8_t k_msg_img[]  = " img ";
static const uint8_t k_msg_x[]    = "x";
static const uint8_t k_msg_g8[]   = " gray8";
static const uint8_t k_msg_ok[]   = " ok\r\n";

typedef enum : uint32_t {
  k_erb_gray4_levels = 16U,       
  k_erb_level_count  = 256U,      
  k_erb_img_max_px   = 96U * 48U, 
} erb_img_const_t;

static void erb_print(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}

static void erb_panic_halt(const uint8_t* msg, uint32_t len)
{
  erb_print(msg, len);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void erb_print_hex(uint32_t value)
{
  uint8_t buf[k_erb_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_erb_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_erb_hex_nibbles - 1U - i) * (uint32_t)k_erb_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_erb_nibble_mask;
    buf[i] =
      (uint8_t)((nib < (uint32_t)k_erb_dec_ten) ? ('0' + nib) : ('A' + (nib - k_erb_dec_ten)));
  }
  erb_print(buf, (uint32_t)k_erb_hex_nibbles);
}

static void erb_print_uint(uint32_t value)
{
  uint8_t  buf[k_erb_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_erb_dec_ten)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_erb_dec_ten));
    n++;
    value /= (uint32_t)k_erb_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    erb_print(&buf[n - 1U - i], 1U);
  }
}

static uint32_t erb_hash_fb(uint32_t seed)
{
  const size_t   nbytes = (size_t)k_erb_fb_w * (size_t)k_erb_fb_h * sizeof(uint16_t);
  const uint8_t* fb     = (const uint8_t*)s_framebuffer;
  uint32_t       hsh    = seed;
  for (size_t i = 0U; i < nbytes; i++) {
    hsh = (hsh ^ (uint32_t)fb[i]) * (uint32_t)k_erb_fnv_prime;
  }
  return hsh;
}

static uint32_t erb_render_all(uint32_t* out_hash)
{
  uint32_t pages = 0U;
  (void)reflow_get_page_count(&s_engine, &pages);
  uint32_t hsh = (uint32_t)k_erb_fnv_offset;
  for (uint32_t p = 0U; p < pages; p++) {
    (void)ra8_gfx_clear((uint32_t)k_erb_bg);
    (void)reflow_render_page(&s_engine, p, s_framebuffer);
    hsh = erb_hash_fb(hsh);
  }
  *out_hash = hsh;
  return pages;
}

static void erb_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    erb_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    erb_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    erb_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_erb_uart_baud) != k_ra8_ok) {
    erb_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static void erb_render_chapter(const void* book, uint32_t chapter_idx)
{
  size_t xlen = 0U;
  if (book_chapter_to_xhtml(book, chapter_idx, s_xhtml, (size_t)k_erb_xhtml_cap, &xlen) !=
      k_ra8_ok) {
    erb_panic_halt(k_msg_berr, (uint32_t)sizeof(k_msg_berr) - 1U);
  }
  uint32_t pages = 0U;
  if (reflow_layout_chapter(&s_engine, (const uint8_t*)s_xhtml, (uint32_t)xlen, &pages) !=
      k_ra8_ok) {
    erb_panic_halt(k_msg_lerr, (uint32_t)sizeof(k_msg_lerr) - 1U);
  }
  uint32_t       hash     = 0U;
  const uint32_t rendered = erb_render_all(&hash);
 
  erb_print(k_msg_ch, (uint32_t)sizeof(k_msg_ch) - 1U);
  erb_print_uint(chapter_idx);
  erb_print(k_msg_p, (uint32_t)sizeof(k_msg_p) - 1U);
  erb_print_uint(rendered);
  erb_print(k_msg_crc, (uint32_t)sizeof(k_msg_crc) - 1U);
  erb_print_hex(hash);
}

static uint32_t erb_distinct_levels(const uint8_t* px, uint32_t n)
{
  bool           seen[k_erb_level_count] = {};
  uint32_t       distinct                = 0U;
  const uint32_t lim = (n < (uint32_t)k_erb_img_max_px) ? n : (uint32_t)k_erb_img_max_px;
  for (uint32_t i = 0U; i < lim; i++) {
    if (!seen[px[i]]) {
      seen[px[i]] = true;
      distinct++;
    }
  }
  return distinct;
}

static void erb_render_image(void)
{
  const void* img_book = (const void*)k_rabook_gray8_fixture;
  if (book_validate(img_book, (size_t)k_rabook_gray8_fixture_len) != k_ra8_ok) {
    erb_panic_halt(k_msg_berr, (uint32_t)sizeof(k_msg_berr) - 1U);
  }
  const book_header_t* hdr = book_header(img_book);
  if (hdr->image_count == 0U) {
    erb_panic_halt(k_msg_berr, (uint32_t)sizeof(k_msg_berr) - 1U);
  }
  const book_image_t* im  = &book_images(img_book)[0];
  const uint32_t      npx = (uint32_t)im->width * (uint32_t)im->height;
  /* Must be a gray8 raster (8bpp: one byte per pixel), within the scan bound. */
  if ((im->format != (uint8_t)k_book_image_gray4) ||
      (book_image_pixfmt(im) != k_book_pixfmt_gray8) || (im->raw_size != npx) || (npx == 0U) ||
      (npx > (uint32_t)k_erb_img_max_px)) {
    erb_panic_halt(k_msg_berr, (uint32_t)sizeof(k_msg_berr) - 1U);
  }
  /* Continuous tone survived: more than 16 distinct levels is impossible for a
   * 4bpp store, so this proves the source was kept at full depth, not quantised. */
  const uint8_t* px = book_image_data(img_book, im);
  if (erb_distinct_levels(px, npx) <= (uint32_t)k_erb_gray4_levels) {
    erb_panic_halt(k_msg_berr, (uint32_t)sizeof(k_msg_berr) - 1U);
  }
 
  /* Render the retained pixels straight (1 byte/pixel, no unpack) at full res. */
  (void)ra8_gfx_clear((uint32_t)k_erb_bg);
  (void)ra8_gfx_blit_gray8(px, (int32_t)im->width, (int32_t)im->height, 0, 0);
 
  erb_print(k_msg_img, (uint32_t)sizeof(k_msg_img) - 1U);
  erb_print_uint((uint32_t)im->width);
  erb_print(k_msg_x, (uint32_t)sizeof(k_msg_x) - 1U);
  erb_print_uint((uint32_t)im->height);
  erb_print(k_msg_g8, (uint32_t)sizeof(k_msg_g8) - 1U);
}

void main(void)
{
  erb_setup_or_halt();
  ra8_isr_globals_enable();
  erb_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  const void* book = (const void*)k_rabook_fixture;
  if (book_validate(book, (size_t)k_rabook_fixture_len) != k_ra8_ok) {
    erb_panic_halt(k_msg_berr, (uint32_t)sizeof(k_msg_berr) - 1U);
  }
  const uint32_t chapters = book_header(book)->chapter_count;
 
  if (ra8_gfx_init(s_framebuffer,
                   (uint16_t)k_erb_fb_w,
                   (uint16_t)k_erb_fb_h,
                   k_ra8_gfx_format_rgb565) != k_ra8_ok) {
    erb_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (reflow_init((uint16_t)k_erb_fb_w,
                  (uint16_t)k_erb_fb_h,
                  k_ahem_ttf,
                  (size_t)k_ahem_ttf_len,
                  (uint16_t)k_erb_font_px,
                  (uint32_t)k_erb_ink,
                  (uint32_t)k_erb_link_col,
                  &s_engine) != k_ra8_ok) {
    erb_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
 
  erb_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  erb_print_uint(chapters);
  for (uint32_t ci = 0U; ci < chapters; ci++) {
    erb_render_chapter(book, ci);
  }
  erb_render_image(); /* #476: render the retained full-resolution gray8 figure */
  erb_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}