mdl_export.c

Go to the documentation of this file.

 
#include "mdl_export.h"
 
#include <ctype.h>
#include <stdio.h>
#include <string.h>
 
#include "mdl_export_internal.h"
#include "ra8_attributes.h"

typedef enum : uint8_t {
  k_export_month_radix        = 13U, 
  k_export_hours_per_day      = 24U, 
  k_export_minutes_per_hour   = 60U, 
  k_export_seconds_per_minute = 60U, 
} mdl_export_time_radix_t;
 
mdl_format_t mdl_format_from_str(const char* s)
{
  if ((s == nullptr) || (strcmp(s, "loose") == 0)) {
    return k_mdl_format_loose;
  }
  if (strcmp(s, "cbz") == 0) {
    return k_mdl_format_cbz;
  }
  if (strcmp(s, "cbt") == 0) {
    return k_mdl_format_cbt;
  }
  if (strcmp(s, "cbt.gz") == 0) {
    return k_mdl_format_cbt_gz;
  }
  if (strcmp(s, "epub") == 0) {
    return k_mdl_format_epub;
  }
  if (strcmp(s, "jof") == 0) {
    return k_mdl_format_jof;
  }
  if (strcmp(s, "rabook") == 0) {
    return k_mdl_format_rabook;
  }
  return k_mdl_format_invalid;
}
 
const char* mdl_format_ext(mdl_format_t fmt)
{
  switch (fmt) {
    case k_mdl_format_cbz:
      return "cbz";
    case k_mdl_format_cbt:
      return "cbt";
    case k_mdl_format_cbr:
      return "cbr";
    case k_mdl_format_cbt_xz:
      return "cbt.xz";
    case k_mdl_format_cbt_gz:
      return "cbt.gz";
    case k_mdl_format_epub:
      return "epub";
    case k_mdl_format_jof:
      return "jof";
    case k_mdl_format_rabook:
      return "rabook";
    case k_mdl_format_loose:
    case k_mdl_format_invalid:
    default:
      return "";
  }
}
 
bool mdl_format_is_dir_output(mdl_format_t fmt)
{
  /* JOF is inherently per-page: one `.jof` band atlas is written beside each
   * source image, so a chapter is a directory of atlases rather than a single
   * container file at out_path. Every other archive format produces one file.
   */
  return fmt == k_mdl_format_jof;
}

