media_download_image.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "book.h"
#include "mdl_format.h"
#include "media_download_format_internal.h"
#include "media_download_image_internal.h"
#include "ra8_compress.h"
#include "ra8_img_arena.h"
#include "ra8_mdl_storage_ram.h"
#include "ra8_webp_arena.h"

typedef enum : uint32_t {
  k_image_source_bytes     = 4194304U,  
  k_image_stb_arena_bytes  = 12582912U, 
  k_image_webp_arena_bytes = 4194304U,  
  k_image_rgba_bytes       = 16777216U, 
  k_image_edge             = 1600U,     
  k_image_gray_bytes       = 2560000U,  
  k_image_normalized_bytes = 1280000U,  
  k_image_flat_bytes       = 1500000U,  
  k_image_packed_bytes     = 1600000U,  
  k_image_string_bytes     = 1024U,     
  k_image_chunk_bytes      = 65536U,    
  k_image_compressed_bytes = 66560U,    
  k_image_offset_entries   = 25U,       
} image_limit_t;

typedef struct {
  alignas(max_align_t) uint8_t bytes[k_ra8_compress_scratch_bytes];
} image_compressor_t;

static const mdl_format_t s_output_format = k_mdl_format_rabook;
static ra8_mdl_storage_ram_t s_source_storage;
static book_chapter_t s_chapters[1];
static book_node_t s_nodes[2];
static book_attr_t s_attrs[1];
static book_stylesheet_t s_styles[1];
static book_image_t s_images[1];
static char s_strings[k_image_string_bytes];
static uint8_t s_dummy_image[1];
static uint8_t s_dummy_output[1];

[[gnu::section(".sdram_data"), gnu::aligned(16)]] static uint8_t s_source[k_image_source_bytes];
[[gnu::section(".sdram_data"),
  gnu::aligned(16)]] static uint8_t s_stb_arena[k_image_stb_arena_bytes];
[[gnu::section(".sdram_data"),
  gnu::aligned(16)]] static uint8_t s_webp_arena[k_image_webp_arena_bytes];
[[gnu::section(".sdram_data"), gnu::aligned(16)]] static uint8_t s_rgba[k_image_rgba_bytes];
[[gnu::section(".sdram_data"), gnu::aligned(16)]] static uint8_t s_gray[k_image_gray_bytes];
[[gnu::section(".sdram_data"),
  gnu::aligned(16)]] static uint8_t s_normalized[k_image_normalized_bytes];
[[gnu::section(".sdram_data"), gnu::aligned(16)]] static uint8_t s_image[k_image_normalized_bytes];
[[gnu::section(".sdram_data"), gnu::aligned(16)]] static uint8_t s_flat[k_image_flat_bytes];
[[gnu::section(".sdram_data"), gnu::aligned(16)]] static uint8_t s_packed[k_image_packed_bytes];
[[gnu::section(".sdram_data"),
  gnu::aligned(16)]] static uint8_t s_container_input[k_image_chunk_bytes];
[[gnu::section(".sdram_data"),
  gnu::aligned(16)]] static uint8_t s_container_compressed[k_image_compressed_bytes];
[[gnu::section(".sdram_data"),
  gnu::aligned(16)]] static uint64_t s_container_offsets[k_image_offset_entries];
[[gnu::section(".sdram_data"), gnu::aligned(16)]] static image_compressor_t s_compressor;

RA8_INTERNAL static ra8_rabook_buffers_t internal_builder(void)
{
  return (ra8_rabook_buffers_t){.chapters       = s_chapters,
                                .nodes          = s_nodes,
                                .attrs          = s_attrs,
                                .stylesheets    = s_styles,
                                .images         = s_images,
                                .string_pool    = s_strings,
                                .image_pool     = s_dummy_image,
                                .out            = s_dummy_output,
                                .chapter_cap    = 1U,
                                .node_cap       = 2U,
                                .attr_cap       = 1U,
                                .stylesheet_cap = 1U,
                                .image_cap      = 1U,
                                .string_cap     = sizeof s_strings,
                                .image_pool_cap = sizeof s_dummy_image,
                                .out_cap        = sizeof s_dummy_output};
}

RA8_INTERNAL static media_download_format_workspace_t internal_workspace(ra8_img_arena_t*  stb,
                                                                         ra8_webp_arena_t* webp)
{
  *stb  = (ra8_img_arena_t){.base = s_stb_arena, .cap = sizeof s_stb_arena};
  *webp = (ra8_webp_arena_t){.base = s_webp_arena, .cap = sizeof s_webp_arena};
  const ra8_rabook_comic_workspace_t comic = {
    .builder            = internal_builder(),
    .raster             = {.stb_arena  = stb,
                           .webp_arena = webp,
                           .rgba       = s_rgba,
                           .rgba_cap   = sizeof s_rgba,
                           .gray       = s_gray,
                           .gray_cap   = sizeof s_gray},
    .normalized         = s_normalized,
    .normalized_cap     = sizeof s_normalized,
    .stream_scratch     = s_container_input,
    .stream_scratch_cap = sizeof s_container_input,
  };
  const ra8_rabook_container_workspace_t container = {
    .input          = s_container_input,
    .compressed     = s_container_compressed,
    .compressor     = s_compressor.bytes,
    .offsets        = s_container_offsets,
    .input_cap      = sizeof s_container_input,
    .compressed_cap = sizeof s_container_compressed,
    .compressor_cap = sizeof s_compressor.bytes,
    .offset_cap     = k_image_offset_entries,
  };
  return (media_download_format_workspace_t){.comic      = comic,
                                             .container  = container,
                                             .image      = s_image,
                                             .flat       = s_flat,
                                             .packed     = s_packed,
                                             .image_cap  = sizeof s_image,
                                             .flat_cap   = sizeof s_flat,
                                             .packed_cap = sizeof s_packed};
}

