ra8_viewer_reader.c

Go to the documentation of this file.

 
#include "ra8_viewer_reader.h"
 
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdalign.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "jof.h"
#include "ra8_attributes.h"
#include "ra8_decomp_limits.h"
#include "ra8_err.h"
#include "ra8_viewer_reader_internal.h"
 
#ifndef O_CLOEXEC
#define O_CLOEXEC (0)
#endif

typedef enum : uint8_t {
  k_viewer_fmt_unknown    = 0U, 
  k_viewer_fmt_jof        = 1U, 
  k_viewer_fmt_comic      = 2U, 
  k_viewer_fmt_comic_wrap = 3U, 
  k_viewer_fmt_reflow     = 4U, 
} viewer_fmt_t;

typedef struct {
  uint8_t* base;     
  size_t   capacity; 
  size_t   used;     
  bool     valid;    
} viewer_layout_t;

RA8_INTERNAL static bool internal_align_up(size_t value, size_t alignment, size_t* out)
{
  const size_t mask = alignment - 1U;
  if ((alignment == 0U) || ((alignment & mask) != 0U) || (value > (SIZE_MAX - mask))) {
    return false;
  }
  *out = (value + mask) & ~mask;
  return true;
}

RA8_INTERNAL static void* internal_take(viewer_layout_t* layout, size_t bytes, size_t alignment)
{
  size_t start = 0U;
  if (!layout->valid || !internal_align_up(layout->used, alignment, &start) ||
      (start > SIZE_MAX - bytes)) {
    layout->valid = false;
    return nullptr;
  }
  const size_t end = start + bytes;
  if ((layout->base != nullptr) && (end > layout->capacity)) {
    layout->valid = false;
    return nullptr;
  }
  void* result = (layout->base == nullptr) ? nullptr : &layout->base[start];
  layout->used = end;
  return result;
}

RA8_INTERNAL static viewer_jof_t
internal_take_jof(viewer_layout_t* layout, const ra8_viewer_reader_requirements_t* requirements)
{
  viewer_jof_t jof = {};
  jof.cells = (uint8_t*)internal_take(layout, requirements->cell_bytes, alignof(max_align_t));
  jof.meta  = (ra8_keycache_cell_t*)internal_take(layout,
                                                  sizeof(ra8_keycache_cell_t),
                                                  alignof(ra8_keycache_cell_t));
  jof.keys =
    (ra8_tile_key_t*)internal_take(layout, sizeof(ra8_tile_key_t), alignof(ra8_tile_key_t));
  jof.dims =
    (ra8_tile_dims_t*)internal_take(layout, sizeof(ra8_tile_dims_t), alignof(ra8_tile_dims_t));
  jof.buckets  = (int32_t*)internal_take(layout,
                                         (size_t)k_viewer_jof_buckets * sizeof(int32_t),
                                         alignof(int32_t));
  jof.scratch  = (uint8_t*)internal_take(layout, requirements->scratch_bytes, alignof(max_align_t));
  jof.cell_cap = requirements->cell_bytes;
  jof.scratch_cap = requirements->scratch_bytes;
  return jof;
}

RA8_INTERNAL static viewer_comic_t
internal_take_comic(viewer_layout_t* layout, const ra8_viewer_reader_requirements_t* requirements)
{
  viewer_comic_t comic = {};
  comic.pages =
    (comic_page_t*)internal_take(layout, requirements->comic_pages_bytes, alignof(comic_page_t));
  comic.names = (char*)internal_take(layout, requirements->comic_names_bytes, alignof(char));
  comic.page =
    (uint8_t*)internal_take(layout, requirements->comic_page_bytes, alignof(max_align_t));
  comic.arena =
    (uint8_t*)internal_take(layout, requirements->comic_arena_bytes, alignof(max_align_t));
  comic.page_cap  = requirements->comic_page_bytes;
  comic.arena_cap = requirements->comic_arena_bytes;
  return comic;
}

