render_progress.c

Go to the documentation of this file.

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define TUI_RENDER_PROGRESS_LABEL_BUFFER_SIZE 160
#define TUI_RENDER_PROGRESS_TOTAL_BUFFER_SIZE 32
#define TUI_RENDER_PROGRESS_TITLE_BUFFER_SIZE 64
#define TUI_RENDER_PROGRESS_BAR_BUFFER_SIZE 4096
 
#include <ascii-chat/ui/text.h>
#include <ascii-chat/ui/progress.h>
#include <ascii-chat/tui/render_progress.h>
#include <ascii-chat/tui/controller.h>
#include <ascii-chat/ui/frame_buffer.h>
#include <libplatform/compiler.h>
#include <libplatform/system.h>
#include <libplatform/terminal.h>
#include <ascii-chat/os/memory.h>
#include <ascii-chat/util/string.h>
#include <ascii-chat/util/display.h>
#include <ascii-chat/util/time.h>
#include <ascii-chat/video/ascii/rle.h>
#include <string.h>
#include <stdio.h>
 
// Preview storage is bounded independently of recording duration and queue depth.
#define PREVIEW_MAX_BYTES (1024 * 1024)
 
typedef struct {
  uint64_t started_ns;
  uint64_t completed;
  uint64_t total;
  bool total_known;
  bool finalizing;
  bool failed;
  size_t length;
  size_t destination_length;
  // The NUL-terminated destination follows the NUL-terminated preview.
  char frame[];
} progress_snapshot_t;

struct render_progress {
  mutex_t mutex;
  progress_snapshot_t *snapshot;
  int fd;
  uint64_t last_preview_ns;
  bool active;
};
 
static void progress_render(terminal_size_t size, const void *data) {
  const progress_snapshot_t *snapshot = data;
  frame_buffer_t *buffer = frame_buffer_create(size.rows, size.cols);
  if (!buffer)
    return;
  char *line = SAFE_MALLOC(snapshot->length + 1, char *);
  char *clipped = SAFE_MALLOC(snapshot->length + UI_CLIPPED_TEXT_OVERHEAD, char *);
  const char *cursor = snapshot->frame;
  const char *end = cursor + snapshot->length;
  // Address each row explicitly, leaving the last column free to prevent wrapping.
  for (int row = 1; row <= size.rows; ++row) {
    frame_buffer_printf(buffer, "\033[%d;1H\033[0m\033[2K", row);
    if (cursor < end) {
      const char *newline = memchr(cursor, '\n', (size_t)(end - cursor));
      size_t length = (size_t)((newline ? newline : end) - cursor);
      memcpy(line, cursor, length);
      line[length] = '\0';
      char *expanded = ansi_expand_rle(line, length);
      truncate_with_ellipsis(expanded ? expanded : line, clipped, snapshot->length + UI_CLIPPED_TEXT_OVERHEAD,
                             size.cols - 1);
      SAFE_FREE(expanded);
      frame_buffer_append(buffer, clipped, strlen(clipped));
      cursor += length + (newline ? 1 : 0);
    }
  }
  uint64_t elapsed = snapshot->started_ns ? time_get_ns() - snapshot->started_ns : 0;
  uint64_t seconds = elapsed / NS_PER_SEC_INT;
  char label[TUI_RENDER_PROGRESS_LABEL_BUFFER_SIZE], total[TUI_RENDER_PROGRESS_TOTAL_BUFFER_SIZE];
  if (snapshot->total_known)
    snprintf(total, sizeof(total), "%llu", (unsigned long long)snapshot->total);
  else
    snprintf(total, sizeof(total), "?");
  const char *phase = snapshot->failed       ? "Recording failed"
                      : snapshot->finalizing ? "Finalizing file"
                                             : "Rendering file";
  snprintf(label, sizeof(label), " %c %s (%llu:%02llu) (frame %llu/%s) ",
           "|/-\\"[(elapsed / (125 * NS_PER_MS_INT)) % 4], phase, (unsigned long long)(seconds / 60),
           (unsigned long long)(seconds % 60), (unsigned long long)snapshot->completed, total);
  int width = (int)strlen(label);
  if (width > size.cols - 2) {
    width = size.cols - 2;
    label[width] = '\0';
  }
  char title[TUI_RENDER_PROGRESS_TITLE_BUFFER_SIZE];
  truncate_with_ellipsis("--render-file Progress", title, sizeof(title), size.cols - 4);
  int col = (size.cols - display_width(title) - 2) / 2 + 1;
  frame_buffer_printf(buffer, "\033[%d;%dH\033[0;1;7m %s \033[0m", (size.rows + 1) / 2 - 1, col, title);
  col = (size.cols - width) / 2 + 1;
  frame_buffer_printf(buffer, "\033[%d;%dH\033[0;7m%s\033[0m", (size.rows + 1) / 2, col, label);
  size_t destination_size = snapshot->destination_length + UI_CLIPPED_TEXT_OVERHEAD;
  char *destination = SAFE_MALLOC(destination_size, char *);
  truncate_with_ellipsis(snapshot->frame + snapshot->length + 1, destination, destination_size, size.cols - 4);
  int destination_width = display_width(destination) + 2;
  col = (size.cols - destination_width) / 2 + 1;
  frame_buffer_printf(buffer, "\033[%d;%dH\033[0;7m %s \033[0m", (size.rows + 1) / 2 + 1, col, destination);
  if (snapshot->total_known && snapshot->total && size.rows >= 9) {
    char bar[TUI_RENDER_PROGRESS_BAR_BUFFER_SIZE];
    int bar_width = size.cols > 44 ? 40 : size.cols - 4;
    ui_progress_format(bar, sizeof(bar), (double)snapshot->completed / (double)snapshot->total, bar_width);
    frame_buffer_printf(buffer, "\033[%d;%dH%s", (size.rows + 1) / 2 + 2, (size.cols - bar_width) / 2 + 1, bar);
  }
  SAFE_FREE(destination);
  ui_controller_write(STDOUT_FILENO, frame_buffer_get_content(buffer), frame_buffer_get_length(buffer));
  SAFE_FREE(line);
  SAFE_FREE(clipped);
  frame_buffer_destroy(buffer);
}
 
