vk-video 0.3.1

[DEPRECATED] Renamed to `gpu-video`
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

#[cfg(vulkan)]
fn main() {
    use std::{
        fs::File,
        io::{Read, Write},
        num::NonZeroU32,
        time::Duration,
    };

    use vk_video::{
        EncodedInputChunk,
        parameters::{
            RateControl, ScalingAlgorithm, TranscoderOutputParameters, TranscoderParameters,
            VulkanAdapterDescriptor, VulkanDeviceDescriptor,
        },
    };

    let subscriber = tracing_subscriber::FmtSubscriber::builder()
        .with_max_level(tracing::Level::INFO)
        .finish();

    tracing::subscriber::set_global_default(subscriber).expect("Failed to initialize tracing");

    let args = std::env::args().collect::<Vec<_>>();
    if args.len() < 4 || args.len() > 5 {
        print_usage_and_exit(&args[0]);
    }

    let input_file = &args[1];
    let Ok(output_width) = args[2].parse::<NonZeroU32>() else {
        print_usage_and_exit(&args[0]);
    };
    let Ok(output_height) = args[3].parse::<NonZeroU32>() else {
        print_usage_and_exit(&args[0]);
    };

    let scaling_algorithm = if args.len() == 5 {
        match args[4].as_str() {
            "nearest" => ScalingAlgorithm::NearestNeighbor,
            "bilinear" => ScalingAlgorithm::Bilinear,
            "lanczos3" => ScalingAlgorithm::Lanczos3,
            _ => print_usage_and_exit(&args[0]),
        }
    } else {
        ScalingAlgorithm::default()
    };

    let instance = vk_video::VulkanInstance::new().unwrap();
    let adapter = instance
        .create_adapter(&VulkanAdapterDescriptor::default())
        .unwrap();
    let device = adapter
        .create_device(&VulkanDeviceDescriptor::default())
        .unwrap();

    let params = device
        .encoder_output_parameters_high_quality(RateControl::VariableBitrate {
            average_bitrate: 10_000_000,
            max_bitrate: 12_000_000,
            virtual_buffer_size: Duration::from_secs(2),
        })
        .unwrap();

    let mut transcoder = device
        .create_transcoder(TranscoderParameters {
            input_framerate: 30.into(),
            output_parameters: vec![TranscoderOutputParameters {
                output_width,
                output_height,
                encoder_parameters: params,
                scaling_algorithm,
            }],
        })
        .unwrap();

    let mut input_file = File::open(input_file).unwrap();
    let mut output_file = File::create("output.h264").unwrap();

    let mut buffer = vec![0; 4096];
    while let Ok(n) = input_file.read(&mut buffer)
        && n > 0
    {
        let input = EncodedInputChunk {
            data: &buffer[..n],
            pts: None,
        };
        let output = transcoder.transcode(input).unwrap();

        for output in output {
            output_file.write_all(&output[0].data).unwrap();
        }
    }

    let flushed = transcoder.flush().unwrap();
    for output in flushed {
        output_file.write_all(&output[0].data).unwrap();
    }
}

#[cfg(vulkan)]
fn print_usage_and_exit(executable_name: &str) -> ! {
    eprintln!("usage: {executable_name} INPUT OUT_WIDTH OUT_HEIGHT [nearest|bilinear|lanczos3]");
    std::process::exit(1);
}

#[cfg(not(vulkan))]
fn main() {
    println!(
        "This crate doesn't work on your operating system, because it does not support vulkan"
    );
}