render_progress.c File Reference

Go to the source code of this file.

Data Structures
struct	progress_snapshot_t
struct	render_progress
	render progress keeps the values that move through the subsystem: mutex, snapshot, fd, last_preview_ns. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself. More...

Macros
#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
#define	PREVIEW_MAX_BYTES   (1024 * 1024)

Functions
render_progress_t *	render_progress_create (bool enabled, const char *destination)
void	render_progress_frame (render_progress_t *progress, const char *frame, bool succeeded)
void	render_progress_begin (render_progress_t *progress, uint64_t total, bool total_known)
void	render_progress_finalize (render_progress_t *progress)
void	render_progress_destroy (render_progress_t *progress)

Macro Definition Documentation

PREVIEW_MAX_BYTES

#define PREVIEW_MAX_BYTES   (1024 * 1024)

Definition at line 25 of file render_progress.c.

Referenced by render_progress_frame().

TUI_RENDER_PROGRESS_BAR_BUFFER_SIZE

#define TUI_RENDER_PROGRESS_BAR_BUFFER_SIZE   4096

Definition at line 6 of file render_progress.c.

TUI_RENDER_PROGRESS_LABEL_BUFFER_SIZE

#define TUI_RENDER_PROGRESS_LABEL_BUFFER_SIZE   160

Definition at line 3 of file render_progress.c.

TUI_RENDER_PROGRESS_TITLE_BUFFER_SIZE

#define TUI_RENDER_PROGRESS_TITLE_BUFFER_SIZE   64

Definition at line 5 of file render_progress.c.

TUI_RENDER_PROGRESS_TOTAL_BUFFER_SIZE

#define TUI_RENDER_PROGRESS_TOTAL_BUFFER_SIZE   32

Definition at line 4 of file render_progress.c.

Function Documentation

render_progress_begin()

void render_progress_begin	(	render_progress_t *	progress,
		uint64_t	total,
		bool	total_known )

Definition at line 196 of file render_progress.c.

                                                                                          {
  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);
}

References render_progress::active, render_progress::mutex, render_progress::snapshot, progress_snapshot_t::total, and progress_snapshot_t::total_known.

Referenced by render_file_begin_drain().

render_progress_create()

render_progress_t * render_progress_create	(	bool	enabled,
		const char *	destination )

Retains only the latest ASCII frame. All updates are serialized; callbacks own copied snapshots.

Definition at line 135 of file render_progress.c.

                                                                                 {
  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;
}

References progress_snapshot_t::destination_length, enabled, render_progress::fd, progress_snapshot_t::frame, render_progress::mutex, platform_dup(), SAFE_CALLOC, SAFE_FREE, render_progress::snapshot, and progress_snapshot_t::started_ns.

Referenced by render_file_create().

render_progress_destroy()

void render_progress_destroy

(

render_progress_t *

progress

)

Definition at line 221 of file render_progress.c.

                                                          {
  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);
}

References render_progress::fd, render_progress::mutex, SAFE_FREE, render_progress::snapshot, ui_controller_remove(), and UI_SCREEN_RENDER_PROGRESS.

Referenced by render_file_destroy().

render_progress_finalize()

void render_progress_finalize

(

render_progress_t *

progress

)

Definition at line 207 of file render_progress.c.

                                                           {
  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);
}

References render_progress::active, progress_snapshot_t::completed, progress_snapshot_t::finalizing, render_progress::mutex, render_progress::snapshot, progress_snapshot_t::total, and progress_snapshot_t::total_known.

Referenced by render_file_destroy().

render_progress_frame()

void render_progress_frame	(	render_progress_t *	progress,
		const char *	frame,
		bool	succeeded )

Definition at line 159 of file render_progress.c.

                                                                                           {
  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);
}

References progress_snapshot_t::completed, progress_snapshot_t::destination_length, progress_snapshot_t::failed, progress_snapshot_t::frame, render_progress::last_preview_ns, progress_snapshot_t::length, render_progress::mutex, NS_PER_MS_INT, PREVIEW_MAX_BYTES, SAFE_CALLOC, SAFE_FREE, render_progress::snapshot, and progress_snapshot_t::started_ns.

Referenced by render_file_write_frame().