main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "jof.h"
#include "longstrip.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_check.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_io_i2c_bus.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_panel.h"
#include "ra8_panel_timing.h"
#include "ra8_sdramc.h"
#include "ra8_tile_cache.h"
#include "ra8_time.h"
#include "ra8_touch.h"
 
/* ===========================================================================
 * Geometry (no magic numbers)
 * ===========================================================================
 */

typedef enum : uint16_t {
  k_ls_view_w    = k_panel_width_px,  
  k_ls_view_h    = k_panel_height_px, 
  k_ls_band_h    = 280U,              
  k_ls_bands     = 16U,               
  k_ls_status_h  = 40U,               
  k_ls_rail_w    = 12U,               
  k_ls_text_pad  = 16U,               
  k_ls_glyph_w   = 8U,                
  k_ls_glyph_h   = 16U,               
  k_ls_settle_ms = 500U,              
  k_ls_frame_ms  = 20U,               
  k_ls_led_every = 16U,               
} ls_geom_t;

typedef enum : uint32_t {
  k_ls_canvas_w = (uint32_t)k_panel_width_px,                   
  k_ls_canvas_h = (uint32_t)k_ls_bands * (uint32_t)k_ls_band_h, 
  k_ls_bpp      = 3U,                                           
  k_ls_band_bytes = (uint32_t)k_panel_width_px * (uint32_t)k_ls_band_h * 3U,
  k_ls_cells      = 6U,  
  k_ls_buckets    = 16U, 
  k_ls_image_id   = 1U,  
  k_ls_scroll_page =
    ((uint32_t)k_panel_height_px * 9U) / 10U, 
} ls_size_t;

typedef enum : uint32_t {
  k_ls_hdr_bytes     = 32U, 
  k_ls_ftr_bytes     = 16U, 
  k_ls_idx_entry     = 8U,  
  k_ls_ftr_magic_off = 12U, 
  k_ls_atlas_total   = (uint32_t)k_ls_hdr_bytes + ((uint32_t)k_ls_bands * 8U) +
                       (uint32_t)k_ls_ftr_bytes, 
  k_ls_byte_mask     = 0xFFU,                    
  k_ls_shift_8       = 8U,                       
  k_ls_shift_16      = 16U,                      
  k_ls_shift_24      = 24U,                      
} ls_atlas_t;

typedef enum : uint32_t {
  k_ls_grad_lo      = 55U,   
  k_ls_grad_span    = 45U,   
  k_ls_pct_full     = 100U,  
  k_ls_seam_h       = 6U,    
  k_ls_seam_level   = 0xF0U, 
  k_ls_palette_size = 16U,   
} ls_paint_t;

typedef enum : uint16_t {
  k_ls_zone_top = (uint16_t)(k_panel_height_px / 3U),        
  k_ls_zone_mid = (uint16_t)((k_panel_height_px * 2U) / 3U), 
} ls_zone_t;

typedef enum : uint32_t {
  k_ls_col_bg         = 0x0A0A12U, 
  k_ls_col_status_bg  = 0x101826U, 
  k_ls_col_text       = 0xF0F4FFU, 
  k_ls_col_text_dim   = 0x8FA0C0U, 
  k_ls_col_rail_bg    = 0x263042U, 
  k_ls_col_rail_thumb = 0xF5C542U, 
} ls_color_t;

typedef enum : int32_t {
  k_ls_rail_min_thumb = 32, 
} ls_rail_t;

typedef enum : uint32_t {
  k_ls_uart_baud   = 115200U,     
  k_ls_fnv_offset  = 2166136261U, 
  k_ls_fnv_prime   = 16777619U,   
  k_ls_hex_nibbles = 8U,          
  k_ls_nibble_bits = 4U,          
  k_ls_nibble_mask = 0x0FU,       
  k_ls_dec_ten     = 10U,         
  k_ls_dec_digits  = 10U,         
} ls_console_t;

typedef enum : uint8_t {
  k_ls_touch_max_points = 1U, 
} ls_touch_cfg_t;
 
/* ===========================================================================
 * Static storage
 * ===========================================================================
 */

static const char* const s_tag = "ereader_longstrip";

static const uint32_t k_ls_palette[k_ls_palette_size] = {
  0xE6194BU,
  0xF58231U,
  0xFFE119U,
  0xBFEF45U,
  0x3CB44BU,
  0x42D4F4U,
  0x4363D8U,
  0x911EB4U,
  0xF032E6U,
  0xFABEBEU,
  0x469990U,
  0x9A6324U,
  0x800000U,
  0x808000U,
  0x000075U,
  0xA9A9A9U,
};

