ffmpeg-the-third 5.0.0+ffmpeg-8.1

Safe FFmpeg wrapper (FFmpeg 5+ compatible fork of the ffmpeg crate)
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

use super::*;
use crate::ffi::*;

// `cargo test` does not have support for "fails to compile" tests, so we use trybuild
#[test]
fn test_failing() {
    let t = trybuild::TestCases::new();
    t.compile_fail("src/util/dictionary/tests/fail.rs");
}

#[test]
fn simple() {
    let mut d = Dictionary::new();
    assert!(d.is_empty());
    assert_eq!(d.len(), 0);

    d.set("test", "42");
    d.set("foo", "100");
    d.set("bar", "Hello World!");

    assert!(!d.is_empty());
    assert_eq!(d.len(), 3);
    assert_eq!(d.get("foo"), Some("100"));
    assert_eq!(d.get("test"), Some("42"));
    assert_eq!(d.get("bar"), Some("Hello World!"));
    assert_eq!(d.get("baz"), None);
}

#[test]
fn with_flags() {
    let mut d = Dictionary::new();

    d.set("test", "42");

    assert_eq!(d.get_with_flags("TEST", Flags::MATCH_CASE), None);

    assert_eq!(d.get("test"), Some("42"));

    d.set_with_flags("TEST", "100", Flags::MATCH_CASE);
    assert_eq!(d.get_with_flags("TEST", Flags::MATCH_CASE), Some("100"));
    assert_eq!(d.get_with_flags("test", Flags::MATCH_CASE), Some("42"));

    d.unset_with_flags("test", Flags::MATCH_CASE);
    assert_eq!(d.get_with_flags("test", Flags::MATCH_CASE), None);
    assert_eq!(d.get_with_flags("TEST", Flags::MATCH_CASE), Some("100"));
    assert_eq!(d.get("test"), Some("100"));

    d.set_with_flags("foo", "123", Flags::DONT_OVERWRITE);
    assert_eq!(d.get("foo"), Some("123"));

    d.set_with_flags("test", "321", Flags::DONT_OVERWRITE);
    assert_eq!(d.get("test"), Some("100"));

    d.set_with_flags("TEST", "Hello", Flags::MATCH_CASE);
    d.set_with_flags("TEST", ", World!", Flags::MATCH_CASE | Flags::APPEND);
    assert_eq!(d.get("TEST"), Some("Hello, World!"));

    assert_eq!(
        d.get_with_flags("te", Flags::IGNORE_SUFFIX),
        Some("Hello, World!")
    );
}

#[test]
fn owned_and_ref() {
    let mut d = Dictionary::new();
    d.set("foo", "Hello, World!");
    d.set("bar", "123");
    d.set("testing", "321");

    let r = d.as_ref();

    // This would cause an error:
    // d.set("baz", "impossible");
    // let m = d.as_mut();

    assert_eq!(r.get("bar"), Some("123"));
}

// TODO: add multikey tests

#[test]
fn mut_inside_struct() {
    struct ContainsDictionary {
        x: i32,
        dict: *mut AVDictionary,
        y: f32,
    }

    let mut t = ContainsDictionary {
        x: 42,
        dict: std::ptr::null_mut(),
        y: -17.0,
    };

    let mut dict = unsafe { DictionaryMut::from_raw(&mut t.dict) };

    t.x = 100; // only t.dict is (mutably) borrowed

    // This would cause an error:
    // t.dict = std::ptr::null_mut();

    dict.set("testing", "123");
    #[allow(clippy::drop_non_drop)] // here for clarity
    drop(dict);

    assert!(!t.dict.is_null());
    let dict = unsafe { DictionaryRef::from_raw(t.dict) };

    assert_eq!(dict.get("testing"), Some("123"));
    assert_eq!(dict.len(), 1);

    assert_eq!(t.x, 100);
    assert_eq!(t.y, -17.0);
}