ffmpeg_decoder.h File Reference

🎞️ FFmpeg-based media decoder for video and audio streams More...

Go to the source code of this file.

Typedefs
typedef struct ffmpeg_decoder_t	ffmpeg_decoder_t
	Opaque FFmpeg decoder handle.

Enumerations
enum	ffmpeg_frame_status_t { FFMPEG_FRAME_READY , FFMPEG_FRAME_WAITING , FFMPEG_FRAME_EOF , FFMPEG_FRAME_FAILED }
	Decode next video frame. More...

Functions
ffmpeg_decoder_t *	ffmpeg_decoder_create (const char *path)
	Create FFmpeg decoder from file path.
ffmpeg_decoder_t *	ffmpeg_decoder_create_stdin (void)
	Create FFmpeg decoder from stdin.
void	ffmpeg_decoder_destroy (ffmpeg_decoder_t *decoder)
	Destroy FFmpeg decoder and free resources.
asciichat_error_t	ffmpeg_decoder_start_prefetch (ffmpeg_decoder_t *decoder)
	Start background frame prefetching thread.
void	ffmpeg_decoder_stop_prefetch (ffmpeg_decoder_t *decoder)
	Stop background frame prefetching thread.
void	ffmpeg_decoder_set_exit_callback (ffmpeg_decoder_t *decoder, bool(*should_exit_callback)(void *), void *user_data)
	Set exit signal callback for graceful shutdown during I/O.
bool	ffmpeg_decoder_is_prefetch_running (ffmpeg_decoder_t *decoder)
	Check if background frame prefetching thread is running.
ffmpeg_frame_status_t	ffmpeg_decoder_poll_video (ffmpeg_decoder_t *decoder, image_t **frame, asciichat_error_context_t *failure)
image_t *	ffmpeg_decoder_read_video_frame (ffmpeg_decoder_t *decoder)
bool	ffmpeg_decoder_has_video (ffmpeg_decoder_t *decoder)
	Check if decoder has video stream.
asciichat_error_t	ffmpeg_decoder_get_video_dimensions (ffmpeg_decoder_t *decoder, int *width, int *height)
	Get video dimensions.
double	ffmpeg_decoder_get_video_fps (ffmpeg_decoder_t *decoder)
	Get video frame rate.
size_t	ffmpeg_decoder_read_audio_samples (ffmpeg_decoder_t *decoder, float *buffer, size_t num_samples)
	Decode audio samples.
bool	ffmpeg_decoder_has_audio (ffmpeg_decoder_t *decoder)
	Check if decoder has audio stream.
asciichat_error_t	ffmpeg_decoder_rewind (ffmpeg_decoder_t *decoder)
	Seek to beginning of media.
asciichat_error_t	ffmpeg_decoder_seek_to_timestamp (ffmpeg_decoder_t *decoder, double timestamp_sec)
	Seek to specific timestamp in media.
bool	ffmpeg_decoder_at_end (ffmpeg_decoder_t *decoder)
	Check if decoder reached end of stream.
double	ffmpeg_decoder_get_duration (ffmpeg_decoder_t *decoder)
	Get media duration in seconds.
double	ffmpeg_decoder_get_position (ffmpeg_decoder_t *decoder)
	Get current playback position in seconds.
ffmpeg_decoder_t *	ffmpeg_decoder_create_interruptible (const char *path, bool(*cancel)(void *), void *data)
ffmpeg_decoder_t *	ffmpeg_decoder_create_with_request_options (const char *path, bool(*cancel)(void *), void *data, const char *headers, const char *cookies, const char *proxy)

Detailed Description

🎞️ FFmpeg-based media decoder for video and audio streams

Definition in file ffmpeg_decoder.h.

Function Documentation

ffmpeg_decoder_create_interruptible()

ffmpeg_decoder_t * ffmpeg_decoder_create_interruptible	(	const char *	path,
		bool(*	cancel )(void *),
		void *	data )

Definition at line 773 of file ffmpeg_decoder.c.

                                                                                                            {
  return ffmpeg_decoder_create_with_request_options(path, cancel, data, NULL, NULL, NULL);
}

References ffmpeg_decoder_create_with_request_options().

Referenced by ffmpeg_decoder_create(), and http_renderer_render_file().

ffmpeg_decoder_create_with_request_options()

ffmpeg_decoder_t * ffmpeg_decoder_create_with_request_options	(	const char *	path,
		bool(*	cancel )(void *),
		void *	data,
		const char *	headers,
		const char *	cookies,
		const char *	proxy )

