ra8_viewer_comic.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "comic.h"
#include "ra8_attributes.h"
#include "ra8_decomp_limits.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_img_arena.h"
#include "ra8_viewer_reader_internal.h"
#include "reflow_image.h"

typedef struct {
  int32_t x;      
  int32_t y;      
  int32_t width;  
  int32_t height; 
} viewer_fit_box_t;

RA8_INTERNAL static void internal_fit_centered(int32_t           source_width,
                                               int32_t           source_height,
                                               int32_t           target_width,
                                               int32_t           target_height,
                                               viewer_fit_box_t* box)
{
  const int64_t tw     = (int64_t)target_width;
  const int64_t th     = (int64_t)target_height;
  int64_t       width  = tw;
  int64_t       height = ((int64_t)source_height * tw) / (int64_t)source_width;
  if (height > th) {
    height = th;
    width  = ((int64_t)source_width * th) / (int64_t)source_height;
  }
  if (width < 1) {
    width = 1;
  }
  if (height < 1) {
    height = 1;
  }
  *box = (viewer_fit_box_t){.x      = (int32_t)((tw - width) / 2),
                            .y      = (int32_t)((th - height) / 2),
                            .width  = (int32_t)width,
                            .height = (int32_t)height};
}

RA8_INTERNAL static void internal_cap_render(uint32_t  native_width,
                                             uint32_t  native_height,
                                             uint32_t* render_width,
                                             uint32_t* render_height)
{
  const uint32_t edge   = (uint32_t)k_ra8_gfx_max_dim;
  uint32_t       width  = native_width;
  uint32_t       height = native_height;
  if (width > edge) {
    height = (uint32_t)(((uint64_t)height * (uint64_t)edge) / (uint64_t)width);
    width  = edge;
  }
  if (height > edge) {
    width  = (uint32_t)(((uint64_t)width * (uint64_t)edge) / (uint64_t)height);
    height = edge;
  }
  *render_width  = (width == 0U) ? 1U : width;
  *render_height = (height == 0U) ? 1U : height;
}

