sh_app.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "book.h"
#include "book_paged.h"
#include "library.h"
#include "ra8_panel.h"
#include "ra8_ui.h"
#include "ra8_vsource.h"
#include "sh_classify.h"

typedef enum : uint32_t {
  k_sh_fb_w        = 1024U,       
  k_sh_fb_h        = 600U,        
  k_sh_glyph_w     = 8U,          
  k_sh_glyph_h     = 16U,         
  k_sh_line_h      = 22U,         
  k_sh_bar_h       = 56U,         
  k_sh_pad         = 24U,         
  k_sh_gap         = 24U,         
  k_sh_card_pad    = 14U,         
  k_sh_thumb_w     = 130U,        
  k_sh_thumb_h     = 195U,        
  k_sh_grid_cols   = 4U,          
  k_sh_toc_row_h   = 40U,         
  k_sh_linebuf     = 160U,        
  k_sh_text_cap    = 48U * 1024U, 
  k_sh_max_lines   = 6144U,       
  k_sh_max_books   = 12U,         
  k_sh_thumb_bytes = 150U * 225U, 
  k_sh_name_cap    = 128U,        
  k_sh_title_cap   = 72U,         
  k_sh_author_cap  = 56U,         
  k_sh_uart_chan   = 8U,          
  k_sh_uart_baud   = 115200U,     
  k_sh_poll_pts    = 5U,          
  k_sh_poll_ms     = 30U,         
  k_sh_dec_base    = 10U,         
} sh_const_t;

typedef enum : uint32_t {
  k_sh_loupe_w       = 320U, 
  k_sh_loupe_h       = 320U, 
  k_sh_loupe_zoom    = 2U,   
  k_sh_loupe_border  = 2U,   
  k_sh_loupe_hold_ms = 350U, 
} sh_loupe_const_t;

typedef enum : uint32_t {
  k_sh_col_bg      = 0x201A14U, 
  k_sh_col_bar     = 0x3A2E22U, 
  k_sh_col_card    = 0xF4ECDFU, 
  k_sh_col_card_hi = 0xFFF7E0U, 
  k_sh_col_ink     = 0x1A140EU, 
  k_sh_col_sub     = 0x6A5C4AU, 
  k_sh_col_edge    = 0xB7A789U, 
  k_sh_col_sel     = 0xC8762AU, 
  k_sh_col_barfg   = 0xF4ECDFU, 
  k_sh_col_rowhi   = 0xE7DCC6U, 
} sh_color_t;

typedef enum : uint8_t {
  k_sh_screen_shelf  = 0U, 
  k_sh_screen_cover  = 1U, 
  k_sh_screen_toc    = 2U, 
  k_sh_screen_reader = 3U, 
  k_sh_screen_comic  = 4U, 
} sh_screen_t;

typedef struct {
  uint32_t off; 
  uint16_t len; 
} sh_line_t;

typedef struct {
  bool           from_sd;                 
  sh_book_fmt_t  fmt;                     
  const uint8_t* blob;                    
  uint32_t       blob_len;                
  const uint8_t* thumb;                   
  uint16_t       thumb_w;                 
  uint16_t       thumb_h;                 
  char           sd_name[k_sh_name_cap];  
  char           title[k_sh_title_cap];   
  char           author[k_sh_author_cap]; 
} sh_entry_t;

typedef struct {
  sh_screen_t screen;                
  uint16_t    selected;              
  uint16_t    book_count;            
  bool        sd_ready;              
  sh_entry_t  entry[k_sh_max_books]; 
 
  sh_book_fmt_t open_fmt;      
  book_src_t    book_src;      
  uint32_t      chapter;       
  uint32_t      chapter_count; 
  uint32_t      page;          
  uint32_t      chap_pages;    
  int32_t       toc_scroll;    
 
  uint32_t comic_page;  
  uint32_t comic_count; 
  bool     comic_rtl;   
 
  bool     loupe_active;  
  int32_t  loupe_cx;      
  int32_t  loupe_cy;      
  uint32_t touch_down_ms; 
  int32_t  touch_down_x;  
  int32_t  touch_down_y;  
 
  size_t    text_len;              
  uint32_t  line_count;            
  char      text[k_sh_text_cap];   
  sh_line_t lines[k_sh_max_lines]; 
 
  ra8_ui_rect_t card_rect[k_sh_max_books];               
  uint8_t       thumb[k_sh_max_books][k_sh_thumb_bytes]; 
  uint16_t      thumb_w[k_sh_max_books];                 
  uint16_t      thumb_h[k_sh_max_books];                 
} sh_state_t;

extern sh_state_t g_sh;
 
/* ----- sh_image.c : 4bpp grayscale cover / image rendering ----------------- */

ra8_err_t sh_image_decode_gray8(const book_src_t* src,
                                uint32_t          img_idx,
                                uint8_t*          out,
                                int32_t           box_w,
                                int32_t           box_h,
                                int32_t*          out_w,
                                int32_t*          out_h);

