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
116
117
118
119
120
121
122
123
124
125

use std::fmt;
use std::ptr;

use libc::c_int;

use crate::ffi::*;
use crate::{AsMutPtr, AsPtr};

use super::flag::Flags;
use super::{DictionaryMut, DictionaryRef};

pub struct Dictionary {
    ptr: *mut AVDictionary,
}

impl Default for Dictionary {
    fn default() -> Self {
        Self::new()
    }
}

impl Dictionary {
    pub unsafe fn from_raw(ptr: *mut AVDictionary) -> Self {
        Self { ptr }
    }

    pub fn into_raw(mut self) -> *mut AVDictionary {
        let result = self.ptr;
        self.ptr = ptr::null_mut();

        result
    }

    pub fn replace_with(&mut self, new: Self) {
        unsafe { av_dict_free(&mut self.ptr) };
        self.ptr = new.into_raw();
    }

    pub fn as_ptr(&self) -> *const AVDictionary {
        self.ptr
    }

    pub fn as_mut_ptr(&mut self) -> &mut *mut AVDictionary {
        &mut self.ptr
    }

    pub fn as_ref(&self) -> DictionaryRef<'_> {
        unsafe { DictionaryRef::from_raw(self.as_ptr()) }
    }

    pub fn as_mut(&mut self) -> DictionaryMut<'_> {
        unsafe { DictionaryMut::from_raw(self.as_mut_ptr()) }
    }
}

impl Dictionary {
    pub fn new() -> Self {
        Self {
            ptr: ptr::null_mut(),
        }
    }
}

impl<S, U> FromIterator<(S, U)> for Dictionary
where
    S: AsRef<str>,
    U: AsRef<str>,
{
    fn from_iter<T: IntoIterator<Item = (S, U)>>(iter: T) -> Self {
        let mut result = Dictionary::new();

        for (key, value) in iter {
            result.set(key.as_ref(), value.as_ref())
        }

        result
    }
}

impl Clone for Dictionary {
    fn clone(&self) -> Self {
        let mut dictionary = Dictionary::new();
        dictionary.clone_from(self);

        dictionary
    }

    fn clone_from(&mut self, source: &Self) {
        unsafe {
            av_dict_copy(
                &mut self.ptr,
                source.as_ptr(),
                Flags::MULTIKEY.bits() as c_int,
            );
        }
    }
}

impl Drop for Dictionary {
    fn drop(&mut self) {
        unsafe {
            av_dict_free(&mut self.ptr);
        }
    }
}

impl fmt::Debug for Dictionary {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        self.as_ref().fmt(fmt)
    }
}

impl AsPtr<AVDictionary> for Dictionary {
    fn as_ptr(&self) -> *const AVDictionary {
        self.ptr
    }
}

// *mut *mut because this is the common way for FFmpeg APIs to accept
// a Dictionary reference (empty Dictionaries use an internal nullptr).
impl AsMutPtr<*mut AVDictionary> for Dictionary {
    fn as_mut_ptr(&mut self) -> *mut *mut AVDictionary {
        &mut self.ptr
    }
}