RA8_INTERNAL static bool internal_ends_with(const char* path, const char* suffix)
{
  const size_t path_len   = strlen(path);
  const size_t suffix_len = strlen(suffix);
  if (path_len < suffix_len) {
    return false;
  }
  const char* tail = &path[path_len - suffix_len];
  for (size_t index = 0U; index < suffix_len; ++index) {
    char value = tail[index];
    if ((value >= 'A') && (value <= 'Z')) {
      value = (char)(value + ('a' - 'A'));
    }
    if (value != suffix[index]) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static viewer_fmt_t internal_classify(const char* path)
{
  if (internal_ends_with(path, ".jof")) {
    return k_viewer_fmt_jof;
  }
  if (internal_ends_with(path, ".cbz") || internal_ends_with(path, ".cbr") ||
      internal_ends_with(path, ".cbt")) {
    return k_viewer_fmt_comic;
  }
  if (internal_ends_with(path, ".gz") || internal_ends_with(path, ".xz")) {
    return k_viewer_fmt_comic_wrap;
  }
  if (internal_ends_with(path, ".epub") || internal_ends_with(path, ".epb") ||
      internal_ends_with(path, ".rabook") || internal_ends_with(path, ".rbk")) {
    return k_viewer_fmt_reflow;
  }
  return k_viewer_fmt_unknown;
}

RA8_INTERNAL static void internal_stderr_write(const char* text)
{
  size_t       offset = 0U;
  const size_t length = strlen(text);
  while (offset < length) {
    const ssize_t written = write(STDERR_FILENO, &text[offset], length - offset);
    if ((written < 0) && (errno == EINTR)) {
      continue;
    }
    if (written <= 0) {
      return;
    }
    offset += (size_t)written;
  }
}

RA8_INTERNAL static ra8_err_t internal_reject(viewer_fmt_t format, const char* path)
{
  internal_stderr_write("ra8_viewer: '");
  internal_stderr_write(path);
  if (format == k_viewer_fmt_comic_wrap) {
    internal_stderr_write("' recognised but wrapped comics require a streaming or "
                          "descriptor-spooled gzip/XZ output seam");
  } else if (format == k_viewer_fmt_reflow) {
    internal_stderr_write("' recognised but its reflow reader engine "
                          "(font + image loader) is not wired into the viewer yet");
  } else {
    internal_stderr_write("' has an unsupported file type");
  }
  internal_stderr_write("\n");
  return k_ra8_err_not_supported;
}

RA8_INTERNAL static ra8_err_t internal_file_open(viewer_file_ctx_t* file, const char* path)
{
  const int descriptor = open(path, O_RDONLY | O_CLOEXEC);
  if (descriptor < 0) {
    return k_ra8_err_not_found;
  }
  struct stat metadata = {};
  if ((fstat(descriptor, &metadata) != 0) || !S_ISREG(metadata.st_mode) ||
      (metadata.st_size <= 0)) {
    (void)close(descriptor);
    return k_ra8_err_not_found;
  }
  *file =
    (viewer_file_ctx_t){.size = (uint64_t)metadata.st_size, .fd = descriptor, .is_open = true};
  return k_ra8_ok;
}
 
ra8_err_t
priv_viewer_pread(void* ctx, uint64_t offset, uint8_t* buffer, size_t length, size_t* out_read)
{
  viewer_file_ctx_t* file = (viewer_file_ctx_t*)ctx;
  if (out_read == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *out_read = 0U;
  if ((file == nullptr) || (buffer == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!file->is_open || (offset > (uint64_t)INT64_MAX)) {
    return k_ra8_err_invalid_state;
  }
  if (offset >= file->size) {
    return k_ra8_ok;
  }
  const uint64_t available = file->size - offset;
  size_t         requested = ((uint64_t)length > available) ? (size_t)available : length;
  size_t         completed = 0U;
  while (completed < requested) {
    size_t pass = requested - completed;
    if (pass > (size_t)SSIZE_MAX) {
      pass = (size_t)SSIZE_MAX;
    }
    const ssize_t got =
      pread(file->fd, &((uint8_t*)buffer)[completed], pass, (off_t)(offset + (uint64_t)completed));
    if ((got < 0) && (errno == EINTR)) {
      continue;
    }
    if (got <= 0) {
      if (got == 0) {
        *out_read = completed;
        return k_ra8_ok;
      }
      return k_ra8_err_not_found;
    }
    completed += (size_t)got;
  }
  *out_read = completed;
  return k_ra8_ok;
}

RA8_INTERNAL static viewer_layout_t
internal_layout(const ra8_viewer_reader_requirements_t* need, uint8_t* base, size_t capacity)
{
  viewer_layout_t layout = {.base = base, .capacity = capacity, .used = 0U, .valid = true};
  (void)internal_take(&layout, sizeof(ra8_viewer_reader_t), alignof(max_align_t));
  (void)internal_take(&layout, need->framebuffer_bytes, alignof(uint16_t));
  const size_t dimension_bytes = need->dimensions_bytes / 2U;
  (void)internal_take(&layout, dimension_bytes, alignof(uint32_t));
  (void)internal_take(&layout, dimension_bytes, alignof(uint32_t));
  if (need->engine == (uint32_t)k_ra8_viewer_engine_jof) {
    (void)internal_take_jof(&layout, need);
  } else if (need->engine == (uint32_t)k_ra8_viewer_engine_comic) {
    (void)internal_take_comic(&layout, need);
  } else {
    layout.valid = false;
  }
  return layout;
}

RA8_INTERNAL static bool
internal_engine_requirements_valid(const ra8_viewer_reader_requirements_t* need)
{
  if (need->engine == (uint32_t)k_ra8_viewer_engine_jof) {
    return (need->cell_bytes != 0U) && (need->scratch_bytes != 0U) &&
           (need->comic_pages_bytes == 0U) && (need->comic_names_bytes == 0U) &&
           (need->comic_page_bytes == 0U) && (need->comic_arena_bytes == 0U);
  }
  if (need->engine == (uint32_t)k_ra8_viewer_engine_comic) {
    return (need->cell_bytes == 0U) && (need->scratch_bytes == 0U) &&
           (need->tile_count == (uint32_t)k_viewer_comic_page_cap) &&
           (need->comic_pages_bytes == ((size_t)k_viewer_comic_page_cap * sizeof(comic_page_t))) &&
           (need->comic_names_bytes == (size_t)k_viewer_comic_name_bytes) &&
           (need->comic_page_bytes == (size_t)k_viewer_comic_page_bytes) &&
           (need->comic_arena_bytes == (size_t)k_viewer_comic_arena_bytes);
  }
  return false;
}

RA8_INTERNAL static bool internal_requirements_valid(const ra8_viewer_reader_requirements_t* need)
{
  if ((need->layout_version != (uint32_t)k_viewer_layout_version) ||
      (need->required_alignment != alignof(max_align_t)) || (need->tile_count == 0U) ||
      (need->framebuffer_bytes !=
       ((size_t)k_ra8_viewer_fb_width * (size_t)k_ra8_viewer_fb_height * sizeof(uint16_t))) ||
      (need->dimensions_bytes != ((size_t)need->tile_count * 2U * sizeof(uint32_t))) ||
      !internal_engine_requirements_valid(need)) {
    return false;
  }
  const viewer_layout_t layout = internal_layout(need, nullptr, 0U);
  return layout.valid && (layout.used == need->required_bytes);
}

RA8_INTERNAL static ra8_err_t internal_require_jof(viewer_file_ctx_t*                file,
                                                   ra8_viewer_reader_requirements_t* out)
{
  jof_info_t     info  = {};
  ra8_err_t      error = jof_parse(priv_viewer_pread, file, file->size, &info);
  const uint64_t band  = (uint64_t)info.tile_w * (uint64_t)info.tile_h * (uint64_t)info.bpp;
  if ((error == k_ra8_ok) && (band == 0U)) {
    error = k_ra8_err_invalid_size;
  }
  const ra8_decomp_limits_t limits = ra8_decomp_limits_default();
  if (error == k_ra8_ok) {
    error = ra8_decomp_check_declared(&limits, file->size, band);
  }
  if (error != k_ra8_ok) {
    return error;
  }
  const uint32_t tiles  = ((uint32_t)info.height + (uint32_t)k_ra8_viewer_fb_height - 1U) /
                          (uint32_t)k_ra8_viewer_fb_height;
  out->dimensions_bytes = (size_t)tiles * 2U * sizeof(uint32_t);
  out->cell_bytes       = (size_t)band;
  out->scratch_bytes =
    (info.codec == (uint8_t)k_jof_codec_raw) ? 1U : (size_t)jof_stored_bound((uint32_t)band);
  out->tile_count = tiles;
  out->engine     = (uint32_t)k_ra8_viewer_engine_jof;
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_require_comic(ra8_viewer_reader_requirements_t* out)
{
  out->tile_count        = (uint32_t)k_viewer_comic_page_cap;
  out->dimensions_bytes  = (size_t)out->tile_count * 2U * sizeof(uint32_t);
  out->comic_pages_bytes = (size_t)out->tile_count * sizeof(comic_page_t);
  out->comic_names_bytes = (size_t)k_viewer_comic_name_bytes;
  out->comic_page_bytes  = (size_t)k_viewer_comic_page_bytes;
  out->comic_arena_bytes = (size_t)k_viewer_comic_arena_bytes;
  out->engine            = (uint32_t)k_ra8_viewer_engine_comic;
}
 
ra8_err_t ra8_viewer_reader_requirements(const char* path, ra8_viewer_reader_requirements_t* out)
{
  if ((path == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out                      = (ra8_viewer_reader_requirements_t){};
  const viewer_fmt_t format = internal_classify(path);
  if ((format != k_viewer_fmt_jof) && (format != k_viewer_fmt_comic)) {
    return internal_reject(format, path);
  }
  viewer_file_ctx_t file  = {.fd = -1};
  ra8_err_t         error = internal_file_open(&file, path);
  if (error == k_ra8_ok) {
    out->required_alignment = alignof(max_align_t);
    out->framebuffer_bytes =
      (size_t)k_ra8_viewer_fb_width * (size_t)k_ra8_viewer_fb_height * sizeof(uint16_t);
    out->layout_version = (uint32_t)k_viewer_layout_version;
    if (format == k_viewer_fmt_jof) {
      error = internal_require_jof(&file, out);
    } else {
      internal_require_comic(out);
    }
  }
  if (file.is_open) {
    (void)close(file.fd);
  }
  if (error != k_ra8_ok) {
    *out = (ra8_viewer_reader_requirements_t){};
    return error;
  }
  const viewer_layout_t layout = internal_layout(out, nullptr, 0U);
  if (!layout.valid) {
    *out = (ra8_viewer_reader_requirements_t){};
    return k_ra8_err_invalid_size;
  }
  out->required_bytes = layout.used;
  return k_ra8_ok;
}
 
ra8_err_t ra8_viewer_reader_bind(ra8_viewer_reader_t**                   out,
                                 void*                                   workspace,
                                 size_t                                  workspace_bytes,
                                 const ra8_viewer_reader_requirements_t* requirements,
                                 ra8_viewer_workspace_report_t*          report)
{
  if ((out == nullptr) || (requirements == nullptr) || (report == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out    = nullptr;
  *report = (ra8_viewer_workspace_report_t){.required_bytes = requirements->required_bytes,
                                            .supplied_bytes = workspace_bytes};
  if ((workspace == nullptr) || !internal_requirements_valid(requirements) ||
      (((uintptr_t)workspace % requirements->required_alignment) != 0U) ||
      (workspace_bytes < requirements->required_bytes)) {
    return k_ra8_err_invalid_size;
  }
  viewer_layout_t      layout = {.base     = (uint8_t*)workspace,
                                 .capacity = workspace_bytes,
                                 .used     = 0U,
                                 .valid    = true};
  ra8_viewer_reader_t* reader =
    (ra8_viewer_reader_t*)internal_take(&layout, sizeof(*reader), alignof(max_align_t));
  uint16_t* framebuffer =
    (uint16_t*)internal_take(&layout, requirements->framebuffer_bytes, alignof(uint16_t));
  const size_t   dimension_bytes = requirements->dimensions_bytes / 2U;
  uint32_t*      widths  = (uint32_t*)internal_take(&layout, dimension_bytes, alignof(uint32_t));
  uint32_t*      heights = (uint32_t*)internal_take(&layout, dimension_bytes, alignof(uint32_t));
  viewer_jof_t   jof     = {};
  viewer_comic_t comic   = {};
  if (requirements->engine == (uint32_t)k_ra8_viewer_engine_jof) {
    jof = internal_take_jof(&layout, requirements);
  } else {
    comic = internal_take_comic(&layout, requirements);
  }
  if (!layout.valid || (layout.used != requirements->required_bytes)) {
    return k_ra8_err_invalid_size;
  }
  *reader = (ra8_viewer_reader_t){.file     = {.fd = -1},
                                  .is_bound = true,
                                  .engine   = requirements->engine,
                                  .limits   = ra8_decomp_limits_default(),
                                  .fb       = framebuffer,
                                  .tile_wpx = widths,
                                  .tile_hpx = heights,
                                  .tile_cap = requirements->tile_count,
                                  .rt565    = framebuffer,
                                  .rt_w     = (uint32_t)k_ra8_viewer_fb_width,
                                  .rt_h     = (uint32_t)k_ra8_viewer_fb_height,
                                  .jof      = jof,
                                  .comic    = comic};
  *out    = reader;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_open_selected(ra8_viewer_reader_t* reader)
{
  ra8_err_t error = k_ra8_err_invalid_state;
  if (reader->engine == (uint32_t)k_ra8_viewer_engine_jof) {
    error = priv_viewer_open_jof(reader);
    if (error == k_ra8_ok) {
      reader->tile_n =
        ((uint32_t)reader->jof.dctx.info.height + (uint32_t)k_ra8_viewer_fb_height - 1U) /
        (uint32_t)k_ra8_viewer_fb_height;
    }
    if ((error == k_ra8_ok) && ((reader->tile_n == 0U) || (reader->tile_n > reader->tile_cap))) {
      error = k_ra8_err_invalid_size;
    }
    if (error == k_ra8_ok) {
      priv_viewer_size_jof_tiles(reader, reader->tile_n);
    }
  } else if (reader->engine == (uint32_t)k_ra8_viewer_engine_comic) {
    error = priv_viewer_open_comic(reader);
    if (error == k_ra8_ok) {
      reader->tile_n = comic_page_count(&reader->comic.archive);
    }
    if ((error == k_ra8_ok) && ((reader->tile_n == 0U) || (reader->tile_n > reader->tile_cap))) {
      error = k_ra8_err_invalid_size;
    }
    if (error == k_ra8_ok) {
      error = priv_viewer_size_comic_tiles(reader);
    }
  }
  return error;
}

RA8_INTERNAL static bool internal_engine_matches(const ra8_viewer_reader_t* reader,
                                                 viewer_fmt_t               format)
{
  return ((reader->engine == (uint32_t)k_ra8_viewer_engine_jof) && (format == k_viewer_fmt_jof)) ||
         ((reader->engine == (uint32_t)k_ra8_viewer_engine_comic) &&
          (format == k_viewer_fmt_comic));
}
 
ra8_err_t ra8_viewer_open(ra8_viewer_reader_t* reader, const char* path)
{
  if ((reader == nullptr) || (path == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!reader->is_bound || reader->is_open || reader->file.is_open) {
    return k_ra8_err_invalid_state;
  }
  const viewer_fmt_t format = internal_classify(path);
  if (!internal_engine_matches(reader, format)) {
    return k_ra8_err_invalid_state;
  }
  ra8_err_t error = internal_file_open(&reader->file, path);
  if (error == k_ra8_ok) {
    error = internal_open_selected(reader);
  }
  if (error == k_ra8_ok) {
    reader->is_open = true;
    return k_ra8_ok;
  }
  if (reader->engine == (uint32_t)k_ra8_viewer_engine_comic) {
    (void)comic_close(&reader->comic.archive);
  }
  if (reader->file.is_open) {
    (void)close(reader->file.fd);
  }
  reader->file   = (viewer_file_ctx_t){.fd = -1};
  reader->tile_n = 0U;
  return error;
}
 
uint32_t ra8_viewer_page_count(const ra8_viewer_reader_t* reader)
{
  return ((reader == nullptr) || !reader->is_open) ? 0U : reader->tile_n;
}
 
ra8_err_t ra8_viewer_render_page(ra8_viewer_reader_t* reader, uint32_t page)
{
  if (reader == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!reader->is_open) {
    return k_ra8_err_invalid_state;
  }
  if (page >= reader->tile_n) {
    return k_ra8_err_out_of_range;
  }
  return (reader->engine == (uint32_t)k_ra8_viewer_engine_comic)
           ? priv_viewer_render_comic(reader, page)
           : priv_viewer_render_jof(reader, page);
}
 
uint32_t ra8_viewer_tile_count(const ra8_viewer_reader_t* reader)
{
  return ra8_viewer_page_count(reader);
}
 
ra8_err_t ra8_viewer_tile_size(const ra8_viewer_reader_t* reader,
                               uint32_t                   index,
                               uint32_t*                  width,
                               uint32_t*                  height)
{
  if ((reader == nullptr) || (width == nullptr) || (height == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!reader->is_open) {
    return k_ra8_err_invalid_state;
  }
  if (index >= reader->tile_n) {
    return k_ra8_err_out_of_range;
  }
  *width  = reader->tile_wpx[index];
  *height = reader->tile_hpx[index];
  return k_ra8_ok;
}
 
ra8_err_t ra8_viewer_tile_requirements(const ra8_viewer_reader_t* reader,
                                       uint32_t                   index,
                                       size_t*                    out_bytes,
                                       size_t*                    out_alignment)
{
  uint32_t        width  = 0U;
  uint32_t        height = 0U;
  const ra8_err_t error  = ra8_viewer_tile_size(reader, index, &width, &height);
  if ((out_bytes == nullptr) || (out_alignment == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (error != k_ra8_ok) {
    return error;
  }
  *out_bytes     = (size_t)width * (size_t)height * sizeof(uint16_t);
  *out_alignment = alignof(uint16_t);
  return k_ra8_ok;
}
 
ra8_err_t ra8_viewer_render_tile565(ra8_viewer_reader_t*           reader,
                                    uint32_t                       index,
                                    void*                          workspace,
                                    size_t                         workspace_bytes,
                                    uint32_t*                      width,
                                    uint32_t*                      height,
                                    uint16_t**                     out_pixels,
                                    ra8_viewer_workspace_report_t* report)
{
  if ((reader == nullptr) || (width == nullptr) || (height == nullptr) || (out_pixels == nullptr) ||
      (report == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_pixels               = nullptr;
  size_t          required  = 0U;
  size_t          alignment = 0U;
  const ra8_err_t error     = ra8_viewer_tile_requirements(reader, index, &required, &alignment);
  *report =
    (ra8_viewer_workspace_report_t){.required_bytes = required, .supplied_bytes = workspace_bytes};
  if (error != k_ra8_ok) {
    return error;
  }
  if ((workspace == nullptr) || (((uintptr_t)workspace % alignment) != 0U) ||
      (workspace_bytes < required)) {
    return k_ra8_err_invalid_size;
  }
  const ra8_err_t render =
    (reader->engine == (uint32_t)k_ra8_viewer_engine_comic)
      ? priv_viewer_tile_comic(reader, index, (uint16_t*)workspace, workspace_bytes, width, height)
      : priv_viewer_tile_jof(reader, index, (uint16_t*)workspace, workspace_bytes, width, height);
  if (render == k_ra8_ok) {
    *out_pixels = (uint16_t*)workspace;
  }
  return render;
}
 
void ra8_viewer_close(ra8_viewer_reader_t* reader)
{
  if (reader == nullptr) {
    return;
  }
  if (reader->file.is_open) {
    if (reader->engine == (uint32_t)k_ra8_viewer_engine_comic) {
      (void)comic_close(&reader->comic.archive);
    }
    (void)close(reader->file.fd);
  }
  reader->file    = (viewer_file_ctx_t){.fd = -1};
  reader->is_open = false;
  reader->tile_n  = 0U;
  reader->rt565   = reader->fb;
  reader->rt_w    = (uint32_t)k_ra8_viewer_fb_width;
  reader->rt_h    = (uint32_t)k_ra8_viewer_fb_height;
}