ff-encode 0.14.1

Video and audio encoding - the Rust way
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

//! Codec type re-exports and encode-specific extensions.
//!
//! `VideoCodec` and `AudioCodec` are the canonical types defined in
//! `ff-format` and re-exported here so callers can import them from a
//! single crate.  Encode-specific behaviour (LGPL licensing, default
//! file extension) is provided via the [`VideoCodecEncodeExt`] trait.

pub use ff_format::{AudioCodec, VideoCodec};

/// Encode-specific methods for [`VideoCodec`].
///
/// This trait adds encoding-oriented helpers to the shared `VideoCodec` type.
/// Import it to call [`is_lgpl_compatible`](Self::is_lgpl_compatible) or
/// [`default_extension`](Self::default_extension) on a codec value.
///
/// # Examples
///
/// ```
/// use ff_encode::{VideoCodec, VideoCodecEncodeExt};
///
/// assert!(VideoCodec::Vp9.is_lgpl_compatible());
/// assert_eq!(VideoCodec::H264.default_extension(), "mp4");
/// ```
pub trait VideoCodecEncodeExt {
    /// Returns `true` if the *software* encoder for this codec is
    /// LGPL-compatible (i.e. does not require a GPL or proprietary licence).
    ///
    /// **Important**: This reflects the codec family's typical software
    /// encoder licensing, not the actual encoder chosen at runtime.
    /// H.264 and H.265 return `false` because their software encoders
    /// (libx264/libx265) are GPL; hardware encoders (NVENC, QSV, etc.)
    /// are LGPL-compatible regardless.
    ///
    /// Use [`VideoEncoder::is_lgpl_compliant`](crate::VideoEncoder) to
    /// query the actual encoder selected at runtime.
    fn is_lgpl_compatible(&self) -> bool;

    /// Returns the default output file extension for this codec.
    fn default_extension(&self) -> &'static str;
}

impl VideoCodecEncodeExt for VideoCodec {
    fn is_lgpl_compatible(&self) -> bool {
        matches!(
            self,
            VideoCodec::Vp9
                | VideoCodec::Av1
                | VideoCodec::Av1Svt
                | VideoCodec::Mpeg4
                | VideoCodec::ProRes
                | VideoCodec::DnxHd
                | VideoCodec::Ffv1
        )
    }

    fn default_extension(&self) -> &'static str {
        match self {
            VideoCodec::Vp9 | VideoCodec::Av1 => "webm",
            VideoCodec::Ffv1 => "mkv",
            _ => "mp4",
        }
    }
}

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

    #[test]
    fn video_codec_is_lgpl_compatible_should_return_true_for_open_codecs() {
        assert!(VideoCodec::Vp9.is_lgpl_compatible());
        assert!(VideoCodec::Av1.is_lgpl_compatible());
        assert!(VideoCodec::Mpeg4.is_lgpl_compatible());
        assert!(VideoCodec::ProRes.is_lgpl_compatible());
        assert!(VideoCodec::DnxHd.is_lgpl_compatible());
    }

    #[test]
    fn video_codec_is_lgpl_compatible_should_return_false_for_gpl_codecs() {
        assert!(!VideoCodec::H264.is_lgpl_compatible());
        assert!(!VideoCodec::H265.is_lgpl_compatible());
    }

    #[test]
    fn video_codec_default_extension_should_return_webm_for_web_codecs() {
        assert_eq!(VideoCodec::H264.default_extension(), "mp4");
        assert_eq!(VideoCodec::Vp9.default_extension(), "webm");
        assert_eq!(VideoCodec::Av1.default_extension(), "webm");
    }

    #[test]
    fn video_and_audio_codec_default_should_be_accessible() {
        assert_eq!(VideoCodec::default(), VideoCodec::H264);
        assert_eq!(AudioCodec::default(), AudioCodec::Aac);
    }
}