ffmpeg_decoder.c File Reference

FFmpeg-based media decoder implementation. More...

Go to the source code of this file.

Data Structures
struct	ffmpeg_decoder_t
	FFmpeg decoder state for video and audio decoding. More...

Macros
#define	TARGET_SAMPLE_RATE   48000
#define	TARGET_CHANNELS   1
#define	AVIO_BUFFER_SIZE   (64 * 1024)

Functions
ffmpeg_decoder_t *	ffmpeg_decoder_create (const char *path)
ffmpeg_decoder_t *	ffmpeg_decoder_create_stdin (void)
void	ffmpeg_decoder_destroy (ffmpeg_decoder_t *decoder)
image_t *	ffmpeg_decoder_read_video_frame (ffmpeg_decoder_t *decoder)
asciichat_error_t	ffmpeg_decoder_start_prefetch (ffmpeg_decoder_t *decoder)
	Start the background frame prefetching thread.
void	ffmpeg_decoder_stop_prefetch (ffmpeg_decoder_t *decoder)
	Stop the background frame prefetching thread.
bool	ffmpeg_decoder_is_prefetch_running (ffmpeg_decoder_t *decoder)
bool	ffmpeg_decoder_has_video (ffmpeg_decoder_t *decoder)
asciichat_error_t	ffmpeg_decoder_get_video_dimensions (ffmpeg_decoder_t *decoder, int *width, int *height)
double	ffmpeg_decoder_get_video_fps (ffmpeg_decoder_t *decoder)
size_t	ffmpeg_decoder_read_audio_samples (ffmpeg_decoder_t *decoder, float *buffer, size_t num_samples)
bool	ffmpeg_decoder_has_audio (ffmpeg_decoder_t *decoder)
asciichat_error_t	ffmpeg_decoder_rewind (ffmpeg_decoder_t *decoder)
asciichat_error_t	ffmpeg_decoder_seek_to_timestamp (ffmpeg_decoder_t *decoder, double timestamp_sec)
bool	ffmpeg_decoder_at_end (ffmpeg_decoder_t *decoder)
double	ffmpeg_decoder_get_duration (ffmpeg_decoder_t *decoder)
double	ffmpeg_decoder_get_position (ffmpeg_decoder_t *decoder)

Detailed Description

FFmpeg-based media decoder implementation.

Definition in file ffmpeg_decoder.c.

Macro Definition Documentation

AVIO_BUFFER_SIZE

#define AVIO_BUFFER_SIZE   (64 * 1024)

AVIO buffer size for stdin reading (64KB)

Definition at line 54 of file ffmpeg_decoder.c.

TARGET_CHANNELS

#define TARGET_CHANNELS   1

Target audio channels (mono)

Definition at line 51 of file ffmpeg_decoder.c.

TARGET_SAMPLE_RATE

#define TARGET_SAMPLE_RATE   48000

Target audio sample rate (48kHz for Opus compatibility)

Definition at line 48 of file ffmpeg_decoder.c.

Function Documentation

ffmpeg_decoder_at_end()

bool ffmpeg_decoder_at_end

(

ffmpeg_decoder_t *

decoder

)

Definition at line 1246 of file ffmpeg_decoder.c.

                                                      {
  return decoder && decoder->eof_reached;
}

References ffmpeg_decoder_t::eof_reached.

Referenced by media_source_at_end(), media_source_read_audio(), and media_source_read_video().

ffmpeg_decoder_create()

ffmpeg_decoder_t * ffmpeg_decoder_create

(

const char *

path

)

