main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "cm_tiled_check.h"
#include "comic.h"
#include "comic_pages_fixture.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_board_ek_ra8d2_touch.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_display_pal.h"
#include "ra8_display_pal_lcd.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_gfx_font.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_panel.h"
#include "ra8_panel_timing.h"
#include "ra8_sdramc.h"
#include "ra8_time.h"
#include "ra8_touch.h"
#include "reflow_image.h"

typedef enum : uint16_t {
  k_cm_fb_w = k_panel_width_px,  
  k_cm_fb_h = k_panel_height_px, 
} cm_fb_dim_t;

typedef enum : uint16_t {
  k_cm_settle_ms   = 500U, 
  k_cm_frame_ms    = 25U,  
  k_cm_led_every   = 16U,  
  k_cm_statusbar_h = 56U,  
  k_cm_progress_h  = 40U,  
  k_cm_text_pad    = 20U,  
  k_cm_glyph_h     = 16U,  
  k_cm_glyph_w     = 8U,   
  k_cm_track_inset = 10U,  
  k_cm_track_h     = 12U,  
} cm_layout_t;

typedef enum : uint32_t {
  k_cm_col_letterbox = 0x0C0C10U, 
  k_cm_col_bar_bg    = 0x1C1C24U, 
  k_cm_col_bar_fg    = 0xF0F0F0U, 
  k_cm_col_bar_muted = 0x9098A8U, 
  k_cm_col_track     = 0x39414FU, 
  k_cm_col_fill      = 0x4C8BF5U, 
} cm_color_t;

typedef enum : uint32_t {
  k_cm_uart_baud   = 115200U,            
  k_cm_arena_bytes = 2U * 1024U * 1024U, 
  k_cm_page_cap    = 8U,                 
  k_cm_name_cap    = 256U,               
  k_cm_pagebuf     = 64U * 1024U,        
  k_cm_batt_pct    = 87U,                
  k_cm_fnv_offset  = 2166136261U,        
  k_cm_fnv_prime   = 16777619U,          
  k_cm_hex_nibbles = 8U,                 
  k_cm_nibble_bits = 4U,                 
  k_cm_nibble_mask = 0x0FU,              
  k_cm_dec_ten     = 10U,                
  k_cm_pos_cap     = 24U,                
  k_cm_batt_cap    = 8U,                 
} cm_reader_cfg_t;

typedef enum : uint8_t {
  k_cm_zone_none   = 0U, 
  k_cm_zone_prev   = 1U, 
  k_cm_zone_next   = 2U, 
  k_cm_zone_chrome = 3U, 
} cm_zone_t;

typedef enum : uint8_t {
  k_cm_thirds = 3U, 
  k_cm_halves = 2U, 
} cm_zone_div_t;

typedef enum : uint8_t {
  k_cm_touch_max_points = 1U, 
} cm_touch_cfg_t;

typedef enum : uint32_t {
  k_cm_touch_bus_hz   = 400000U,   
  k_cm_touch_pclka_hz = 60000000U, 
} cm_touch_bus_cfg_t;

RA8_BOARD_PANEL_FRAMEBUFFER(s_framebuffer);

[[gnu::section(".sdram_data")]] static uint8_t s_img_arena[k_cm_arena_bytes];

[[gnu::section(".sdram_data")]] static uint8_t s_pagebuf[k_cm_pagebuf];

static comic_t s_comic;

static comic_page_t s_pages[k_cm_page_cap];

static char s_names[k_cm_name_cap];

static display_handle_t* s_display = nullptr;

static display_fb_t s_fb;

static uint32_t s_page = 0U;

static uint32_t s_page_count = 1U;

static bool s_chrome_on = true;

static bool s_was_touching = false;

static uint32_t s_loop_ticks = 0U;

static const char k_cm_title[] = "COMIC READER";
static const char k_cm_pos_prefix[] = "Page ";
static const char k_cm_pos_infix[] = " of ";

static const uint8_t k_cm_msg_boot[] = "ereader-comic: boot\r\n";
static const uint8_t k_cm_msg_cerr[] = "ereader-comic: FAIL comic\r\n";
static const uint8_t k_cm_msg_pre[] = "ereader-comic: pages=";
static const uint8_t k_cm_msg_dim[] = " ";
static const uint8_t k_cm_msg_x[] = "x";
static const uint8_t k_cm_msg_page[] = " page=1 crc=";
static const uint8_t k_cm_msg_tiled[] = " tiled=";
static const uint8_t k_cm_msg_colon[] = ":";
static const uint8_t k_cm_msg_ok[] = " ok\r\n";

