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
	Opaque handle for IO capture state. More...

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

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:

  do {                                                                        \
    log_io_t _log_io = log_io_start();                                       \
    block;                                                                    \
    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

Definition at line 81 of file io.h.

     {                                                                        \
    log_io_t _log_io = log_io_start();                                       \
    block;                                                                    \
    log_io_stop(_log_io, (prefix));                                         \
  } while (0)

Function Documentation

log_io_start()

log_io_t log_io_start

(

void

)

Start capturing stdout and stderr.

Redirects both stdout and stderr to a pipe 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, .pipe_fd = -1};
 
  // Save original stdout and stderr
  capture.saved_stdout_fd = dup(STDOUT_FILENO);
  capture.saved_stderr_fd = dup(STDERR_FILENO);
 
  if (capture.saved_stdout_fd < 0 || capture.saved_stderr_fd < 0) {
    if (capture.saved_stdout_fd >= 0)
      close(capture.saved_stdout_fd);
    if (capture.saved_stderr_fd >= 0)
      close(capture.saved_stderr_fd);
    return (log_io_t){.saved_stdout_fd = -1, .saved_stderr_fd = -1, .pipe_fd = -1};
  }
 
  // Create a pipe for capturing output
  int pipefd[2];
#ifdef _WIN32
  if (_pipe(pipefd, LOG_IO_BUFFER_SIZE, _O_BINARY) < 0) {
#else
  if (pipe(pipefd) < 0) {
#endif
    close(capture.saved_stdout_fd);
    close(capture.saved_stderr_fd);
    return (log_io_t){.saved_stdout_fd = -1, .saved_stderr_fd = -1, .pipe_fd = -1};
  }
 
  // pipefd[0] is read end, pipefd[1] is write end
  int write_fd = pipefd[1];
  capture.pipe_fd = pipefd[0];
 
#ifndef _WIN32
  // Make the read end non-blocking so we can drain without hanging
  int flags = fcntl(capture.pipe_fd, F_GETFL, 0);
  if (flags >= 0) {
    fcntl(capture.pipe_fd, F_SETFL, flags | O_NONBLOCK);
  }
 
  // Make the write end non-blocking. LOG_IO redirects the process-global stderr,
  // so ALL threads write to this pipe. If the pipe buffer fills (64KB on Linux),
  // blocking writes would stall other threads and potentially deadlock (e.g. x265
  // internal threads block on stderr while avcodec_open2 can't return). Non-blocking
  // writes silently drop excess output (EAGAIN) which is acceptable for diagnostics.
  int wflags = fcntl(write_fd, F_GETFL, 0);
  if (wflags >= 0) {
    fcntl(write_fd, F_SETFL, wflags | O_NONBLOCK);
  }
#endif
 
  // Redirect both stdout and stderr to the pipe
  if (dup2(write_fd, STDOUT_FILENO) < 0 || dup2(write_fd, STDERR_FILENO) < 0) {
    close(write_fd);
    close(capture.pipe_fd);
    close(capture.saved_stdout_fd);
    close(capture.saved_stderr_fd);
    return (log_io_t){.saved_stdout_fd = -1, .saved_stderr_fd = -1, .pipe_fd = -1};
  }
 
  // Close the write end in the parent process (we only need it in redirected streams)
  close(write_fd);
 
  return capture;
}

References LOG_IO_BUFFER_SIZE, log_io_t::pipe_fd, 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 pipe, and logs it at INFO 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 79 of file io.c.

                                                       {
  if (capture.saved_stdout_fd < 0 || capture.saved_stderr_fd < 0) {
    return; // Capture was not started successfully
  }
 
  // Flush stdout/stderr BEFORE restoring to ensure all output is in the pipe
  fflush(stdout);
  fflush(stderr);
 
  // Restore stdout and stderr
  dup2(capture.saved_stdout_fd, STDOUT_FILENO);
  dup2(capture.saved_stderr_fd, STDERR_FILENO);
  close(capture.saved_stdout_fd);
  close(capture.saved_stderr_fd);
 
  // Read and log the captured output
  if (capture.pipe_fd >= 0) {
    char buffer[LOG_IO_BUFFER_SIZE];
    ssize_t bytes_read;
 
    // Read all available data from the pipe
    while ((bytes_read = read(capture.pipe_fd, buffer, sizeof(buffer) - 1)) > 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);
        }
      }
    }
 
    close(capture.pipe_fd);
  }
}

References log_debug, LOG_IO_BUFFER_SIZE, log_io_t::pipe_fd, log_io_t::saved_stderr_fd, and log_io_t::saved_stdout_fd.