yt_dlp.h File Reference

yt-dlp stream URL extraction More...

Go to the source code of this file.

Data Structures
struct	yt_dlp_request_options_t

Enumerations
enum	{ YT_DLP_HEADERS_CAPACITY = 8192 , YT_DLP_COOKIES_CAPACITY = 8192 , YT_DLP_PROXY_CAPACITY = 2048 }

Functions
asciichat_error_t	yt_dlp_extract_with_options (const char *url, const char *yt_dlp_options, char *output_url, size_t output_size, char *audio_url, size_t audio_size, yt_dlp_request_options_t *video_options, yt_dlp_request_options_t *audio_options, bool(*cancel)(void *), void *data)
asciichat_error_t	yt_dlp_extract_stream_urls (const char *url, const char *yt_dlp_options, char *output_url, size_t output_size, char *audio_url, size_t audio_size)
	For yt dlp request options, this is the live record that ties proxy_specified together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record.
asciichat_error_t	yt_dlp_extract_stream_urls_interruptible (const char *url, const char *yt_dlp_options, char *output_url, size_t output_size, char *audio_url, size_t audio_size, bool(*cancel)(void *), void *data)
asciichat_error_t	yt_dlp_extract_stream_url (const char *url, const char *yt_dlp_options, char *output_url, size_t output_size)
bool	yt_dlp_is_available (void)
	Check if yt-dlp is installed and accessible.

Detailed Description

yt-dlp stream URL extraction

Encapsulates yt-dlp subprocess logic for extracting playable stream URLs from URLs that yt-dlp supports (YouTube, Twitch, etc.)

Definition in file yt_dlp.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
YT_DLP_HEADERS_CAPACITY
YT_DLP_COOKIES_CAPACITY
YT_DLP_PROXY_CAPACITY

Definition at line 16 of file yt_dlp.h.

{ YT_DLP_HEADERS_CAPACITY = 8192, YT_DLP_COOKIES_CAPACITY = 8192, YT_DLP_PROXY_CAPACITY = 2048 };

Function Documentation

yt_dlp_extract_stream_url()

asciichat_error_t yt_dlp_extract_stream_url	(	const char *	url,
		const char *	yt_dlp_options,
		char *	output_url,
		size_t	output_size )

Extract the first playable stream URL. Prefer the two-output API for audio.

Definition at line 558 of file yt_dlp.c.

                                                                {
  char audio_url[MEDIA_STREAM_URL_SIZE];
  return yt_dlp_extract_stream_urls(url, yt_dlp_options, output_url, output_size, audio_url, sizeof(audio_url));
}

References MEDIA_STREAM_URL_SIZE, and yt_dlp_extract_stream_urls().

yt_dlp_extract_stream_urls_interruptible()

asciichat_error_t yt_dlp_extract_stream_urls_interruptible	(	const char *	url,
		const char *	yt_dlp_options,
		char *	output_url,
		size_t	output_size,
		char *	audio_url,
		size_t	audio_size,
		bool(*	cancel )(void *),
		void *	data )

Definition at line 544 of file yt_dlp.c.

                                                                                                                  {
  yt_dlp_request_options_t video_request, audio_request;
  return yt_dlp_extract_with_options(url, yt_dlp_options, output_url, output_size, audio_url, audio_size,
                                     &video_request, &audio_request, cancel, data);
}

References yt_dlp_extract_with_options().

Referenced by yt_dlp_extract_stream_urls().

yt_dlp_extract_with_options()

asciichat_error_t yt_dlp_extract_with_options	(	const char *	url,
		const char *	yt_dlp_options,
		char *	output_url,
		size_t	output_size,
		char *	audio_url,
		size_t	audio_size,
		yt_dlp_request_options_t *	video_options,
		yt_dlp_request_options_t *	audio_options,
		bool(*	cancel )(void *),
		void *	data )

