libav-sys 0.2.0

Rust bindings for system libav libraries
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


use libav_sys::ffi::{
    avformat_open_input,
    AVFormatContext, avformat_network_init, av_strerror, avformat_find_stream_info, av_dump_format
};

use std::{os::raw::c_char, error::Error};


fn main() -> Result<(), Box<dyn Error>> {
    println!("Hello, world!");

    // initialize and deinitialize libav
    let _guard = InitGuard::new();

    let url = r#"file:C:/Users/lucac/downloads/BigBuckBunny.mp4"#;
    //let url = r#"http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"#;

    let c_url = std::ffi::CString::new(url)?;

    let mut format_context_ptr: *mut AVFormatContext = std::ptr::null_mut();

    handle_result(unsafe {
        avformat_open_input(
            &mut format_context_ptr,
            c_url.as_ptr(),
            std::ptr::null_mut(),
            std::ptr::null_mut()
        )
    }, "avformat_open_input failed")?;

    println!("Input opened!");
    println!("format_context_ptr: {:?}", format_context_ptr);

    handle_result(unsafe {
        avformat_find_stream_info(
            format_context_ptr,
            std::ptr::null_mut()
        )
    }, "failed to find stream info")?;

    unsafe {
        av_dump_format(
            format_context_ptr,
            0,
            c_url.as_ptr() as *const c_char,
            0
        );
    }

    // Find the first video stream
    let video_stream_index = {
        let mut video_stream_index = -1;
        for i in 0..unsafe { (*format_context_ptr).nb_streams } {
            let stream = unsafe { *(*format_context_ptr).streams.offset(i as isize) };
            if unsafe { (*(*stream).codecpar).codec_type } == libav_sys::ffi::AVMediaType_AVMEDIA_TYPE_VIDEO {
                video_stream_index = i as i32;
                break;
            }
        }
        video_stream_index
    };

    if video_stream_index < 0 {
        return Err("Could not find a video stream".into());
    }

    Ok(())
}

struct InitGuard;

impl InitGuard {
    fn new() -> Self {
        init();
        InitGuard
    }
}

impl Drop for InitGuard {
    fn drop(&mut self) {
        deinit();
    }
}

fn init() {
    // TODO ??? libav_sys::ffi::av_register_all();

    let result =  unsafe { avformat_network_init() };
    if result != 0 {
        panic!("avformat_network_init failed");
    }
}

fn deinit() {
    let result =  unsafe { libav_sys::ffi::avformat_network_deinit() };
    if result != 0 {
        panic!("avformat_network_deinit failed");
    }
}

fn av_error_to_string(error_code: std::os::raw::c_int) -> String {
    // create a buffer for the error message
    let mut error_buffer: Vec<std::os::raw::c_char> = vec![0; 1024];

    // get the error message
    let result = unsafe {
        av_strerror(
            error_code,
            error_buffer.as_mut_ptr(),
            error_buffer.len()
        )
    };
    if result != 0 {
        panic!("av_strerror failed");
    }

    // convert to rust string
    error_buffer.iter().take_while(|c| **c != 0).map(|c| *c as u8 as char).collect()
}

fn handle_result(result: std::os::raw::c_int, error_message: &str) -> Result<(), Box<dyn Error>> {
    if result < 0 {
        return Err(format!("{}: {}", error_message, av_error_to_string(result)).into());
    }

    Ok(())
}

fn tmp() {
    Drop
}