vsd 0.4.3

Download video streams served over HTTP from websites, DASH (.mpd) and HLS (.m3u8) playlists.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

mod encryption;
mod fetch;
mod mux;
mod parse;
mod stream;
mod subtitle;

pub use encryption::Decrypter;
pub use fetch::fetch_playlist;
pub use parse::{list_all_streams, parse_all_streams, parse_selected_streams};
pub use subtitle::download_subtitle_streams;

use crate::{
    playlist::{MediaPlaylist, MediaType},
    utils,
};
use anyhow::{Result, bail};
use kdam::{Column, RichProgress, tqdm};
use reqwest::{Url, blocking::Client};
use std::{collections::HashMap, fs, path::PathBuf};

#[allow(clippy::too_many_arguments)]
pub fn download(
    base_url: Option<Url>,
    client: Client,
    decrypter: Decrypter,
    directory: Option<PathBuf>,
    no_decrypt: bool,
    no_merge: bool,
    output: Option<PathBuf>,
    query: HashMap<String, String>,
    mut streams: Vec<MediaPlaylist>,
    subs_codec: String,
    retries: u8,
    threads: u8,
) -> Result<()> {
    let should_mux = mux::should_mux(no_decrypt, no_merge, output.as_ref(), &streams);

    if should_mux && utils::find_ffmpeg().is_none() {
        bail!("ffmpeg couldn't be found, it is required to continue further.");
    }

    if !no_decrypt {
        encryption::check_unsupported_encryptions(&streams)?;
        let default_kids = encryption::extract_default_kids(&base_url, &client, &streams, &query)?;
        encryption::check_key_exists_for_kid(&decrypter, &default_kids)?;
    }

    if let Some(directory) = &directory
        && !directory.exists() {
            fs::create_dir_all(directory)?;
        }

    for stream in &mut streams {
        if stream.media_type != MediaType::Subtitles {
            stream.split_segment(&base_url, &client, &query)?;
        }
    }

    let mut pb = RichProgress::new(
        tqdm!(
            dynamic_ncols = true,
            total = streams.iter().map(|x| x.segments.len()).sum(),
            unit = " SEG"
        ),
        vec![
            Column::Text("[bold blue]?".to_owned()), // downladed bytes / estimated bytes
            Column::Animation,
            Column::Percentage(0),
            Column::Text("•".to_owned()),
            Column::CountTotal, // downloaded segments / total segments
            Column::Text("•".to_owned()),
            Column::ElapsedTime,
            Column::Text(">".to_owned()),
            Column::RemainingTime,
            Column::Text("•".to_owned()),
            Column::Rate,
        ],
    );
    let mut temp_files = vec![];

    download_subtitle_streams(
        &base_url,
        &client,
        directory.as_ref(),
        &streams,
        &mut pb,
        &query,
        &mut temp_files,
    )?;

    stream::download_streams(
        &base_url,
        &client,
        decrypter,
        directory.as_ref(),
        no_decrypt,
        no_merge,
        pb,
        &query,
        retries,
        streams,
        threads,
        &mut temp_files,
    )?;

    if should_mux {
        mux::ffmpeg(output.as_ref(), &subs_codec, &temp_files)?;
        mux::delete_temp_files(directory.as_ref(), &temp_files)?;
    }

    Ok(())
}