void sh_image_blit_gray8(const uint8_t* src, int32_t w, int32_t h, int32_t dst_x, int32_t dst_y);

ra8_err_t sh_image_blit_cover(const book_src_t* src,
                              uint32_t          img_idx,
                              int32_t           dst_x,
                              int32_t           dst_y,
                              int32_t           box_w,
                              int32_t           box_h,
                              int32_t*          out_w,
                              int32_t*          out_h);

ra8_err_t sh_image_loupe(const book_src_t* src,
                         uint32_t          img_idx,
                         int32_t           src_cx,
                         int32_t           src_cy,
                         int32_t           dst_x,
                         int32_t           dst_y);

bool sh_image_loupe_map(const book_src_t* src,
                        uint32_t          img_idx,
                        int32_t           box_x,
                        int32_t           box_y,
                        int32_t           box_w,
                        int32_t           box_h,
                        int32_t           px,
                        int32_t           py,
                        int32_t*          out_cx,
                        int32_t*          out_cy);
 
/* ----- shared small helpers (sh_util.c) ------------------------------------ */

int32_t sh_cells(int32_t pixels);

void sh_fit(char* dst, size_t cap, const char* src, int32_t max_chars);

size_t sh_fmt_uint(char* dst, size_t pos, uint32_t v);

void sh_border(ra8_ui_rect_t r, uint32_t colour, int32_t width);

void sh_titlebar(const char* title, const char* right);
 
/* ----- per-screen render + input (one module each) ------------------------- */
 
/* ----- sh_sd.c : optional SD-card book source ------------------------------ */

bool sh_sd_mount(void);

void sh_sd_scan(void);

bool sh_sd_book_open(const char* name, uint32_t* out_len);

ra8_err_t sh_sd_book_read(void* ctx, uint64_t offset, uint8_t* buf, uint32_t len);

void sh_sd_book_close(void);

size_t sh_sd_comic_read(void* ctx, uint64_t offset, void* buf, size_t len);

bool sh_sd_open_epub(const char* name, void* out_book);

void sh_sd_close_epub(void* book);

uint16_t* sh_fb_pixels(void);

void sh_decode_cover(uint16_t idx, const book_src_t* src);

void sh_shelf_build_thumbs(void);

void sh_shelf_render(void);

int32_t sh_shelf_hit(int32_t x, int32_t y);

typedef enum : uint8_t {
  k_sh_cover_none = 0U, 
  k_sh_cover_read = 1U, 
  k_sh_cover_toc  = 2U, 
} sh_cover_act_t;

void sh_cover_render(void);

sh_cover_act_t sh_cover_action(int32_t x, int32_t y);

bool sh_cover_loupe_map(int32_t px, int32_t py, int32_t* out_cx, int32_t* out_cy);

void sh_cover_loupe_render(void);

void sh_toc_render(void);

int32_t sh_toc_hit(int32_t x, int32_t y);

void sh_toc_scroll(int32_t dir);

ra8_err_t sh_inflate(const void* src, size_t src_len, void* dst, size_t dst_cap, size_t* out_len);
 
/* ----- sh_paged.c : demand-paged .rabook backing (#204/#205) ---------------- */

bool sh_paged_open(ra8_vsource_read_fn file_read, void* file_ctx, uint64_t file_len);

bool sh_paged_open_mram(const uint8_t* blob, uint32_t blob_len);

void sh_paged_close(void);
 
/* ----- sh_book.c : format-agnostic book backend (rabook + epub) ------------ */

bool sh_book_open(uint16_t idx);

ra8_err_t sh_book_chapter_text(uint32_t chapter, char* out, size_t cap, size_t* out_len);

void sh_book_chapter_label(uint32_t chapter, char* out, size_t cap);

bool sh_book_decode_thumb(uint16_t idx);

void sh_book_cover_fullscreen(int32_t x, int32_t y, int32_t w, int32_t h);

void sh_reader_load_chapter(uint32_t chapter);

uint32_t sh_reader_first_content(void);

void sh_reader_render(void);

bool sh_reader_turn(int32_t dir);

void sh_reader_prefetch_adjacent(void);
 
/* ----- sh_comic.c : full-page image reader for CBZ / CBR comics (#236) ------ */

bool sh_comic_open(uint16_t idx);

void sh_comic_close(void);

void sh_comic_render(void);

int32_t sh_comic_edge_dir(int32_t x);

bool sh_comic_turn(int32_t dir);

bool sh_comic_tap(int32_t x, bool header);

void sh_comic_toggle_rtl(void);

typedef struct {
  bool     ok;    
  uint32_t pages; 
  int32_t  w;     
  int32_t  h;     
  uint32_t crc;   
} sh_comic_probe_t;

void sh_comic_selfcheck(sh_comic_probe_t* cbz, sh_comic_probe_t* cbr, bool* rtl_ok);

void sh_comic_append_banner(char*                   b,
                            size_t*                 pos,
                            const sh_comic_probe_t* cbz,
                            const sh_comic_probe_t* cbr,
                            bool                    rtl_ok);