[[gnu::section(".sdram_data"), gnu::aligned(k_ra8_board_fb_align_bytes)]] static uint16_t
  s_framebuffer[(size_t)k_ls_view_h * (size_t)k_ls_view_w];

[[gnu::section(
  ".sdram_data")]] static uint8_t s_cells[(size_t)k_ls_cells * (size_t)k_ls_band_bytes];

static uint8_t s_atlas[k_ls_atlas_total];
 
static ra8_tile_key_t      s_keys[(size_t)k_ls_cells];      
static ra8_tile_dims_t     s_dims[(size_t)k_ls_cells];      
static ra8_keycache_cell_t s_meta[(size_t)k_ls_cells];      
static int32_t             s_buckets[(size_t)k_ls_buckets]; 
 
static jof_memstore_t   s_store; 
static ra8_tile_cache_t s_cache; 
static longstrip_t      s_strip; 

typedef struct {
  uint32_t width;    
  uint32_t canvas_h; 
  uint16_t band_h;   
  uint8_t  bpp;      
} ls_paint_ctx_t;

static ls_paint_ctx_t s_paint;

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

static display_handle_t* s_display = nullptr;
static display_fb_t s_fb;
static bool s_chrome = true;
static uint16_t s_last_skipped = 0U;
static bool s_was_sw1 = false;
static bool s_was_sw2 = false;

volatile uint32_t g_ls_loop_ticks = 0U;
volatile uint32_t g_ls_scroll_y = 0U;
volatile uint32_t g_ls_redraws = 0U;
volatile uint32_t g_ls_frame_crc = 0U;

static const uint8_t k_msg_boot[]   = "ereader-longstrip: boot\r\n";
static const uint8_t k_msg_pre[]    = "ereader-longstrip: bands=";
static const uint8_t k_msg_view[]   = " view=";
static const uint8_t k_msg_x[]      = "x";
static const uint8_t k_msg_scroll[] = " scroll=";
static const uint8_t k_msg_crc[]    = " crc=";
static const uint8_t k_msg_eol[]    = "\r\n";
 
/* ===========================================================================
 * Console helpers
 * ===========================================================================
 */

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

static void ls_print_hex(uint32_t value)
{
  uint8_t buf[k_ls_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_ls_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_ls_hex_nibbles - 1U - i) * (uint32_t)k_ls_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_ls_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_ls_dec_ten) ? ('0' + nib) : ('A' + (nib - k_ls_dec_ten)));
  }
  ls_print(buf, (uint32_t)k_ls_hex_nibbles);
}

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

static const char* ls_utoa(char* buf, uint32_t value)
{
  char     tmp[k_ls_dec_digits];
  uint32_t n = 0U;
  if (value == 0U) {
    tmp[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_ls_dec_digits)) {
    tmp[n] = (char)('0' + (value % (uint32_t)k_ls_dec_ten));
    n++;
    value /= (uint32_t)k_ls_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    buf[i] = tmp[n - 1U - i];
  }
  buf[n] = '\0';
  return buf;
}
 
/* ===========================================================================
 * Boot helpers
 * ===========================================================================
 */

static void app_panic_halt(void)
{
  (void)ra8_board_led_on(k_ra8_board_led_red);
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void app_bringup_clocks(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    app_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    app_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    app_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_ls_uart_baud) != k_ra8_ok) {
    app_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)) {
    app_panic_halt();
  }
  ra8_isr_globals_enable();
}

static void app_bringup_panel(void)
{
  ra8_delay_ms((uint32_t)k_ls_settle_ms);
  if (ra8_sdramc_init() != k_ra8_ok) {
    app_panic_halt();
  }
  if (display_init(&k_ls_display_cfg, &s_display) != k_ra8_ok) {
    app_panic_halt();
  }
  if (display_get_framebuffer(s_display, &s_fb) != k_ra8_ok) {
    app_panic_halt();
  }
}

static void app_bringup_gfx(void)
{
  if (ra8_gfx_init(s_fb.pixels, s_fb.width_px, s_fb.height_px, k_ra8_gfx_format_rgb565) !=
      k_ra8_ok) {
    app_panic_halt();
  }
}

static void app_bringup_touch(void)
{
  const ra8_board_touch_cfg_t cfg = {
    .max_points = (uint8_t)k_ls_touch_max_points,
    .irq_pin    = (uint8_t)k_ra8_touch_irq_pin_unset,
  };
  (void)ra8_board_touch_open(&cfg);
}
 
