io.h File Reference

Capture stdout/stderr and redirect to logging system. More...

Go to the source code of this file.

Data Structures
struct	log_io_t
	Saved descriptors and temporary file used during stdout/stderr capture. More...

Macros
#define	LOG_IO_IF(condition, prefix, block)
	Capture output from a code block and log it.
#define	LOG_IO(prefix, block)

Functions
log_io_t	log_io_start (void)
	Start capturing stdout and stderr.
void	log_io_stop (log_io_t capture, const char *prefix)
	Stop capturing and log the accumulated output.

Detailed Description

Capture stdout/stderr and redirect to logging system.

Provides functions and macros to capture stdout and stderr output and redirect it to the logging system instead of suppressing it.

Usage: // Capture specific code: log_io_t capture = log_io_start(); ffmpeg_function_that_prints_stuff(); log_io_stop(capture, "ffmpeg");

// Capture a code block (recommended): LOG_IO("ffmpeg", { ffmpeg_function_that_prints_stuff(); });

Definition in file io.h.

Macro Definition Documentation

LOG_IO

#define LOG_IO	(		prefix,
			block )

Value:

LOG_IO_IF(true, prefix, block)

Definition at line 104 of file io.h.

Referenced by audio_start_duplex(), audio_stop_duplex(), audio_terminate_portaudio_final(), ffmpeg_decoder_create_stdin(), ffmpeg_decoder_create_with_request_options(), gpg_sign_with_key(), h265_decoder_create(), h265_encoder_destroy(), and yt_dlp_is_available().

LOG_IO_IF

#define LOG_IO_IF	(		condition,
			prefix,
			block )

Value:

  do {                                                                                                                 \
    bool _log_io_enabled = (condition);                                                                                \
    log_io_t _log_io = {0};                                                                                            \
    if (_log_io_enabled)                                                                                               \
      _log_io = log_io_start();                                                                                        \
    block;                                                                                                             \
    if (_log_io_enabled)                                                                                               \
      log_io_stop(_log_io, (prefix));                                                                                  \
  } while (0)

Capture output from a code block and log it.

This macro redirects stdout and stderr for the duration of the code block, then logs any captured output with the given prefix.

