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


use std::{os::raw::c_char, error::Error};
use libav_sys::ffi::{
    avformat_open_input,
    AVFormatContext,
    avformat_network_init,
    av_strerror,
    avformat_find_stream_info,
    av_dump_format
};

type MyResult = Result<(), Box<dyn Error>>;


fn main() -> MyResult {
    println!("Hello, world!");

    init_libav()?;

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

    // convert url to c string
    let c_url = std::ffi::CString::new(url)?;

    // we will store the av format context here
    let mut format_context_ptr: *mut AVFormatContext = std::ptr::null_mut();

    // try to open the input
    handle_libav_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);

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

    // dumpo fomat info to console
    unsafe {
        av_dump_format(
            format_context_ptr,
            0,
            c_url.as_ptr() as *const c_char,
            0
        );
    }

    deinit_libav()?;

    Ok(())
}

fn init_libav() -> MyResult {
    // TODO ??? libav_sys::ffi::av_register_all();

    handle_libav_result(
        unsafe { avformat_network_init() },
        "avformat_network_init failed"
    )
}

fn deinit_libav() -> MyResult {
    handle_libav_result(
        unsafe { libav_sys::ffi::avformat_network_deinit() },
        "avformat_network_deinit failed"
    )
}

/// Convert an error code to a string
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()
}

/// Handle a result from a libav function
fn handle_libav_result(result: std::os::raw::c_int, error_message: &str) -> MyResult {
    if result < 0 {
        return Err(format!("{}: {}", error_message, av_error_to_string(result)).into());
    }

    Ok(())
}