/* ===========================================================================
 * Metadata-only JOF atlas builder
 * ===========================================================================
 */

static void ls_put_u16(uint8_t* p, uint16_t v)
{
  p[0] = (uint8_t)(v & (uint16_t)k_ls_byte_mask);
  p[1] = (uint8_t)((v >> (uint16_t)k_ls_shift_8) & (uint16_t)k_ls_byte_mask);
}

static void ls_put_u32(uint8_t* p, uint32_t v)
{
  p[0] = (uint8_t)(v & (uint32_t)k_ls_byte_mask);
  p[1] = (uint8_t)((v >> (uint32_t)k_ls_shift_8) & (uint32_t)k_ls_byte_mask);
  p[2] = (uint8_t)((v >> (uint32_t)k_ls_shift_16) & (uint32_t)k_ls_byte_mask);
  p[3] = (uint8_t)((v >> (uint32_t)k_ls_shift_24) & (uint32_t)k_ls_byte_mask);
}

static uint32_t ls_build_atlas(void)
{
  const uint32_t width  = (uint32_t)k_ls_canvas_w;
  const uint32_t height = (uint32_t)k_ls_canvas_h;
  const uint32_t band_h = (uint32_t)k_ls_band_h;
  const uint32_t bands  = (uint32_t)k_ls_bands;
  for (uint32_t i = 0U; i < (uint32_t)k_ls_hdr_bytes; i++) {
    s_atlas[i] = 0U;
  }
  s_atlas[0] = 'J';
  s_atlas[1] = 'O';
  s_atlas[2] = 'F';
  s_atlas[3] = '1';
  ls_put_u16(&s_atlas[4], (uint16_t)width);
  ls_put_u16(&s_atlas[6], (uint16_t)height);
  ls_put_u16(&s_atlas[8], (uint16_t)width); /* tile_w == width (band column) */
  ls_put_u16(&s_atlas[10], (uint16_t)band_h);
  s_atlas[12] = (uint8_t)k_ls_bpp;
  s_atlas[13] = (uint8_t)k_jof_codec_raw;
  ls_put_u32(&s_atlas[16], bands);
 
  const uint32_t index_off = (uint32_t)k_ls_hdr_bytes; /* no pixel region */
  for (uint32_t n = 0U; n < bands; n++) {
    const uint32_t y0 = n * band_h;
    const uint32_t th = ((height - y0) < band_h) ? (height - y0) : band_h;
    ls_put_u32(&s_atlas[index_off + (n * (uint32_t)k_ls_idx_entry)], index_off);
    ls_put_u32(&s_atlas[index_off + (n * (uint32_t)k_ls_idx_entry) + 4U],
               width * th * (uint32_t)k_ls_bpp);
  }
  const uint32_t ftr = index_off + (bands * (uint32_t)k_ls_idx_entry);
  ls_put_u32(&s_atlas[ftr], index_off);
  ls_put_u32(&s_atlas[ftr + 4U], bands);
  ls_put_u32(&s_atlas[ftr + 8U], (uint32_t)k_ls_atlas_total);
  const uint32_t mag = ftr + (uint32_t)k_ls_ftr_magic_off;
  s_atlas[mag + 0U]  = 'J';
  s_atlas[mag + 1U]  = 'O';
  s_atlas[mag + 2U]  = 'F';
  s_atlas[mag + 3U]  = 'E';
  return (uint32_t)k_ls_atlas_total;
}
 
/* ===========================================================================
 * Procedural band painter (tile-cache decode-on-miss seam)
 * ===========================================================================
 */

static uint8_t ls_scale_u8(uint8_t v, uint32_t pct)
{
  return (uint8_t)(((uint32_t)v * pct) / (uint32_t)k_ls_pct_full);
}

static void ls_row_color(uint32_t base, uint32_t r, uint32_t th, uint8_t* rgb)
{
  if (r < (uint32_t)k_ls_seam_h) {
    rgb[0] = (uint8_t)k_ls_seam_level;
    rgb[1] = (uint8_t)k_ls_seam_level;
    rgb[2] = (uint8_t)k_ls_seam_level;
    return;
  }
  const uint32_t span = (th > 1U) ? (th - 1U) : 1U;
  const uint32_t pct  = (uint32_t)k_ls_grad_lo + (((uint32_t)k_ls_grad_span * r) / span);
  rgb[0] =
    ls_scale_u8((uint8_t)((base >> (uint32_t)k_ls_shift_16) & (uint32_t)k_ls_byte_mask), pct);
  rgb[1] = ls_scale_u8((uint8_t)((base >> (uint32_t)k_ls_shift_8) & (uint32_t)k_ls_byte_mask), pct);
  rgb[2] = ls_scale_u8((uint8_t)(base & (uint32_t)k_ls_byte_mask), pct);
}

