shepherd 0.1.5

A distributed video encoder that splits files into chunks to encode them on multiple machines in parallel.
Documentation 
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use clap::{App, AppSettings, Arg};
use log::error;
use simplelog::{
    ColorChoice, ConfigBuilder, LevelFilter, TermLogger, TerminalMode,
};
use std::process;

use shepherd;

fn main() {
    let matches = App::new(clap::crate_name!())
        .version(clap::crate_version!())
        .about(
            "A distributed video encoder that splits files into chunks \
             for multiple machines.",
        )
        .author(clap::crate_authors!())
        .setting(AppSettings::TrailingVarArg)
        .arg(
            Arg::with_name("clients")
                .short("c")
                .long("clients")
                .value_name("hostnames")
                .use_delimiter(true)
                .takes_value(true)
                .required(true)
                .help("Comma-separated list of encoding hosts"),
        )
        .arg(
            Arg::with_name("length")
                .short("l")
                .long("length")
                .value_name("seconds")
                .takes_value(true)
                .help("The length of video chunks in seconds"),
        )
        .arg(
            Arg::with_name("tmp")
                .short("t")
                .long("tmp")
                .value_name("path")
                .takes_value(true)
                .help("The path to the local temporary directory"),
        )
        .arg(
            Arg::with_name("keep")
                .short("k")
                .long("keep")
                .help("Don't clean up temporary files"),
        )
        .arg(
            Arg::with_name("IN")
                .help("The original video file")
                .required(true),
        )
        .arg(
            Arg::with_name("OUT")
                .help("The output video file")
                .required(true),
        )
        .arg(
            Arg::with_name("ffmpeg")
                .value_name("FFMPEG OPTIONS")
                .multiple(true)
                .help(
                    "Options/flags for ffmpeg encoding of chunks. The\n\
                     chunks are video only, so don't pass in anything\n\
                     concerning audio. Input/output file names are added\n\
                     by the application, so there is no need for that\n\
                     either. This is the last positional argument and\n\
                     needs to be preceeded by double hypens (--) as in:\n\
                     shepherd -c c1,c2 in.mp4 out.mp4 -- -c:v libx264\n\
                     -crf 26 -preset veryslow -profile:v high -level 4.2\n\
                     -pix_fmt yuv420p\n\
                     This is also the default that is used if no options\n\
                     are provided.",
                ),
        )
        .get_matches();
    // If we get here, unwrap is safe on mandatory arguments
    let input = matches.value_of("IN").unwrap();
    let output = matches.value_of("OUT").unwrap();
    let hosts = matches.values_of("clients").unwrap().collect();
    let seconds = matches.value_of("length");
    let tmp = matches.value_of("tmp");
    let keep = matches.is_present("keep");
    // Take the given arguments for ffmpeg or use the defaults
    let args: Vec<&str> = matches
        .values_of("ffmpeg")
        .map(|a| a.collect())
        .unwrap_or_else(|| {
            vec![
                "-c:v",
                "libx264",
                "-crf",
                "26",
                "-preset",
                "veryslow",
                "-profile:v",
                "high",
                "-level",
                "4.2",
                "-pix_fmt",
                "yuv420p",
            ]
        });

    TermLogger::init(
        LevelFilter::Info,
        ConfigBuilder::new()
            .set_time_offset_to_local()
            .expect("Unable to determine time offset")
            .build(),
        TerminalMode::Mixed,
        ColorChoice::Auto,
    )
    .expect("Failed initializing logger");

    if cfg!(debug_assertions) {
        shepherd::run(input, output, &args, hosts, seconds, tmp, keep)
            .unwrap();
    } else if let Err(e) =
        shepherd::run(input, output, &args, hosts, seconds, tmp, keep)
    {
        error!("{}", e);
        process::exit(1);
    }
}