typedef struct {
  const uint8_t* d; 
  size_t         n; 
} cm_src_t;

static cm_src_t s_src;

static cm_tiled_result_t s_tiled;
 
/* ===========================================================================
 * Console helpers
 * =========================================================================== */

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

static void cm_print_hex(uint32_t value)
{
  uint8_t buf[k_cm_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_cm_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_cm_hex_nibbles - 1U - i) * (uint32_t)k_cm_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_cm_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_cm_dec_ten) ? ('0' + nib) : ('A' + (nib - k_cm_dec_ten)));
  }
  cm_print(buf, (uint32_t)k_cm_hex_nibbles);
}

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

static uint32_t cm_utoa(uint32_t value, char* buf, uint32_t cap)
{
  char     tmp[k_cm_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    tmp[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_cm_dec_ten)) {
    tmp[n] = (char)('0' + (value % (uint32_t)k_cm_dec_ten));
    n++;
    value /= (uint32_t)k_cm_dec_ten;
  }
  uint32_t o = 0U;
  while ((n > 0U) && (o < (cap - 1U))) {
    n--;
    buf[o] = tmp[n];
    o++;
  }
  buf[o] = '\0';
  return o;
}

static void cm_append(char* dst, uint32_t cap, uint32_t* cursor, const char* src)
{
  uint32_t o = *cursor;
  for (uint32_t j = 0U; (src[j] != '\0') && (o < (cap - 1U)); j++) {
    dst[o] = src[j];
    o++;
  }
  dst[o]  = '\0';
  *cursor = o;
}

static uint32_t cm_framebuffer_hash(void)
{
  const uint8_t* p   = (const uint8_t*)s_framebuffer;
  const size_t   nby = sizeof(s_framebuffer);
  uint32_t       hsh = (uint32_t)k_cm_fnv_offset;
  for (size_t i = 0U; i < nby; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_cm_fnv_prime;
  }
  return hsh;
}
 
/* ===========================================================================
 * Boot
 * =========================================================================== */

[[noreturn]] static void cm_panic_halt(void)
{
  (void)ra8_board_led_on(k_ra8_board_led_red);
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void cm_bringup_clocks(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    cm_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    cm_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    cm_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_cm_uart_baud) != k_ra8_ok) {
    cm_panic_halt();
  }
  if ((ra8_board_led_init(k_ra8_board_led_blue) != k_ra8_ok) ||
      (ra8_board_led_init(k_ra8_board_led_red) != k_ra8_ok)) {
    cm_panic_halt();
  }
  ra8_isr_globals_enable();
}

static const display_cfg_t k_cm_display_cfg = {
  .iface             = &k_display_backend_lcd_ra8_glcdc,
  .framebuffer       = s_framebuffer,
  .framebuffer_bytes = sizeof(s_framebuffer),
  .width_px          = (uint16_t)k_cm_fb_w,
  .height_px         = (uint16_t)k_cm_fb_h,
  .pixfmt            = k_display_pixfmt_rgb565,
  .panel_timing      = &s_ra8_panel_ek_ra8d2_timing,
};

static void cm_bringup_panel(void)
{
  ra8_delay_ms((uint32_t)k_cm_settle_ms);
  if (ra8_sdramc_init() != k_ra8_ok) {
    cm_panic_halt();
  }
  if (display_init(&k_cm_display_cfg, &s_display) != k_ra8_ok) {
    cm_panic_halt();
  }
  if (display_get_framebuffer(s_display, &s_fb) != k_ra8_ok) {
    cm_panic_halt();
  }
  if (ra8_gfx_init(s_fb.pixels, s_fb.width_px, s_fb.height_px, k_ra8_gfx_format_rgb565) !=
      k_ra8_ok) {
    cm_panic_halt();
  }
}

static void cm_bringup_touch(void)
{
  const ra8_board_touch_cfg_t cfg = {
    .max_points = (uint8_t)k_cm_touch_max_points,
    .irq_pin    = (uint8_t)k_ra8_touch_irq_pin_unset,
  };
  (void)ra8_board_touch_open(&cfg);
}
 
/* ===========================================================================
 * Comic reader
 * =========================================================================== */

static size_t cm_read(void* ctx, uint64_t off, void* buf, size_t len)
{
  const cm_src_t* s = (const cm_src_t*)ctx;
  if (off >= (uint64_t)s->n) {
    return 0U;
  }
  const uint64_t avail = (uint64_t)s->n - off;
  const size_t   k     = (len > (size_t)avail) ? (size_t)avail : len;
  (void)memcpy(buf, &s->d[off], k);
  return k;
}