Definition at line 406 of file ffmpeg_decoder.c.

                                                          {
  if (!path) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Path is NULL");
    return NULL;
  }
 
  // Suppress FFmpeg's verbose debug logging (H.264 codec warnings, etc.)
  // Only set this once, it's a global setting
  static bool ffmpeg_log_level_set = false;
  if (!ffmpeg_log_level_set) {
    av_log_set_level(AV_LOG_QUIET);                  // Suppress all FFmpeg logging
    av_log_set_callback(ffmpeg_silent_log_callback); // Install silent callback to discard all output
    ffmpeg_log_level_set = true;
  }
 
  ffmpeg_decoder_t *decoder = SAFE_MALLOC(sizeof(ffmpeg_decoder_t), ffmpeg_decoder_t *);
  if (!decoder) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate decoder");
    return NULL;
  }
 
  memset(decoder, 0, sizeof(*decoder));
  decoder->video_stream_idx = -1;
  decoder->audio_stream_idx = -1;
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
 
  // Suppress FFmpeg's probing output by redirecting both stdout and stderr to /dev/null
  // FFmpeg may write directly to either stream, so we suppress both
  platform_stderr_redirect_handle_t stdio_handle = platform_stdout_stderr_redirect_to_null();
 
  // Configure FFmpeg options for HTTP streaming performance
  AVDictionary *options = NULL;
 
  // For HTTP/HTTPS streams: enable fast probing and reconnection (validated via production-grade URL regex)
  if (path && url_is_valid(path)) {
    // Limit probing to 32KB for faster format detection
    av_dict_set(&options, "probesize", "32768", 0);
    // Analyze for 100ms max to determine streams quickly
    av_dict_set(&options, "analyzeduration", "100000", 0);
    // Enable auto-reconnection for interrupted connections
    av_dict_set(&options, "reconnect", "1", 0);
    // Allow reconnection for streamed protocols
    av_dict_set(&options, "reconnect_streamed", "1", 0);
    // Set reasonable I/O timeout (10 seconds)
    av_dict_set(&options, "rw_timeout", "10000000", 0);
    // Enable HTTP persistent connection (keep-alive) for better performance
    av_dict_set(&options, "http_persistent", "1", 0);
    // Reduce connect timeout to fail faster if server is unreachable
    av_dict_set(&options, "connect_timeout", "5000000", 0);
  }
 
  // Open input file
  int ret = avformat_open_input(&decoder->format_ctx, path, NULL, &options);
  av_dict_free(&options); // Free options dictionary
 
  if (ret < 0) {
    platform_stdout_stderr_restore(stdio_handle);
    SET_ERRNO(ERROR_MEDIA_OPEN, "Failed to open media file: %s", path);
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Find stream info
  if (avformat_find_stream_info(decoder->format_ctx, NULL) < 0) {
    platform_stdout_stderr_restore(stdio_handle);
    SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to find stream info");
    avformat_close_input(&decoder->format_ctx);
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Install interrupt callback to allow seeking to interrupt long av_read_frame() calls
  // Do this AFTER finding stream info to ensure format context is fully initialized
  if (decoder->format_ctx) {
    decoder->format_ctx->interrupt_callback.callback = ffmpeg_interrupt_callback;
    decoder->format_ctx->interrupt_callback.opaque = decoder;
  }
 
  // Restore stdout and stderr after FFmpeg initialization
  platform_stdout_stderr_restore(stdio_handle);
 
  // Open video codec
  asciichat_error_t err = open_codec_context(decoder->format_ctx, AVMEDIA_TYPE_VIDEO, &decoder->video_stream_idx,
                                             &decoder->video_codec_ctx);
  if (err != ASCIICHAT_OK) {
    log_warn("Failed to open video codec (file may be audio-only)");
  }
 
  // Open audio codec - audio is enabled by default (no option needed)
  // Always try to open audio codec, don't rely on GET_OPTION(audio_enabled) which has a default issue
  err = open_codec_context(decoder->format_ctx, AVMEDIA_TYPE_AUDIO, &decoder->audio_stream_idx,
                           &decoder->audio_codec_ctx);
  if (err != ASCIICHAT_OK) {
    log_debug("No audio codec found (file may be video-only or audio codec not available)");
    decoder->audio_stream_idx = -1;
    decoder->audio_codec_ctx = NULL;
  }
 
  // Require at least one stream
  if (decoder->video_stream_idx < 0 && decoder->audio_stream_idx < 0) {
    SET_ERRNO(ERROR_MEDIA_DECODE, "No video or audio streams found");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Allocate frame and packet
  decoder->frame = av_frame_alloc();
  decoder->packet = av_packet_alloc();
  if (!decoder->frame || !decoder->packet) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate frame/packet");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Initialize swscale context for video if present
  if (decoder->video_codec_ctx) {
    // Validate codec context has valid dimensions and pixel format
    // For HTTP streams, these might not be valid until first frame is read
    if (decoder->video_codec_ctx->width <= 0 || decoder->video_codec_ctx->height <= 0) {
      log_warn("Video codec has invalid dimensions (%dx%d), will initialize swscale on first frame",
               decoder->video_codec_ctx->width, decoder->video_codec_ctx->height);
      // Don't create swscale context yet - will create it lazily on first frame read
    } else if (decoder->video_codec_ctx->pix_fmt == AV_PIX_FMT_NONE) {
      log_warn("Video codec has invalid pixel format, will initialize swscale on first frame");
      // Don't create swscale context yet - will create it lazily on first frame read
    } else {
      // Create swscale context with valid parameters
      decoder->sws_ctx =
          sws_getContext(decoder->video_codec_ctx->width, decoder->video_codec_ctx->height,
                         decoder->video_codec_ctx->pix_fmt, decoder->video_codec_ctx->width,
                         decoder->video_codec_ctx->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL);
      if (!decoder->sws_ctx) {
        SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to create swscale context");
        ffmpeg_decoder_destroy(decoder);
        return NULL;
      }
    }
  }
 
  // Initialize swresample context for audio if present
  if (decoder->audio_codec_ctx) {
    // Store output sample rate for position tracking
    decoder->audio_sample_rate = TARGET_SAMPLE_RATE;
 
    // Allocate resampler context
    decoder->swr_ctx = swr_alloc();
    if (!decoder->swr_ctx) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    // Set options
    av_opt_set_chlayout(decoder->swr_ctx, "in_chlayout", &decoder->audio_codec_ctx->ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "in_sample_rate", decoder->audio_codec_ctx->sample_rate, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "in_sample_fmt", decoder->audio_codec_ctx->sample_fmt, 0);
 
    AVChannelLayout out_ch_layout = AV_CHANNEL_LAYOUT_MONO;
    av_opt_set_chlayout(decoder->swr_ctx, "out_chlayout", &out_ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "out_sample_rate", TARGET_SAMPLE_RATE, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
 
    // Initialize
    if (swr_init(decoder->swr_ctx) < 0) {
      SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to initialize swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    // Allocate audio buffer (10 seconds worth)
    decoder->audio_buffer_size = TARGET_SAMPLE_RATE * 10;
    decoder->audio_buffer = SAFE_MALLOC(decoder->audio_buffer_size * sizeof(float), float *);
    if (!decoder->audio_buffer) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate audio buffer");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
  }
 
  // Initialize video frame prefetching system (for YouTube streaming)
  if (decoder->video_stream_idx >= 0) {
    int width = decoder->video_codec_ctx->width;
    int height = decoder->video_codec_ctx->height;
 
    // Create two prefetch image buffers for double-buffering
    decoder->prefetch_image_a = image_new((size_t)width, (size_t)height);
    decoder->prefetch_image_b = image_new((size_t)width, (size_t)height);
    if (!decoder->prefetch_image_a || !decoder->prefetch_image_b) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate prefetch image buffers");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    decoder->current_prefetch_image = decoder->prefetch_image_a;
    decoder->prefetch_frame_ready = false;
 
    // Initialize prefetch mutex
    if (mutex_init(&decoder->prefetch_mutex) != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch mutex");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    if (cond_init(&decoder->prefetch_cond) != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch condition variable");
      mutex_destroy(&decoder->prefetch_mutex);
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    decoder->prefetch_thread_running = false;
    decoder->prefetch_should_stop = false;
  }
 
  log_debug("FFmpeg decoder opened: %s (video=%s, audio=%s)", path, decoder->video_stream_idx >= 0 ? "yes" : "no",
            decoder->audio_stream_idx >= 0 ? "yes" : "no");
 
  return decoder;
}

References ffmpeg_decoder_t::audio_buffer, ffmpeg_decoder_t::audio_buffer_size, ffmpeg_decoder_t::audio_codec_ctx, ffmpeg_decoder_t::audio_sample_rate, ffmpeg_decoder_t::audio_stream_idx, ffmpeg_decoder_t::current_prefetch_image, ffmpeg_decoder_destroy(), ffmpeg_decoder_t::format_ctx, ffmpeg_decoder_t::frame, image_new(), ffmpeg_decoder_t::last_audio_pts, ffmpeg_decoder_t::last_video_pts, mutex_destroy(), mutex_init(), ffmpeg_decoder_t::packet, ffmpeg_decoder_t::prefetch_cond, ffmpeg_decoder_t::prefetch_frame_ready, ffmpeg_decoder_t::prefetch_image_a, ffmpeg_decoder_t::prefetch_image_b, ffmpeg_decoder_t::prefetch_mutex, ffmpeg_decoder_t::prefetch_should_stop, ffmpeg_decoder_t::prefetch_thread_running, ffmpeg_decoder_t::swr_ctx, ffmpeg_decoder_t::sws_ctx, TARGET_SAMPLE_RATE, url_is_valid(), ffmpeg_decoder_t::video_codec_ctx, and ffmpeg_decoder_t::video_stream_idx.

Referenced by media_source_create().

ffmpeg_decoder_create_stdin()

ffmpeg_decoder_t * ffmpeg_decoder_create_stdin

(

void

)

Definition at line 627 of file ffmpeg_decoder.c.

                                                    {
  ffmpeg_decoder_t *decoder = SAFE_MALLOC(sizeof(ffmpeg_decoder_t), ffmpeg_decoder_t *);
  if (!decoder) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate decoder");
    return NULL;
  }
 
  memset(decoder, 0, sizeof(*decoder));
  decoder->video_stream_idx = -1;
  decoder->audio_stream_idx = -1;
  decoder->is_stdin = true;
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
 
  // Allocate AVIO buffer
  decoder->avio_buffer = SAFE_MALLOC(AVIO_BUFFER_SIZE, unsigned char *);
  if (!decoder->avio_buffer) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate AVIO buffer");
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Create AVIO context for stdin
  decoder->avio_ctx = avio_alloc_context(decoder->avio_buffer, AVIO_BUFFER_SIZE,
                                         0,    // write_flag
                                         NULL, // opaque
                                         stdin_read_packet,
                                         NULL, // write_packet
                                         NULL  // seek (stdin is not seekable)
  );
 
  if (!decoder->avio_ctx) {
    SET_ERRNO(ERROR_MEMORY, "Failed to create AVIO context");
    SAFE_FREE(decoder->avio_buffer);
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Allocate format context
  decoder->format_ctx = avformat_alloc_context();
  if (!decoder->format_ctx) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate format context");
    av_freep(&decoder->avio_ctx->buffer);
    avio_context_free(&decoder->avio_ctx);
    SAFE_FREE(decoder);
    return NULL;
  }
 
  decoder->format_ctx->pb = decoder->avio_ctx;
 
  // Suppress FFmpeg's probing output by redirecting both stdout and stderr to /dev/null
  platform_stderr_redirect_handle_t stdio_handle = platform_stdout_stderr_redirect_to_null();
 
  // Open input from stdin
  if (avformat_open_input(&decoder->format_ctx, NULL, NULL, NULL) < 0) {
    platform_stdout_stderr_restore(stdio_handle);
    SET_ERRNO(ERROR_MEDIA_OPEN, "Failed to open stdin");
    av_freep(&decoder->avio_ctx->buffer);
    avio_context_free(&decoder->avio_ctx);
    avformat_free_context(decoder->format_ctx);
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Find stream info
  if (avformat_find_stream_info(decoder->format_ctx, NULL) < 0) {
    platform_stdout_stderr_restore(stdio_handle);
    SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to find stream info from stdin");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  platform_stdout_stderr_restore(stdio_handle);
 
  // Open codecs (same as file-based decoder)
  asciichat_error_t err = open_codec_context(decoder->format_ctx, AVMEDIA_TYPE_VIDEO, &decoder->video_stream_idx,
                                             &decoder->video_codec_ctx);
  if (err != ASCIICHAT_OK) {
    log_warn("Failed to open video codec from stdin");
  }
 
  if (GET_OPTION(audio_enabled)) {
    err = open_codec_context(decoder->format_ctx, AVMEDIA_TYPE_AUDIO, &decoder->audio_stream_idx,
                             &decoder->audio_codec_ctx);
    if (err != ASCIICHAT_OK) {
      log_warn("Failed to open audio codec from stdin");
    }
  } else {
    decoder->audio_stream_idx = -1;
    decoder->audio_codec_ctx = NULL;
    log_debug("Audio decoding disabled by user option");
  }
 
  if (decoder->video_stream_idx < 0 && decoder->audio_stream_idx < 0) {
    SET_ERRNO(ERROR_MEDIA_DECODE, "No video or audio streams found in stdin");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Allocate frame and packet
  decoder->frame = av_frame_alloc();
  decoder->packet = av_packet_alloc();
  if (!decoder->frame || !decoder->packet) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate frame/packet");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Initialize swscale/swresample (same as file-based)
  if (decoder->video_codec_ctx) {
    // Validate codec context has valid dimensions and pixel format
    // For stdin/HTTP streams, these might not be valid until first frame is read
    if (decoder->video_codec_ctx->width <= 0 || decoder->video_codec_ctx->height <= 0) {
      log_warn("Video codec has invalid dimensions (%dx%d), will initialize swscale on first frame",
               decoder->video_codec_ctx->width, decoder->video_codec_ctx->height);
      // Don't create swscale context yet - will create it lazily on first frame read
    } else if (decoder->video_codec_ctx->pix_fmt == AV_PIX_FMT_NONE) {
      log_warn("Video codec has invalid pixel format, will initialize swscale on first frame");
      // Don't create swscale context yet - will create it lazily on first frame read
    } else {
      // Create swscale context with valid parameters
      decoder->sws_ctx =
          sws_getContext(decoder->video_codec_ctx->width, decoder->video_codec_ctx->height,
                         decoder->video_codec_ctx->pix_fmt, decoder->video_codec_ctx->width,
                         decoder->video_codec_ctx->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL);
      if (!decoder->sws_ctx) {
        SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to create swscale context");
        ffmpeg_decoder_destroy(decoder);
        return NULL;
      }
    }
  }
 
  if (decoder->audio_codec_ctx) {
    decoder->swr_ctx = swr_alloc();
    if (!decoder->swr_ctx) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    av_opt_set_chlayout(decoder->swr_ctx, "in_chlayout", &decoder->audio_codec_ctx->ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "in_sample_rate", decoder->audio_codec_ctx->sample_rate, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "in_sample_fmt", decoder->audio_codec_ctx->sample_fmt, 0);
 
    AVChannelLayout out_ch_layout = AV_CHANNEL_LAYOUT_MONO;
    av_opt_set_chlayout(decoder->swr_ctx, "out_chlayout", &out_ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "out_sample_rate", TARGET_SAMPLE_RATE, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
 
    if (swr_init(decoder->swr_ctx) < 0) {
      SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to initialize swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    decoder->audio_buffer_size = TARGET_SAMPLE_RATE * 10;
    decoder->audio_buffer = SAFE_MALLOC(decoder->audio_buffer_size * sizeof(float), float *);
    if (!decoder->audio_buffer) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate audio buffer");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
  }
 
  log_debug("FFmpeg decoder opened from stdin (video=%s, audio=%s)", decoder->video_stream_idx >= 0 ? "yes" : "no",
            decoder->audio_stream_idx >= 0 ? "yes" : "no");
 
  return decoder;
}

References ffmpeg_decoder_t::audio_buffer, ffmpeg_decoder_t::audio_buffer_size, ffmpeg_decoder_t::audio_codec_ctx, ffmpeg_decoder_t::audio_stream_idx, ffmpeg_decoder_t::avio_buffer, AVIO_BUFFER_SIZE, ffmpeg_decoder_t::avio_ctx, ffmpeg_decoder_destroy(), ffmpeg_decoder_t::format_ctx, ffmpeg_decoder_t::frame, ffmpeg_decoder_t::is_stdin, ffmpeg_decoder_t::last_audio_pts, ffmpeg_decoder_t::last_video_pts, ffmpeg_decoder_t::packet, ffmpeg_decoder_t::swr_ctx, ffmpeg_decoder_t::sws_ctx, TARGET_SAMPLE_RATE, ffmpeg_decoder_t::video_codec_ctx, and ffmpeg_decoder_t::video_stream_idx.

Referenced by media_source_create().

ffmpeg_decoder_destroy()

void ffmpeg_decoder_destroy

(

ffmpeg_decoder_t *

decoder

)

Definition at line 798 of file ffmpeg_decoder.c.

                                                       {
  if (!decoder) {
    return;
  }
 
  // Stop prefetch thread (signal it to stop and wait for it to finish)
  if (decoder->prefetch_thread_running) {
    mutex_lock(&decoder->prefetch_mutex);
    decoder->prefetch_should_stop = true;
    mutex_unlock(&decoder->prefetch_mutex);
 
    // Wait for thread to finish
    asciichat_thread_join(&decoder->prefetch_thread, NULL);
    decoder->prefetch_thread_running = false;
  }
 
  // Clean up prefetch state
  cond_destroy(&decoder->prefetch_cond);
  mutex_destroy(&decoder->prefetch_mutex);
 
  // Free prefetch image buffers
  if (decoder->prefetch_image_a) {
    image_destroy(decoder->prefetch_image_a);
    decoder->prefetch_image_a = NULL;
  }
  if (decoder->prefetch_image_b) {
    image_destroy(decoder->prefetch_image_b);
    decoder->prefetch_image_b = NULL;
  }
 
  // Don't destroy current_image - it points to one of the prefetch buffers
  // which have already been destroyed above
  decoder->current_image = NULL;
 
  // Free audio buffer
  SAFE_FREE(decoder->audio_buffer);
 
  // Free swscale context
  if (decoder->sws_ctx) {
    sws_freeContext(decoder->sws_ctx);
    decoder->sws_ctx = NULL;
  }
 
  // Free swresample context
  if (decoder->swr_ctx) {
    swr_free(&decoder->swr_ctx);
  }
 
  // Free frame and packet
  if (decoder->frame) {
    av_frame_free(&decoder->frame);
  }
  if (decoder->packet) {
    av_packet_free(&decoder->packet);
  }
 
  // Free codec contexts
  if (decoder->video_codec_ctx) {
    avcodec_free_context(&decoder->video_codec_ctx);
  }
  if (decoder->audio_codec_ctx) {
    avcodec_free_context(&decoder->audio_codec_ctx);
  }
 
  // Free format context
  if (decoder->format_ctx) {
    avformat_close_input(&decoder->format_ctx);
  }
 
  // Free AVIO context (stdin only)
  if (decoder->avio_ctx) {
    av_freep(&decoder->avio_ctx->buffer);
    avio_context_free(&decoder->avio_ctx);
  }
 
  SAFE_FREE(decoder);
}

References asciichat_thread_join(), ffmpeg_decoder_t::audio_buffer, ffmpeg_decoder_t::audio_codec_ctx, ffmpeg_decoder_t::avio_ctx, ffmpeg_decoder_t::current_image, ffmpeg_decoder_t::format_ctx, ffmpeg_decoder_t::frame, image_destroy(), mutex_destroy(), ffmpeg_decoder_t::packet, ffmpeg_decoder_t::prefetch_cond, ffmpeg_decoder_t::prefetch_image_a, ffmpeg_decoder_t::prefetch_image_b, ffmpeg_decoder_t::prefetch_mutex, ffmpeg_decoder_t::prefetch_should_stop, ffmpeg_decoder_t::prefetch_thread, ffmpeg_decoder_t::prefetch_thread_running, ffmpeg_decoder_t::swr_ctx, ffmpeg_decoder_t::sws_ctx, and ffmpeg_decoder_t::video_codec_ctx.

Referenced by ffmpeg_decoder_create(), ffmpeg_decoder_create_stdin(), media_source_create(), and media_source_destroy().

ffmpeg_decoder_get_duration()

double ffmpeg_decoder_get_duration

(

ffmpeg_decoder_t *

decoder

)

Definition at line 1250 of file ffmpeg_decoder.c.

                                                              {
  if (!decoder || !decoder->format_ctx) {
    return -1.0;
  }
 
  if (decoder->format_ctx->duration == AV_NOPTS_VALUE) {
    return -1.0;
  }
 
  return (double)decoder->format_ctx->duration / AV_TIME_BASE;
}

References ffmpeg_decoder_t::format_ctx.

Referenced by media_source_get_duration().

ffmpeg_decoder_get_position()

double ffmpeg_decoder_get_position

(

ffmpeg_decoder_t *

decoder

)

Definition at line 1262 of file ffmpeg_decoder.c.

                                                              {
  if (!decoder) {
    return -1.0;
  }
 
  // Prefer sample-based position tracking (continuous, works before frames are decoded)
  if (decoder->audio_sample_rate > 0 && decoder->audio_samples_read >= 0) {
    return (double)decoder->audio_samples_read / (double)decoder->audio_sample_rate;
  }
 
  // Fallback to frame-based position if available
  if (decoder->last_video_pts >= 0.0) {
    return decoder->last_video_pts;
  } else if (decoder->last_audio_pts >= 0.0) {
    return decoder->last_audio_pts;
  }
 
  return -1.0;
}

References ffmpeg_decoder_t::audio_sample_rate, ffmpeg_decoder_t::audio_samples_read, ffmpeg_decoder_t::last_audio_pts, and ffmpeg_decoder_t::last_video_pts.

Referenced by media_source_get_position(), media_source_read_audio(), and media_source_seek().

ffmpeg_decoder_get_video_dimensions()

asciichat_error_t ffmpeg_decoder_get_video_dimensions	(	ffmpeg_decoder_t *	decoder,
		int *	width,
		int *	height
	)

Definition at line 991 of file ffmpeg_decoder.c.

                                                                                                          {
  if (!decoder || decoder->video_stream_idx < 0) {
    return ERROR_INVALID_PARAM;
  }
 
  if (width) {
    *width = decoder->video_codec_ctx->width;
  }
  if (height) {
    *height = decoder->video_codec_ctx->height;
  }
 
  return ASCIICHAT_OK;
}

References ffmpeg_decoder_t::video_codec_ctx, and ffmpeg_decoder_t::video_stream_idx.

ffmpeg_decoder_get_video_fps()

double ffmpeg_decoder_get_video_fps

(

ffmpeg_decoder_t *

decoder

)

Definition at line 1006 of file ffmpeg_decoder.c.

                                                               {
  if (!decoder || decoder->video_stream_idx < 0) {
    return -1.0;
  }
 
  AVStream *stream = decoder->format_ctx->streams[decoder->video_stream_idx];
 
  // Try avg_frame_rate first (average frame rate from entire stream)
  double fps = av_q2d_safe(stream->avg_frame_rate);
 
  // Fallback to r_frame_rate if avg_frame_rate is invalid or zero
  // r_frame_rate is the "real" frame rate based on codec parameters
  // This is more reliable for YouTube videos and some video codecs
  if (fps <= 0.0) {
    fps = av_q2d_safe(stream->r_frame_rate);
  }
 
  return fps;
}

References ffmpeg_decoder_t::format_ctx, and ffmpeg_decoder_t::video_stream_idx.

Referenced by media_source_get_video_fps().

ffmpeg_decoder_has_audio()

bool ffmpeg_decoder_has_audio

(

ffmpeg_decoder_t *

decoder

)

Definition at line 1136 of file ffmpeg_decoder.c.

                                                         {
  return decoder && decoder->audio_stream_idx >= 0;
}

References ffmpeg_decoder_t::audio_stream_idx.

Referenced by media_source_has_audio().

ffmpeg_decoder_has_video()

bool ffmpeg_decoder_has_video

(

ffmpeg_decoder_t *

decoder

)

Definition at line 987 of file ffmpeg_decoder.c.

                                                         {
  return decoder && decoder->video_stream_idx >= 0;
}

References ffmpeg_decoder_t::video_stream_idx.

Referenced by media_source_has_video().

ffmpeg_decoder_is_prefetch_running()

bool ffmpeg_decoder_is_prefetch_running

(

ffmpeg_decoder_t *

decoder

)

Definition at line 980 of file ffmpeg_decoder.c.

                                                                   {
  if (!decoder) {
    return false;
  }
  return decoder->prefetch_thread_running;
}

References ffmpeg_decoder_t::prefetch_thread_running.

ffmpeg_decoder_read_audio_samples()

size_t ffmpeg_decoder_read_audio_samples	(	ffmpeg_decoder_t *	decoder,
		float *	buffer,
		size_t	num_samples
	)

Definition at line 1030 of file ffmpeg_decoder.c.

                                                                                                       {
  if (!decoder || decoder->audio_stream_idx < 0 || !buffer || num_samples == 0) {
    return 0;
  }
 
  size_t samples_written = 0;
 
  // First, drain any buffered samples
  if (decoder->audio_buffer_offset > 0) {
    size_t available = decoder->audio_buffer_offset;
    size_t to_copy = (available < num_samples) ? available : num_samples;
 
    memcpy(buffer, decoder->audio_buffer, to_copy * sizeof(float));
    samples_written += to_copy;
 
    // Shift buffer
    if (to_copy < available) {
      memmove(decoder->audio_buffer, decoder->audio_buffer + to_copy, (available - to_copy) * sizeof(float));
    }
    decoder->audio_buffer_offset -= to_copy;
 
    if (samples_written >= num_samples) {
      return samples_written;
    }
  }
 
  // Read more packets to fill the request
  static uint64_t packet_count = 0;
  while (samples_written < num_samples) {
    int ret = av_read_frame(decoder->format_ctx, decoder->packet);
    if (ret < 0) {
      if (ret == AVERROR_EOF) {
        decoder->eof_reached = true;
      }
      break;
    }
 
    // Check if this is an audio packet
    if (decoder->packet->stream_index != decoder->audio_stream_idx) {
      av_packet_unref(decoder->packet);
      continue;
    }
 
    log_info_every(50 * US_PER_MS_INT, "Audio packet #%lu: pts=%ld dts=%ld duration=%d size=%d", packet_count++,
                   decoder->packet->pts, decoder->packet->dts, decoder->packet->duration, decoder->packet->size);
 
    // Send packet to decoder
    ret = avcodec_send_packet(decoder->audio_codec_ctx, decoder->packet);
    av_packet_unref(decoder->packet);
 
    if (ret < 0) {
      log_warn("Error sending audio packet to decoder");
      continue;
    }
 
    // Receive all decoded frames from this packet
    // Important: a single packet can produce multiple frames. Must drain all before next packet.
    while (1) {
      ret = avcodec_receive_frame(decoder->audio_codec_ctx, decoder->frame);
      if (ret == AVERROR(EAGAIN)) {
        break; // No more frames from this packet, get next packet
      } else if (ret < 0) {
        log_warn("Error receiving audio frame from decoder");
        goto audio_read_done;
      }
 
      // Update position tracking
      decoder->last_audio_pts =
          get_frame_pts_seconds(decoder->frame, decoder->format_ctx->streams[decoder->audio_stream_idx]->time_base);
 
      // Resample to target format
      float *out_buf = buffer + samples_written;
      int out_samples = (int)(num_samples - samples_written);
 
      uint8_t *out_ptr = (uint8_t *)out_buf;
      int converted = swr_convert(decoder->swr_ctx, &out_ptr, out_samples, (const uint8_t **)decoder->frame->data,
                                  decoder->frame->nb_samples);
 
      if (converted > 0) {
        samples_written += (size_t)converted;
      }
 
      if (samples_written >= num_samples) {
        goto audio_read_done;
      }
    }
  }
 
audio_read_done:
  // Flush resampler buffer if we haven't filled the full request
  // The resampler may have buffered samples that need to be output
  if (samples_written < num_samples) {
    int remaining_space = (int)(num_samples - samples_written);
    uint8_t *out_ptr = (uint8_t *)(buffer + samples_written);
    int flushed = swr_convert(decoder->swr_ctx, &out_ptr, remaining_space, NULL, 0);
    if (flushed > 0) {
      samples_written += (size_t)flushed;
    }
  }
 
  // Update sample-based position tracking
  decoder->audio_samples_read += samples_written;
 
  return samples_written;
}

References ffmpeg_decoder_t::audio_buffer, ffmpeg_decoder_t::audio_buffer_offset, ffmpeg_decoder_t::audio_codec_ctx, ffmpeg_decoder_t::audio_samples_read, ffmpeg_decoder_t::audio_stream_idx, ffmpeg_decoder_t::eof_reached, ffmpeg_decoder_t::format_ctx, ffmpeg_decoder_t::frame, ffmpeg_decoder_t::last_audio_pts, ffmpeg_decoder_t::packet, and ffmpeg_decoder_t::swr_ctx.

Referenced by media_source_read_audio().

ffmpeg_decoder_read_video_frame()

image_t * ffmpeg_decoder_read_video_frame

(

ffmpeg_decoder_t *

decoder

)

Definition at line 880 of file ffmpeg_decoder.c.

                                                                    {
  if (!decoder || decoder->video_stream_idx < 0) {
    return NULL;
  }
 
  // Try to get a prefetched frame from the background thread (preferred path)
  mutex_lock(&decoder->prefetch_mutex);
  if (decoder->prefetch_frame_ready && decoder->current_prefetch_image) {
    // Release the previous buffer (rendering is now complete)
    if (decoder->current_read_buffer == decoder->prefetch_image_a) {
      decoder->buffer_a_in_use = false;
    } else if (decoder->current_read_buffer == decoder->prefetch_image_b) {
      decoder->buffer_b_in_use = false;
    }
 
    image_t *frame = decoder->current_prefetch_image;
    decoder->prefetch_frame_ready = false;
 
    // Mark the new buffer as in use (prevent prefetch thread from overwriting it during rendering)
    if (frame == decoder->prefetch_image_a) {
      decoder->buffer_a_in_use = true;
    } else if (frame == decoder->prefetch_image_b) {
      decoder->buffer_b_in_use = true;
    }
 
    decoder->current_read_buffer = frame;
    mutex_unlock(&decoder->prefetch_mutex);
 
    // Use the prefetched frame
    decoder->current_image = frame;
    log_dev_every(5 * US_PER_SEC_INT, "Using prefetched frame");
    return frame;
  }
  mutex_unlock(&decoder->prefetch_mutex);
 
  // No fallback synchronous decode - rely on background prefetch thread
  // Skipping frames when prefetch not ready allows audio timing to advance
  // This is critical for proper audio-video sync when prefetch is active
  log_dev_every(5 * US_PER_SEC_INT,
                "Prefetch frame not ready, skipping to next iteration (allow prefetch to catch up)");
  return NULL;
}

References ffmpeg_decoder_t::buffer_a_in_use, ffmpeg_decoder_t::buffer_b_in_use, ffmpeg_decoder_t::current_image, ffmpeg_decoder_t::current_prefetch_image, ffmpeg_decoder_t::current_read_buffer, ffmpeg_decoder_t::prefetch_frame_ready, ffmpeg_decoder_t::prefetch_image_a, ffmpeg_decoder_t::prefetch_image_b, ffmpeg_decoder_t::prefetch_mutex, and ffmpeg_decoder_t::video_stream_idx.

Referenced by media_source_read_video().

ffmpeg_decoder_rewind()

asciichat_error_t ffmpeg_decoder_rewind

(

ffmpeg_decoder_t *

decoder

)

Definition at line 1144 of file ffmpeg_decoder.c.

                                                                   {
  if (!decoder) {
    return ERROR_INVALID_PARAM;
  }
 
  if (decoder->is_stdin) {
    return ERROR_NOT_SUPPORTED; // Cannot seek stdin
  }
 
  // Flush codec buffers
  if (decoder->video_codec_ctx) {
    avcodec_flush_buffers(decoder->video_codec_ctx);
  }
  if (decoder->audio_codec_ctx) {
    avcodec_flush_buffers(decoder->audio_codec_ctx);
  }
 
  // Seek to beginning
  if (av_seek_frame(decoder->format_ctx, -1, 0, AVSEEK_FLAG_BACKWARD) < 0) {
    return SET_ERRNO(ERROR_MEDIA_SEEK, "Failed to seek to beginning");
  }
 
  decoder->eof_reached = false;
  decoder->audio_buffer_offset = 0;
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
  decoder->audio_samples_read = 0; // Reset sample counter to 0
 
  return ASCIICHAT_OK;
}

References ffmpeg_decoder_t::audio_buffer_offset, ffmpeg_decoder_t::audio_codec_ctx, ffmpeg_decoder_t::audio_samples_read, ffmpeg_decoder_t::eof_reached, ffmpeg_decoder_t::format_ctx, ffmpeg_decoder_t::is_stdin, ffmpeg_decoder_t::last_audio_pts, ffmpeg_decoder_t::last_video_pts, and ffmpeg_decoder_t::video_codec_ctx.

Referenced by media_source_rewind().

ffmpeg_decoder_seek_to_timestamp()

asciichat_error_t ffmpeg_decoder_seek_to_timestamp	(	ffmpeg_decoder_t *	decoder,
		double	timestamp_sec
	)

Definition at line 1175 of file ffmpeg_decoder.c.

                                                                                                    {
  if (!decoder) {
    return ERROR_INVALID_PARAM;
  }
 
  if (decoder->is_stdin) {
    return ERROR_NOT_SUPPORTED; // Cannot seek stdin
  }
 
  // Hold mutex during entire seek operation to prevent race with prefetch thread
  mutex_lock(&decoder->prefetch_mutex);
 
  // Set flag to pause prefetch thread via condition variable
  decoder->seeking_in_progress = true;
 
  // Convert seconds to FFmpeg time base units (AV_TIME_BASE = 1,000,000)
  int64_t target_ts = (int64_t)(timestamp_sec * AV_TIME_BASE);
 
  // For HTTP streams, use simple keyframe seeking (faster than frame-accurate seeking)
  // HTTP seeking is expensive and can break stream state, so prefer speed over precision
  int seek_ret = av_seek_frame(decoder->format_ctx, -1, target_ts, AVSEEK_FLAG_BACKWARD);
  if (seek_ret < 0) {
    // Fallback: try without backward flag
    seek_ret = av_seek_frame(decoder->format_ctx, -1, target_ts, 0);
  }
 
  if (seek_ret < 0) {
    decoder->seeking_in_progress = false;
    cond_signal(&decoder->prefetch_cond);
    mutex_unlock(&decoder->prefetch_mutex);
    return SET_ERRNO(ERROR_MEDIA_SEEK, "Failed to seek to timestamp %.2f seconds", timestamp_sec);
  }
 
  // Flush codec buffers AFTER seeking
  if (decoder->video_codec_ctx) {
    avcodec_flush_buffers(decoder->video_codec_ctx);
  }
  if (decoder->audio_codec_ctx) {
    avcodec_flush_buffers(decoder->audio_codec_ctx);
  }
 
  // Reset state
  decoder->eof_reached = false;
  decoder->audio_buffer_offset = 0;
  // Clear any stale audio data in buffer
  if (decoder->audio_buffer) {
    memset(decoder->audio_buffer, 0, decoder->audio_buffer_size * sizeof(float));
  }
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
  decoder->prefetch_frame_ready = false;
  // Set audio_samples_read to match the seek target so position tracking works correctly
  decoder->audio_samples_read = (uint64_t)(timestamp_sec * decoder->audio_sample_rate);
 
  // Reset current_read_buffer and mark both buffers as not in use
  // After seeking, the prefetch thread may reallocate buffers, so current_read_buffer
  // could point to freed memory. Clear it so the next read doesn't try to release stale pointers.
  decoder->current_read_buffer = NULL;
  decoder->buffer_a_in_use = false;
  decoder->buffer_b_in_use = false;
 
  // Resume prefetch thread
  decoder->seeking_in_progress = false;
  cond_signal(&decoder->prefetch_cond);
 
  // Release mutex - prefetch thread can resume
  mutex_unlock(&decoder->prefetch_mutex);
 
  return ASCIICHAT_OK;
}

References ffmpeg_decoder_t::audio_buffer, ffmpeg_decoder_t::audio_buffer_offset, ffmpeg_decoder_t::audio_buffer_size, ffmpeg_decoder_t::audio_codec_ctx, ffmpeg_decoder_t::audio_sample_rate, ffmpeg_decoder_t::audio_samples_read, ffmpeg_decoder_t::buffer_a_in_use, ffmpeg_decoder_t::buffer_b_in_use, ffmpeg_decoder_t::current_read_buffer, ffmpeg_decoder_t::eof_reached, ffmpeg_decoder_t::format_ctx, ffmpeg_decoder_t::is_stdin, ffmpeg_decoder_t::last_audio_pts, ffmpeg_decoder_t::last_video_pts, ffmpeg_decoder_t::prefetch_cond, ffmpeg_decoder_t::prefetch_frame_ready, ffmpeg_decoder_t::prefetch_mutex, ffmpeg_decoder_t::seeking_in_progress, and ffmpeg_decoder_t::video_codec_ctx.

Referenced by media_source_seek().

ffmpeg_decoder_start_prefetch()

asciichat_error_t ffmpeg_decoder_start_prefetch

(

ffmpeg_decoder_t *

decoder

)

Start the background frame prefetching thread.

Starts a background thread that continuously reads and decodes video frames, storing them in double-buffer structures. The render loop pulls frames from these buffers. This prevents the render thread from blocking on YouTube HTTP requests.

Definition at line 930 of file ffmpeg_decoder.c.

                                                                           {
  if (!decoder || decoder->video_stream_idx < 0) {
    return ERROR_INVALID_PARAM;
  }
 
  if (!decoder->prefetch_image_a || !decoder->prefetch_image_b) {
    return ERROR_INVALID_PARAM;
  }
 
  // Already running
  if (decoder->prefetch_thread_running) {
    return ASCIICHAT_OK;
  }
 
  // Reset stop flag and create thread
  decoder->prefetch_should_stop = false;
 
  int thread_err = asciichat_thread_create(&decoder->prefetch_thread, ffmpeg_decoder_prefetch_thread_func, decoder);
  if (thread_err != 0) {
    return SET_ERRNO(ERROR_THREAD, "Failed to create video prefetch thread");
  }
 
  decoder->prefetch_thread_running = true;
  return ASCIICHAT_OK;
}

References asciichat_thread_create(), ffmpeg_decoder_t::prefetch_image_a, ffmpeg_decoder_t::prefetch_image_b, ffmpeg_decoder_t::prefetch_should_stop, ffmpeg_decoder_t::prefetch_thread, ffmpeg_decoder_t::prefetch_thread_running, and ffmpeg_decoder_t::video_stream_idx.

Referenced by media_source_create().

ffmpeg_decoder_stop_prefetch()

void ffmpeg_decoder_stop_prefetch

(

ffmpeg_decoder_t *

decoder

)

Stop the background frame prefetching thread.

Definition at line 959 of file ffmpeg_decoder.c.

                                                             {
  if (!decoder || !decoder->prefetch_thread_running) {
    return;
  }
 
  decoder->prefetch_should_stop = true;
  // Wait up to 2 seconds for thread to stop
  // The interrupt callback should cause av_read_frame to abort quickly
  int join_result = asciichat_thread_join_timeout(&decoder->prefetch_thread, NULL, 2000 * NS_PER_MS_INT);
 
  if (join_result == 0) {
    // Thread exited successfully
    decoder->prefetch_thread_running = false;
  } else {
    // Timeout: thread is still running (blocked on I/O)
    // Mark as stopped anyway - we'll create a new thread on restart
    // The old thread will eventually finish and exit
    decoder->prefetch_thread_running = false;
  }
}

References ffmpeg_decoder_t::prefetch_should_stop, ffmpeg_decoder_t::prefetch_thread, and ffmpeg_decoder_t::prefetch_thread_running.