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

// Copyright (C) 2017 Sebastian Dröge <sebastian@centricular.com>
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use ffi;
use glib;
use glib::signal::connect;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib_ffi;
use gst;
use std::boxed::Box as Box_;
use std::mem::transmute;
use Player;
use PlayerSignalDispatcher;
use PlayerVideoRenderer;

impl Player {
    /// Creates a new `Player` instance that uses `signal_dispatcher` to dispatch
    /// signals to some event loop system, or emits signals directly if NULL is
    /// passed. See `PlayerGMainContextSignalDispatcher::new`.
    ///
    /// Video is going to be rendered by `video_renderer`, or if `None` is provided
    /// no special video set up will be done and some default handling will be
    /// performed.
    /// ## `video_renderer`
    /// GstPlayerVideoRenderer to use
    /// ## `signal_dispatcher`
    /// GstPlayerSignalDispatcher to use
    ///
    /// # Returns
    ///
    /// a new `Player` instance
    pub fn new(
        video_renderer: Option<&PlayerVideoRenderer>,
        signal_dispatcher: Option<&PlayerSignalDispatcher>,
    ) -> Player {
        assert_initialized_main_thread!();
        let video_renderer = video_renderer.to_glib_full();
        let signal_dispatcher = signal_dispatcher.to_glib_full();

        let (major, minor, _, _) = gst::version();
        if (major, minor) > (1, 12) {
            unsafe { from_glib_full(ffi::gst_player_new(video_renderer, signal_dispatcher)) }
        } else {
            // Workaround for bad floating reference handling in 1.12. This issue was fixed for 1.13 in
            // https://cgit.freedesktop.org/gstreamer/gst-plugins-bad/commit/gst-libs/gst/player/gstplayer.c?id=634cd87c76f58b5e1383715bafd5614db825c7d1
            unsafe { from_glib_none(ffi::gst_player_new(video_renderer, signal_dispatcher)) }
        }
    }

    pub fn get_config(&self) -> ::PlayerConfig {
        unsafe { from_glib_full(ffi::gst_player_get_config(self.to_glib_none().0)) }
    }

    pub fn set_config(&self, config: ::PlayerConfig) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::error::BoolError::from_glib(
                ffi::gst_player_set_config(self.to_glib_none().0, config.into_ptr()),
                "Failed to set config",
            )
        }
    }

    pub fn connect_duration_changed<F: Fn(&Player, gst::ClockTime) + Send + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Player, gst::ClockTime) + Send + 'static>> =
                Box_::new(Box_::new(f));
            connect(
                self.to_glib_none().0,
                "duration-changed",
                transmute(duration_changed_trampoline as usize),
                Box_::into_raw(f) as *mut _,
            )
        }
    }

    pub fn connect_position_updated<F: Fn(&Player, gst::ClockTime) + Send + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Player, gst::ClockTime) + Send + 'static>> =
                Box_::new(Box_::new(f));
            connect(
                self.to_glib_none().0,
                "position-updated",
                transmute(position_updated_trampoline as usize),
                Box_::into_raw(f) as *mut _,
            )
        }
    }

    pub fn connect_seek_done<F: Fn(&Player, gst::ClockTime) + Send + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Player, gst::ClockTime) + Send + 'static>> =
                Box_::new(Box_::new(f));
            connect(
                self.to_glib_none().0,
                "seek-done",
                transmute(seek_done_trampoline as usize),
                Box_::into_raw(f) as *mut _,
            )
        }
    }
}

unsafe extern "C" fn duration_changed_trampoline(
    this: *mut ffi::GstPlayer,
    object: u64,
    f: glib_ffi::gpointer,
) {
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let f: &&(Fn(&Player, gst::ClockTime) + Send + 'static) = transmute(f);
    f(&from_glib_borrow(this), gst::ClockTime(Some(object)))
}

unsafe extern "C" fn position_updated_trampoline(
    this: *mut ffi::GstPlayer,
    object: u64,
    f: glib_ffi::gpointer,
) {
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let f: &&(Fn(&Player, gst::ClockTime) + Send + Sync + 'static) = transmute(f);
    f(&from_glib_borrow(this), gst::ClockTime(Some(object)))
}

unsafe extern "C" fn seek_done_trampoline(
    this: *mut ffi::GstPlayer,
    object: u64,
    f: glib_ffi::gpointer,
) {
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let f: &&(Fn(&Player, gst::ClockTime) + Send + 'static) = transmute(f);
    f(&from_glib_borrow(this), gst::ClockTime(Some(object)))
}