// The presentation callback reads only the controller-owned copy and never takes this mutex.
static void progress_publish(render_progress_t *progress) {
  if (progress->active)
    ui_controller_submit(UI_SCREEN_RENDER_PROGRESS, progress->fd, (terminal_size_t){.cols = 20, .rows = 5},
                         progress_render, progress->snapshot,
                         sizeof(*progress->snapshot) + progress->snapshot->length +
                             progress->snapshot->destination_length + 2);
}
 
render_progress_t *render_progress_create(bool enabled, const char *destination) {
  if (!enabled || !terminal_is_stdout_tty())
    return NULL;
  render_progress_t *progress = SAFE_CALLOC(1, sizeof(*progress), render_progress_t *);
  progress->fd = platform_dup(STDOUT_FILENO);
  if (progress->fd < 0) {
    SAFE_FREE(progress);
    return NULL;
  }
  mutex_init(&progress->mutex, "render_progress");
  size_t destination_length = strlen(destination);
  progress->snapshot = SAFE_CALLOC(1, sizeof(*progress->snapshot) + destination_length + 2, progress_snapshot_t *);
  progress->snapshot->destination_length = destination_length;
  char *name = progress->snapshot->frame + 1;
  memcpy(name, destination, destination_length);
  // A path must not inject terminal control sequences into the overlay.
  for (size_t i = 0; i < destination_length; ++i) {
    if ((unsigned char)name[i] < 0x20 || name[i] == 0x7f)
      name[i] = '?';
  }
  progress->snapshot->started_ns = time_get_ns();
  return progress;
}
 
void render_progress_frame(render_progress_t *progress, const char *frame, bool succeeded) {
  if (!progress)
    return;
  mutex_lock(&progress->mutex);
  uint64_t now = time_get_ns();
  // The overlay refreshes at most eight times per second. Expanding and copying
  // every full-resolution frame only slows the encoder and cannot be displayed.
  if (succeeded && !progress->snapshot->failed && progress->last_preview_ns && now >= progress->last_preview_ns &&
      now - progress->last_preview_ns < 125 * NS_PER_MS_INT) {
    ++progress->snapshot->completed;
    mutex_unlock(&progress->mutex);
    return;
  }
  progress->last_preview_ns = now;
  size_t length = strnlen(frame, (size_t)PREVIEW_MAX_BYTES + 1u);
  // Oversized frames still encode normally; omit their terminal preview.
  if (length > PREVIEW_MAX_BYTES)
    length = 0;
  progress_snapshot_t *next =
      SAFE_CALLOC(1, sizeof(*next) + length + progress->snapshot->destination_length + 2, progress_snapshot_t *);
  memcpy(next, progress->snapshot, sizeof(*next));
  next->length = length;
  memcpy(next->frame, frame, length);
  memcpy(next->frame + length + 1, progress->snapshot->frame + progress->snapshot->length + 1,
         next->destination_length + 1);
  if (!next->started_ns)
    next->started_ns = time_get_ns();
  if (succeeded)
    next->completed++;
  else
    next->failed = true;
  SAFE_FREE(progress->snapshot);
  progress->snapshot = next;
  progress_publish(progress);
  mutex_unlock(&progress->mutex);
}
 
void render_progress_begin(render_progress_t *progress, uint64_t total, bool total_known) {
  if (!progress)
    return;
  mutex_lock(&progress->mutex);
  progress->active = true;
  progress->snapshot->total = total;
  progress->snapshot->total_known = total_known;
  progress_publish(progress);
  mutex_unlock(&progress->mutex);
}
 
void render_progress_finalize(render_progress_t *progress) {
  if (!progress)
    return;
  mutex_lock(&progress->mutex);
  progress->active = true;
  progress->snapshot->finalizing = true;
  if (!progress->snapshot->total_known) {
    progress->snapshot->total = progress->snapshot->completed;
    progress->snapshot->total_known = true;
  }
  progress_publish(progress);
  mutex_unlock(&progress->mutex);
}
 
void render_progress_destroy(render_progress_t *progress) {
  if (!progress)
    return;
  ui_controller_remove(UI_SCREEN_RENDER_PROGRESS);
  platform_close(progress->fd);
  SAFE_FREE(progress->snapshot);
  mutex_destroy(&progress->mutex);
  SAFE_FREE(progress);
}