RA8_INTERNAL static ra8_err_t internal_format(uint64_t* packed_size)
{
  if (s_output_format != k_mdl_format_rabook) {
    return k_ra8_err_not_supported;
  }
  const uint8_t* source      = nullptr;
  size_t         source_size = 0U;
  ra8_err_t      err         = ra8_mdl_storage_ram_view(&s_source_storage, &source, &source_size);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_img_arena_t                      stb       = {};
  ra8_webp_arena_t                     webp      = {};
  media_download_format_workspace_t    workspace = internal_workspace(&stb, &webp);
  const media_download_format_config_t config    = {
    .page_id        = "source-image",
    .metadata       = {.title      = "Downloaded image",
                       .author     = "C6 HTTPS source",
                       .language   = "und",
                       .identifier = "urn:ra8:media-download:image"},
    .chunk_bytes    = k_image_chunk_bytes,
    .max_image_edge = (uint16_t)k_image_edge,
    .pixel_format   = (uint8_t)k_book_pixfmt_gray4,
  };
  return priv_media_download_format_rabook(source, source_size, &config, &workspace, packed_size);
}

RA8_INTERNAL static ra8_err_t internal_publish_fragment(const ra8_mdl_transfer_config_t* transfer,
                                                        uint64_t                         offset,
                                                        uint16_t                         length)
{
  uint16_t  written = 0U;
  ra8_err_t err =
    transfer->storage.write(transfer->storage.ctx, &s_packed[(size_t)offset], length, &written);
  if ((err == k_ra8_ok) && (written != length)) {
    err = k_ra8_err_invalid_size;
  }
  if (err == k_ra8_ok) {
    err = transfer->sha256.update(transfer->sha256.ctx, &s_packed[(size_t)offset], length);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_publish(const ra8_mdl_transfer_config_t* transfer,
                                               uint64_t                         packed_size,
                                               const char*                      destination)
{
  if ((packed_size == 0U) || (packed_size > sizeof s_packed) || (transfer->chunk_bytes == 0U)) {
    return k_ra8_err_invalid_size;
  }
  ra8_err_t err    = transfer->storage.begin(transfer->storage.ctx, destination);
  bool      active = err == k_ra8_ok;
  if (err == k_ra8_ok) {
    err = transfer->sha256.init(transfer->sha256.ctx);
  }
  uint64_t offset = 0U;
  while ((err == k_ra8_ok) && (offset < packed_size)) {
    uint64_t remaining = packed_size - offset;
    uint16_t chunk     = transfer->chunk_bytes;
    if (remaining < (uint64_t)chunk) {
      chunk = (uint16_t)remaining;
    }
    err = internal_publish_fragment(transfer, offset, chunk);
    offset += (err == k_ra8_ok) ? chunk : 0U;
  }
  uint8_t digest[k_ra8_mdl_sha256_bytes] = {};
  if (err == k_ra8_ok) {
    err = transfer->sha256.final(transfer->sha256.ctx, digest);
  }
  if (err == k_ra8_ok) {
    err = transfer->storage.validate(transfer->storage.ctx, packed_size, digest);
  }
  if (err == k_ra8_ok) {
    err = transfer->storage.commit(transfer->storage.ctx);
    if (err == k_ra8_ok) {
      active = false;
    }
  }
  if ((err != k_ra8_ok) && active) {
    (void)transfer->storage.abort(transfer->storage.ctx);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_check_transfer(const ra8_mdl_transfer_config_t* transfer)
{
  if (transfer == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if ((transfer->storage.begin == nullptr) || (transfer->storage.write == nullptr) ||
      (transfer->storage.validate == nullptr) || (transfer->storage.commit == nullptr) ||
      (transfer->storage.abort == nullptr) || (transfer->storage.ctx == nullptr) ||
      (transfer->sha256.init == nullptr) || (transfer->sha256.update == nullptr) ||
      (transfer->sha256.final == nullptr) || (transfer->sha256.ctx == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_media_download_image_run(ra8_c6link_t*                    link,
                                                 const char*                      url,
                                                 const char*                      destination,
                                                 const ra8_mdl_transfer_config_t* transfer)
{
  if ((link == nullptr) || (url == nullptr) || (destination == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  ra8_err_t                 err             = internal_check_transfer(transfer);
  ra8_mdl_transfer_config_t source_transfer = {};
  if (err == k_ra8_ok) {
    source_transfer        = *transfer;
    source_transfer.format = k_mdl_format_loose;
    err                    = ra8_mdl_storage_ram_init(&s_source_storage,
                                                      &source_transfer.storage,
                                                      s_source,
                                                      sizeof s_source);
  }
  if (err == k_ra8_ok) {
    ra8_mdl_transfer_result_t result = {};
    err = ra8_c6link_mdl_transfer(link, url, "source-image", &source_transfer, &result);
  }
  uint64_t packed_size = 0U;
  if (err == k_ra8_ok) {
    err = internal_format(&packed_size);
  }
  if (err == k_ra8_ok) {
    err = internal_publish(transfer, packed_size, destination);
  }
  return err;
}