mpv 0.2.3

safe mpv bindings 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

extern crate mpv ;
extern crate sdl2;
extern crate sdl2_sys;
#[macro_use]
extern crate log;

use std::env;
use std::path::Path;
use std::os::raw::{c_void,c_char};
use std::ffi::CStr;

use sdl2::event::Event as SdlEvent;
use sdl2::keyboard::Keycode;

unsafe extern "C" fn get_proc_address(arg: *mut c_void,
                                      name: *const c_char) -> *mut c_void {
    let arg: &sdl2::VideoSubsystem = &*(arg as *mut sdl2::VideoSubsystem);
    let name = CStr::from_ptr(name).to_str().unwrap();
    arg.gl_get_proc_address(name) as *mut c_void
}

fn sdl_example(video_path: &Path) {
    let mut opengl_driver : Option<i32> = None ;
    info!("Detecting drivers ...");
    // SDL drivers are counted from 0
    // Typically here if we want to draw with SDL on mpv we must use the "opengl" driver,
    // and for instance not the direct3d driver (on windows), nor the opengles driver, ...
    let mut driver_index = -1 ;
    for item in sdl2::render::drivers() {
        driver_index = driver_index + 1 ;
        info!("* Found driver '{}'",item.name);
        if item.name == "opengl"{
            opengl_driver = Some(driver_index);
        }
    }
    if let Some(opengl_driver) = opengl_driver {
        let opengl_driver = opengl_driver as u32;
        // initialize SDL
        let sdl_context = sdl2::init().unwrap();
        // initialize the video subsystem for SDL
        let mut video_subsystem = sdl_context.video().unwrap();
        // Create a new window
        let window = video_subsystem.window("MPV-RS SDL2 EXAMPLE", 960, 540)
            .resizable()
            .position_centered()
            .opengl()
            .build()
            .unwrap();
        // Create an SDL renderer with vsync enabled, using the given opengl driver
        let renderer = window.renderer()
            .present_vsync()
            .index(opengl_driver)
            .build()
            .expect("Failed to create renderer with given parameters");

        // this step is necessary
        renderer.window()
                .expect("Failed to extract window from displayer")
                .gl_set_context_to_current()
                .unwrap();
        let ptr = &mut video_subsystem as *mut _ as *mut c_void;
        let mut mpv_builder = mpv::MpvHandlerBuilder::new().expect("Error while creating MPV builder");
        mpv_builder.try_hardware_decoding();
        let mut mpv : Box<mpv::MpvHandlerWithGl> = mpv_builder.build_with_gl(Some(get_proc_address), ptr).expect("Error while initializing MPV with opengl");
        // observe the property "pause" with userdata 5.
        // When we will pause later, an event PropertyChange will be sent with userdata 5
        mpv.observe_property::<bool>("pause",5).unwrap();

        let video_path = video_path.to_str().expect("Expected a string for Path, got None");

        // Send a command synchronously, telling the libmpv core to load a file
        mpv.command(&["loadfile", video_path as &str])
           .expect("Error loading file");

        let mut event_pump = sdl_context.event_pump().expect("Failed to create event_pump");
        'main: loop {
            for event in event_pump.poll_iter() {
                match event {
                    SdlEvent::Quit {..} | SdlEvent::KeyDown { keycode: Some(Keycode::Escape), .. } => {
                        break 'main
                    },
                    SdlEvent::KeyDown { keycode: Some(Keycode::Space),repeat: false, .. } => {
                        match mpv.get_property("pause").unwrap() {
                            true => {mpv.set_property_async("pause",false,1).expect("Failed to pause player");},
                            false => {mpv.set_property_async("pause",true,1).expect("Failed to unpause player");}
                        }
                    },
                    // this is useless and only here to show the possibilities of the mpv-rs API
                    SdlEvent::KeyDown { keycode: Some(Keycode::O),repeat: false, .. } => {
                        mpv.get_property_async::<&str>("speed",5).unwrap();
                    },
                    _ => {}
                }
            }
            // wait up to 0.0 seconds for an event.
            while let Some(event) = mpv.wait_event(0.0) {
                // even if you don't do anything with the events, it is still necessary to empty
                // the event loop
                println!("RECEIVED EVENT : {:?}", event);
                match event {
                    mpv::Event::Shutdown | mpv::Event::EndFile(_) => {
                        break 'main;
                    }
                    _ => {}
                };
            }
            let (width, height) = renderer.window().unwrap().size();
            mpv.draw(0, width as i32, -(height as i32)).expect("Failed to draw on SDL2 window");
            renderer.window().unwrap().gl_swap_window();
        }
    }else{
        error!("OpenGL driver not found, aborting");
    }
}

fn main() {
    let args: Vec<_> = env::args().collect();
    if args.len() < 2 {
        println!("Usage: ./sdl [any mp4, avi, mkv, ... file]");
    } else {
        let path: &Path = Path::new(&args[1]);
        if path.is_file() {
            sdl_example(path);
        } else {
            println!("A file is required; {} is not a valid file",
                     path.to_str().unwrap());
        }
    }
}