Struct PlaylistDownloader 

pub struct PlaylistDownloader { /* private fields */ }

A downloader for HLS and DASH playlist streams.

PlaylistDownloader allows configuring the download behavior (threads, retries, filters, etc.), parsing the manifest, fetching segments concurrently, decrypting, and muxing the output files.

Implementations

impl PlaylistDownloader

pub fn new(client: &Client) -> Self

Creates a new PlaylistDownloader with defaults.

Examples found in repository

examples/playlist_dl.rs (line 49)

async fn main() -> Result<()> {
    let client = Client::new();

    // We use ./target as temporary directory for downloaded files.
    let dl = PlaylistDownloader::new(&client).directory("target");
    let config = dl.get_config();

    let mp = dl
        .parse(
            "https://media.axprod.net/TestVectors/Dash/not_protected_dash_1080p_h264/manifest.mpd",
            false,
        )
        .await?;

    // You can clone this token and call .cancel() to pause a download.
    let token = CancellationToken::new();
    let mut muxer = Muxer::new();

    // Download first subtitle stream.
    for stream in mp.streams {
        if stream.media_type == MediaType::Subtitles {
            println!(
                "Downloading {} subtitles",
                stream.language.as_deref().unwrap_or("unknown")
            );

            // We download to a temporary file, mux it in, and then clean up.
            // You could also just move the file after download and avoid muxing if you want.
            let dl_info = match stream.download(config, Arc::new(Progress), &token).await {
                Ok(info) => info,
                Err(Error::MissingSegments) => {
                    println!("Stream has no segments");
                    continue;
                }
                Err(Error::UnsupportedEncryption(e)) => {
                    println!("Unsupported encryption {}", e);
                    continue;
                }
                Err(Error::MissingKey(key_id)) => {
                    println!("Missing decryption key for {key_id}");
                    continue;
                }
                Err(Error::DownloadInterrupted) => {
                    println!("Download paused");
                    std::process::exit(0);
                }
                Err(e) => return Err(e),
            };

            println!("Downloaded {}", dl_info.path.to_string_lossy());
            muxer.push(dl_info);

            break;
        }
    }

    println!("Muxing to target/output.srt");
    muxer
        .mux(&vsd::find_ffmpeg().unwrap(), "target/output.srt", "srt")
        .await?;
    muxer.clean(config.directory.as_deref()).await?;

    Ok(())
}

pub fn base_url(self, base_url: impl Into<Url>) -> Self

Sets the base URL for resolving relative links.

pub fn clip(self, clip: &str) -> Result<Self>

Sets the clip range to download a subset of the playlist (e.g. 01:00-01:30).

Errors

Returns an error if the clip range string is invalid.

pub fn decrypt(self, decrypt: bool) -> Self

Sets whether to attempt decrypting the streams (default: true).

pub fn directory(self, directory: impl Into<PathBuf>) -> Self

Sets the temporary download directory (default: .).

Examples found in repository

examples/playlist_dl.rs (line 49)

async fn main() -> Result<()> {
    let client = Client::new();

    // We use ./target as temporary directory for downloaded files.
    let dl = PlaylistDownloader::new(&client).directory("target");
    let config = dl.get_config();

    let mp = dl
        .parse(
            "https://media.axprod.net/TestVectors/Dash/not_protected_dash_1080p_h264/manifest.mpd",
            false,
        )
        .await?;

    // You can clone this token and call .cancel() to pause a download.
    let token = CancellationToken::new();
    let mut muxer = Muxer::new();

    // Download first subtitle stream.
    for stream in mp.streams {
        if stream.media_type == MediaType::Subtitles {
            println!(
                "Downloading {} subtitles",
                stream.language.as_deref().unwrap_or("unknown")
            );

            // We download to a temporary file, mux it in, and then clean up.
            // You could also just move the file after download and avoid muxing if you want.
            let dl_info = match stream.download(config, Arc::new(Progress), &token).await {
                Ok(info) => info,
                Err(Error::MissingSegments) => {
                    println!("Stream has no segments");
                    continue;
                }
                Err(Error::UnsupportedEncryption(e)) => {
                    println!("Unsupported encryption {}", e);
                    continue;
                }
                Err(Error::MissingKey(key_id)) => {
                    println!("Missing decryption key for {key_id}");
                    continue;
                }
                Err(Error::DownloadInterrupted) => {
                    println!("Download paused");
                    std::process::exit(0);
                }
                Err(e) => return Err(e),
            };

            println!("Downloaded {}", dl_info.path.to_string_lossy());
            muxer.push(dl_info);

            break;
        }
    }

    println!("Muxing to target/output.srt");
    muxer
        .mux(&vsd::find_ffmpeg().unwrap(), "target/output.srt", "srt")
        .await?;
    muxer.clean(config.directory.as_deref()).await?;

    Ok(())
}

pub fn format(self, format: &str) -> Result<Self>

Sets the format expression for stream selection (default: "bv+ba+s").

Errors

Returns an error if the format expression is invalid.

pub fn interactive(self, raw: bool) -> Self