/* cppcheck-suppress constParameterCallback -- bound to ra8_tile_source_t::decode; constifying ctx would break the binding. */
static ra8_err_t ls_band_decode(void*                 ctx,
                                const ra8_tile_key_t* key,
                                uint8_t*              cell,
                                uint32_t              cell_bytes,
                                uint16_t*             out_w,
                                uint16_t*             out_h)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "decode ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(key, s_tag, "key must not be nullptr");
  RA8_CHECK_NULL_PTR(cell, s_tag, "cell must not be nullptr");
  RA8_CHECK_NULL_PTR(out_w, s_tag, "out_w must not be nullptr");
  RA8_CHECK_NULL_PTR(out_h, s_tag, "out_h must not be nullptr");
  const ls_paint_ctx_t* pc = (const ls_paint_ctx_t*)ctx;
  const uint32_t        y0 = (uint32_t)key->tile_y * (uint32_t)pc->band_h;
  uint32_t              th = (uint32_t)pc->band_h;
  if ((y0 + th) > pc->canvas_h) {
    th = pc->canvas_h - y0;
  }
  if ((pc->width * th * (uint32_t)pc->bpp) > cell_bytes) {
    return k_ra8_err_out_of_range;
  }
  const uint32_t base = k_ls_palette[(uint32_t)key->tile_y % (uint32_t)k_ls_palette_size];
  uint32_t       off  = 0U;
  for (uint32_t r = 0U; r < th; r++) { /* bounded by band_h */
    uint8_t rgb[k_ls_bpp];
    ls_row_color(base, r, th, rgb);
    for (uint32_t x = 0U; x < pc->width; x++) { /* bounded by canvas width */
      cell[off]      = rgb[0];
      cell[off + 1U] = rgb[1];
      cell[off + 2U] = rgb[2];
      off += (uint32_t)pc->bpp;
    }
  }
  *out_w = (uint16_t)pc->width;
  *out_h = (uint16_t)th;
  return k_ra8_ok;
}
 
/* ===========================================================================
 * Strip open + render
 * ===========================================================================
 */
 
static ra8_err_t ls_blit(void*          ctx,
                         const uint8_t* pixels,
                         uint16_t       src_w,
                         uint16_t       src_h,
                         uint8_t        bpp,
                         int32_t        dst_x,
                         int32_t        dst_y);

static void ls_open_strip(uint32_t total)
{
  s_store = (jof_memstore_t){.buf = s_atlas, .cap = (size_t)k_ls_atlas_total, .len = total};
  s_paint = (ls_paint_ctx_t){.width    = (uint32_t)k_ls_canvas_w,
                             .canvas_h = (uint32_t)k_ls_canvas_h,
                             .band_h   = (uint16_t)k_ls_band_h,
                             .bpp      = (uint8_t)k_ls_bpp};
  const ra8_tile_cache_cfg_t ccfg = {.cell_mem     = s_cells,
                                     .cell_bytes   = (uint32_t)k_ls_band_bytes,
                                     .cell_count   = (uint32_t)k_ls_cells,
                                     .meta         = s_meta,
                                     .keys         = s_keys,
                                     .dims         = s_dims,
                                     .buckets      = s_buckets,
                                     .bucket_count = (uint32_t)k_ls_buckets,
                                     .decode       = ls_band_decode,
                                     .decode_ctx   = &s_paint};
  if (ra8_tile_cache_init(&s_cache, &ccfg) != k_ra8_ok) {
    app_panic_halt();
  }
  const longstrip_cfg_t lcfg = {.pread      = jof_memstore_pread,
                                .pread_ctx  = &s_store,
                                .atlas_size = total,
                                .cache      = &s_cache,
                                .image_id   = (uint32_t)k_ls_image_id,
                                .viewport_w = (uint16_t)k_ls_view_w,
                                .viewport_h = (uint16_t)k_ls_view_h,
                                .blit       = ls_blit,
                                .blit_ctx   = nullptr};
  if (longstrip_open(&s_strip, &lcfg) != k_ra8_ok) {
    app_panic_halt();
  }
}