static bool cm_open_comic(void)
{
  s_src.d = k_comic_cbz;
  s_src.n = (size_t)k_comic_cbz_len;
  if (comic_open(&s_comic,
                 cm_read,
                 &s_src,
                 (uint64_t)k_comic_cbz_len,
                 s_pages,
                 (uint32_t)k_cm_page_cap,
                 s_names,
                 (uint32_t)sizeof(s_names)) != k_ra8_ok) {
    return false;
  }
  s_page_count = comic_page_count(&s_comic);
  return (s_page_count >= 1U);
}
 
/* ===========================================================================
 * Rendering
 * =========================================================================== */

static bool cm_draw_page(void)
{
  size_t got = 0U;
  if (comic_page_read(&s_comic, s_page, s_pagebuf, sizeof(s_pagebuf), &got) != k_ra8_ok) {
    return false;
  }
  ra8_img_arena_t arena = {.base = s_img_arena, .cap = (size_t)k_cm_arena_bytes};
  const int32_t   box_y = (int32_t)k_cm_statusbar_h;
  const int32_t   box_h = (int32_t)k_cm_fb_h - (int32_t)k_cm_statusbar_h - (int32_t)k_cm_progress_h;
  return (ra8_img_decode_blit(&arena,
                              s_pagebuf,
                              got,
                              0,
                              box_y,
                              (int32_t)k_cm_fb_w,
                              box_h,
                              nullptr,
                              nullptr) == k_ra8_ok);
}

static void cm_draw_status_bar(void)
{
  (void)ra8_gfx_rect(0,
                     0,
                     (int32_t)k_cm_fb_w,
                     (int32_t)k_cm_statusbar_h,
                     (uint32_t)k_cm_col_bar_bg,
                     true);
  const int32_t ty = ((int32_t)k_cm_statusbar_h - (int32_t)k_cm_glyph_h) / 2;
  (void)ra8_gfx_text_out((int32_t)k_cm_text_pad,
                         ty,
                         k_cm_title,
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_cm_col_bar_fg,
                         (uint32_t)k_cm_col_bar_bg);
 
  char     pos[k_cm_pos_cap];
  char     num[k_cm_dec_ten];
  uint32_t cur = 0U;
  (void)cm_utoa(s_page + 1U, num, (uint32_t)sizeof(num));
  cm_append(pos, (uint32_t)sizeof(pos), &cur, k_cm_pos_prefix);
  cm_append(pos, (uint32_t)sizeof(pos), &cur, num);
  cm_append(pos, (uint32_t)sizeof(pos), &cur, k_cm_pos_infix);
  (void)cm_utoa(s_page_count, num, (uint32_t)sizeof(num));
  cm_append(pos, (uint32_t)sizeof(pos), &cur, num);
  const int32_t pos_x = ((int32_t)k_cm_fb_w / 2) - (((int32_t)cur * (int32_t)k_cm_glyph_w) / 2);
  (void)ra8_gfx_text_out(pos_x,
                         ty,
                         pos,
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_cm_col_bar_fg,
                         (uint32_t)k_cm_col_bar_bg);
 
  char     batt[k_cm_batt_cap];
  uint32_t bl   = cm_utoa((uint32_t)k_cm_batt_pct, batt, (uint32_t)sizeof(batt));
  batt[bl]      = '%';
  batt[bl + 1U] = '\0';
  bl++;
  const int32_t bx =
    (int32_t)k_cm_fb_w - (int32_t)k_cm_text_pad - ((int32_t)bl * (int32_t)k_cm_glyph_w);
  (void)ra8_gfx_text_out(bx,
                         ty,
                         batt,
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_cm_col_bar_muted,
                         (uint32_t)k_cm_col_bar_bg);
}

static void cm_draw_progress_bar(void)
{
  const int32_t band_y = (int32_t)k_cm_fb_h - (int32_t)k_cm_progress_h;
  (void)ra8_gfx_rect(0,
                     band_y,
                     (int32_t)k_cm_fb_w,
                     (int32_t)k_cm_progress_h,
                     (uint32_t)k_cm_col_bar_bg,
                     true);
  const int32_t tx = (int32_t)k_cm_track_inset;
  const int32_t tw = (int32_t)k_cm_fb_w - (2 * (int32_t)k_cm_track_inset);
  const int32_t th = (int32_t)k_cm_track_h;
  const int32_t ty = band_y + (((int32_t)k_cm_progress_h - th) / 2);
  (void)ra8_gfx_rect(tx, ty, tw, th, (uint32_t)k_cm_col_track, true);
  const int32_t fw = (int32_t)(((int64_t)tw * (int64_t)(s_page + 1U)) / (int64_t)s_page_count);
  (void)ra8_gfx_rect(tx, ty, fw, th, (uint32_t)k_cm_col_fill, true);
}