Configures the stream selection interface.

If raw is true, a basic text list prompt is displayed; otherwise, a modern interactive multi-select prompt is used.

pub fn keys(self, keys: HashMap<String, String>) -> Self

Sets the decryption keys (key_id hex -> key hex).

pub fn merge(self, merge: bool) -> Self

Sets whether to merge downloaded streams into a single output file (default: true).

pub fn query(self, query: &str) -> Self

Sets query parameters to append to requests.

pub fn resume(self, resume: bool) -> Self

Sets whether to resume partial downloads (default: true).

pub fn retries(self, retries: u8) -> Self

Sets the maximum retry count per segment download (default: 10).

pub fn threads(self, threads: u8) -> Self

Sets concurrent segment download thread count (default: 5, clamped between 1 and 16).

pub fn get_config(&self) -> &PlaylistDownloadConfig

Gets a reference to the download configuration.

Examples found in repository

examples/playlist_dl.rs (line 50)

async fn main() -> Result<()> {
    let client = Client::new();

    // We use ./target as temporary directory for downloaded files.
    let dl = PlaylistDownloader::new(&client).directory("target");
    let config = dl.get_config();

    let mp = dl
        .parse(
            "https://media.axprod.net/TestVectors/Dash/not_protected_dash_1080p_h264/manifest.mpd",
            false,
        )
        .await?;

    // You can clone this token and call .cancel() to pause a download.
    let token = CancellationToken::new();
    let mut muxer = Muxer::new();

    // Download first subtitle stream.
    for stream in mp.streams {
        if stream.media_type == MediaType::Subtitles {
            println!(
                "Downloading {} subtitles",
                stream.language.as_deref().unwrap_or("unknown")
            );

            // We download to a temporary file, mux it in, and then clean up.
            // You could also just move the file after download and avoid muxing if you want.
            let dl_info = match stream.download(config, Arc::new(Progress), &token).await {
                Ok(info) => info,
                Err(Error::MissingSegments) => {
                    println!("Stream has no segments");
                    continue;
                }
                Err(Error::UnsupportedEncryption(e)) => {
                    println!("Unsupported encryption {}", e);
                    continue;
                }
                Err(Error::MissingKey(key_id)) => {
                    println!("Missing decryption key for {key_id}");
                    continue;
                }
                Err(Error::DownloadInterrupted) => {
                    println!("Download paused");
                    std::process::exit(0);
                }
                Err(e) => return Err(e),
            };

            println!("Downloaded {}", dl_info.path.to_string_lossy());
            muxer.push(dl_info);

            break;
        }
    }

    println!("Muxing to target/output.srt");
    muxer
        .mux(&vsd::find_ffmpeg().unwrap(), "target/output.srt", "srt")
        .await?;
    muxer.clean(config.directory.as_deref()).await?;

    Ok(())
}

pub async fn parse( &self, uri: &str, partial_parse: bool, ) -> Result<MasterPlaylist>

Fetches and parses the playlist manifest.

If partial_parse is true, it applies format selection and interactive prompts to determine which streams should be processed.

Errors

Returns an error if fetching or parsing the playlist fails.

Examples found in repository

examples/playlist_dl.rs (lines 53-56)

async fn main() -> Result<()> {
    let client = Client::new();

    // We use ./target as temporary directory for downloaded files.
    let dl = PlaylistDownloader::new(&client).directory("target");
    let config = dl.get_config();

    let mp = dl
        .parse(
            "https://media.axprod.net/TestVectors/Dash/not_protected_dash_1080p_h264/manifest.mpd",
            false,
        )
        .await?;

    // You can clone this token and call .cancel() to pause a download.
    let token = CancellationToken::new();
    let mut muxer = Muxer::new();

    // Download first subtitle stream.
    for stream in mp.streams {
        if stream.media_type == MediaType::Subtitles {
            println!(
                "Downloading {} subtitles",
                stream.language.as_deref().unwrap_or("unknown")
            );

            // We download to a temporary file, mux it in, and then clean up.
            // You could also just move the file after download and avoid muxing if you want.
            let dl_info = match stream.download(config, Arc::new(Progress), &token).await {
                Ok(info) => info,
                Err(Error::MissingSegments) => {
                    println!("Stream has no segments");
                    continue;
                }
                Err(Error::UnsupportedEncryption(e)) => {
                    println!("Unsupported encryption {}", e);
                    continue;
                }
                Err(Error::MissingKey(key_id)) => {
                    println!("Missing decryption key for {key_id}");
                    continue;
                }
                Err(Error::DownloadInterrupted) => {
                    println!("Download paused");
                    std::process::exit(0);
                }
                Err(e) => return Err(e),
            };

            println!("Downloaded {}", dl_info.path.to_string_lossy());
            muxer.push(dl_info);

            break;
        }
    }

    println!("Muxing to target/output.srt");
    muxer
        .mux(&vsd::find_ffmpeg().unwrap(), "target/output.srt", "srt")
        .await?;
    muxer.clean(config.directory.as_deref()).await?;

    Ok(())
}