static ra8_err_t ls_blit(void*          ctx,
                         const uint8_t* pixels,
                         uint16_t       src_w,
                         uint16_t       src_h,
                         uint8_t        bpp,
                         int32_t        dst_x,
                         int32_t        dst_y)
{
  (void)ctx;
  (void)bpp; /* strip is RGB888 by construction */
  RA8_CHECK_NULL_PTR(pixels, s_tag, "blit pixels must not be nullptr");
  return ra8_gfx_blit(pixels, src_w, src_h, k_ra8_gfx_format_rgb888, dst_x, dst_y);
}

static int32_t ls_text(int32_t x, int32_t y, const char* str, uint32_t color)
{
  (void)ra8_gfx_text_out(x, y, str, &ra8_gfx_font_8x16, color, (uint32_t)k_ls_col_status_bg);
  uint32_t w = 0U;
  uint32_t h = 0U;
  if (ra8_gfx_text_size(str, &ra8_gfx_font_8x16, &w, &h) != k_ra8_ok) {
    return x;
  }
  return x + (int32_t)w;
}

static void ls_draw_status(void)
{
  (void)ra8_gfx_rect(0,
                     0,
                     (int32_t)k_ls_view_w,
                     (int32_t)k_ls_status_h,
                     (uint32_t)k_ls_col_status_bg,
                     true);
  const int32_t  y = (int32_t)((k_ls_status_h - k_ls_glyph_h) / 2U);
  const uint32_t band =
    (s_strip.band_h > 0U) ? ((uint32_t)s_strip.scroll_y / (uint32_t)s_strip.band_h) + 1U : 1U;
  const uint32_t pct =
    (s_strip.max_scroll > 0)
      ? ((uint32_t)s_strip.scroll_y * (uint32_t)k_ls_pct_full) / (uint32_t)s_strip.max_scroll
      : 0U;
  char    num[k_ls_dec_digits + 1U];
  int32_t x = (int32_t)k_ls_text_pad;
  x         = ls_text(x, y, "LONGSTRIP", (uint32_t)k_ls_col_text);
  x         = ls_text(x, y, "   band ", (uint32_t)k_ls_col_text_dim);
  x         = ls_text(x, y, ls_utoa(num, band), (uint32_t)k_ls_col_text);
  x         = ls_text(x, y, "/", (uint32_t)k_ls_col_text_dim);
  x         = ls_text(x, y, ls_utoa(num, (uint32_t)k_ls_bands), (uint32_t)k_ls_col_text);
  x         = ls_text(x, y, "   pos ", (uint32_t)k_ls_col_text_dim);
  x         = ls_text(x, y, ls_utoa(num, pct), (uint32_t)k_ls_col_text);
  x         = ls_text(x, y, "%   skip ", (uint32_t)k_ls_col_text_dim);
  (void)ls_text(x, y, ls_utoa(num, (uint32_t)s_last_skipped), (uint32_t)k_ls_col_text);
}

static void ls_draw_rail(void)
{
  const int32_t rx = (int32_t)k_ls_view_w - (int32_t)k_ls_rail_w;
  (void)ra8_gfx_rect(rx,
                     0,
                     (int32_t)k_ls_rail_w,
                     (int32_t)k_ls_view_h,
                     (uint32_t)k_ls_col_rail_bg,
                     true);
  int32_t th = (int32_t)(((uint32_t)k_ls_view_h * (uint32_t)k_ls_view_h) / (uint32_t)k_ls_canvas_h);
  if (th < (int32_t)k_ls_rail_min_thumb) {
    th = (int32_t)k_ls_rail_min_thumb;
  }
  const int32_t range = (int32_t)k_ls_view_h - th;
  int32_t       ty    = 0;
  if ((s_strip.max_scroll > 0) && (range > 0)) {
    ty = (int32_t)(((uint32_t)s_strip.scroll_y * (uint32_t)range) / (uint32_t)s_strip.max_scroll);
  }
  (void)ra8_gfx_rect(rx, ty, (int32_t)k_ls_rail_w, th, (uint32_t)k_ls_col_rail_thumb, true);
}

static void ls_redraw(void)
{
  (void)ra8_gfx_reset_clip();
  (void)ra8_gfx_clear((uint32_t)k_ls_col_bg);
  longstrip_render_stats_t st = {};
  (void)longstrip_render(&s_strip, &st);
  s_last_skipped = st.skipped;
  if (s_chrome) {
    ls_draw_rail();
    ls_draw_status();
  }
  g_ls_scroll_y = (uint32_t)s_strip.scroll_y;
  g_ls_redraws++;
}