RA8_INTERNAL static ra8_err_t
internal_read_page(ra8_viewer_reader_t* reader, uint32_t page, size_t* out_bytes)
{
  uint64_t  declared = 0U;
  ra8_err_t error =
    comic_page_info(&reader->comic.archive, page, nullptr, 0U, nullptr, &declared, nullptr);
  if (error == k_ra8_ok) {
    error = ra8_decomp_check_declared(&reader->limits, reader->file.size, declared);
  }
  if ((error == k_ra8_ok) && (declared > (uint64_t)reader->comic.page_cap)) {
    error = k_ra8_err_invalid_size;
  }
  if (error != k_ra8_ok) {
    return error;
  }
  *out_bytes = 0U;
  error      = comic_page_read(&reader->comic.archive,
                               page,
                               reader->comic.page,
                               reader->comic.page_cap,
                               out_bytes);
  if ((error == k_ra8_ok) && ((uint64_t)*out_bytes != declared)) {
    return k_ra8_err_invalid_size;
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_probe_page(ra8_viewer_reader_t* reader, uint32_t page)
{
  size_t    encoded = 0U;
  ra8_err_t error   = internal_read_page(reader, page, &encoded);
  int32_t   width   = 0;
  int32_t   height  = 0;
  if (error == k_ra8_ok) {
    ra8_img_arena_t arena = {.base = reader->comic.arena, .cap = reader->comic.arena_cap};
    ra8_img_arena_bind(&arena);
    error = ra8_img_probe_size(reader->comic.page, encoded, &width, &height);
    ra8_img_arena_unbind();
  }
  if ((error == k_ra8_ok) && ((width <= 0) || (height <= 0))) {
    error = k_ra8_err_invalid_size;
  }
  if (error == k_ra8_ok) {
    internal_cap_render((uint32_t)width,
                        (uint32_t)height,
                        &reader->tile_wpx[page],
                        &reader->tile_hpx[page]);
  }
  return error;
}

RA8_INTERNAL static ra8_err_t
internal_decode(ra8_viewer_reader_t* reader, uint32_t page, const viewer_fit_box_t* fit)
{
  size_t    encoded = 0U;
  ra8_err_t error   = internal_read_page(reader, page, &encoded);
  if (error == k_ra8_ok) {
    error = ra8_gfx_clear((uint32_t)k_viewer_background);
  }
  if (error == k_ra8_ok) {
    ra8_img_arena_t arena = {.base = reader->comic.arena, .cap = reader->comic.arena_cap};
    error                 = ra8_img_decode_blit(&arena,
                                                reader->comic.page,
                                                encoded,
                                                fit->x,
                                                fit->y,
                                                fit->width,
                                                fit->height,
                                                nullptr,
                                                nullptr);
  }
  return error;
}
 
size_t priv_viewer_comic_read(void* ctx, uint64_t offset, void* buffer, size_t length)
{
  size_t got = 0U;
  return (priv_viewer_pread(ctx, offset, (uint8_t*)buffer, length, &got) == k_ra8_ok) ? got : 0U;
}
 
ra8_err_t priv_viewer_open_comic(ra8_viewer_reader_t* reader)
{
  return comic_open(&reader->comic.archive,
                    priv_viewer_comic_read,
                    &reader->file,
                    reader->file.size,
                    reader->comic.pages,
                    (uint32_t)k_viewer_comic_page_cap,
                    reader->comic.names,
                    (uint32_t)k_viewer_comic_name_bytes);
}
 
ra8_err_t priv_viewer_size_comic_tiles(ra8_viewer_reader_t* reader)
{
  for (uint32_t page = 0U; page < reader->tile_n; ++page) {
    const ra8_err_t error = internal_probe_page(reader, page);
    if (error != k_ra8_ok) {
      return error;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t priv_viewer_render_comic(ra8_viewer_reader_t* reader, uint32_t page)
{
  const uint32_t   source_width  = reader->tile_wpx[page];
  const uint32_t   source_height = reader->tile_hpx[page];
  viewer_fit_box_t fit           = {};
  internal_fit_centered((int32_t)source_width,
                        (int32_t)source_height,
                        (int32_t)k_ra8_viewer_fb_width,
                        (int32_t)k_ra8_viewer_fb_height,
                        &fit);
  const ra8_err_t error = ra8_gfx_init(reader->fb,
                                       k_ra8_viewer_fb_width,
                                       k_ra8_viewer_fb_height,
                                       k_ra8_gfx_format_rgb565);
  return (error == k_ra8_ok) ? internal_decode(reader, page, &fit) : error;
}
 
ra8_err_t priv_viewer_tile_comic(ra8_viewer_reader_t* reader,
                                 uint32_t             index,
                                 uint16_t*            pixels,
                                 size_t               pixel_bytes,
                                 uint32_t*            width,
                                 uint32_t*            height)
{
  const uint32_t render_width  = reader->tile_wpx[index];
  const uint32_t render_height = reader->tile_hpx[index];
  const uint64_t required =
    (uint64_t)render_width * (uint64_t)render_height * (uint64_t)sizeof(uint16_t);
  if ((required > (uint64_t)pixel_bytes) || (render_width > UINT16_MAX) ||
      (render_height > UINT16_MAX)) {
    return k_ra8_err_invalid_size;
  }
  ra8_err_t error =
    ra8_gfx_init(pixels, (uint16_t)render_width, (uint16_t)render_height, k_ra8_gfx_format_rgb565);
  if (error == k_ra8_ok) {
    const viewer_fit_box_t fit = {.x      = 0,
                                  .y      = 0,
                                  .width  = (int32_t)render_width,
                                  .height = (int32_t)render_height};
    error                      = internal_decode(reader, index, &fit);
  }
  const ra8_err_t restored = ra8_gfx_init(reader->fb,
                                          k_ra8_viewer_fb_width,
                                          k_ra8_viewer_fb_height,
                                          k_ra8_gfx_format_rgb565);
  if ((error == k_ra8_ok) && (restored != k_ra8_ok)) {
    error = restored;
  }
  if (error == k_ra8_ok) {
    *width  = render_width;
    *height = render_height;
  }
  return error;
}