direct_play_nice 0.2.0-beta.1

CLI program that converts video files to direct-play-compatible formats.
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

//! CUDA video resize filter graph support.

#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "linux")]
pub(crate) use linux::*;

#[cfg(not(target_os = "linux"))]
mod non_linux {
    use anyhow::{bail, Result};
    use rsmpeg::avcodec::AVCodecContext;
    use rsmpeg::avutil::AVFrame;
    use rsmpeg::ffi;

    use crate::types::ResizeQuality;

    pub(crate) fn cuda_resize_supported_for_quality(_quality: ResizeQuality) -> bool {
        false
    }

    pub(crate) fn scale_cuda_filter_available() -> bool {
        false
    }

    pub(crate) fn attach_cuda_encoder_frames_context(
        _encode_context: &mut AVCodecContext,
        _device: *mut ffi::AVBufferRef,
        _sw_format: ffi::AVPixelFormat,
    ) -> Result<()> {
        bail!("CUDA resize backend is only available on Linux builds")
    }

    pub(crate) struct CudaResizeFilter;

    impl CudaResizeFilter {
        pub(crate) fn is_compatible(
            &self,
            _source_width: i32,
            _source_height: i32,
            _target_width: i32,
            _target_height: i32,
            _quality: ResizeQuality,
        ) -> bool {
            false
        }

        pub(crate) fn new(
            _frame: &AVFrame,
            _source_time_base: ffi::AVRational,
            _target_width: i32,
            _target_height: i32,
            _quality: ResizeQuality,
        ) -> Result<Self> {
            bail!("CUDA resize backend is only available on Linux builds")
        }

        pub(crate) fn process_frame(&mut self, _frame: &AVFrame) -> Result<AVFrame> {
            bail!("CUDA resize backend is only available on Linux builds")
        }
    }
}

#[cfg(not(target_os = "linux"))]
pub(crate) use non_linux::*;

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ResizeQuality;

    #[test]
    fn cuda_resize_supports_only_scale_cuda_kernels_on_linux() {
        let supported = [
            ResizeQuality::Bilinear,
            ResizeQuality::Bicubic,
            ResizeQuality::Lanczos,
        ];
        let unsupported = [ResizeQuality::FastBilinear, ResizeQuality::Spline];

        for quality in supported {
            assert_eq!(
                cuda_resize_supported_for_quality(quality),
                cfg!(target_os = "linux"),
                "unexpected CUDA resize support for {quality}"
            );
        }
        for quality in unsupported {
            assert!(
                !cuda_resize_supported_for_quality(quality),
                "unexpected CUDA resize support for {quality}"
            );
        }
    }
}