Definition at line 377 of file yt_dlp.c.

                                                          {
  if (!video_request || !audio_request)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing yt-dlp request options output");
  memset(video_request, 0, sizeof(*video_request));
  memset(audio_request, 0, sizeof(*audio_request));
  ASCII_OTEL_SCOPE(YTDLP_EXTRACT);
  ASCII_OTEL_ATTR_STRING("media.extractor", "yt-dlp");
  if (output_url && output_size) {
    output_url[0] = '\0';
    output_url[output_size - 1] = '\0';
  }
  if (audio_url && audio_size) {
    audio_url[0] = '\0';
    audio_url[audio_size - 1] = '\0';
  }
  if (!url || !output_url || output_size < 256 || !audio_url || audio_size < 256) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for yt-dlp URL extraction");
  }
  static_mutex_lock_named(&g_yt_dlp_cache_lock, "yt_dlp_cache");
  bool cached = yt_dlp_cache_get(url, yt_dlp_options, output_url, output_size, audio_url, audio_size, video_request,
                                 audio_request);
  static_mutex_unlock(&g_yt_dlp_cache_lock);
  if (cached) {
    ascii_otel_metric(ASCII_OTEL_METRIC_YTDLP_HIT, 1);
    ASCII_OTEL_ATTR_STRING("cache.result", *output_url ? "hit" : "negative_hit");
    if (!*output_url) {
      ascii_otel_metric(ASCII_OTEL_METRIC_YTDLP_NEGATIVE, 1);
      return ERROR_YOUTUBE_EXTRACT_FAILED;
    }
    return ASCIICHAT_OK;
  }
 
  ascii_otel_metric(ASCII_OTEL_METRIC_YTDLP_MISS, 1);
  ASCII_OTEL_ATTR_STRING("cache.result", "miss");
 
  enum { YT_DLP_MAX_ARGS = 64 };
  const char *argv[YT_DLP_MAX_ARGS];
  char option_storage[MEDIA_YT_DLP_YT_DLP_OPTIONS_BUFFER_SIZE];
  size_t argc = 0;
  argv[argc++] = "yt-dlp";
  argv[argc++] = "--quiet";
  argv[argc++] = "--no-warnings";
  argv[argc++] = "--no-playlist";
  argv[argc++] = "--user-agent";
  argv[argc++] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36";
  argv[argc++] = "-f";
  // Only select separate streams when no combined format is available.
  // Prefer H.264 for fallback: some FFmpeg builds cannot decode AV1.
  argv[argc++] = "b/bv[vcodec^=avc1]+ba/bv+ba";
  // A user-provided -f or --format overrides the default selector.
  if (!yt_dlp_parse_options(yt_dlp_options, option_storage, sizeof(option_storage), argv, &argc, YT_DLP_MAX_ARGS - 5)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid or too long yt-dlp options");
  }
  // Pass the explicit yt-dlp proxy to the independent FFmpeg requests.
  bool skip_proxy_value = false;
  for (size_t i = 0; i < argc; ++i) {
    if (skip_proxy_value) {
      skip_proxy_value = false;
      continue;
    }
    const char *proxy = NULL;
    if (!strcmp(argv[i], "--proxy") && i + 1 < argc) {
      proxy = argv[i + 1];
      skip_proxy_value = true;
    } else if (!strncmp(argv[i], "--proxy=", sizeof("--proxy=") - 1)) {
      proxy = argv[i] + sizeof("--proxy=") - 1;
    }
    if (proxy) {
      const size_t proxy_length = strlen(proxy);
      if (proxy_length >= sizeof(video_request->proxy))
        return SET_ERRNO(ERROR_NOT_SUPPORTED, "yt-dlp proxy is too long for media requests");
      memcpy(video_request->proxy, proxy, proxy_length + sizeof(char));
      memcpy(audio_request->proxy, proxy, proxy_length + sizeof(char));
      video_request->proxy_specified = audio_request->proxy_specified = true;
    }
  }
  if (video_request->proxy_specified && video_request->proxy[0] &&
      strncmp(video_request->proxy, "http://", sizeof("http://") - 1))
    return SET_ERRNO(ERROR_NOT_SUPPORTED,
                     "FFmpeg media requests require an HTTP proxy; the yt-dlp proxy is unsupported");
  if (!yt_dlp_is_available_interruptible(cancel, data)) {
    return SET_ERRNO(ERROR_YOUTUBE_EXTRACT_FAILED, "yt-dlp is not installed. Please install it with: "
                                                   "pip install yt-dlp (or: brew install yt-dlp on macOS)");
  }
  argv[argc++] = "--print";
  argv[argc++] =
      "{\"base\":%(.{url,http_headers,cookies})j,\"formats\":%(requested_formats.:.{url,http_headers,cookies}|null)j}";
  argv[argc++] = "--";
  argv[argc++] = url;
  argv[argc] = NULL;
 
  // Two URLs can each occupy the full stream URL capacity, plus diagnostics.
  char output[MEDIA_YT_DLP_FULL_OUTPUT_BUFFER_SIZE + MEDIA_STREAM_URL_SIZE] = {0};
  int status = 0;
  // Interactive extractors need their prompts visible on the real terminal.
  LOG_IO_IF(!platform_isatty(STDIN_FILENO), "yt-dlp",
            { status = platform_execute_subprocess("yt-dlp", argv, output, sizeof(output), cancel, data); });
  if (cancel && cancel(data)) {
    return ERROR_YOUTUBE_EXTRACT_FAILED;
  }
  if (status != 0 || strlen(output) == sizeof(output) - 1) {
    static_mutex_lock_named(&g_yt_dlp_cache_lock, "yt_dlp_cache");
    yt_dlp_cache_set(url, yt_dlp_options, NULL, NULL, video_request, audio_request);
    static_mutex_unlock(&g_yt_dlp_cache_lock);
    log_error("yt-dlp failed to extract streams (exit %d)", status);
    return SET_ERRNO(ERROR_YOUTUBE_EXTRACT_FAILED, "yt-dlp failed to extract streams");
  }
 
  size_t count = 0;
  yyjson_doc *doc = yyjson_read(output, strlen(output), 0);
  yyjson_val *root = doc ? yyjson_doc_get_root(doc) : NULL;
  yyjson_val *base = yt_dlp_object_get(root, "base");
  yyjson_val *formats = yt_dlp_object_get(root, "formats");
  if (!yyjson_is_arr(formats))
    formats = NULL;
  size_t total = yyjson_is_arr(formats) ? yyjson_arr_size(formats) : 1;
  if (!yyjson_is_obj(base) || total > 2) {
    if (doc)
      yyjson_doc_free(doc);
    return SET_ERRNO(ERROR_YOUTUBE_EXTRACT_FAILED, "yt-dlp returned invalid stream metadata");
  }
  // Walk the array once; indexed lookup in yyjson uses an unsigned countdown
  // that trips integer sanitizers on non-flat format objects.
  yyjson_arr_iter format_iter = yyjson_arr_iter_with(formats);
  for (size_t i = 0; i < total; ++i) {
    yyjson_val *format = formats ? yyjson_arr_iter_next(&format_iter) : base;
    yyjson_val *stream_value = yt_dlp_object_get(format, "url");
    const char *stream = yyjson_get_str(stream_value);
    char *dest = i == 0 ? output_url : audio_url;
    size_t capacity = i == 0 ? output_size : audio_size;
    yt_dlp_request_options_t *request = i == 0 ? video_request : audio_request;
    const size_t stream_length = stream ? strlen(stream) : 0;
    if (stream && request->proxy_specified && request->proxy[0] &&
        platform_strncasecmp(stream, "http://", sizeof("http://") - 1) &&
        platform_strncasecmp(stream, "https://", sizeof("https://") - 1)) {
      yyjson_doc_free(doc);
      output_url[0] = audio_url[0] = '\0';
      return SET_ERRNO(ERROR_NOT_SUPPORTED, "The selected proxy cannot be used with this media protocol");
    }
    if (!stream || stream_length != yyjson_get_len(stream_value) || !yt_dlp_is_stream_url(stream) ||
        stream_length >= capacity || !yt_dlp_parse_request(format, base, stream, request)) {
      yyjson_doc_free(doc);
      output_url[0] = audio_url[0] = '\0';
      return SET_ERRNO(ERROR_YOUTUBE_EXTRACT_FAILED, "yt-dlp returned invalid stream metadata");
    }
    memcpy(dest, stream, stream_length + sizeof(char));
    ++count;
  }
  yyjson_doc_free(doc);
  if (count == 0) {
    static_mutex_lock_named(&g_yt_dlp_cache_lock, "yt_dlp_cache");
    yt_dlp_cache_set(url, yt_dlp_options, NULL, NULL, video_request, audio_request);
    static_mutex_unlock(&g_yt_dlp_cache_lock);
    log_error("yt-dlp returned no playable stream URL");
    return SET_ERRNO(ERROR_YOUTUBE_EXTRACT_FAILED, "yt-dlp returned no playable formats");
  }
  static_mutex_lock_named(&g_yt_dlp_cache_lock, "yt_dlp_cache");
  yt_dlp_cache_set(url, yt_dlp_options, output_url, audio_url, video_request, audio_request);
  static_mutex_unlock(&g_yt_dlp_cache_lock);
  log_debug("yt-dlp extracted %zu stream URL(s)", count);
  return ASCIICHAT_OK;
}

References ASCII_OTEL_ATTR_STRING, ascii_otel_metric(), ASCII_OTEL_SCOPE, ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NOT_SUPPORTED, ERROR_YOUTUBE_EXTRACT_FAILED, log_debug, log_error, LOG_IO_IF, MEDIA_STREAM_URL_SIZE, MEDIA_YT_DLP_FULL_OUTPUT_BUFFER_SIZE, MEDIA_YT_DLP_YT_DLP_OPTIONS_BUFFER_SIZE, platform_execute_subprocess(), yt_dlp_request_options_t::proxy, yt_dlp_request_options_t::proxy_specified, and SET_ERRNO.

Referenced by yt_dlp_extract_stream_urls_interruptible().