RA8_INTERNAL static bool internal_ends_with_ci(const char* name, const char* suffix)
{
  const size_t nl = strlen(name);
  const size_t sl = strlen(suffix);
  if (sl > nl) {
    return false;
  }
  const char* tail = name + (nl - sl);
  for (size_t i = 0U; i < sl; ++i) {
    if (tolower((unsigned char)tail[i]) != tolower((unsigned char)suffix[i])) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool internal_is_page_image(const char* name)
{
  static const char* const k_img_exts[] = {".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp"};
  for (size_t i = 0U; i < (sizeof(k_img_exts) / sizeof(k_img_exts[0])); ++i) {
    if (internal_ends_with_ci(name, k_img_exts[i])) {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static void internal_sort_pages(char names[][k_name_max], size_t count)
{
  for (size_t i = 1U; i < count; ++i) {
    char   held[k_name_max];
    size_t cursor = i;
    memcpy(held, names[i], sizeof(held));
    while ((cursor > 0U) && (strcmp(names[cursor - 1U], held) > 0)) {
      memcpy(names[cursor], names[cursor - 1U], k_name_max);
      --cursor;
    }
    memcpy(names[cursor], held, sizeof(held));
  }
}

RA8_INTERNAL static ra8_err_t internal_list_pages_open_dir(mdl_storage_t*          storage,
                                                           const char*             dir,
                                                           mdl_export_workspace_t* ws,
                                                           fw_fs_dir_t*            directory)
{
  fw_fs_caps_t caps          = {};
  ra8_err_t    err           = fw_fs_get_caps(storage->fs, &caps);
  void*        dir_workspace = nullptr;
  if (err == k_ra8_ok) {
    dir_workspace =
      mdl_export_workspace_take(ws, caps.directory_workspace_bytes, caps.directory_workspace_align);
    if (dir_workspace == nullptr) {
      err = k_ra8_err_invalid_size;
    }
  }
  if (err == k_ra8_ok) {
    err = fw_fs_dir_open(&storage->fs->names,
                         dir,
                         directory,
                         dir_workspace,
                         caps.directory_workspace_bytes);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_list_pages(mdl_storage_t*          storage,
                                                  const char*             dir,
                                                  char                    names[][k_name_max],
                                                  size_t                  cap,
                                                  mdl_export_workspace_t* ws,
                                                  size_t*                 out_count)
{
  const size_t floor     = ws->used;
  fw_fs_dir_t  directory = {};
  ra8_err_t    err       = internal_list_pages_open_dir(storage, dir, ws, &directory);
  size_t       count     = 0U;
  bool         entry     = true;
  while ((err == k_ra8_ok) && entry) {
    fw_fs_dirent_value_t value = {};
    err                        = fw_fs_dir_next(&directory, &value, &entry);
    if ((err == k_ra8_ok) && entry && (value.name[0] != '.') &&
        internal_is_page_image(value.name)) {
      if (value.type != k_fw_fs_node_file) {
        err = k_ra8_err_invalid_arg;
      } else if ((value.name_bytes >= (uint16_t)k_name_max) || (count >= cap)) {
        err = k_ra8_err_invalid_size;
      } else {
        memcpy(names[count], value.name, (size_t)value.name_bytes + 1U);
        ++count;
      }
    }
  }
  if (directory.is_open) {
    const ra8_err_t closed = fw_fs_dir_close(&directory);
    if ((err == k_ra8_ok) && (closed != k_ra8_ok)) {
      err = closed;
    }
  }
  ws->used = floor;
  if (err == k_ra8_ok) {
    internal_sort_pages(names, count);
    *out_count = count;
  }
  return err;
}

RA8_INTERNAL static uint64_t internal_timestamp_key(const fw_fs_datetime_t* value)
{
  uint64_t key = value->year;
  key          = (key * k_export_month_radix) + value->month;
  key          = (key * 32U) + value->day;
  key          = (key * k_export_hours_per_day) + value->hour;
  key          = (key * k_export_minutes_per_hour) + value->minute;
  return (key * k_export_seconds_per_minute) + value->second;
}

RA8_INTERNAL static bool internal_metadata_set_page_timestamp(mdl_storage_t*     storage,
                                                              mdl_export_meta_t* meta,
                                                              const char*        dir,
                                                              const char names[][k_name_max],
                                                              size_t     count)
{
  fw_fs_timestamp_t latest     = {};
  uint64_t          latest_key = 0U;
  for (size_t i = 0U; i < count; ++i) {
    char path[k_fw_fs_path_cap];
    if (priv_mdl_export_path_join(path, sizeof(path), dir, names[i]) != k_ra8_ok) {
      return false;
    }
    fw_fs_stat_t stat = {};
    if ((fw_fs_stat(&storage->fs->names, path, &stat) != k_ra8_ok) || !stat.exists ||
        (stat.type != k_fw_fs_node_file)) {
      return false;
    }
    if (stat.modified.valid) {
      const uint64_t key = internal_timestamp_key(&stat.modified.value);
      if (!latest.valid || (key > latest_key)) {
        latest     = stat.modified;
        latest_key = key;
      }
    }
  }
  if (!latest.valid) {
    return snprintf(meta->modified, sizeof(meta->modified), "1970-01-01T00:00:00Z") > 0;
  }
  const fw_fs_datetime_t* value = &latest.value;
  if (latest.utc_offset_valid && (value->utc_offset_min != 0)) {
    const int offset   = value->utc_offset_min;
    const int absolute = (offset < 0) ? -offset : offset;
    return snprintf(meta->modified,
                    sizeof(meta->modified),
                    "%04u-%02u-%02uT%02u:%02u:%02u%c%02d:%02d",
                    value->year,
                    value->month,
                    value->day,
                    value->hour,
                    value->minute,
                    value->second,
                    (offset < 0) ? '-' : '+',
                    absolute / k_export_minutes_per_hour,
                    absolute % k_export_minutes_per_hour) > 0;
  }
  return snprintf(meta->modified,
                  sizeof(meta->modified),
                  "%04u-%02u-%02uT%02u:%02u:%02uZ",
                  value->year,
                  value->month,
                  value->day,
                  value->hour,
                  value->minute,
                  value->second) > 0;
}

RA8_INTERNAL static ra8_err_t internal_export_dispatch(mdl_storage_t*           storage,
                                                       mdl_format_t             fmt,
                                                       const char*              dir,
                                                       char                     names[][k_name_max],
                                                       size_t                   count,
                                                       mdl_export_output_t*     output,
                                                       const mdl_export_meta_t* meta,
                                                       mdl_export_workspace_t*  ws)
{
  switch (fmt) {
    case k_mdl_format_cbz:
      return priv_mdl_export_cbz(storage, dir, names, count, output, meta, ws);
    case k_mdl_format_cbt:
      return priv_mdl_export_tar(storage, dir, names, count, output, meta);
    case k_mdl_format_cbt_gz:
      return priv_mdl_export_tar_gzip(storage, dir, names, count, output, meta, ws);
    case k_mdl_format_epub:
      return priv_mdl_export_epub(storage, dir, names, count, output, meta, ws);
    case k_mdl_format_cbr:
    case k_mdl_format_cbt_xz:
      return k_ra8_err_not_supported;
    case k_mdl_format_rabook:
    case k_mdl_format_jof:
    case k_mdl_format_loose:
    case k_mdl_format_invalid:
    default:
      return k_ra8_err_invalid_arg;
  }
}

RA8_INTERNAL static ra8_err_t internal_export_transaction(mdl_storage_t* storage,
                                                          mdl_format_t   fmt,
                                                          const char*    dir,
                                                          char           names[][k_name_max],
                                                          size_t         count,
                                                          const char*    out_path,
                                                          const mdl_export_meta_t* meta,
                                                          mdl_export_workspace_t*  ws)
{
  mdl_export_output_t output = {};
  ra8_err_t           rc     = priv_mdl_export_output_begin(&output, storage, out_path, fmt);
  if (rc == k_ra8_ok) {
    rc = internal_export_dispatch(storage, fmt, dir, names, count, &output, meta, ws);
  }
  if ((rc != k_ra8_ok) && output.writer.transaction.active) {
    const ra8_err_t aborted = priv_mdl_export_output_abort(&output);
    return (aborted == k_ra8_ok) ? rc : aborted;
  }
  bool published = false;
  return (rc == k_ra8_ok) ? priv_mdl_export_output_commit(&output, ws, &published) : rc;
}

RA8_INTERNAL static ra8_err_t internal_resolve_export_metadata(mdl_storage_t* storage,
                                                               const char*    chapter_dir,
                                                               char           names[][k_name_max],
                                                               size_t         count,
                                                               const mdl_export_meta_t* meta,
                                                               mdl_export_meta_t*       resolved)
{
  if (meta != nullptr) {
    *resolved = *meta;
  } else {
    mdl_meta_init(resolved);
  }
  const ra8_err_t source_rc = priv_mdl_export_validate_source_url(resolved->source_url);
  if (source_rc != k_ra8_ok) {
    return source_rc;
  }
  if ((resolved->modified[0] == '\0') &&
      !internal_metadata_set_page_timestamp(storage, resolved, chapter_dir, names, count)) {
    return k_ra8_fail;
  }
  return k_ra8_ok;
}
 
ra8_err_t mdl_export_chapter_meta_ws(mdl_storage_t*           storage,
                                     mdl_format_t             fmt,
                                     const char*              chapter_dir,
                                     const char*              out_path,
                                     const mdl_export_meta_t* meta,
                                     mdl_export_workspace_t*  ws)
{
  if ((storage == nullptr) || (chapter_dir == nullptr) || (out_path == nullptr) ||
      (fmt == k_mdl_format_loose) || (fmt == k_mdl_format_invalid) || (ws == nullptr) ||
      (ws->data == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  ws->used = 0U;
  if ((fmt == k_mdl_format_cbr) || (fmt == k_mdl_format_cbt_xz)) {
    return k_ra8_err_not_supported;
  }
 
  ws->high_water            = 0U;
  char (*names)[k_name_max] = mdl_export_workspace_take(ws,
                                                        (size_t)k_max_pages * (size_t)k_name_max,
                                                        _Alignof(char[k_name_max]));
  if (names == nullptr) {
    return k_ra8_err_invalid_size;
  }
 
  size_t          count = 0U;
  const ra8_err_t listed =
    internal_list_pages(storage, chapter_dir, names, (size_t)k_max_pages, ws, &count);
  if (listed != k_ra8_ok) {
    return listed;
  }
  if (count == 0U) {
    return k_ra8_err_empty;
  }
  mdl_export_meta_t resolved = {};
  const ra8_err_t   meta_rc =
    internal_resolve_export_metadata(storage, chapter_dir, names, count, meta, &resolved);
  if (meta_rc != k_ra8_ok) {
    return meta_rc;
  }
 
  if (fmt == k_mdl_format_jof) {
    /* JOF writes one `.jof` sibling per page into chapter_dir; out_path names
     * no single container (see mdl_format_is_dir_output), so there is no single
     * file to rename into place -- priv_mdl_export_jof commits each page itself. */
    return priv_mdl_export_jof(storage, chapter_dir, names, count, ws);
  }
  if (fmt == k_mdl_format_rabook) {
    return priv_mdl_export_rabook(storage, chapter_dir, names, count, out_path, &resolved, ws);
  }
  return internal_export_transaction(storage,
                                     fmt,
                                     chapter_dir,
                                     names,
                                     count,
                                     out_path,
                                     &resolved,
                                     ws);
}
 
ra8_err_t mdl_export_chapter_ws(mdl_storage_t*          storage,
                                mdl_format_t            fmt,
                                const char*             chapter_dir,
                                const char*             out_path,
                                mdl_export_workspace_t* ws)
{
  mdl_export_meta_t meta;
  if (chapter_dir != nullptr) {
    (void)mdl_meta_load_dir(storage, &meta, chapter_dir);
  } else {
    mdl_meta_init(&meta);
  }
  return mdl_export_chapter_meta_ws(storage, fmt, chapter_dir, out_path, &meta, ws);
}