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

use anyhow::{bail, Result};
use clap::{Args, ValueEnum};
use std::{
    fs,
    fs::File,
    io::{BufReader, Read, Write},
    process::Command,
};

/// Merge multiple segments to a single file.
#[derive(Args, Clone, Debug)]
pub struct Merge {
    /// List of files (at least 2) to merge together e.g. *.ts, *.m4s etc. .
    #[arg(required = true)]
    files: Vec<String>,

    /// Path for merged output file.
    #[arg(short, long, required = true)]
    output: String,

    /// Type of merge to be performed.
    #[arg(short, long, value_enum, default_value_t = MergeType::Binary)]
    _type: MergeType,
}

#[derive(Debug, Clone, ValueEnum)]
enum MergeType {
    Binary,
    Ffmpeg,
}

impl Merge {
    pub fn execute(self) -> Result<()> {
        let mut files = vec![];

        for pattern in &self.files {
            for file in glob::glob(pattern)? {
                files.push(file?);
            }
        }

        if 1 >= files.len() {
            bail!("At least 2 files are required to merge together.")
        }

        match self._type {
            MergeType::Binary => {
                let mut output = File::create(self.output)?;
                let buffer_size = 1024 * 1024 * 2; // 2 MiB

                for file in files {
                    let file_size = fs::metadata(&file)?.len();

                    if buffer_size >= file_size {
                        let buf = fs::read(file)?;
                        output.write_all(&buf)?;
                    } else {
                        let file = File::open(file)?;
                        let mut reader = BufReader::new(file);

                        loop {
                            let mut buf = vec![];
                            reader.by_ref().take(buffer_size).read_to_end(&mut buf)?;

                            if buf.is_empty() {
                                break;
                            }

                            output.write_all(&buf)?;
                        }
                    }
                }
            }
            MergeType::Ffmpeg => {
                let concat_file = "vsd-ffmpeg-concat.txt";
                let mut concat = File::create(concat_file)?;

                for file in files {
                    let file = file.to_string_lossy();

                    if file != self.output {
                        concat.write_fmt(format_args!("file '{file}'\n"))?;
                    }
                }

                let status = Command::new("ffmpeg")
                    .args([
                        "-hide_banner",
                        "-y",
                        "-f",
                        "concat",
                        "-i",
                        concat_file,
                        "-c",
                        "copy",
                        &self.output,
                    ])
                    .spawn()?
                    .wait()?;

                if !status.success() {
                    bail!("ffmpeg exited with code {}.", status.code().unwrap_or(1))
                }

                fs::remove_file(concat_file)?;
            }
        }

        Ok(())
    }
}