static void ls_present(void)
{
  (void)display_flush(s_display, display_full_rect(s_display), k_display_refresh_quality);
}

static uint32_t ls_hash_fb(void)
{
  const uint8_t* p   = (const uint8_t*)s_framebuffer;
  const size_t   n   = sizeof(s_framebuffer);
  uint32_t       hsh = (uint32_t)k_ls_fnv_offset;
  for (size_t i = 0U; i < n; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_ls_fnv_prime;
  }
  return hsh;
}

static void ls_emit_banner(void)
{
  g_ls_frame_crc = ls_hash_fb();
  ls_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  ls_print_uint((uint32_t)k_ls_bands);
  ls_print(k_msg_view, (uint32_t)sizeof(k_msg_view) - 1U);
  ls_print_uint((uint32_t)k_ls_view_w);
  ls_print(k_msg_x, (uint32_t)sizeof(k_msg_x) - 1U);
  ls_print_uint((uint32_t)k_ls_view_h);
  ls_print(k_msg_scroll, (uint32_t)sizeof(k_msg_scroll) - 1U);
  ls_print_uint((uint32_t)s_strip.scroll_y);
  ls_print(k_msg_crc, (uint32_t)sizeof(k_msg_crc) - 1U);
  ls_print_hex(g_ls_frame_crc);
  ls_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
}
 
/* ===========================================================================
 * Input handling (tap zones + buttons)
 * ===========================================================================
 */

static void ls_apply_nav(int32_t delta, bool toggle)
{
  if (toggle) {
    s_chrome = !s_chrome;
  } else {
    const int32_t before = s_strip.scroll_y;
    (void)longstrip_scroll_by(&s_strip, delta);
    if ((s_strip.scroll_y == before) && (delta != 0)) {
      return; /* already pinned at an end -- nothing to repaint */
    }
  }
  ls_redraw();
  ls_present();
}

static void ls_handle_tap(int32_t y)
{
  if (y < (int32_t)k_ls_zone_top) {
    ls_apply_nav(-(int32_t)k_ls_scroll_page, false);
  } else if (y < (int32_t)k_ls_zone_mid) {
    ls_apply_nav(0, true);
  } else {
    ls_apply_nav((int32_t)k_ls_scroll_page, false);
  }
}

static void ls_poll_touch(void)
{
  ra8_touch_point_t pt  = {};
  uint8_t           got = 0U;
  if (ra8_touch_read(&pt, (uint8_t)k_ls_touch_max_points, &got) != k_ra8_ok) {
    return;
  }
  if (got > 0U) {
    ls_handle_tap((int32_t)pt.y);
  }
}

static void ls_poll_buttons(void)
{
  ra8_board_sw_state_t s1 = {};
  ra8_board_sw_state_t s2 = {};
  const bool           d1 =
    (ra8_board_sw_read(k_ra8_board_sw1, &s1) == k_ra8_ok) && (s1 == k_ra8_board_sw_pressed);
  const bool d2 =
    (ra8_board_sw_read(k_ra8_board_sw2, &s2) == k_ra8_ok) && (s2 == k_ra8_board_sw_pressed);
  if (d1 && !s_was_sw1) {
    ls_apply_nav((int32_t)k_ls_scroll_page, false);
  }
  if (d2 && !s_was_sw2) {
    ls_apply_nav(-(int32_t)k_ls_scroll_page, false);
  }
  s_was_sw1 = d1;
  s_was_sw2 = d2;
}
 
/* ===========================================================================
 * Boot + main
 * ===========================================================================
 */

void main(void)
{
  app_bringup_clocks();
  ls_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
  app_bringup_panel();
  app_bringup_gfx();
  app_bringup_touch();
  (void)ra8_board_sw_init(k_ra8_board_sw1);
  (void)ra8_board_sw_init(k_ra8_board_sw2);
 
  const uint32_t total = ls_build_atlas();
  ls_open_strip(total);
 
  ls_redraw();
  ls_present();
  ls_emit_banner();
 
  while (1) {
    ls_poll_touch();
    ls_poll_buttons();
    if ((g_ls_loop_ticks % (uint32_t)k_ls_led_every) == 0U) {
      (void)ra8_board_led_toggle(k_ra8_board_led_blue);
    }
    g_ls_loop_ticks++;
    ra8_delay_ms((uint32_t)k_ls_frame_ms);
  }
}