main.c

Go to the documentation of this file.

 
#include <signal.h>
#include <stdalign.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_io_stream.h"
#include "ra8_io_stream_posix.h"
#include "ra8_log.h"
#include "ra8_viewer_output_internal.h"
#include "ra8_viewer_reader.h"
#include "ra8_viewer_view.h"

typedef enum : int32_t {
  k_viewer_frame_ns  = 16000000, 
  k_viewer_min_args  = 2,        
  k_viewer_radix_dec = 10,       
  k_viewer_composition_bytes = 32 * 1024 * 1024,
} viewer_main_config_t;

typedef struct {
  const char* path;      
  const char* dump_ppm;  
  uint32_t    page;      
  int64_t     dump_tile; 
  bool        headless;  
} viewer_options_t;

alignas(max_align_t) static uint8_t s_viewer_composition[k_viewer_composition_bytes];

RA8_INTERNAL static void internal_usage(ra8_io_stream_t* output, const char* executable)
{
  (void)priv_viewer_output_usage(output, executable);
}

RA8_INTERNAL static bool internal_parse_arguments(int argc, char** argv, viewer_options_t* options)
{
  if (argc < (int)k_viewer_min_args) {
    return false;
  }
  *options = (viewer_options_t){.path = argv[1], .dump_tile = -1};
  for (int index = 2; index < argc; ++index) {
    if ((strcmp(argv[index], "--page") == 0) && ((index + 1) < argc)) {
      options->page = (uint32_t)strtoul(argv[++index], nullptr, (int)k_viewer_radix_dec);
    } else if ((strcmp(argv[index], "--dump-ppm") == 0) && ((index + 1) < argc)) {
      options->dump_ppm = argv[++index];
    } else if ((strcmp(argv[index], "--dump-tile") == 0) && ((index + 1) < argc)) {
      options->dump_tile = strtoll(argv[++index], nullptr, (int)k_viewer_radix_dec);
    } else if (strcmp(argv[index], "--headless") == 0) {
      options->headless = true;
    } else {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static uint32_t internal_clamp_page(uint32_t page, uint32_t count)
{
  if (count == 0U) {
    return 0U;
  }
  return (page >= count) ? (count - 1U) : page;
}

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

RA8_INTERNAL static void internal_report_capacity(ra8_io_stream_t*                     output,
                                                  const char*                          subject,
                                                  const ra8_viewer_workspace_report_t* report)
{
  (void)
    priv_viewer_output_capacity(output, subject, report->required_bytes, report->supplied_bytes);
}

RA8_INTERNAL static bool internal_render_page(ra8_viewer_reader_t*    reader,
                                              const viewer_options_t* options,
                                              uint32_t                page,
                                              ra8_io_stream_t*        diagnostic)
{
  const ra8_err_t error = ra8_viewer_render_page(reader, page);
  if (error != k_ra8_ok) {
    (void)priv_viewer_output_index_error(diagnostic, "render page ", page, error);
    return false;
  }
  if ((options->dump_ppm != nullptr) &&
      (ra8_viewer_dump_ppm(reader, options->dump_ppm) != k_ra8_ok)) {
    (void)priv_viewer_output_text(diagnostic, "dump ppm failed\n");
    return false;
  }
  if (options->dump_ppm != nullptr) {
    (void)priv_viewer_output_wrote(diagnostic, options->dump_ppm);
  }
  return true;
}

RA8_INTERNAL static bool internal_dump_tile(ra8_viewer_reader_t* reader,
                                            uint32_t             tile,
                                            const char*          path,
                                            void*                workspace,
                                            size_t               workspace_bytes,
                                            ra8_io_stream_t*     diagnostic)
{
  uint32_t                      width  = 0U;
  uint32_t                      height = 0U;
  uint16_t*                     pixels = nullptr;
  ra8_viewer_workspace_report_t report = {};
  const ra8_err_t               error  = ra8_viewer_render_tile565(reader,
                                                                   tile,
                                                                   workspace,
                                                                   workspace_bytes,
                                                                   &width,
                                                                   &height,
                                                                   &pixels,
                                                                   &report);
  if (error != k_ra8_ok) {
    if (error == k_ra8_err_invalid_size) {
      internal_report_capacity(diagnostic, "tile", &report);
    }
    (void)priv_viewer_output_index_error(diagnostic, "render tile ", tile, error);
    return false;
  }
  const ra8_err_t write_error = ra8_viewer_write_ppm565(pixels, width, height, path);
  if (write_error != k_ra8_ok) {
    (void)priv_viewer_output_error(diagnostic, "write tile ppm", write_error);
    return false;
  }
  (void)priv_viewer_output_tile(diagnostic, tile, width, height, path);
  return true;
}

RA8_INTERNAL static int internal_run_window(ra8_viewer_reader_t* reader,
                                            void*                workspace,
                                            size_t               workspace_bytes,
                                            ra8_io_stream_t*     diagnostic)
{
  ra8_viewer_view_requirements_t requirements = {};
  if (ra8_viewer_view_requirements(reader, &requirements) != k_ra8_ok) {
    (void)priv_viewer_output_text(diagnostic,
                                  "no window (headless host?); use --headless --dump-ppm PATH\n");
    return 1;
  }
  ra8_viewer_view_t*            view   = nullptr;
  ra8_viewer_workspace_report_t report = {};
  const ra8_err_t               error  = ra8_viewer_view_open(&view,
                                                              reader,
                                                              "RA8 Viewer",
                                                              workspace,
                                                              workspace_bytes,
                                                              &requirements,
                                                              &report);
  if (error != k_ra8_ok) {
    if (error == k_ra8_err_invalid_size) {
      internal_report_capacity(diagnostic, "view", &report);
    }
    (void)priv_viewer_output_text(diagnostic,
                                  "no window (headless host?); use --headless --dump-ppm PATH\n");
    return 1;
  }
  const struct timespec frame = {.tv_sec = 0, .tv_nsec = k_viewer_frame_ns};
  while (!ra8_viewer_view_pump(view)) {
    (void)nanosleep(&frame, nullptr);
  }
  ra8_viewer_view_close(view);
  return 0;
}

RA8_INTERNAL static void internal_log_sink(void* context, uint8_t byte)
{
  (void)ra8_io_stream_putc((ra8_io_stream_t*)context, (char)byte);
}

RA8_INTERNAL static ra8_err_t internal_bind_diagnostic(ra8_io_stream_t*             output,
                                                       ra8_io_stream_posix_state_t* state)
{
  struct sigaction action = {.sa_handler = SIG_IGN};
  if ((sigemptyset(&action.sa_mask) != 0) || (sigaction(SIGPIPE, &action, nullptr) != 0)) {
    return k_ra8_err_comm_error;
  }
  return ra8_io_stream_posix_init(output, state, STDERR_FILENO);
}

RA8_INTERNAL static int internal_execute(ra8_viewer_reader_t*                    reader,
                                         const ra8_viewer_reader_requirements_t* requirements,
                                         const viewer_options_t*                 options,
                                         uint32_t                                page,
                                         ra8_io_stream_t*                        diagnostic)
{
  size_t scratch_offset = 0U;
  if (!internal_align_offset(requirements->required_bytes, alignof(max_align_t), &scratch_offset) ||
      (scratch_offset > sizeof(s_viewer_composition))) {
    return 1;
  }
  void*        scratch       = &s_viewer_composition[scratch_offset];
  const size_t scratch_bytes = sizeof(s_viewer_composition) - scratch_offset;
  if (options->dump_tile >= 0) {
    const char* output = (options->dump_ppm != nullptr) ? options->dump_ppm : "/tmp/ra8_tile.ppm";
    return internal_dump_tile(reader,
                              (uint32_t)options->dump_tile,
                              output,
                              scratch,
                              scratch_bytes,
                              diagnostic)
             ? 0
             : 1;
  }
  if (options->headless || (options->dump_ppm != nullptr)) {
    return internal_render_page(reader, options, page, diagnostic) ? 0 : 1;
  }
  return internal_run_window(reader, scratch, scratch_bytes, diagnostic);
}

int main(int argc, char** argv)
{
  ra8_io_stream_t             diagnostic       = {};
  ra8_io_stream_posix_state_t diagnostic_state = {};
  if (internal_bind_diagnostic(&diagnostic, &diagnostic_state) != k_ra8_ok) {
    return 1;
  }
  ra8_log_set_byte_sink(internal_log_sink, &diagnostic);
  viewer_options_t options = {};
  if (!internal_parse_arguments(argc, argv, &options)) {
    internal_usage(&diagnostic, argv[0]);
    return 2;
  }
  ra8_viewer_reader_requirements_t requirements = {};
  ra8_err_t error = ra8_viewer_reader_requirements(options.path, &requirements);
  if (error != k_ra8_ok) {
    (void)priv_viewer_output_open_error(&diagnostic, options.path, error);
    return 1;
  }
  ra8_viewer_reader_t*          reader = nullptr;
  ra8_viewer_workspace_report_t report = {};
  error                                = ra8_viewer_reader_bind(&reader,
                                                                s_viewer_composition,
                                                                sizeof(s_viewer_composition),
                                                                &requirements,
                                                                &report);
  if (error != k_ra8_ok) {
    internal_report_capacity(&diagnostic, "reader", &report);
    (void)priv_viewer_output_open_error(&diagnostic, options.path, error);
    return 1;
  }
  error = ra8_viewer_open(reader, options.path);
  if (error != k_ra8_ok) {
    (void)priv_viewer_output_open_error(&diagnostic, options.path, error);
    return 1;
  }
  const uint32_t count = ra8_viewer_page_count(reader);
  const uint32_t page  = internal_clamp_page(options.page, count);
  (void)priv_viewer_output_opened(&diagnostic, options.path, count);
  const int status = internal_execute(reader, &requirements, &options, page, &diagnostic);
  ra8_viewer_close(reader);
  return status;
}