ffmpeg-pipeline 0.2.0

Composable FFmpeg decoding, encoding, remuxing, and media I/O for Rust
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use super::*;
use ffmpeg_next::{format::context, sys, Error};
use std::{ffi::CString, mem, ptr::null_mut};

pub struct BufferedOutput {
    _ctx: Box<AVOutputContextData>,
    output: Output,
    io_ctx: Box<*mut sys::AVIOContext>,
}

impl BufferedOutput {
    pub fn from_writer(writer: impl Writable + 'static, format: &str) -> FFmpegResult<Self> {
        let cursor = Box::new(writer) as Box<dyn Writable>;
        let ctx = Box::new(AVOutputContextData { cursor });
        let (io_ctx, output) = Self::output_buffer(ctx.as_ref(), format)?;
        Ok(Self {
            _ctx: ctx,
            output,
            io_ctx,
        })
    }

    fn output_buffer(
        ctx: &AVOutputContextData,
        format: &str,
    ) -> FFmpegResult<(Box<*mut sys::AVIOContext>, Output)> {
        unsafe {
            let avio_ctx = get_avio_context(true, ctx as *const _ as *mut _);

            let mut ps = sys::avformat_alloc_context();
            let format =
                CString::new(format).map_err(|_| FFmpegError::InvalidFormat(format.into()))?;
            let res = sys::avformat_alloc_output_context2(
                &mut ps,
                null_mut(),
                format.as_ptr(),
                null_mut(),
            );

            (*ps).pb = avio_ctx;

            match res {
                0 => Ok((Box::new(avio_ctx), context::Output::wrap(ps))),
                e => Err(Error::from(e)),
            }
        }
        .map_err(|e| e.into())
    }

    pub fn into_inner<T: Writable>(self) -> FFmpegResult<T> {
        use std::io::{Error, ErrorKind};

        let Self {
            mut _ctx,
            mut output,
            mut io_ctx,
        } = self;
        unsafe {
            sys::avio_context_free(io_ctx.as_mut());
            (*output.as_mut_ptr()).pb = null_mut();
            sys::avformat_free_context(output.as_mut_ptr());
        }
        // ffmpeg-next 7.1 always closes Output.pb as URL IO. The custom AVIO and
        // format context are already released above, so its destructor must not run.
        mem::forget(output);

        let cursor = _ctx.cursor.into_any();
        if let Ok(cursor) = cursor.downcast::<T>() {
            Ok(*cursor)
        } else {
            Err(FFmpegError::Io(Error::new(
                ErrorKind::InvalidData,
                "invalid cursor type",
            )))
        }
    }
}

impl AsRef<Output> for BufferedOutput {
    fn as_ref(&self) -> &Output {
        &self.output
    }
}

impl AsMut<Output> for BufferedOutput {
    fn as_mut(&mut self) -> &mut Output {
        &mut self.output
    }
}

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

    fn init() {
        initialize(log::Level::Debug).unwrap();
    }

    #[test]
    fn test_buffered_input() {
        init();
        let mut input = BufferedInput::from_reader_with_format(
            Cursor::new(crate::tests::encoded_ivf(2)),
            Some("ivf"),
        )
        .unwrap();
        let decoder = Decoder::new_with_video(input.as_mut(), 0, FrameProcess::Decode).unwrap();

        for (idx, frame) in decoder.enumerate() {
            let frame = frame.unwrap();
            match frame {
                Frame::Frame(StreamFrame::Audio(audio)) => {
                    println!("frame: {:?}", audio.format());
                }
                Frame::Frame(StreamFrame::Video(video)) => {
                    println!("frame: {:?}", video.format());
                }
                Frame::Frame(StreamFrame::Eof) => {
                    println!("eof");
                }
                Frame::Packet(_) => {
                    println!("packet: {}", idx);
                }
            }
        }
    }

    #[test]
    fn test_buffered_output() {
        init();
        let output = crate::tests::encoded_ogg();
        assert!(output.starts_with(b"OggS"));

        // for (idx, frame) in frames.enumerate() {
        //     match frame {
        //         Frame::Frame(StreamFrame::Audio(audio)) => {
        //             println!("frame: {:?}", audio.format());
        //         }
        //         Frame::Frame(StreamFrame::Video(video)) => {
        //             println!("frame: {:?}", video.format());
        //         }
        //         Frame::Frame(StreamFrame::Eof) => {
        //             println!("eof");
        //         }
        //         Frame::Packet(_) => {
        //             println!("packet: {}", idx);
        //         }
        //     }
        // }
    }
}