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

// 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 std::ptr;
use Buffer;
use BufferList;
use FlowError;
use FlowReturn;
use FlowSuccess;
use Object;
use Pad;
use ProxyPad;

use glib::object::IsA;
use glib::translate::{from_glib, from_glib_full, ToGlibPtr};

use gst_sys;

impl ProxyPad {
    /// Invoke the default chain function of the proxy pad.
    /// ## `pad`
    /// a sink `Pad`, returns GST_FLOW_ERROR if not.
    /// ## `parent`
    /// the parent of `pad` or `None`
    /// ## `buffer`
    /// the `Buffer` to send, return GST_FLOW_ERROR
    ///  if not.
    ///
    /// # Returns
    ///
    /// a `FlowReturn` from the pad.
    pub fn chain_default<O: IsA<ProxyPad>, P: IsA<Object>>(
        pad: &O,
        parent: Option<&P>,
        buffer: Buffer,
    ) -> Result<FlowSuccess, FlowError> {
        skip_assert_initialized!();
        let ret: FlowReturn = unsafe {
            from_glib(gst_sys::gst_proxy_pad_chain_default(
                pad.as_ptr() as *mut gst_sys::GstPad,
                parent.map(|p| p.as_ref()).to_glib_none().0,
                buffer.into_ptr(),
            ))
        };
        ret.into_result()
    }

    /// Invoke the default chain list function of the proxy pad.
    /// ## `pad`
    /// a sink `Pad`, returns GST_FLOW_ERROR if not.
    /// ## `parent`
    /// the parent of `pad` or `None`
    /// ## `list`
    /// the `BufferList` to send, return GST_FLOW_ERROR
    ///  if not.
    ///
    /// # Returns
    ///
    /// a `FlowReturn` from the pad.
    pub fn chain_list_default<O: IsA<ProxyPad>, P: IsA<Object>>(
        pad: &O,
        parent: Option<&P>,
        list: BufferList,
    ) -> Result<FlowSuccess, FlowError> {
        skip_assert_initialized!();
        let ret: FlowReturn = unsafe {
            from_glib(gst_sys::gst_proxy_pad_chain_list_default(
                pad.as_ptr() as *mut gst_sys::GstPad,
                parent.map(|p| p.as_ref()).to_glib_none().0,
                list.into_ptr(),
            ))
        };
        ret.into_result()
    }

    /// Invoke the default getrange function of the proxy pad.
    /// ## `pad`
    /// a src `Pad`, returns `FlowReturn::Error` if not.
    /// ## `parent`
    /// the parent of `pad`
    /// ## `offset`
    /// The start offset of the buffer
    /// ## `size`
    /// The length of the buffer
    /// ## `buffer`
    /// a pointer to hold the `Buffer`,
    ///  returns `FlowReturn::Error` if `None`.
    ///
    /// # Returns
    ///
    /// a `FlowReturn` from the pad.
    pub fn getrange_default<O: IsA<ProxyPad>, P: IsA<Object>>(
        pad: &O,
        parent: Option<&P>,
        offset: u64,
        size: u32,
    ) -> Result<Buffer, FlowError> {
        skip_assert_initialized!();
        unsafe {
            let mut buffer = ptr::null_mut();
            let ret: FlowReturn = from_glib(gst_sys::gst_proxy_pad_getrange_default(
                pad.as_ptr() as *mut gst_sys::GstPad,
                parent.map(|p| p.as_ref()).to_glib_none().0,
                offset,
                size,
                &mut buffer,
            ));
            ret.into_result_value(|| from_glib_full(buffer))
        }
    }

    /// Invoke the default iterate internal links function of the proxy pad.
    /// ## `pad`
    /// the `Pad` to get the internal links of.
    /// ## `parent`
    /// the parent of `pad` or `None`
    ///
    /// # Returns
    ///
    /// a `Iterator` of `Pad`, or `None` if `pad`
    /// has no parent. Unref each returned pad with `GstObjectExt::unref`.
    pub fn iterate_internal_links_default<O: IsA<ProxyPad>, P: IsA<Object>>(
        pad: &O,
        parent: Option<&P>,
    ) -> Option<::Iterator<Pad>> {
        skip_assert_initialized!();
        unsafe {
            from_glib_full(gst_sys::gst_proxy_pad_iterate_internal_links_default(
                pad.as_ptr() as *mut gst_sys::GstPad,
                parent.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }
}