static void cm_render(void)
{
  (void)ra8_gfx_clear((uint32_t)k_cm_col_letterbox);
  (void)cm_draw_page();
  if (s_chrome_on) {
    cm_draw_status_bar();
    cm_draw_progress_bar();
  }
}

static void cm_present(void)
{
  (void)display_flush(s_display, display_full_rect(s_display), k_display_refresh_quality);
}
 
/* ===========================================================================
 * Tap-zone navigation
 * =========================================================================== */

static cm_zone_t cm_zone_at(int32_t x, int32_t y)
{
  const int32_t third = (int32_t)k_cm_fb_w / (int32_t)k_cm_thirds;
  if (x < third) {
    return k_cm_zone_prev;
  }
  if (x >= (2 * third)) {
    return k_cm_zone_next;
  }
  if (y < ((int32_t)k_cm_fb_h / (int32_t)k_cm_halves)) {
    return k_cm_zone_chrome;
  }
  return k_cm_zone_none;
}

static bool cm_handle_tap(int32_t x, int32_t y)
{
  switch (cm_zone_at(x, y)) {
    case k_cm_zone_next:
      if ((s_page + 1U) < s_page_count) {
        s_page++;
        return true;
      }
      return false;
    case k_cm_zone_prev:
      if (s_page > 0U) {
        s_page--;
        return true;
      }
      return false;
    case k_cm_zone_chrome:
      s_chrome_on = !s_chrome_on;
      return true;
    case k_cm_zone_none:
    default:
      return false;
  }
}

static void cm_poll_touch(void)
{
  ra8_touch_point_t pt  = {};
  uint8_t           got = 0U;
  if (ra8_touch_read(&pt, (uint8_t)k_cm_touch_max_points, &got) != k_ra8_ok) {
    return;
  }
  const bool touching = (got > 0U);
  if (touching && !s_was_touching) {
    if (cm_handle_tap((int32_t)pt.x, (int32_t)pt.y)) {
      cm_render();
      cm_present();
    }
  }
  s_was_touching = touching;
}

static void cm_print_banner(void)
{
  cm_print(k_cm_msg_pre, (uint32_t)sizeof(k_cm_msg_pre) - 1U);
  cm_print_uint(s_page_count);
  cm_print(k_cm_msg_dim, (uint32_t)sizeof(k_cm_msg_dim) - 1U);
  cm_print_uint((uint32_t)k_cm_fb_w);
  cm_print(k_cm_msg_x, (uint32_t)sizeof(k_cm_msg_x) - 1U);
  cm_print_uint((uint32_t)k_cm_fb_h);
  cm_print(k_cm_msg_page, (uint32_t)sizeof(k_cm_msg_page) - 1U);
  cm_print_hex(cm_framebuffer_hash());
  cm_print(k_cm_msg_tiled, (uint32_t)sizeof(k_cm_msg_tiled) - 1U);
  cm_print_uint(s_tiled.w);
  cm_print(k_cm_msg_x, (uint32_t)sizeof(k_cm_msg_x) - 1U);
  cm_print_uint(s_tiled.h);
  cm_print(k_cm_msg_colon, (uint32_t)sizeof(k_cm_msg_colon) - 1U);
  cm_print_uint(s_tiled.tiles);
  cm_print(k_cm_msg_colon, (uint32_t)sizeof(k_cm_msg_colon) - 1U);
  cm_print_hex(s_tiled.crc);
  cm_print(k_cm_msg_ok, (uint32_t)sizeof(k_cm_msg_ok) - 1U);
}

void main(void)
{
  cm_bringup_clocks();
  cm_print(k_cm_msg_boot, (uint32_t)sizeof(k_cm_msg_boot) - 1U);
  cm_bringup_panel();
  cm_bringup_touch();
 
  if (!cm_open_comic()) {
    cm_print(k_cm_msg_cerr, (uint32_t)sizeof(k_cm_msg_cerr) - 1U);
    cm_panic_halt();
  }
 
  cm_render();
  cm_present();
  s_tiled = cm_comic_tiled_selfcheck();
  cm_print_banner();
 
  while (1) {
    cm_poll_touch();
    if ((s_loop_ticks % (uint32_t)k_cm_led_every) == 0U) {
      (void)ra8_board_led_toggle(k_ra8_board_led_blue);
    }
    s_loop_ticks++;
    ra8_delay_ms((uint32_t)k_cm_frame_ms);
  }
}