Example: LOG_IO("ffmpeg", { av_log_set_callback(NULL); // Use default ffmpeg logging process_file("input.mp4"); });

Parameters

prefix	Prefix for log messages (const char *)
block	Code block to capture (must be valid C statement block)

Note

Prefix and block are only evaluated once

Variables in the enclosing scope are accessible in the block

Capture a block only when condition is true; execute the block once either way.

Note

The condition is evaluated once, before executing the block.

Definition at line 93 of file io.h.

#define LOG_IO_IF(condition, prefix, block)                                                                            \
  do {                                                                                                                 \
    bool _log_io_enabled = (condition);                                                                                \
    log_io_t _log_io = {0};                                                                                            \
    if (_log_io_enabled)                                                                                               \
      _log_io = log_io_start();                                                                                        \
    block;                                                                                                             \
    if (_log_io_enabled)                                                                                               \
      log_io_stop(_log_io, (prefix));                                                                                  \
  } while (0)

Referenced by yt_dlp_extract_with_options().

Function Documentation

log_io_start()

log_io_t log_io_start

(

void

)

Start capturing stdout and stderr.

Redirects both stdout and stderr to a temporary file so their output can be captured and logged. Call log_io_stop() to end capture and log the accumulated output.

Returns

Capture handle (use with log_io_stop)

Note

If capture fails, returns a handle with saved_stdout_fd = -1

Do not use stdout/stderr directly while capturing

Definition at line 15 of file io.c.

                            {
  log_io_t capture = {.saved_stdout_fd = -1, .saved_stderr_fd = -1, .output = NULL};
 
  // A pipe cannot be drained until the wrapped call returns. A temporary file
  // lets backend worker threads finish even when diagnostics exceed pipe capacity.
  capture.output = platform_tmpfile();
  if (!capture.output)
    return capture;
 
  fflush(stdout);
  fflush(stderr);
  capture.saved_stdout_fd = platform_dup(STDOUT_FILENO);
  capture.saved_stderr_fd = platform_dup(STDERR_FILENO);
  if (capture.saved_stdout_fd < 0 || capture.saved_stderr_fd < 0)
    goto fail;
 
  int output_fd = platform_fileno(capture.output);
  if (platform_dup2(output_fd, STDOUT_FILENO) != ASCIICHAT_OK)
    goto fail;
  if (platform_dup2(output_fd, STDERR_FILENO) != ASCIICHAT_OK) {
    // Restore stdout if only the first redirection succeeded.
    platform_dup2(capture.saved_stdout_fd, STDOUT_FILENO);
    goto fail;
  }
  return capture;
 
fail:
  if (capture.saved_stdout_fd >= 0)
    platform_close(capture.saved_stdout_fd);
  if (capture.saved_stderr_fd >= 0)
    platform_close(capture.saved_stderr_fd);
  fclose(capture.output);
  return (log_io_t){.saved_stdout_fd = -1, .saved_stderr_fd = -1, .output = NULL};
}

References ASCIICHAT_OK, log_io_t::output, platform_dup(), platform_dup2(), platform_fileno(), log_io_t::saved_stderr_fd, and log_io_t::saved_stdout_fd.

log_io_stop()

void log_io_stop	(	log_io_t	capture,
		const char *	prefix )

Stop capturing and log the accumulated output.

Restores stdout and stderr to their original state, reads all captured output from the temporary file, and logs it at DEBUG level with the given prefix.

Parameters

capture	Capture handle returned by log_io_start()
prefix	Prefix to use in log messages (e.g., "ffmpeg", "portaudio")

Note

Safe to call with invalid handle (saved_stdout_fd = -1)

After calling this, the capture handle is invalidated

Definition at line 50 of file io.c.

                                                       {
  if (capture.saved_stdout_fd < 0 || capture.saved_stderr_fd < 0) {
    return; // Capture was not started successfully
  }
 
  // Flush before restoring so buffered backend output is captured.
  fflush(stdout);
  fflush(stderr);
 
  // Restore stdout and stderr
  platform_dup2(capture.saved_stdout_fd, STDOUT_FILENO);
  platform_dup2(capture.saved_stderr_fd, STDERR_FILENO);
  platform_close(capture.saved_stdout_fd);
  platform_close(capture.saved_stderr_fd);
 
  // Read and log the captured output
  if (capture.output) {
    char buffer[LOG_IO_BUFFER_SIZE];
    size_t bytes_read;
 
    // Replay only after restoring the descriptors, so logger output cannot feed
    // back into this capture. fseek synchronizes the stream with descriptor writes.
    if (fseek(capture.output, 0, SEEK_SET) != 0) {
      fclose(capture.output);
      return;
    }
    while ((bytes_read = fread(buffer, 1, sizeof(buffer) - 1, capture.output)) > 0) {
      buffer[bytes_read] = '\0';
 
      // Split by lines and log each line
      char *line_start = buffer;
      char *line_end;
 
      while ((line_end = strchr(line_start, '\n')) != NULL) {
        // Null-terminate the line (overwriting the newline)
        *line_end = '\0';
 
        // Log the line if it's not empty
        if (line_start[0] != '\0') {
          if (prefix) {
            log_debug("[%s] %s", prefix, line_start);
          } else {
            log_debug("%s", line_start);
          }
        }
 
        // Move to the next line
        line_start = line_end + 1;
      }
 
      // Log any remaining partial line
      if (line_start[0] != '\0') {
        if (prefix) {
          log_debug("[%s] %s", prefix, line_start);
        } else {
          log_debug("%s", line_start);
        }
      }
    }
 
    fclose(capture.output);
  }
}

References log_debug, LOG_IO_BUFFER_SIZE, log_io_t::output, platform_dup2(), log_io_t::saved_stderr_fd, and log_io_t::saved_stdout_fd.