comic.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "epub_miniz_alloc.h"
#include "ra8_err.h"
#include "ra8_rar.h"
#include "ra8_rar5.h"
#include "unarch_gzip.h"
#include "unarch_tar.h"
#include "unarch_xz.h"
 
#ifdef __cplusplus
extern "C" {
#endif

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

typedef enum : uint8_t {
  k_comic_kind_none = 0U, 
  k_comic_kind_cbz  = 1U, 
  k_comic_kind_cbr  = 2U, 
  k_comic_kind_cbt  = 3U, 
} comic_kind_t;

typedef enum : uint16_t {
  k_comic_magic_len = 8U,   
  k_comic_zip_bytes = 256U, 
} comic_limits_t;

typedef struct {
  uint32_t name_off;    
  uint16_t name_len;    
  uint8_t  extractable; 
  uint8_t  rar_method;  
  uint32_t zip_index;   
  uint64_t data_off;    
  uint64_t pack_size;   
  uint64_t raw_size;    
} comic_page_t;

typedef struct {
  comic_read_fn read; 
  void*         ctx;  
  uint64_t      size; 
} comic_stream_t;

typedef struct {
  comic_read_fn    read;       
  void*            ctx;        
  uint64_t         size;       
  comic_page_t*    pages;      
  uint32_t         page_cap;   
  uint32_t         page_count; 
  char*            names;      
  uint32_t         names_cap;  
  uint32_t         names_len;  
  comic_stream_t   stream;     
  ra8_rar_t        rar;        
  ra8_rar5_state_t rar5_state; 
  unarch_tar_t     tar;        
  comic_kind_t     kind;       
  uint8_t          zip_active; 
  alignas(max_align_t) uint8_t zip_storage[k_comic_zip_bytes];
  epub_miniz_arena_t miniz_arena;
  epub_miniz_workspace_t miniz_workspace;
} comic_t;

[[nodiscard]] ra8_err_t comic_open(comic_t*      c,
                                   comic_read_fn read,
                                   void*         ctx,
                                   uint64_t      size,
                                   comic_page_t* pages,
                                   uint32_t      page_cap,
                                   char*         names,
                                   uint32_t      names_cap);

static inline uint32_t comic_page_count(const comic_t* c)
{
  if (c == nullptr) {
    return 0U;
  }
  if (c->kind == k_comic_kind_none) {
    return 0U;
  }
  return c->page_count;
}

static inline comic_kind_t comic_kind(const comic_t* c)
{
  if (c == nullptr) {
    return k_comic_kind_none;
  }
  return c->kind;
}

[[nodiscard]] ra8_err_t comic_page_info(const comic_t* c,
                                        uint32_t       page,
                                        char*          name_buf,
                                        uint16_t       name_cap,
                                        uint16_t*      out_name_len,
                                        uint64_t*      out_raw_size,
                                        uint8_t*       out_extractable);

[[nodiscard]] ra8_err_t
comic_page_read(comic_t* c, uint32_t page, uint8_t* buf, size_t cap, size_t* got);

[[nodiscard]] ra8_err_t comic_close(comic_t* c);

typedef enum : uint8_t {
  k_comic_wrap_align = 8U, 
} comic_wrap_dims_t;

[[nodiscard]] ra8_err_t comic_open_wrapped(comic_t*      c,
                                           comic_read_fn read,
                                           void*         ctx,
                                           uint64_t      size,
                                           comic_page_t* pages,
                                           uint32_t      page_cap,
                                           char*         names,
                                           uint32_t      names_cap,
                                           uint8_t*      arena,
                                           size_t        arena_cap,
                                           void*         xz_scratch,
                                           uint32_t      xz_scratch_len);
 
#ifdef __cplusplus
}
#endif