Definition at line 777 of file ffmpeg_decoder.c.

                                                                                {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_CREATE_INTERRUPTIBLE);
  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));
  atomic_ptr_store(&decoder->should_exit_callback, (void *)cancel);
  atomic_ptr_store(&decoder->exit_callback_user_data, data);
  decoder->format_ctx = avformat_alloc_context();
  if (!decoder->format_ctx) {
    SAFE_FREE(decoder);
    return NULL;
  }
  decoder->format_ctx->interrupt_callback.callback = ffmpeg_interrupt_callback;
  decoder->format_ctx->interrupt_callback.opaque = decoder;
  decoder->video_stream_idx = -1;
  decoder->audio_stream_idx = -1;
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
 
  // Capture FFmpeg's probing output (FFmpeg may write directly to either stream)
  int ret = 0;
  LOG_IO("ffmpeg", {
    // Configure FFmpeg options for HTTP streaming performance
    AVDictionary *options = NULL;
 
    // FFmpeg accepts HTTP authorities that the application URL validator rejects.
    // Classify the protocol rather than validating the host for timeout settings.
    bool is_http = path && (platform_strncasecmp(path, "http://", sizeof("http://") - 1) == 0 ||
                            platform_strncasecmp(path, "https://", sizeof("https://") - 1) == 0);
    asciichat_errno_scope_t url_scope = errno_scope_begin();
    bool is_url = is_http || (path && strstr(path, "://") && url_is_valid(path));
    errno_scope_end(url_scope, ASCIICHAT_ERRNO_DISMISSED);
    if (is_url) {
      if (headers && *headers)
        av_dict_set(&options, "headers", headers, 0);
      if (cookies && *cookies)
        av_dict_set(&options, "cookies", cookies, 0);
      if (proxy)
        av_dict_set(&options, "http_proxy", proxy, 0);
      // 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
    ret = traced_format_open(&decoder->format_ctx, path, NULL, &options);
    av_dict_free(&options); // Free options dictionary
 
    if (ret >= 0) {
      // Find stream info
      if (traced_format_probe(decoder->format_ctx, NULL) < 0) {
        ret = -1;
      }
    }
  });
 
  if (ret < 0) {
    if (ret == -1) {
      SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to find stream info");
    } else {
      SET_ERRNO(ERROR_MEDIA_OPEN, "Failed to open media file: %s", path);
    }
    if (decoder->format_ctx) {
      avformat_close_input(&decoder->format_ctx);
    }
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Install interrupt callback to allow seeking to interrupt long traced_packet_read() 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;
  }
 
  // Open video codec
  asciichat_error_t err = open_optional_codec_context(decoder->format_ctx, AVMEDIA_TYPE_VIDEO,
                                                      &decoder->video_stream_idx, &decoder->video_codec_ctx);
  if (err != ASCIICHAT_OK) {
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // 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_optional_codec_context(decoder->format_ctx, AVMEDIA_TYPE_AUDIO, &decoder->audio_stream_idx,
                                    &decoder->audio_codec_ctx);
  if (err != ASCIICHAT_OK) {
    ffmpeg_decoder_destroy(decoder);
    return 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
      LOG_IO("swscaler", {
        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_STEREO;
    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);
 
    // A mono source stays centered at unity gain in the stereo pipeline.
    if (decoder->audio_codec_ctx->ch_layout.nb_channels == 1) {
      const double matrix[] = {1.0, 1.0};
      swr_set_matrix(decoder->swr_ctx, matrix, 1);
    }
    // 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 * TARGET_CHANNELS * 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, "ffmpeg_prefetch") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch mutex");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    if (cond_init(&decoder->prefetch_cond, "ffmpeg_prefetch") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch condition variable");
      mutex_destroy(&decoder->prefetch_mutex);
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    if (mutex_init(&decoder->read_frame_mutex, "ffmpeg_read_frame") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize read_frame mutex");
      mutex_destroy(&decoder->prefetch_mutex);
      cond_destroy(&decoder->prefetch_cond);
      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");
 
  char decoder_name[MEDIA_FFMPEG_DECODER_DECODER_NAME_BUFFER_SIZE];
  snprintf(decoder_name, sizeof(decoder_name), "%s", path);
  NAMED_REGISTER_FFMPEG_DECODER(decoder, decoder_name, NULL);
  NAMED_REGISTER_ATOMIC(&decoder->eof_reached, "ffmpeg_eof", decoder);
 
  return decoder;
}

References ASCII_OTEL_SCOPE, ASCIICHAT_ERRNO_DISMISSED, ASCIICHAT_OK, 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_t::eof_reached, errno_scope_begin(), errno_scope_end(), ERROR_INVALID_PARAM, ERROR_MEDIA_DECODE, ERROR_MEDIA_OPEN, ERROR_MEMORY, ffmpeg_decoder_t::exit_callback_user_data, ffmpeg_decoder_destroy(), ffmpeg_decoder_t::format_ctx, ffmpeg_decoder_t::frame, height, image_new(), ffmpeg_decoder_t::last_audio_pts, ffmpeg_decoder_t::last_video_pts, log_debug, LOG_IO, log_warn, MEDIA_FFMPEG_DECODER_DECODER_NAME_BUFFER_SIZE, NAMED_REGISTER_ATOMIC, NAMED_REGISTER_FFMPEG_DECODER, 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::read_frame_mutex, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, ffmpeg_decoder_t::should_exit_callback, ffmpeg_decoder_t::swr_ctx, ffmpeg_decoder_t::sws_ctx, TARGET_CHANNELS, TARGET_SAMPLE_RATE, url_is_valid(), ffmpeg_decoder_t::video_codec_ctx, ffmpeg_decoder_t::video_stream_idx, and width.

Referenced by ffmpeg_decoder_create_interruptible(), and media_source_create_interruptible().