mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-12-31 20:38:44 +00:00
Code Issues Projects Releases Wiki Activity

Change FormatValue related API to be more convenient to use

Browse source 
FormatValue is now renamed to GenericFormattedValue and the API slightly
changed. In addition there is now a FormattedValue trait, and a
SpecificFormattedValue trait plus types for Bytes, Buffers and the
existing ClockTime.

This allows to create functions like
  Pad::query_duration<F: SpecificFormattedValue>() -> Option<F>
and doesn't require the caller to unwrap the generic value anymore,
which is completely unneeded in these cases.

In addition, Segment became FormattedSegment<T> with API to
upcast/downcast between the specific formatted values and the generic
formatted value. This greatly simplifies usage of Segments.
This commit is contained in:
Sebastian Dröge 2017-12-09 18:20:21 +02:00
parent 520a9bb879
commit c99928d030
17 changed files with 1212 additions and 761 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
examples/src/bin/gtksink.rs
View file

@ -59,13 +59,9 @@ fn create_ui(app: &gtk::Application) {
let pipeline_clone = pipeline.clone();
gtk::timeout_add(500, move || {
let pipeline = &pipeline_clone;
let position = if let Some(gst::FormatValue::Time(position)) =
pipeline.query_position(gst::Format::Time)
{
position
} else {
0.into()
};
let position = pipeline
.query_position::<gst::ClockTime>()
.unwrap_or(0.into());
label.set_text(&format!("Position: {:.0}", position));
glib::Continue(true)

10
examples/src/bin/gtkvideooverlay.rs
View file

@ -129,13 +129,9 @@ fn create_ui(app: &gtk::Application) {
let pipeline_clone = pipeline.clone();
gtk::timeout_add(500, move || {
let pipeline = &pipeline_clone;
let position = if let Some(gst::FormatValue::Time(position)) =
pipeline.query_position(gst::Format::Time)
{
position
} else {
0.into()
};
let position = pipeline
.query_position::<gst::ClockTime>()
.unwrap_or(0.into());
label.set_text(&format!("Position: {:.0}", position));
glib::Continue(true)

4
examples/src/bin/queries.rs
View file

@ -41,7 +41,7 @@ fn example_main() {
} else {
None
}
}.and_then(|pos| pos.try_to_time())
}.and_then(|pos| pos.try_into_time().ok())
.unwrap();
let dur = {
@ -54,7 +54,7 @@ fn example_main() {
} else {
None
}
}.and_then(|dur| dur.try_to_time())
}.and_then(|dur| dur.try_into_time().ok())
.unwrap();
println!("{} / {}", pos, dur);

40
gstreamer-audio/src/audio_info.rs
View file

@ -11,7 +11,7 @@ use glib_ffi;
use gobject_ffi;
use gst;
use gst::miniobject::MiniObject;
use gst::prelude::*;
use glib;
use glib::translate::{from_glib, from_glib_full, from_glib_none, FromGlibPtrNone, ToGlib,
ToGlibPtr, ToGlibPtrMut};
@ -155,23 +155,47 @@ impl AudioInfo {
}
}
pub fn convert(
pub fn convert<V: Into<gst::GenericFormattedValue>, U: gst::SpecificFormattedValue>(
&self,
src_val: gst::FormatValue,
dest_fmt: gst::Format,
) -> Option<gst::FormatValue> {
src_val: V,
) -> Option<U> {
assert_initialized_main_thread!();
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
if from_glib(ffi::gst_audio_info_convert(
&self.0,
src_val.to_format().to_glib(),
src_val.to_value(),
src_val.get_format().to_glib(),
src_val.to_glib(),
U::get_default_format().to_glib(),
&mut dest_val,
)) {
Some(U::from_glib(U::get_default_format(), dest_val))
} else {
None
}
}
}
pub fn convert_generic<V: Into<gst::GenericFormattedValue>>(
&self,
src_val: V,
dest_fmt: gst::Format,
) -> Option<gst::GenericFormattedValue> {
assert_initialized_main_thread!();
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
if from_glib(ffi::gst_audio_info_convert(
&self.0,
src_val.get_format().to_glib(),
src_val.to_glib(),
dest_fmt.to_glib(),
&mut dest_val,
)) {
Some(gst::FormatValue::new(dest_fmt, dest_val))
Some(gst::GenericFormattedValue::new(dest_fmt, dest_val))
} else {
None
}

38
gstreamer-video/src/video_info.rs
View file

@ -11,7 +11,7 @@ use glib_ffi;
use gobject_ffi;
use gst;
use gst::miniobject::MiniObject;
use gst::prelude::*;
use glib;
use glib::translate::{from_glib, from_glib_full, from_glib_none, FromGlib, FromGlibPtrNone,
ToGlib, ToGlibPtr, ToGlibPtrMut};
@ -545,25 +545,47 @@ impl VideoInfo {
self.format_info().n_components()
}
pub fn convert<V: Into<gst::FormatValue>>(
pub fn convert<V: Into<gst::GenericFormattedValue>, U: gst::SpecificFormattedValue>(
&self,
src_val: V,
dest_fmt: gst::Format,
) -> Option<gst::FormatValue> {
) -> Option<U> {
skip_assert_initialized!();
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
if from_glib(ffi::gst_video_info_convert(
&self.0 as *const _ as *mut _,
src_val.to_format().to_glib(),
src_val.to_value(),
src_val.get_format().to_glib(),
src_val.to_glib(),
U::get_default_format().to_glib(),
&mut dest_val,
)) {
Some(U::from_glib(U::get_default_format(), dest_val))
} else {
None
}
}
}
pub fn convert_generic<V: Into<gst::GenericFormattedValue>>(
&self,
src_val: V,
dest_fmt: gst::Format,
) -> Option<gst::GenericFormattedValue> {
skip_assert_initialized!();
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
if from_glib(ffi::gst_video_info_convert(
&self.0 as *const _ as *mut _,
src_val.get_format().to_glib(),
src_val.to_glib(),
dest_fmt.to_glib(),
&mut dest_val,
)) {
Some(gst::FormatValue::new(dest_fmt, dest_val))
Some(gst::GenericFormattedValue::new(dest_fmt, dest_val))
} else {
None
}

227
gstreamer/src/clock_time.rs
View file

@ -6,12 +6,10 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::ops;
use ffi;
use glib;
use glib::translate::*;
use std::{cmp, fmt};
use muldiv::MulDiv;
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug, Default)]
pub struct ClockTime(pub Option<u64>);
@ -66,56 +64,6 @@ impl ClockTime {
}
}
impl From<u64> for ClockTime {
fn from(v: u64) -> ClockTime {
from_glib(v)
}
}
impl From<Option<u64>> for ClockTime {
fn from(v: Option<u64>) -> ClockTime {
ClockTime(v)
}
}
impl Into<u64> for ClockTime {
fn into(self) -> u64 {
self.to_glib()
}
}
impl Into<Option<u64>> for ClockTime {
fn into(self) -> Option<u64> {
self.0
}
}
impl ops::Deref for ClockTime {
type Target = Option<u64>;
fn deref(&self) -> &Option<u64> {
&self.0
}
}
impl ops::DerefMut for ClockTime {
fn deref_mut(&mut self) -> &mut Option<u64> {
&mut self.0
}
}
impl AsRef<Option<u64>> for ClockTime {
fn as_ref(&self) -> &Option<u64> {
&self.0
}
}
impl AsMut<Option<u64>> for ClockTime {
fn as_mut(&mut self) -> &mut Option<u64> {
&mut self.0
}
}
impl fmt::Display for ClockTime {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
let precision = f.precision().unwrap_or(9);
@ -156,108 +104,6 @@ impl fmt::Display for ClockTime {
}
}
macro_rules! impl_op_same(
($op:ident, $op_name:ident, $op_assign:ident, $op_assign_name:ident, $e:expr) => {
impl ops::$op<ClockTime> for ClockTime {
type Output = ClockTime;
fn $op_name(self, other: ClockTime) -> ClockTime {
match (self.0, other.0) {
(Some(a), Some(b)) => ClockTime(Some($e(a, b))),
_ => ClockTime(None),
}
}
}
impl<'a> ops::$op<&'a ClockTime> for ClockTime {
type Output = ClockTime;
fn $op_name(self, other: &'a ClockTime) -> ClockTime {
self.$op_name(*other)
}
}
impl ops::$op_assign<ClockTime> for ClockTime {
fn $op_assign_name(&mut self, other: ClockTime) {
match (self.0, other.0) {
(Some(a), Some(b)) => self.0 = Some($e(a, b)),
_ => self.0 = None,
}
}
}
impl<'a> ops::$op_assign<&'a ClockTime> for ClockTime {
fn $op_assign_name(&mut self, other: &'a ClockTime) {
self.$op_assign_name(*other)
}
}
};
);
impl_op_same!(Add, add, AddAssign, add_assign, |a, b| a + b);
impl_op_same!(Sub, sub, SubAssign, sub_assign, |a, b| a - b);
impl_op_same!(Mul, mul, MulAssign, mul_assign, |a, b| a * b);
impl_op_same!(Div, div, DivAssign, div_assign, |a, b| a / b);
impl_op_same!(Rem, rem, RemAssign, rem_assign, |a, b| a % b);
macro_rules! impl_op_u64(
($op:ident, $op_name:ident, $op_assign:ident, $op_assign_name:ident, $e:expr) => {
impl ops::$op<u64> for ClockTime {
type Output = ClockTime;
fn $op_name(self, other: u64) -> ClockTime {
match self.0 {
Some(a) => ClockTime(Some($e(a, other))),
_ => ClockTime(None),
}
}
}
impl<'a> ops::$op<&'a u64> for ClockTime {
type Output = ClockTime;
fn $op_name(self, other: &'a u64) -> ClockTime {
self.$op_name(*other)
}
}
impl ops::$op_assign<u64> for ClockTime {
fn $op_assign_name(&mut self, other: u64) {
match self.0 {
Some(a) => self.0 = Some($e(a, other)),
_ => self.0 = None,
}
}
}
impl<'a> ops::$op_assign<&'a u64> for ClockTime {
fn $op_assign_name(&mut self, other: &'a u64) {
self.$op_assign_name(*other)
}
}
};
);
impl_op_u64!(Mul, mul, MulAssign, mul_assign, |a, b| a * b);
impl_op_u64!(Div, div, DivAssign, div_assign, |a, b| a / b);
impl_op_u64!(Rem, rem, RemAssign, rem_assign, |a, b| a % b);
impl ops::Mul<ClockTime> for u64 {
type Output = ClockTime;
fn mul(self, other: ClockTime) -> ClockTime {
other.mul(self)
}
}
impl<'a> ops::Mul<&'a ClockTime> for u64 {
type Output = ClockTime;
fn mul(self, other: &'a ClockTime) -> ClockTime {
other.mul(self)
}
}
#[doc(hidden)]
impl ToGlib for ClockTime {
type GlibType = ffi::GstClockTime;
@ -309,76 +155,3 @@ impl glib::StaticType for ClockTime {
<u64 as glib::StaticType>::static_type()
}
}
impl MulDiv<ClockTime> for ClockTime {
type Output = ClockTime;
fn mul_div_floor(self, num: ClockTime, denom: ClockTime) -> Option<Self::Output> {
match (self.0, num.0, denom.0) {
(Some(s), Some(n), Some(d)) => s.mul_div_floor(n, d).map(ClockTime::from_nseconds),
_ => Some(ClockTime(None)),
}
}
fn mul_div_round(self, num: ClockTime, denom: ClockTime) -> Option<Self::Output> {
match (self.0, num.0, denom.0) {
(Some(s), Some(n), Some(d)) => s.mul_div_round(n, d).map(ClockTime::from_nseconds),
_ => Some(ClockTime(None)),
}
}
fn mul_div_ceil(self, num: ClockTime, denom: ClockTime) -> Option<Self::Output> {
match (self.0, num.0, denom.0) {
(Some(s), Some(n), Some(d)) => s.mul_div_ceil(n, d).map(ClockTime::from_nseconds),
_ => Some(ClockTime(None)),
}
}
}
impl<'a> MulDiv<&'a ClockTime> for ClockTime {
type Output = ClockTime;
fn mul_div_floor(self, num: &ClockTime, denom: &ClockTime) -> Option<Self::Output> {
self.mul_div_floor(*num, *denom)
}
fn mul_div_round(self, num: &ClockTime, denom: &ClockTime) -> Option<Self::Output> {
self.mul_div_round(*num, *denom)
}
fn mul_div_ceil(self, num: &ClockTime, denom: &ClockTime) -> Option<Self::Output> {
self.mul_div_ceil(*num, *denom)
}
}
impl<'a> MulDiv<u64> for ClockTime {
type Output = ClockTime;
fn mul_div_floor(self, num: u64, denom: u64) -> Option<Self::Output> {
self.mul_div_floor(ClockTime::from(num), ClockTime::from(denom))
}
fn mul_div_round(self, num: u64, denom: u64) -> Option<Self::Output> {
self.mul_div_round(ClockTime::from(num), ClockTime::from(denom))
}
fn mul_div_ceil(self, num: u64, denom: u64) -> Option<Self::Output> {
self.mul_div_ceil(ClockTime::from(num), ClockTime::from(denom))
}
}
impl<'a> MulDiv<&'a u64> for ClockTime {
type Output = ClockTime;
fn mul_div_floor(self, num: &u64, denom: &u64) -> Option<Self::Output> {
self.mul_div_floor(*num, *denom)
}
fn mul_div_round(self, num: &u64, denom: &u64) -> Option<Self::Output> {
self.mul_div_round(*num, *denom)
}
fn mul_div_ceil(self, num: &u64, denom: &u64) -> Option<Self::Output> {
self.mul_div_ceil(*num, *denom)
}
}

118
gstreamer/src/element.rs
View file

@ -16,6 +16,10 @@ use QueryRef;
use Event;
use Pad;
use PadTemplate;
use Format;
use GenericFormattedValue;
use FormattedValue;
use SpecificFormattedValue;
use miniobject::MiniObject;
use std::ffi::CStr;
@ -137,15 +141,23 @@ pub trait ElementExtManual {
#[cfg(any(feature = "v1_10", feature = "dox"))]
fn remove_property_notify_watch(&self, watch_id: NotifyWatchId);
fn query_convert<V: Into<::FormatValue>>(
fn query_convert<V: Into<GenericFormattedValue>, U: SpecificFormattedValue>(
&self,
src_val: V,
dest_format: ::Format,
) -> Option<::FormatValue>;
fn query_duration(&self, format: ::Format) -> Option<::FormatValue>;
fn query_position(&self, format: ::Format) -> Option<::FormatValue>;
) -> Option<U>;
fn query_convert_generic<V: Into<GenericFormattedValue>>(
&self,
src_val: V,
dest_format: Format,
) -> Option<GenericFormattedValue>;
fn seek<V: Into<::FormatValue>>(
fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T>;
fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue>;
fn query_position<T: SpecificFormattedValue>(&self) -> Option<T>;
fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue>;
fn seek<V: Into<GenericFormattedValue>>(
&self,
rate: f64,
flags: ::SeekFlags,
@ -154,7 +166,7 @@ pub trait ElementExtManual {
stop_type: ::SeekType,
stop: V,
) -> Result<(), glib::error::BoolError>;
fn seek_simple<V: Into<::FormatValue>>(
fn seek_simple<V: Into<GenericFormattedValue>>(
&self,
seek_flags: ::SeekFlags,
seek_pos: V,
@ -363,30 +375,68 @@ impl<O: IsA<Element>> ElementExtManual for O {
}
}
fn query_convert<V: Into<::FormatValue>>(
fn query_convert<V: Into<GenericFormattedValue>, U: SpecificFormattedValue>(
&self,
src_val: V,
dest_format: ::Format,
) -> Option<::FormatValue> {
) -> Option<U> {
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
let ret = from_glib(ffi::gst_element_query_convert(
self.to_glib_none().0,
src_val.to_format().to_glib(),
src_val.to_value(),
dest_format.to_glib(),
src_val.get_format().to_glib(),
src_val.to_glib(),
U::get_default_format().to_glib(),
&mut dest_val,
));
if ret {
Some(::FormatValue::new(dest_format, dest_val))
Some(U::from_glib(U::get_default_format(), dest_val))
} else {
None
}
}
}
fn query_duration(&self, format: ::Format) -> Option<::FormatValue> {
fn query_convert_generic<V: Into<GenericFormattedValue>>(
&self,
src_val: V,
dest_format: Format,
) -> Option<GenericFormattedValue> {
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
let ret = from_glib(ffi::gst_element_query_convert(
self.to_glib_none().0,
src_val.get_format().to_glib(),
src_val.get_value(),
dest_format.to_glib(),
&mut dest_val,
));
if ret {
Some(GenericFormattedValue::new(dest_format, dest_val))
} else {
None
}
}
}
fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe {
let mut duration = mem::uninitialized();
let ret = from_glib(ffi::gst_element_query_duration(
self.to_glib_none().0,
T::get_default_format().to_glib(),
&mut duration,
));
if ret {
Some(T::from_glib(T::get_default_format(), duration))
} else {
None
}
}
}
fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe {
let mut duration = mem::uninitialized();
let ret = from_glib(ffi::gst_element_query_duration(
@ -395,14 +445,30 @@ impl<O: IsA<Element>> ElementExtManual for O {
&mut duration,
));
if ret {
Some(::FormatValue::new(format, duration))
Some(GenericFormattedValue::new(format, duration))
} else {
None
}
}
}
fn query_position(&self, format: ::Format) -> Option<::FormatValue> {
fn query_position<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe {
let mut cur = mem::uninitialized();
let ret = from_glib(ffi::gst_element_query_position(
self.to_glib_none().0,
T::get_default_format().to_glib(),
&mut cur,
));
if ret {
Some(T::from_glib(T::get_default_format(), cur))
} else {
None
}
}
}
fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe {
let mut cur = mem::uninitialized();
let ret = from_glib(ffi::gst_element_query_position(
@ -411,14 +477,14 @@ impl<O: IsA<Element>> ElementExtManual for O {
&mut cur,
));
if ret {
Some(::FormatValue::new(format, cur))
Some(GenericFormattedValue::new(format, cur))
} else {
None
}
}
}
fn seek<V: Into<::FormatValue>>(
fn seek<V: Into<GenericFormattedValue>>(
&self,
rate: f64,
flags: ::SeekFlags,
@ -430,26 +496,26 @@ impl<O: IsA<Element>> ElementExtManual for O {
let start = start.into();
let stop = stop.into();
assert_eq!(stop.to_format(), start.to_format());
assert_eq!(stop.get_format(), start.get_format());
unsafe {
glib::error::BoolError::from_glib(
ffi::gst_element_seek(
self.to_glib_none().0,
rate,
start.to_format().to_glib(),
start.get_format().to_glib(),
flags.to_glib(),
start_type.to_glib(),
start.to_value(),
start.get_value(),
stop_type.to_glib(),
stop.to_value(),
stop.get_value(),
),
"Failed to seek",
)
}
}
fn seek_simple<V: Into<::FormatValue>>(
fn seek_simple<V: Into<GenericFormattedValue>>(
&self,
seek_flags: ::SeekFlags,
seek_pos: V,
@ -459,9 +525,9 @@ impl<O: IsA<Element>> ElementExtManual for O {
glib::error::BoolError::from_glib(
ffi::gst_element_seek_simple(
self.to_glib_none().0,
seek_pos.to_format().to_glib(),
seek_pos.get_format().to_glib(),
seek_flags.to_glib(),
seek_pos.to_value(),
seek_pos.get_value(),
),
"Failed to seek",
)

81
gstreamer/src/event.rs
View file

@ -9,6 +9,7 @@
use ffi;
use miniobject::*;
use structure::*;
use GenericFormattedValue;
use std::ptr;
use std::mem;
@ -264,9 +265,9 @@ impl GstRc<EventRef> {
CapsBuilder::new(caps)
}
pub fn new_segment(segment: &::Segment) -> SegmentBuilder {
pub fn new_segment<F: ::FormattedValue>(segment: &::FormattedSegment<F>) -> SegmentBuilder {
assert_initialized_main_thread!();
SegmentBuilder::new(segment)
SegmentBuilder::new(segment.as_ref())
}
#[cfg(any(feature = "v1_10", feature = "dox"))]
@ -282,7 +283,7 @@ impl GstRc<EventRef> {
TagBuilder::new(tags)
}
pub fn new_buffer_size<'a, V: Into<::FormatValue>>(
pub fn new_buffer_size<'a, V: Into<GenericFormattedValue>>(
minsize: V,
maxsize: V,
async: bool,
@ -290,7 +291,7 @@ impl GstRc<EventRef> {
assert_initialized_main_thread!();
let minsize = minsize.into();
let maxsize = maxsize.into();
assert_eq!(minsize.to_format(), maxsize.to_format());
assert_eq!(minsize.get_format(), maxsize.get_format());
BufferSizeBuilder::new(minsize, maxsize, async)
}
@ -325,7 +326,9 @@ impl GstRc<EventRef> {
ProtectionBuilder::new(system_id, data, origin)
}
pub fn new_segment_done<'a, V: Into<::FormatValue>>(position: V) -> SegmentDoneBuilder<'a> {
pub fn new_segment_done<'a, V: Into<GenericFormattedValue>>(
position: V,
) -> SegmentDoneBuilder<'a> {
assert_initialized_main_thread!();
let position = position.into();
SegmentDoneBuilder::new(position)
@ -346,7 +349,7 @@ impl GstRc<EventRef> {
QosBuilder::new(type_, proportion, diff, timestamp)
}
pub fn new_seek<'a, V: Into<::FormatValue>>(
pub fn new_seek<'a, V: Into<GenericFormattedValue>>(
rate: f64,
flags: ::SeekFlags,
start_type: ::SeekType,
@ -357,7 +360,7 @@ impl GstRc<EventRef> {
assert_initialized_main_thread!();
let start = start.into();
let stop = stop.into();
assert_eq!(start.to_format(), stop.to_format());
assert_eq!(start.get_format(), stop.get_format());
SeekBuilder::new(rate, flags, start_type, start, stop_type, stop)
}
@ -372,7 +375,7 @@ impl GstRc<EventRef> {
LatencyBuilder::new(latency)
}
pub fn new_step<'a, V: Into<::FormatValue>>(
pub fn new_step<'a, V: Into<GenericFormattedValue>>(
amount: V,
rate: f64,
flush: bool,
@ -597,7 +600,7 @@ impl<'a> Tag<'a> {
pub struct BufferSize<'a>(&'a EventRef);
impl<'a> BufferSize<'a> {
pub fn get(&self) -> (::FormatValue, ::FormatValue, bool) {
pub fn get(&self) -> (GenericFormattedValue, GenericFormattedValue, bool) {
unsafe {
let mut fmt = mem::uninitialized();
let mut minsize = mem::uninitialized();
@ -612,8 +615,8 @@ impl<'a> BufferSize<'a> {
&mut async,
);
(
::FormatValue::new(from_glib(fmt), minsize),
::FormatValue::new(from_glib(fmt), maxsize),
GenericFormattedValue::new(from_glib(fmt), minsize),
GenericFormattedValue::new(from_glib(fmt), maxsize),
from_glib(async),
)
}
@ -687,14 +690,14 @@ impl<'a> Protection<'a> {
pub struct SegmentDone<'a>(&'a EventRef);
impl<'a> SegmentDone<'a> {
pub fn get(&self) -> ::FormatValue {
pub fn get(&self) -> GenericFormattedValue {
unsafe {
let mut fmt = mem::uninitialized();
let mut position = mem::uninitialized();
ffi::gst_event_parse_segment_done(self.0.as_mut_ptr(), &mut fmt, &mut position);
::FormatValue::new(from_glib(fmt), position)
GenericFormattedValue::new(from_glib(fmt), position)
}
}
}
@ -744,9 +747,9 @@ impl<'a> Seek<'a> {
f64,
::SeekFlags,
::SeekType,
::FormatValue,
GenericFormattedValue,
::SeekType,
::FormatValue,
GenericFormattedValue,
) {
unsafe {
let mut rate = mem::uninitialized();
@ -772,9 +775,9 @@ impl<'a> Seek<'a> {
rate,
from_glib(flags),
from_glib(start_type),
::FormatValue::new(from_glib(fmt), start),
GenericFormattedValue::new(from_glib(fmt), start),
from_glib(stop_type),
::FormatValue::new(from_glib(fmt), stop),
GenericFormattedValue::new(from_glib(fmt), stop),
)
}
}
@ -797,7 +800,7 @@ impl<'a> Latency<'a> {
pub struct Step<'a>(&'a EventRef);
impl<'a> Step<'a> {
pub fn get(&self) -> (::FormatValue, f64, bool, bool) {
pub fn get(&self) -> (GenericFormattedValue, f64, bool, bool) {
unsafe {
let mut fmt = mem::uninitialized();
let mut amount = mem::uninitialized();
@ -815,7 +818,7 @@ impl<'a> Step<'a> {
);
(
::FormatValue::new(from_glib(fmt), amount as i64),
GenericFormattedValue::new(from_glib(fmt), amount as i64),
rate,
from_glib(flush),
from_glib(intermediate),
@ -1093,12 +1096,12 @@ pub struct BufferSizeBuilder<'a> {
seqnum: Option<Seqnum>,
running_time_offset: Option<i64>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
minsize: ::FormatValue,
maxsize: ::FormatValue,
minsize: GenericFormattedValue,
maxsize: GenericFormattedValue,
async: bool,
}
impl<'a> BufferSizeBuilder<'a> {
fn new(minsize: ::FormatValue, maxsize: ::FormatValue, async: bool) -> Self {
fn new(minsize: GenericFormattedValue, maxsize: GenericFormattedValue, async: bool) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
@ -1112,9 +1115,9 @@ impl<'a> BufferSizeBuilder<'a> {
event_builder_generic_impl!(|s: &Self| {
ffi::gst_event_new_buffer_size(
s.minsize.to_format().to_glib(),
s.minsize.to_value(),
s.maxsize.to_value(),
s.minsize.get_format().to_glib(),
s.minsize.get_value(),
s.maxsize.get_value(),
s.async.to_glib(),
)
});
@ -1244,10 +1247,10 @@ pub struct SegmentDoneBuilder<'a> {
seqnum: Option<Seqnum>,
running_time_offset: Option<i64>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
position: ::FormatValue,
position: GenericFormattedValue,
}
impl<'a> SegmentDoneBuilder<'a> {
fn new(position: ::FormatValue) -> Self {
fn new(position: GenericFormattedValue) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
@ -1258,7 +1261,7 @@ impl<'a> SegmentDoneBuilder<'a> {
}
event_builder_generic_impl!(|s: &Self| {
ffi::gst_event_new_segment_done(s.position.to_format().to_glib(), s.position.to_value())
ffi::gst_event_new_segment_done(s.position.get_format().to_glib(), s.position.get_value())
});
}
@ -1326,18 +1329,18 @@ pub struct SeekBuilder<'a> {
rate: f64,
flags: ::SeekFlags,
start_type: ::SeekType,
start: ::FormatValue,
start: GenericFormattedValue,
stop_type: ::SeekType,
stop: ::FormatValue,
stop: GenericFormattedValue,
}
impl<'a> SeekBuilder<'a> {
fn new(
rate: f64,
flags: ::SeekFlags,
start_type: ::SeekType,
start: ::FormatValue,
start: GenericFormattedValue,
stop_type: ::SeekType,
stop: ::FormatValue,
stop: GenericFormattedValue,
) -> Self {
skip_assert_initialized!();
Self {
@ -1356,12 +1359,12 @@ impl<'a> SeekBuilder<'a> {
event_builder_generic_impl!(|s: &Self| {
ffi::gst_event_new_seek(
s.rate,
s.start.to_format().to_glib(),
s.start.get_format().to_glib(),
s.flags.to_glib(),
s.start_type.to_glib(),
s.start.to_value(),
s.start.get_value(),
s.stop_type.to_glib(),
s.stop.to_value(),
s.stop.get_value(),
)
});
}
@ -1416,13 +1419,13 @@ pub struct StepBuilder<'a> {
seqnum: Option<Seqnum>,
running_time_offset: Option<i64>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
amount: ::FormatValue,
amount: GenericFormattedValue,
rate: f64,
flush: bool,
intermediate: bool,
}
impl<'a> StepBuilder<'a> {
fn new(amount: ::FormatValue, rate: f64, flush: bool, intermediate: bool) -> Self {
fn new(amount: GenericFormattedValue, rate: f64, flush: bool, intermediate: bool) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
@ -1437,8 +1440,8 @@ impl<'a> StepBuilder<'a> {
event_builder_generic_impl!(|s: &Self| {
ffi::gst_event_new_step(
s.amount.to_format().to_glib(),
s.amount.to_value() as u64,
s.amount.get_format().to_glib(),
s.amount.get_value() as u64,
s.rate,
s.flush.to_glib(),
s.intermediate.to_glib(),

473
gstreamer/src/format.rs
View file

@ -8,162 +8,477 @@
use ClockTime;
use Format;
use std::ops;
use muldiv::MulDiv;
#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
pub enum FormatValue {
pub enum GenericFormattedValue {
Undefined(i64),
Default(Option<u64>),
Bytes(Option<u64>),
Default(Default),
Bytes(Bytes),
Time(ClockTime),
Buffers(Option<u64>),
Buffers(Buffers),
Percent(Option<u32>),
Other(Format, i64),
}
impl FormatValue {
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug, Default)]
pub struct Default(pub Option<u64>);
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug, Default)]
pub struct Bytes(pub Option<u64>);
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug, Default)]
pub struct Buffers(pub Option<u64>);
pub type Time = ClockTime;
pub trait FormattedValue: Copy + Clone + Sized + 'static {
fn get_default_format() -> Format;
fn try_from(v: GenericFormattedValue) -> Option<Self>;
fn get_format(&self) -> Format;
unsafe fn from_glib(format: Format, value: i64) -> Self;
unsafe fn to_glib(&self) -> i64;
}
pub trait SpecificFormattedValue: FormattedValue {}
impl FormattedValue for GenericFormattedValue {
fn get_default_format() -> Format {
Format::Undefined
}
fn try_from(v: GenericFormattedValue) -> Option<Self> {
Some(v)
}
fn get_format(&self) -> Format {
self.get_format()
}
unsafe fn from_glib(format: Format, value: i64) -> Self {
GenericFormattedValue::new(format, value)
}
unsafe fn to_glib(&self) -> i64 {
self.get_value()
}
}
impl GenericFormattedValue {
pub fn new(format: Format, value: i64) -> Self {
match format {
Format::Undefined => FormatValue::Undefined(value),
Format::Default => FormatValue::Default(if value == -1 {
None
Format::Undefined => GenericFormattedValue::Undefined(value),
Format::Default => GenericFormattedValue::Default(if value == -1 {
Default(None)
} else {
Some(value as u64)
Default(Some(value as u64))
}),
Format::Bytes => FormatValue::Bytes(if value == -1 {
None
Format::Bytes => GenericFormattedValue::Bytes(if value == -1 {
Bytes(None)
} else {
Some(value as u64)
Bytes(Some(value as u64))
}),
Format::Time => FormatValue::Time(if value == -1 {
Format::Time => GenericFormattedValue::Time(if value == -1 {
ClockTime::none()
} else {
ClockTime::from(value as u64)
ClockTime::from_nseconds(value as u64)
}),
Format::Buffers => FormatValue::Buffers(if value == -1 {
None
Format::Buffers => GenericFormattedValue::Buffers(if value == -1 {
Buffers(None)
} else {
Some(value as u64)
Buffers(Some(value as u64))
}),
Format::Percent => FormatValue::Percent(if value == -1 {
Format::Percent => GenericFormattedValue::Percent(if value == -1 {
None
} else {
Some(value as u32)
}),
Format::__Unknown(_) => FormatValue::Other(format, value),
Format::__Unknown(_) => GenericFormattedValue::Other(format, value),
}
}
pub fn from_undefined(v: i64) -> Self {
FormatValue::Undefined(v)
GenericFormattedValue::Undefined(v)
}
pub fn from_default<V: Into<Option<u64>>>(v: V) -> Self {
FormatValue::Default(v.into())
pub fn from_default<V: Into<Default>>(v: V) -> Self {
GenericFormattedValue::Default(v.into())
}
pub fn from_bytes<V: Into<Option<u64>>>(v: V) -> Self {
FormatValue::Bytes(v.into())
pub fn from_bytes<V: Into<Bytes>>(v: V) -> Self {
GenericFormattedValue::Bytes(v.into())
}
pub fn from_time(v: ClockTime) -> Self {
FormatValue::Time(v)
pub fn from_time<V: Into<ClockTime>>(v: V) -> Self {
GenericFormattedValue::Time(v.into())
}
pub fn from_buffers<V: Into<Option<u64>>>(v: V) -> Self {
FormatValue::Buffers(v.into())
pub fn from_buffers<V: Into<Buffers>>(v: V) -> Self {
GenericFormattedValue::Buffers(v.into())
}
pub fn from_percent<V: Into<Option<u32>>>(v: V) -> Self {
FormatValue::Percent(v.into())
GenericFormattedValue::Percent(v.into())
}
pub fn from_other(format: Format, v: i64) -> Self {
FormatValue::Other(format, v)
GenericFormattedValue::Other(format, v)
}
pub fn to_format(&self) -> Format {
pub fn get_format(&self) -> Format {
match *self {
FormatValue::Undefined(_) => Format::Undefined,
FormatValue::Default(_) => Format::Default,
FormatValue::Bytes(_) => Format::Bytes,
FormatValue::Time(_) => Format::Time,
FormatValue::Buffers(_) => Format::Buffers,
FormatValue::Percent(_) => Format::Percent,
FormatValue::Other(f, _) => f,
GenericFormattedValue::Undefined(_) => Format::Undefined,
GenericFormattedValue::Default(_) => Format::Default,
GenericFormattedValue::Bytes(_) => Format::Bytes,
GenericFormattedValue::Time(_) => Format::Time,
GenericFormattedValue::Buffers(_) => Format::Buffers,
GenericFormattedValue::Percent(_) => Format::Percent,
GenericFormattedValue::Other(f, _) => f,
}
}
pub fn to_value(&self) -> i64 {
pub fn get_value(&self) -> i64 {
match *self {
FormatValue::Undefined(v) => v,
FormatValue::Default(v) => v.map(|v| v as i64).unwrap_or(-1),
FormatValue::Bytes(v) => v.map(|v| v as i64).unwrap_or(-1),
FormatValue::Time(v) => v.map(|v| v as i64).unwrap_or(-1),
FormatValue::Buffers(v) => v.map(|v| v as i64).unwrap_or(-1),
FormatValue::Percent(v) => v.map(|v| v as i64).unwrap_or(-1),
FormatValue::Other(_, v) => v,
GenericFormattedValue::Undefined(v) => v,
GenericFormattedValue::Default(v) => v.map(|v| v as i64).unwrap_or(-1),
GenericFormattedValue::Bytes(v) => v.map(|v| v as i64).unwrap_or(-1),
GenericFormattedValue::Time(v) => v.map(|v| v as i64).unwrap_or(-1),
GenericFormattedValue::Buffers(v) => v.map(|v| v as i64).unwrap_or(-1),
GenericFormattedValue::Percent(v) => v.map(|v| v as i64).unwrap_or(-1),
GenericFormattedValue::Other(_, v) => v,
}
}
pub fn try_to_undefined(&self) -> Option<i64> {
if let FormatValue::Undefined(v) = *self {
Some(v)
pub fn try_into<F: FormattedValue>(self) -> Result<F, Self> {
if F::get_default_format() == self.get_format()
|| F::get_default_format() == Format::Undefined
{
Ok(unsafe { F::from_glib(self.get_format(), self.to_glib()) })
} else {
None
Err(self)
}
}
pub fn try_to_default(&self) -> Option<Option<u64>> {
if let FormatValue::Default(v) = *self {
Some(v)
pub fn try_into_undefined(self) -> Result<i64, Self> {
if let GenericFormattedValue::Undefined(v) = self {
Ok(v)
} else {
None
Err(self)
}
}
pub fn try_to_bytes(&self) -> Option<Option<u64>> {
if let FormatValue::Bytes(v) = *self {
Some(v)
pub fn try_into_default(self) -> Result<Default, Self> {
if let GenericFormattedValue::Default(v) = self {
Ok(v)
} else {
None
Err(self)
}
}
pub fn try_to_time(&self) -> Option<ClockTime> {
if let FormatValue::Time(v) = *self {
Some(v)
pub fn try_into_bytes(self) -> Result<Bytes, Self> {
if let GenericFormattedValue::Bytes(v) = self {
Ok(v)
} else {
None
Err(self)
}
}
pub fn try_to_buffers(&self) -> Option<Option<u64>> {
if let FormatValue::Buffers(v) = *self {
Some(v)
pub fn try_into_time(self) -> Result<ClockTime, Self> {
if let GenericFormattedValue::Time(v) = self {
Ok(v)
} else {
None
Err(self)
}
}
pub fn try_to_percent(&self) -> Option<Option<u32>> {
if let FormatValue::Percent(v) = *self {
Some(v)
pub fn try_into_buffers(self) -> Result<Buffers, Self> {
if let GenericFormattedValue::Buffers(v) = self {
Ok(v)
} else {
None
Err(self)
}
}
pub fn try_to_other(&self) -> Option<(Format, i64)> {
if let FormatValue::Other(f, v) = *self {
Some((f, v))
pub fn try_into_percent(self) -> Result<Option<u32>, Self> {
if let GenericFormattedValue::Percent(v) = self {
Ok(v)
} else {
None
Err(self)
}
}
pub fn try_into_other(self) -> Result<(Format, i64), Self> {
if let GenericFormattedValue::Other(f, v) = self {
Ok((f, v))
} else {
Err(self)
}
}
}
impl From<ClockTime> for FormatValue {
fn from(v: ClockTime) -> FormatValue {
FormatValue::Time(v)
}
}
macro_rules! impl_op_same(
($name:ident, $op:ident, $op_name:ident, $op_assign:ident, $op_assign_name:ident, $e:expr) => {
impl ops::$op<$name> for $name {
type Output = $name;
fn $op_name(self, other: $name) -> $name {
match (self.0, other.0) {
(Some(a), Some(b)) => $name(Some($e(a, b))),
_ => $name(None),
}
}
}
impl<'a> ops::$op<&'a $name> for $name {
type Output = $name;
fn $op_name(self, other: &'a $name) -> $name {
self.$op_name(*other)
}
}
impl ops::$op_assign<$name> for $name {
fn $op_assign_name(&mut self, other: $name) {
match (self.0, other.0) {
(Some(a), Some(b)) => self.0 = Some($e(a, b)),
_ => self.0 = None,
}
}
}
impl<'a> ops::$op_assign<&'a $name> for $name {
fn $op_assign_name(&mut self, other: &'a $name) {
self.$op_assign_name(*other)
}
}
};
);
macro_rules! impl_op_u64(
($name:ident, $op:ident, $op_name:ident, $op_assign:ident, $op_assign_name:ident, $e:expr) => {
impl ops::$op<u64> for $name {
type Output = $name;
fn $op_name(self, other: u64) -> $name {
match self.0 {
Some(a) => $name(Some($e(a, other))),
_ => $name(None),
}
}
}
impl<'a> ops::$op<&'a u64> for $name {
type Output = $name;
fn $op_name(self, other: &'a u64) -> $name {
self.$op_name(*other)
}
}
impl ops::$op_assign<u64> for $name {
fn $op_assign_name(&mut self, other: u64) {
match self.0 {
Some(a) => self.0 = Some($e(a, other)),
_ => self.0 = None,
}
}
}
impl<'a> ops::$op_assign<&'a u64> for $name {
fn $op_assign_name(&mut self, other: &'a u64) {
self.$op_assign_name(*other)
}
}
};
);
macro_rules! impl_format_value_traits(
($name:ident, $format:ident, $format_value:ident) => {
impl From<$name> for GenericFormattedValue {
fn from(v: $name) -> GenericFormattedValue {
GenericFormattedValue::$format_value(v)
}
}
impl FormattedValue for $name {
fn get_default_format() -> Format {
Format::$format
}
fn try_from(v: GenericFormattedValue) -> Option<Self> {
if let GenericFormattedValue::$format_value(v) = v {
Some(v)
} else {
None
}
}
fn get_format(&self) -> Format {
Format::$format
}
unsafe fn from_glib(format: Format, value: i64) -> Self {
debug_assert_eq!(format, Format::$format);
if value == -1 {
$name(None)
} else {
$name(Some(value as u64))
}
}
unsafe fn to_glib(&self) -> i64 {
self.0.map(|v| v as i64).unwrap_or(-1)
}
}
impl SpecificFormattedValue for $name { }
impl From<u64> for $name {
fn from(v: u64) -> $name {
$name(Some(v))
}
}
impl From<Option<u64>> for $name {
fn from(v: Option<u64>) -> $name {
$name(v)
}
}
impl Into<Option<u64>> for $name {
fn into(self) -> Option<u64> {
self.0
}
}
impl ops::Deref for $name {
type Target = Option<u64>;
fn deref(&self) -> &Option<u64> {
&self.0
}
}
impl ops::DerefMut for $name {
fn deref_mut(&mut self) -> &mut Option<u64> {
&mut self.0
}
}
impl AsRef<Option<u64>> for $name {
fn as_ref(&self) -> &Option<u64> {
&self.0
}
}
impl AsMut<Option<u64>> for $name {
fn as_mut(&mut self) -> &mut Option<u64> {
&mut self.0
}
}
impl_op_same!($name, Add, add, AddAssign, add_assign, |a, b| a + b);
impl_op_same!($name, Sub, sub, SubAssign, sub_assign, |a, b| a - b);
impl_op_same!($name, Mul, mul, MulAssign, mul_assign, |a, b| a * b);
impl_op_same!($name, Div, div, DivAssign, div_assign, |a, b| a / b);
impl_op_same!($name, Rem, rem, RemAssign, rem_assign, |a, b| a % b);
impl_op_u64!($name, Mul, mul, MulAssign, mul_assign, |a, b| a * b);
impl_op_u64!($name, Div, div, DivAssign, div_assign, |a, b| a / b);
impl_op_u64!($name, Rem, rem, RemAssign, rem_assign, |a, b| a % b);
impl ops::Mul<$name> for u64 {
type Output = $name;
fn mul(self, other: $name) -> $name {
other.mul(self)
}
}
impl<'a> ops::Mul<&'a $name> for u64 {
type Output = $name;
fn mul(self, other: &'a $name) -> $name {
other.mul(self)
}
}
impl MulDiv<$name> for $name {
type Output = $name;
fn mul_div_floor(self, num: $name, denom: $name) -> Option<Self::Output> {
match (self.0, num.0, denom.0) {
(Some(s), Some(n), Some(d)) => s.mul_div_floor(n, d).map(|v| $name(Some(v))),
_ => Some($name(None)),
}
}
fn mul_div_round(self, num: $name, denom: $name) -> Option<Self::Output> {
match (self.0, num.0, denom.0) {
(Some(s), Some(n), Some(d)) => s.mul_div_round(n, d).map(|v| $name(Some(v))),
_ => Some($name(None)),
}
}
fn mul_div_ceil(self, num: $name, denom: $name) -> Option<Self::Output> {
match (self.0, num.0, denom.0) {
(Some(s), Some(n), Some(d)) => s.mul_div_ceil(n, d).map(|v| $name(Some(v))),
_ => Some($name(None)),
}
}
}
impl<'a> MulDiv<&'a $name> for $name {
type Output = $name;
fn mul_div_floor(self, num: &$name, denom: &$name) -> Option<Self::Output> {
self.mul_div_floor(*num, *denom)
}
fn mul_div_round(self, num: &$name, denom: &$name) -> Option<Self::Output> {
self.mul_div_round(*num, *denom)
}
fn mul_div_ceil(self, num: &$name, denom: &$name) -> Option<Self::Output> {
self.mul_div_ceil(*num, *denom)
}
}
impl<'a> MulDiv<u64> for $name {
type Output = $name;
fn mul_div_floor(self, num: u64, denom: u64) -> Option<Self::Output> {
self.mul_div_floor($name(Some(num)), $name(Some(denom)))
}
fn mul_div_round(self, num: u64, denom: u64) -> Option<Self::Output> {
self.mul_div_round($name(Some(num)), $name(Some(denom)))
}
fn mul_div_ceil(self, num: u64, denom: u64) -> Option<Self::Output> {
self.mul_div_ceil($name(Some(num)), $name(Some(denom)))
}
}
impl<'a> MulDiv<&'a u64> for $name {
type Output = $name;
fn mul_div_floor(self, num: &u64, denom: &u64) -> Option<Self::Output> {
self.mul_div_floor(*num, *denom)
}
fn mul_div_round(self, num: &u64, denom: &u64) -> Option<Self::Output> {
self.mul_div_round(*num, *denom)
}
fn mul_div_ceil(self, num: &u64, denom: &u64) -> Option<Self::Output> {
self.mul_div_ceil(*num, *denom)
}
}
};
);
impl_format_value_traits!(Default, Default, Default);
impl_format_value_traits!(Bytes, Bytes, Bytes);
impl_format_value_traits!(ClockTime, Time, Time);
impl_format_value_traits!(Buffers, Buffers, Buffers);

7
gstreamer/src/lib.rs
View file

@ -105,7 +105,6 @@ mod device_provider;
mod parse_context;
mod enums;
mod clock_time;
mod format;
mod date_time;
pub use object::GstObjectExtManual;
pub use element::{ElementExtManual, ElementMessageType, NotifyWatchId};
@ -124,7 +123,9 @@ pub use bus::BusStream;
pub use enums::{ClockError, ClockSuccess, FlowError, FlowSuccess, PadLinkError, PadLinkSuccess,
StateChangeError, StateChangeSuccess};
pub use clock_time::ClockTime;
pub use format::FormatValue;
pub mod format;
pub use format::{FormattedValue, GenericFormattedValue, SpecificFormattedValue};
mod value;
pub use value::*;
@ -196,6 +197,8 @@ pub mod prelude {
pub use miniobject::MiniObject;
pub use muldiv::MulDiv;
pub use format::{FormattedValue, SpecificFormattedValue};
}
mod utils;

100
gstreamer/src/message.rs
View file

@ -14,6 +14,7 @@ use TagList;
use GstObjectExt;
use Seqnum;
use GroupId;
use GenericFormattedValue;
use std::ptr;
use std::mem;
@ -156,7 +157,7 @@ impl GstRc<MessageRef> {
StateDirtyBuilder::new()
}
pub fn new_step_done<'a, V: Into<::FormatValue>>(
pub fn new_step_done<'a, V: Into<GenericFormattedValue>>(
amount: V,
rate: f64,
flush: bool,
@ -214,13 +215,17 @@ impl GstRc<MessageRef> {
ElementBuilder::new(structure)
}
pub fn new_segment_start<'a, V: Into<::FormatValue>>(position: V) -> SegmentStartBuilder<'a> {
pub fn new_segment_start<'a, V: Into<GenericFormattedValue>>(
position: V,
) -> SegmentStartBuilder<'a> {
assert_initialized_main_thread!();
let position = position.into();
SegmentStartBuilder::new(position)
}
pub fn new_segment_done<'a, V: Into<::FormatValue>>(position: V) -> SegmentDoneBuilder<'a> {
pub fn new_segment_done<'a, V: Into<GenericFormattedValue>>(
position: V,
) -> SegmentDoneBuilder<'a> {
assert_initialized_main_thread!();
let position = position.into();
SegmentDoneBuilder::new(position)
@ -251,7 +256,7 @@ impl GstRc<MessageRef> {
RequestStateBuilder::new(state)
}
pub fn new_step_start<'a, V: Into<::FormatValue>>(
pub fn new_step_start<'a, V: Into<GenericFormattedValue>>(
active: bool,
amount: V,
rate: f64,
@ -627,7 +632,16 @@ pub struct StateDirty<'a>(&'a MessageRef);
pub struct StepDone<'a>(&'a MessageRef);
impl<'a> StepDone<'a> {
pub fn get(&self) -> (::FormatValue, f64, bool, bool, ::FormatValue, bool) {
pub fn get(
&self,
) -> (
GenericFormattedValue,
f64,
bool,
bool,
GenericFormattedValue,
bool,
) {
unsafe {
let mut format = mem::uninitialized();
let mut amount = mem::uninitialized();
@ -649,11 +663,11 @@ impl<'a> StepDone<'a> {
);
(
::FormatValue::new(from_glib(format), amount as i64),
GenericFormattedValue::new(from_glib(format), amount as i64),
rate,
from_glib(flush),
from_glib(intermediate),
::FormatValue::new(from_glib(format), duration as i64),
GenericFormattedValue::new(from_glib(format), duration as i64),
from_glib(eos),
)
}
@ -758,28 +772,28 @@ pub struct Element<'a>(&'a MessageRef);
pub struct SegmentStart<'a>(&'a MessageRef);
impl<'a> SegmentStart<'a> {
pub fn get(&self) -> ::FormatValue {
pub fn get(&self) -> GenericFormattedValue {
unsafe {
let mut format = mem::uninitialized();
let mut position = mem::uninitialized();
ffi::gst_message_parse_segment_start(self.0.as_mut_ptr(), &mut format, &mut position);
::FormatValue::new(from_glib(format), position)
GenericFormattedValue::new(from_glib(format), position)
}
}
}
pub struct SegmentDone<'a>(&'a MessageRef);
impl<'a> SegmentDone<'a> {
pub fn get(&self) -> ::FormatValue {
pub fn get(&self) -> GenericFormattedValue {
unsafe {
let mut format = mem::uninitialized();
let mut position = mem::uninitialized();
ffi::gst_message_parse_segment_done(self.0.as_mut_ptr(), &mut format, &mut position);
::FormatValue::new(from_glib(format), position)
GenericFormattedValue::new(from_glib(format), position)
}
}
}
@ -818,7 +832,7 @@ impl<'a> RequestState<'a> {
pub struct StepStart<'a>(&'a MessageRef);
impl<'a> StepStart<'a> {
pub fn get(&self) -> (bool, ::FormatValue, f64, bool, bool) {
pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) {
unsafe {
let mut active = mem::uninitialized();
let mut format = mem::uninitialized();
@ -839,7 +853,7 @@ impl<'a> StepStart<'a> {
(
from_glib(active),
::FormatValue::new(from_glib(format), amount as i64),
GenericFormattedValue::new(from_glib(format), amount as i64),
rate,
from_glib(flush),
from_glib(intermediate),
@ -894,7 +908,7 @@ impl<'a> Qos<'a> {
}
}
pub fn get_stats(&self) -> (::FormatValue, ::FormatValue) {
pub fn get_stats(&self) -> (GenericFormattedValue, GenericFormattedValue) {
unsafe {
let mut format = mem::uninitialized();
let mut processed = mem::uninitialized();
@ -908,8 +922,8 @@ impl<'a> Qos<'a> {
);
(
::FormatValue::new(from_glib(format), processed as i64),
::FormatValue::new(from_glib(format), dropped as i64),
GenericFormattedValue::new(from_glib(format), processed as i64),
GenericFormattedValue::new(from_glib(format), dropped as i64),
)
}
}
@ -1554,24 +1568,24 @@ pub struct StepDoneBuilder<'a> {
src: Option<Object>,
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
amount: ::FormatValue,
amount: GenericFormattedValue,
rate: f64,
flush: bool,
intermediate: bool,
duration: ::FormatValue,
duration: GenericFormattedValue,
eos: bool,
}
impl<'a> StepDoneBuilder<'a> {
fn new(
amount: ::FormatValue,
amount: GenericFormattedValue,
rate: f64,
flush: bool,
intermediate: bool,
duration: ::FormatValue,
duration: GenericFormattedValue,
eos: bool,
) -> Self {
skip_assert_initialized!();
assert_eq!(amount.to_format(), duration.to_format());
assert_eq!(amount.get_format(), duration.get_format());
Self {
src: None,
seqnum: None,
@ -1588,12 +1602,12 @@ impl<'a> StepDoneBuilder<'a> {
message_builder_generic_impl!(|s: &mut Self, src| {
ffi::gst_message_new_step_done(
src,
s.amount.to_format().to_glib(),
s.amount.to_value() as u64,
s.amount.get_format().to_glib(),
s.amount.get_value() as u64,
s.rate,
s.flush.to_glib(),
s.intermediate.to_glib(),
s.duration.to_value() as u64,
s.duration.get_value() as u64,
s.eos.to_glib(),
)
});
@ -1784,10 +1798,10 @@ pub struct SegmentStartBuilder<'a> {
src: Option<Object>,
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
position: ::FormatValue,
position: GenericFormattedValue,
}
impl<'a> SegmentStartBuilder<'a> {
fn new(position: ::FormatValue) -> Self {
fn new(position: GenericFormattedValue) -> Self {
skip_assert_initialized!();
Self {
src: None,
@ -1800,8 +1814,8 @@ impl<'a> SegmentStartBuilder<'a> {
message_builder_generic_impl!(|s: &mut Self, src| {
ffi::gst_message_new_segment_start(
src,
s.position.to_format().to_glib(),
s.position.to_value(),
s.position.get_format().to_glib(),
s.position.get_value(),
)
});
}
@ -1810,10 +1824,10 @@ pub struct SegmentDoneBuilder<'a> {
src: Option<Object>,
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
position: ::FormatValue,
position: GenericFormattedValue,
}
impl<'a> SegmentDoneBuilder<'a> {
fn new(position: ::FormatValue) -> Self {
fn new(position: GenericFormattedValue) -> Self {
skip_assert_initialized!();
Self {
src: None,
@ -1826,8 +1840,8 @@ impl<'a> SegmentDoneBuilder<'a> {
message_builder_generic_impl!(|s: &mut Self, src| {
ffi::gst_message_new_segment_done(
src,
s.position.to_format().to_glib(),
s.position.to_value(),
s.position.get_format().to_glib(),
s.position.get_value(),
)
});
}
@ -1935,7 +1949,7 @@ pub struct StepStartBuilder<'a> {
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
active: bool,
amount: ::FormatValue,
amount: GenericFormattedValue,
rate: f64,
flush: bool,
intermediate: bool,
@ -1943,7 +1957,7 @@ pub struct StepStartBuilder<'a> {
impl<'a> StepStartBuilder<'a> {
fn new(
active: bool,
amount: ::FormatValue,
amount: GenericFormattedValue,
rate: f64,
flush: bool,
intermediate: bool,
@ -1965,8 +1979,8 @@ impl<'a> StepStartBuilder<'a> {
ffi::gst_message_new_step_start(
src,
s.active.to_glib(),
s.amount.to_format().to_glib(),
s.amount.to_value() as u64,
s.amount.get_format().to_glib(),
s.amount.get_value() as u64,
s.rate,
s.flush.to_glib(),
s.intermediate.to_glib(),
@ -1984,7 +1998,7 @@ pub struct QosBuilder<'a> {
timestamp: ::ClockTime,
duration: ::ClockTime,
values: Option<(i64, f64, i32)>,
stats: Option<(::FormatValue, ::FormatValue)>,
stats: Option<(GenericFormattedValue, GenericFormattedValue)>,
}
impl<'a> QosBuilder<'a> {
fn new(
@ -2016,8 +2030,10 @@ impl<'a> QosBuilder<'a> {
}
}
pub fn stats(self, processed: ::FormatValue, dropped: ::FormatValue) -> Self {
assert_eq!(processed.to_format(), dropped.to_format());
pub fn stats<V: Into<GenericFormattedValue>>(self, processed: V, dropped: V) -> Self {
let processed = processed.into();
let dropped = dropped.into();
assert_eq!(processed.get_format(), dropped.get_format());
Self {
stats: Some((processed, dropped)),
..self
@ -2039,9 +2055,9 @@ impl<'a> QosBuilder<'a> {
if let Some((processed, dropped)) = s.stats {
ffi::gst_message_set_qos_stats(
msg,
processed.to_format().to_glib(),
processed.to_value() as u64,
dropped.to_value() as u64,
processed.get_format().to_glib(),
processed.get_value() as u64,
dropped.get_value() as u64,
);
}
msg

196
gstreamer/src/pad.rs
View file

@ -12,6 +12,9 @@ use PadProbeReturn;
use Buffer;
use BufferList;
use Format;
use GenericFormattedValue;
use FormattedValue;
use SpecificFormattedValue;
use FlowReturn;
use Query;
use QueryRef;
@ -188,20 +191,37 @@ pub trait PadExtManual {
fn start_task<F: FnMut() + Send + 'static>(&self, func: F) -> Result<(), glib::BoolError>;
fn peer_query_convert<V: Into<::FormatValue>>(
fn peer_query_convert<V: Into<GenericFormattedValue>, U: SpecificFormattedValue>(
&self,
src_val: V,
) -> Option<U>;
fn peer_query_convert_generic<V: Into<GenericFormattedValue>>(
&self,
src_val: V,
dest_format: Format,
) -> Option<::FormatValue>;
fn peer_query_duration(&self, format: Format) -> Option<::FormatValue>;
fn peer_query_position(&self, format: Format) -> Option<::FormatValue>;
fn query_convert<V: Into<::FormatValue>>(
) -> Option<GenericFormattedValue>;
fn peer_query_duration<T: SpecificFormattedValue>(&self) -> Option<T>;
fn peer_query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue>;
fn peer_query_position<T: SpecificFormattedValue>(&self) -> Option<T>;
fn peer_query_position_generic(&self, format: Format) -> Option<GenericFormattedValue>;
fn query_convert<V: Into<GenericFormattedValue>, U: SpecificFormattedValue>(
&self,
src_val: V,
) -> Option<U>;
fn query_convert_generic<V: Into<GenericFormattedValue>>(
&self,
src_val: V,
dest_format: Format,
) -> Option<::FormatValue>;
fn query_duration(&self, format: Format) -> Option<::FormatValue>;
fn query_position(&self, format: Format) -> Option<::FormatValue>;
) -> Option<GenericFormattedValue>;
fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T>;
fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue>;
fn query_position<T: SpecificFormattedValue>(&self) -> Option<T>;
fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue>;
}
impl<O: IsA<Pad>> PadExtManual for O {
@ -611,30 +631,68 @@ impl<O: IsA<Pad>> PadExtManual for O {
}
}
fn peer_query_convert<V: Into<::FormatValue>>(
fn peer_query_convert<V: Into<GenericFormattedValue>, U: SpecificFormattedValue>(
&self,
src_val: V,
dest_format: Format,
) -> Option<::FormatValue> {
) -> Option<U> {
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_peer_query_convert(
self.to_glib_none().0,
src_val.to_format().to_glib(),
src_val.to_value(),
dest_format.to_glib(),
src_val.get_format().to_glib(),
src_val.to_glib(),
U::get_default_format().to_glib(),
&mut dest_val,
));
if ret {
Some(::FormatValue::new(dest_format, dest_val))
Some(U::from_glib(U::get_default_format(), dest_val))
} else {
None
}
}
}
fn peer_query_duration(&self, format: Format) -> Option<::FormatValue> {
fn peer_query_convert_generic<V: Into<GenericFormattedValue>>(
&self,
src_val: V,
dest_format: Format,
) -> Option<GenericFormattedValue> {
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_peer_query_convert(
self.to_glib_none().0,
src_val.get_format().to_glib(),
src_val.to_glib(),
dest_format.to_glib(),
&mut dest_val,
));
if ret {
Some(GenericFormattedValue::new(dest_format, dest_val))
} else {
None
}
}
}
fn peer_query_duration<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe {
let mut duration = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_peer_query_duration(
self.to_glib_none().0,
T::get_default_format().to_glib(),
&mut duration,
));
if ret {
Some(T::from_glib(T::get_default_format(), duration))
} else {
None
}
}
}
fn peer_query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe {
let mut duration = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_peer_query_duration(
@ -643,14 +701,30 @@ impl<O: IsA<Pad>> PadExtManual for O {
&mut duration,
));
if ret {
Some(::FormatValue::new(format, duration))
Some(GenericFormattedValue::new(format, duration))
} else {
None
}
}
}
fn peer_query_position(&self, format: Format) -> Option<::FormatValue> {
fn peer_query_position<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe {
let mut cur = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_peer_query_position(
self.to_glib_none().0,
T::get_default_format().to_glib(),
&mut cur,
));
if ret {
Some(T::from_glib(T::get_default_format(), cur))
} else {
None
}
}
}
fn peer_query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe {
let mut cur = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_peer_query_position(
@ -659,38 +733,77 @@ impl<O: IsA<Pad>> PadExtManual for O {
&mut cur,
));
if ret {
Some(::FormatValue::new(format, cur))
Some(GenericFormattedValue::new(format, cur))
} else {
None
}
}
}
fn query_convert<V: Into<::FormatValue>>(
fn query_convert<V: Into<GenericFormattedValue>, U: SpecificFormattedValue>(
&self,
src_val: V,
dest_format: Format,
) -> Option<::FormatValue> {
) -> Option<U> {
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_query_convert(
self.to_glib_none().0,
src_val.to_format().to_glib(),
src_val.to_value(),
dest_format.to_glib(),
src_val.get_format().to_glib(),
src_val.to_glib(),
U::get_default_format().to_glib(),
&mut dest_val,
));
if ret {
Some(::FormatValue::new(dest_format, dest_val))
Some(U::from_glib(U::get_default_format(), dest_val))
} else {
None
}
}
}
fn query_duration(&self, format: Format) -> Option<::FormatValue> {
fn query_convert_generic<V: Into<GenericFormattedValue>>(
&self,
src_val: V,
dest_format: Format,
) -> Option<GenericFormattedValue> {
let src_val = src_val.into();
unsafe {
let mut dest_val = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_query_convert(
self.to_glib_none().0,
src_val.get_format().to_glib(),
src_val.get_value(),
dest_format.to_glib(),
&mut dest_val,
));
if ret {
Some(GenericFormattedValue::new(dest_format, dest_val))
} else {
None
}
}
}
fn query_duration<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe {
let mut duration = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_query_duration(
self.to_glib_none().0,
T::get_default_format().to_glib(),
&mut duration,
));
if ret {
Some(T::from_glib(T::get_default_format(), duration))
} else {
None
}
}
}
fn query_duration_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe {
let mut duration = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_query_duration(
@ -699,14 +812,30 @@ impl<O: IsA<Pad>> PadExtManual for O {
&mut duration,
));
if ret {
Some(::FormatValue::new(format, duration))
Some(GenericFormattedValue::new(format, duration))
} else {
None
}
}
}
fn query_position(&self, format: Format) -> Option<::FormatValue> {
fn query_position<T: SpecificFormattedValue>(&self) -> Option<T> {
unsafe {
let mut cur = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_query_position(
self.to_glib_none().0,
T::get_default_format().to_glib(),
&mut cur,
));
if ret {
Some(T::from_glib(T::get_default_format(), cur))
} else {
None
}
}
}
fn query_position_generic(&self, format: Format) -> Option<GenericFormattedValue> {
unsafe {
let mut cur = mem::uninitialized();
let ret = from_glib(ffi::gst_pad_query_position(
@ -715,7 +844,7 @@ impl<O: IsA<Pad>> PadExtManual for O {
&mut cur,
));
if ret {
Some(::FormatValue::new(format, cur))
Some(GenericFormattedValue::new(format, cur))
} else {
None
}
@ -1065,9 +1194,10 @@ mod tests {
pad.set_active(true).unwrap();
assert!(pad.send_event(::Event::new_stream_start("test").build()));
let mut segment = ::Segment::default();
segment.init(::Format::Time);
assert!(pad.send_event(::Event::new_segment(&segment).build()));
let segment = ::FormattedSegment::<::ClockTime>::new();
assert!(pad.send_event(
::Event::new_segment(segment.as_ref()).build()
));
assert_eq!(pad.chain(::Buffer::new()), ::FlowReturn::Ok);

132
gstreamer/src/query.rs
View file

@ -9,6 +9,7 @@
use ffi;
use miniobject::*;
use structure::*;
use GenericFormattedValue;
use std::ptr;
use std::mem;
@ -57,12 +58,13 @@ impl GstRc<QueryRef> {
unsafe { from_glib_full(ffi::gst_query_new_segment(fmt.to_glib())) }
}
pub fn new_convert(value: ::FormatValue, dest_fmt: ::Format) -> Self {
pub fn new_convert<V: Into<GenericFormattedValue>>(value: V, dest_fmt: ::Format) -> Self {
assert_initialized_main_thread!();
let value = value.into();
unsafe {
from_glib_full(ffi::gst_query_new_convert(
value.to_format().to_glib(),
value.to_value(),
value.get_format().to_glib(),
value.get_value(),
dest_fmt.to_glib(),
))
}
@ -235,14 +237,14 @@ pub enum QueryView<T> {
pub struct Position<T>(T);
impl<'a> Position<&'a QueryRef> {
pub fn get_result(&self) -> ::FormatValue {
pub fn get_result(&self) -> GenericFormattedValue {
unsafe {
let mut fmt = mem::uninitialized();
let mut pos = mem::uninitialized();
ffi::gst_query_parse_position(self.0.as_mut_ptr(), &mut fmt, &mut pos);
::FormatValue::new(from_glib(fmt), pos)
GenericFormattedValue::new(from_glib(fmt), pos)
}
}
@ -262,14 +264,14 @@ impl<'a> Position<&'a QueryRef> {
}
impl<'a> Position<&'a mut QueryRef> {
pub fn set<V: Into<::FormatValue>>(&mut self, pos: V) {
pub fn set<V: Into<GenericFormattedValue>>(&mut self, pos: V) {
let pos = pos.into();
assert_eq!(pos.to_format(), self.get_format());
assert_eq!(pos.get_format(), self.get_format());
unsafe {
ffi::gst_query_set_position(
self.0.as_mut_ptr(),
pos.to_format().to_glib(),
pos.to_value(),
pos.get_format().to_glib(),
pos.get_value(),
);
}
}
@ -281,14 +283,14 @@ impl<'a> Position<&'a mut QueryRef> {
pub struct Duration<T>(T);
impl<'a> Duration<&'a QueryRef> {
pub fn get_result(&self) -> ::FormatValue {
pub fn get_result(&self) -> GenericFormattedValue {
unsafe {
let mut fmt = mem::uninitialized();
let mut pos = mem::uninitialized();
ffi::gst_query_parse_duration(self.0.as_mut_ptr(), &mut fmt, &mut pos);
::FormatValue::new(from_glib(fmt), pos)
GenericFormattedValue::new(from_glib(fmt), pos)
}
}
@ -308,14 +310,14 @@ impl<'a> Duration<&'a QueryRef> {
}
impl<'a> Duration<&'a mut QueryRef> {
pub fn set<V: Into<::FormatValue>>(&mut self, dur: V) {
pub fn set<V: Into<GenericFormattedValue>>(&mut self, dur: V) {
let dur = dur.into();
assert_eq!(dur.to_format(), self.get_format());
assert_eq!(dur.get_format(), self.get_format());
unsafe {
ffi::gst_query_set_duration(
self.0.as_mut_ptr(),
dur.to_format().to_glib(),
dur.to_value(),
dur.get_format().to_glib(),
dur.get_value(),
);
}
}
@ -389,7 +391,7 @@ impl<'a> Rate<&'a mut QueryRef> {
pub struct Seeking<T>(T);
impl<'a> Seeking<&'a QueryRef> {
pub fn get_result(&self) -> (bool, ::FormatValue, ::FormatValue) {
pub fn get_result(&self) -> (bool, GenericFormattedValue, GenericFormattedValue) {
unsafe {
let mut fmt = mem::uninitialized();
let mut seekable = mem::uninitialized();
@ -405,8 +407,8 @@ impl<'a> Seeking<&'a QueryRef> {
(
from_glib(seekable),
::FormatValue::new(from_glib(fmt), start),
::FormatValue::new(from_glib(fmt), end),
GenericFormattedValue::new(from_glib(fmt), start),
GenericFormattedValue::new(from_glib(fmt), end),
)
}
}
@ -432,20 +434,20 @@ impl<'a> Seeking<&'a QueryRef> {
}
impl<'a> Seeking<&'a mut QueryRef> {
pub fn set<V: Into<::FormatValue>>(&mut self, seekable: bool, start: V, end: V) {
pub fn set<V: Into<GenericFormattedValue>>(&mut self, seekable: bool, start: V, end: V) {
let start = start.into();
let end = end.into();
assert_eq!(self.get_format(), start.to_format());
assert_eq!(start.to_format(), end.to_format());
assert_eq!(self.get_format(), start.get_format());
assert_eq!(start.get_format(), end.get_format());
unsafe {
ffi::gst_query_set_seeking(
self.0.as_mut_ptr(),
start.to_format().to_glib(),
start.get_format().to_glib(),
seekable.to_glib(),
start.to_value(),
end.to_value(),
start.get_value(),
end.get_value(),
);
}
}
@ -457,7 +459,7 @@ impl<'a> Seeking<&'a mut QueryRef> {
pub struct Segment<T>(T);
impl<'a> Segment<&'a QueryRef> {
pub fn get_result(&self) -> (f64, ::FormatValue, ::FormatValue) {
pub fn get_result(&self) -> (f64, GenericFormattedValue, GenericFormattedValue) {
unsafe {
let mut rate = mem::uninitialized();
let mut fmt = mem::uninitialized();
@ -473,8 +475,8 @@ impl<'a> Segment<&'a QueryRef> {
);
(
rate,
::FormatValue::new(from_glib(fmt), start),
::FormatValue::new(from_glib(fmt), stop),
GenericFormattedValue::new(from_glib(fmt), start),
GenericFormattedValue::new(from_glib(fmt), stop),
)
}
}
@ -500,19 +502,19 @@ impl<'a> Segment<&'a QueryRef> {
}
impl<'a> Segment<&'a mut QueryRef> {
pub fn set<V: Into<::FormatValue>>(&mut self, rate: f64, start: V, stop: V) {
pub fn set<V: Into<GenericFormattedValue>>(&mut self, rate: f64, start: V, stop: V) {
let start = start.into();
let stop = stop.into();
assert_eq!(start.to_format(), stop.to_format());
assert_eq!(start.get_format(), stop.get_format());
unsafe {
ffi::gst_query_set_segment(
self.0.as_mut_ptr(),
rate,
start.to_format().to_glib(),
start.to_value(),
stop.to_value(),
start.get_format().to_glib(),
start.get_value(),
stop.get_value(),
);
}
}
@ -524,7 +526,7 @@ impl<'a> Segment<&'a mut QueryRef> {
pub struct Convert<T>(T);
impl<'a> Convert<&'a QueryRef> {
pub fn get_result(&self) -> (::FormatValue, ::FormatValue) {
pub fn get_result(&self) -> (GenericFormattedValue, GenericFormattedValue) {
unsafe {
let mut src_fmt = mem::uninitialized();
let mut src = mem::uninitialized();
@ -539,13 +541,13 @@ impl<'a> Convert<&'a QueryRef> {
&mut dest,
);
(
::FormatValue::new(from_glib(src_fmt), src),
::FormatValue::new(from_glib(dest_fmt), dest),
GenericFormattedValue::new(from_glib(src_fmt), src),
GenericFormattedValue::new(from_glib(dest_fmt), dest),
)
}
}
pub fn get(&self) -> (::FormatValue, ::Format) {
pub fn get(&self) -> (GenericFormattedValue, ::Format) {
unsafe {
let mut src_fmt = mem::uninitialized();
let mut src = mem::uninitialized();
@ -559,7 +561,7 @@ impl<'a> Convert<&'a QueryRef> {
ptr::null_mut(),
);
(
::FormatValue::new(from_glib(src_fmt), src),
GenericFormattedValue::new(from_glib(src_fmt), src),
from_glib(dest_fmt),
)
}
@ -571,17 +573,17 @@ impl<'a> Convert<&'a QueryRef> {
}
impl<'a> Convert<&'a mut QueryRef> {
pub fn set<V: Into<::FormatValue>>(&mut self, src: V, dest: V) {
pub fn set<V: Into<GenericFormattedValue>>(&mut self, src: V, dest: V) {
let src = src.into();
let dest = dest.into();
unsafe {
ffi::gst_query_set_convert(
self.0.as_mut_ptr(),
src.to_format().to_glib(),
src.to_value(),
dest.to_format().to_glib(),
dest.to_value(),
src.get_format().to_glib(),
src.get_value(),
dest.get_format().to_glib(),
dest.get_value(),
);
}
}
@ -656,7 +658,7 @@ impl<'a> Buffering<&'a QueryRef> {
}
}
pub fn get_range(&self) -> (::FormatValue, ::FormatValue, i64) {
pub fn get_range(&self) -> (GenericFormattedValue, GenericFormattedValue, i64) {
unsafe {
let mut fmt = mem::uninitialized();
let mut start = mem::uninitialized();
@ -671,8 +673,8 @@ impl<'a> Buffering<&'a QueryRef> {
&mut estimated_total,
);
(
::FormatValue::new(from_glib(fmt), start),
::FormatValue::new(from_glib(fmt), stop),
GenericFormattedValue::new(from_glib(fmt), start),
GenericFormattedValue::new(from_glib(fmt), stop),
estimated_total,
)
}
@ -697,7 +699,7 @@ impl<'a> Buffering<&'a QueryRef> {
}
}
pub fn get_ranges(&self) -> Vec<(::FormatValue, ::FormatValue)> {
pub fn get_ranges(&self) -> Vec<(GenericFormattedValue, GenericFormattedValue)> {
unsafe {
let mut fmt = mem::uninitialized();
ffi::gst_query_parse_buffering_range(
@ -722,8 +724,8 @@ impl<'a> Buffering<&'a QueryRef> {
));
if s {
res.push((
::FormatValue::new(fmt, start),
::FormatValue::new(fmt, stop),
GenericFormattedValue::new(fmt, start),
GenericFormattedValue::new(fmt, stop),
));
}
}
@ -744,19 +746,24 @@ impl<'a> Buffering<&'a mut QueryRef> {
}
}
pub fn set_range<V: Into<::FormatValue>>(&mut self, start: V, stop: V, estimated_total: i64) {
pub fn set_range<V: Into<GenericFormattedValue>>(
&mut self,
start: V,
stop: V,
estimated_total: i64,
) {
let start = start.into();
let stop = stop.into();
assert_eq!(self.get_format(), start.to_format());
assert_eq!(start.to_format(), stop.to_format());
assert_eq!(self.get_format(), start.get_format());
assert_eq!(start.get_format(), stop.get_format());
unsafe {
ffi::gst_query_set_buffering_range(
self.0.as_mut_ptr(),
start.to_format().to_glib(),
start.to_value(),
stop.to_value(),
start.get_format().to_glib(),
start.get_value(),
stop.get_value(),
estimated_total,
);
}
@ -781,19 +788,22 @@ impl<'a> Buffering<&'a mut QueryRef> {
}
}
pub fn add_buffering_ranges<V: Into<::FormatValue> + Copy>(&mut self, ranges: &[(V, V)]) {
pub fn add_buffering_ranges<V: Into<GenericFormattedValue> + Copy>(
&mut self,
ranges: &[(V, V)],
) {
unsafe {
let fmt = self.get_format();
for &(start, stop) in ranges {
let start = start.into();
let stop = stop.into();
assert_eq!(start.to_format(), fmt);
assert_eq!(stop.to_format(), fmt);
assert_eq!(start.get_format(), fmt);
assert_eq!(stop.get_format(), fmt);
ffi::gst_query_add_buffering_range(
self.0.as_mut_ptr(),
start.to_value(),
stop.to_value(),
start.get_value(),
stop.get_value(),
);
}
}
@ -1159,7 +1169,7 @@ mod tests {
match q.get_mut().unwrap().view_mut() {
QueryView::Position(ref mut p) => {
let pos = p.get_result();
assert_eq!(pos.try_to_time(), Some(::CLOCK_TIME_NONE));
assert_eq!(pos.try_into_time(), Ok(::CLOCK_TIME_NONE));
p.set(2 * ::SECOND);
}
_ => (),
@ -1168,7 +1178,7 @@ mod tests {
match q.view() {
QueryView::Position(ref p) => {
let pos = p.get_result();
assert_eq!(pos.try_to_time(), Some(2 * ::SECOND));
assert_eq!(pos.try_into_time(), Ok(2 * ::SECOND));
}
_ => (),
}

6
gstreamer/src/sample.rs
View file

@ -18,7 +18,9 @@ use miniobject::*;
use Buffer;
use BufferList;
use Caps;
use FormattedValue;
use Segment;
use FormattedSegment;
use StructureRef;
pub type Sample = GstRc<SampleRef>;
@ -29,10 +31,10 @@ unsafe impl MiniObject for SampleRef {
}
impl GstRc<SampleRef> {
pub fn new(
pub fn new<F: FormattedValue>(
buffer: Option<&Buffer>,
caps: Option<&Caps>,
segment: Option<&Segment>,
segment: Option<&FormattedSegment<F>>,
info: Option<&StructureRef>,
) -> Self {
assert_initialized_main_thread!();

521
gstreamer/src/segment.rs
View file

@ -7,7 +7,8 @@
// except according to those terms.
use Format;
use FormatValue;
use GenericFormattedValue;
use FormattedValue;
use SeekFlags;
use SeekType;
use ffi;
@ -18,39 +19,102 @@ use glib;
use std::mem;
use std::ptr;
use std::fmt;
use std::marker::PhantomData;
pub struct Segment(ffi::GstSegment);
pub type Segment = FormattedSegment<GenericFormattedValue>;
pub struct FormattedSegment<T: FormattedValue>(ffi::GstSegment, PhantomData<T>);
impl Segment {
pub fn new() -> Segment {
assert_initialized_main_thread!();
unsafe { Self::uninitialized() }
pub fn reset_with_format(&mut self, format: Format) {
unsafe {
ffi::gst_segment_init(self.to_glib_none_mut().0, format.to_glib());
}
}
pub fn clip<V: Into<FormatValue>>(
&self,
start: V,
stop: V,
) -> Option<(FormatValue, FormatValue)> {
pub fn set_format(&mut self, format: Format) {
self.0.format = format.to_glib();
}
pub fn downcast<T: FormattedValue>(self) -> Result<FormattedSegment<T>, Self> {
if T::get_default_format() == Format::Undefined
|| T::get_default_format() == self.get_format()
{
Ok(FormattedSegment(self.0, PhantomData))
} else {
Err(self)
}
}
pub fn downcast_ref<T: FormattedValue>(&self) -> Option<&FormattedSegment<T>> {
if T::get_default_format() == Format::Undefined
|| T::get_default_format() == self.get_format()
{
Some(unsafe { mem::transmute(self) })
} else {
None
}
}
pub fn downcast_mut<T: FormattedValue>(&mut self) -> Option<&mut FormattedSegment<T>> {
if T::get_default_format() == Format::Undefined
|| T::get_default_format() == self.get_format()
{
Some(unsafe { mem::transmute(self) })
} else {
None
}
}
}
impl<T: FormattedValue> FormattedSegment<T> {
pub fn new() -> Self {
assert_initialized_main_thread!();
let segment = unsafe {
let mut segment = mem::zeroed();
ffi::gst_segment_init(&mut segment, T::get_default_format().to_glib());
segment
};
FormattedSegment(segment, PhantomData)
}
pub fn upcast(self) -> Segment {
FormattedSegment(self.0, PhantomData)
}
pub fn upcast_ref(&self) -> &Segment {
unsafe { mem::transmute(self) }
}
pub fn reset(&mut self) {
unsafe {
ffi::gst_segment_init(&mut self.0, T::get_default_format().to_glib());
}
}
pub fn clip<V: Into<T>>(&self, start: V, stop: V) -> Option<(T, T)> {
let start = start.into();
let stop = stop.into();
assert_eq!(self.get_format(), start.to_format());
assert_eq!(start.to_format(), stop.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), start.get_format());
assert_eq!(self.get_format(), stop.get_format());
}
unsafe {
let mut clip_start = mem::uninitialized();
let mut clip_stop = mem::uninitialized();
let ret = from_glib(ffi::gst_segment_clip(
self.to_glib_none().0,
start.to_format().to_glib(),
start.to_value() as u64,
stop.to_value() as u64,
&self.0,
start.get_format().to_glib(),
start.to_glib() as u64,
stop.to_glib() as u64,
&mut clip_start,
&mut clip_stop,
));
if ret {
Some((
FormatValue::new(self.get_format(), clip_start as i64),
FormatValue::new(self.get_format(), clip_stop as i64),
T::from_glib(self.get_format(), clip_start as i64),
T::from_glib(self.get_format(), clip_stop as i64),
))
} else {
None
@ -58,14 +122,8 @@ impl Segment {
}
}
pub fn copy_into(&self, dest: &mut Segment) {
unsafe {
ffi::gst_segment_copy_into(self.to_glib_none().0, dest.to_glib_none_mut().0);
}
}
#[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
pub fn do_seek<V: Into<FormatValue>>(
pub fn do_seek<V: Into<T>>(
&mut self,
rate: f64,
flags: SeekFlags,
@ -77,19 +135,23 @@ impl Segment {
skip_assert_initialized!();
let start = start.into();
let stop = stop.into();
assert_eq!(self.get_format(), start.to_format());
assert_eq!(start.to_format(), stop.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), start.get_format());
assert_eq!(self.get_format(), stop.get_format());
}
unsafe {
let mut update = mem::uninitialized();
let ret = from_glib(ffi::gst_segment_do_seek(
self.to_glib_none_mut().0,
&mut self.0,
rate,
self.get_format().to_glib(),
flags.to_glib(),
start_type.to_glib(),
start.to_value() as u64,
start.to_glib() as u64,
stop_type.to_glib(),
stop.to_value() as u64,
stop.to_glib() as u64,
&mut update,
));
if ret {
@ -100,184 +162,200 @@ impl Segment {
}
}
pub fn init(&mut self, format: Format) {
unsafe {
ffi::gst_segment_init(self.to_glib_none_mut().0, format.to_glib());
}
}
fn is_equal(&self, s1: &Segment) -> bool {
unsafe {
from_glib(ffi::gst_segment_is_equal(
self.to_glib_none().0,
s1.to_glib_none().0,
))
}
}
pub fn offset_running_time(&mut self, format: Format, offset: i64) -> bool {
pub fn offset_running_time(&mut self, offset: i64) -> bool {
unsafe {
from_glib(ffi::gst_segment_offset_running_time(
self.to_glib_none_mut().0,
format.to_glib(),
&mut self.0,
self.get_format().to_glib(),
offset,
))
}
}
pub fn position_from_running_time<V: Into<FormatValue>>(&self, running_time: V) -> FormatValue {
pub fn position_from_running_time<V: Into<T>>(&self, running_time: V) -> T {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), running_time.get_format());
}
unsafe {
FormatValue::new(
T::from_glib(
self.get_format(),
ffi::gst_segment_position_from_running_time(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
running_time.to_value() as u64,
running_time.to_glib() as u64,
) as i64,
)
}
}
pub fn position_from_running_time_full<V: Into<FormatValue>>(
&self,
running_time: V,
) -> (i32, FormatValue) {
pub fn position_from_running_time_full<V: Into<T>>(&self, running_time: V) -> (i32, T) {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), running_time.get_format());
}
unsafe {
let mut position = mem::uninitialized();
let ret = ffi::gst_segment_position_from_running_time_full(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
running_time.to_value() as u64,
running_time.to_glib() as u64,
&mut position,
);
(ret, FormatValue::new(self.get_format(), position as i64))
(ret, T::from_glib(self.get_format(), position as i64))
}
}
pub fn position_from_stream_time<V: Into<FormatValue>>(&self, stream_time: V) -> FormatValue {
pub fn position_from_stream_time<V: Into<T>>(&self, stream_time: V) -> T {
let stream_time = stream_time.into();
assert_eq!(self.get_format(), stream_time.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), stream_time.get_format());
}
unsafe {
FormatValue::new(
T::from_glib(
self.get_format(),
ffi::gst_segment_position_from_stream_time(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
stream_time.to_value() as u64,
stream_time.to_glib() as u64,
) as i64,
)
}
}
pub fn position_from_stream_time_full<V: Into<FormatValue>>(
&self,
stream_time: V,
) -> (i32, FormatValue) {
pub fn position_from_stream_time_full<V: Into<T>>(&self, stream_time: V) -> (i32, T) {
let stream_time = stream_time.into();
assert_eq!(self.get_format(), stream_time.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), stream_time.get_format());
}
unsafe {
let mut position = mem::uninitialized();
let ret = ffi::gst_segment_position_from_stream_time_full(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
stream_time.to_value() as u64,
stream_time.to_glib() as u64,
&mut position,
);
(ret, FormatValue::new(self.get_format(), position as i64))
(ret, T::from_glib(self.get_format(), position as i64))
}
}
pub fn set_running_time<V: Into<FormatValue>>(&mut self, running_time: V) -> bool {
pub fn set_running_time<V: Into<T>>(&mut self, running_time: V) -> bool {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), running_time.get_format());
}
unsafe {
from_glib(ffi::gst_segment_set_running_time(
self.to_glib_none_mut().0,
&mut self.0,
self.get_format().to_glib(),
running_time.to_value() as u64,
running_time.to_glib() as u64,
))
}
}
pub fn to_position<V: Into<FormatValue>>(&self, running_time: V) -> FormatValue {
pub fn to_position<V: Into<T>>(&self, running_time: V) -> T {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), running_time.get_format());
}
unsafe {
FormatValue::new(
T::from_glib(
self.get_format(),
ffi::gst_segment_to_position(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
running_time.to_value() as u64,
running_time.to_glib() as u64,
) as i64,
)
}
}
pub fn to_running_time<V: Into<FormatValue>>(&self, position: V) -> FormatValue {
pub fn to_running_time<V: Into<T>>(&self, position: V) -> T {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), position.get_format());
}
unsafe {
FormatValue::new(
T::from_glib(
self.get_format(),
ffi::gst_segment_to_running_time(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
position.to_value() as u64,
position.to_glib() as u64,
) as i64,
)
}
}
pub fn to_running_time_full<V: Into<FormatValue>>(&self, position: V) -> (i32, FormatValue) {
pub fn to_running_time_full<V: Into<T>>(&self, position: V) -> (i32, T) {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), position.get_format());
}
unsafe {
let mut running_time = mem::uninitialized();
let ret = ffi::gst_segment_to_running_time_full(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
position.to_value() as u64,
position.to_glib() as u64,
&mut running_time,
);
(
ret,
FormatValue::new(self.get_format(), running_time as i64),
)
(ret, T::from_glib(self.get_format(), running_time as i64))
}
}
pub fn to_stream_time<V: Into<FormatValue>>(&self, position: V) -> FormatValue {
pub fn to_stream_time<V: Into<T>>(&self, position: V) -> T {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), position.get_format());
}
unsafe {
FormatValue::new(
T::from_glib(
self.get_format(),
ffi::gst_segment_to_stream_time(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
position.to_value() as u64,
position.to_glib() as u64,
) as i64,
)
}
}
pub fn to_stream_time_full<V: Into<FormatValue>>(&self, position: V) -> (i32, FormatValue) {
pub fn to_stream_time_full<V: Into<T>>(&self, position: V) -> (i32, T) {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), position.get_format());
}
unsafe {
let mut stream_time = mem::uninitialized();
let ret = ffi::gst_segment_to_stream_time_full(
self.to_glib_none().0,
&self.0,
self.get_format().to_glib(),
position.to_value() as u64,
position.to_glib() as u64,
&mut stream_time,
);
(ret, FormatValue::new(self.get_format(), stream_time as i64))
(ret, T::from_glib(self.get_format(), stream_time as i64))
}
}
@ -294,6 +372,7 @@ impl Segment {
}
pub fn set_rate(&mut self, rate: f64) {
assert_ne!(rate, 0.0);
self.0.rate = rate;
}
@ -302,6 +381,7 @@ impl Segment {
}
pub fn set_applied_rate(&mut self, applied_rate: f64) {
assert_ne!(applied_rate, 0.0);
self.0.applied_rate = applied_rate;
}
@ -309,155 +389,177 @@ impl Segment {
from_glib(self.0.format)
}
pub fn set_format(&mut self, format: Format) {
self.0.format = format.to_glib();
pub fn get_base(&self) -> T {
unsafe { T::from_glib(self.get_format(), self.0.base as i64) }
}
pub fn get_base(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.base as i64)
}
pub fn set_base<V: Into<FormatValue>>(&mut self, base: V) {
pub fn set_base<V: Into<T>>(&mut self, base: V) {
let base = base.into();
assert_eq!(self.get_format(), base.to_format());
self.0.base = base.to_value() as u64;
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), base.get_format());
}
self.0.base = unsafe { base.to_glib() } as u64;
}
pub fn get_offset(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.offset as i64)
pub fn get_offset(&self) -> T {
unsafe { T::from_glib(self.get_format(), self.0.offset as i64) }
}
pub fn set_offset<V: Into<FormatValue>>(&mut self, offset: V) {
pub fn set_offset<V: Into<T>>(&mut self, offset: V) {
let offset = offset.into();
assert_eq!(self.get_format(), offset.to_format());
self.0.offset = offset.to_value() as u64;
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), offset.get_format());
}
self.0.offset = unsafe { offset.to_glib() } as u64;
}
pub fn get_start(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.start as i64)
pub fn get_start(&self) -> T {
unsafe { T::from_glib(self.get_format(), self.0.start as i64) }
}
pub fn set_start<V: Into<FormatValue>>(&mut self, start: V) {
pub fn set_start<V: Into<T>>(&mut self, start: V) {
let start = start.into();
assert_eq!(self.get_format(), start.to_format());
self.0.start = start.to_value() as u64;
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), start.get_format());
}
self.0.start = unsafe { start.to_glib() } as u64;
}
pub fn get_stop(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.stop as i64)
pub fn get_stop(&self) -> T {
unsafe { T::from_glib(self.get_format(), self.0.stop as i64) }
}
pub fn set_stop<V: Into<FormatValue>>(&mut self, stop: V) {
pub fn set_stop<V: Into<T>>(&mut self, stop: V) {
let stop = stop.into();
assert_eq!(self.get_format(), stop.to_format());
self.0.stop = stop.to_value() as u64;
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), stop.get_format());
}
self.0.stop = unsafe { stop.to_glib() } as u64;
}
pub fn get_time(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.time as i64)
pub fn get_time(&self) -> T {
unsafe { T::from_glib(self.get_format(), self.0.time as i64) }
}
pub fn set_time<V: Into<FormatValue>>(&mut self, time: V) {
pub fn set_time<V: Into<T>>(&mut self, time: V) {
let time = time.into();
assert_eq!(self.get_format(), time.to_format());
self.0.time = time.to_value() as u64;
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), time.get_format());
}
self.0.time = unsafe { time.to_glib() } as u64;
}
pub fn get_position(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.position as i64)
pub fn get_position(&self) -> T {
unsafe { T::from_glib(self.get_format(), self.0.position as i64) }
}
pub fn set_position<V: Into<FormatValue>>(&mut self, position: V) {
pub fn set_position<V: Into<T>>(&mut self, position: V) {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
self.0.position = position.to_value() as u64;
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), position.get_format());
}
self.0.position = unsafe { position.to_glib() } as u64;
}
pub fn get_duration(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.duration as i64)
pub fn get_duration(&self) -> T {
unsafe { T::from_glib(self.get_format(), self.0.duration as i64) }
}
pub fn set_duration<V: Into<FormatValue>>(&mut self, duration: V) {
pub fn set_duration<V: Into<T>>(&mut self, duration: V) {
let duration = duration.into();
assert_eq!(self.get_format(), duration.to_format());
self.0.duration = duration.to_value() as u64;
if T::get_default_format() == Format::Undefined {
assert_eq!(self.get_format(), duration.get_format());
}
self.0.duration = unsafe { duration.to_glib() } as u64;
}
}
impl PartialEq for Segment {
impl<T: FormattedValue> PartialEq for FormattedSegment<T> {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.is_equal(other)
unsafe { from_glib(ffi::gst_segment_is_equal(&self.0, &other.0)) }
}
}
impl Eq for Segment {}
impl<T: FormattedValue> Eq for FormattedSegment<T> {}
unsafe impl Send for Segment {}
unsafe impl<T: FormattedValue> Send for FormattedSegment<T> {}
impl Clone for Segment {
impl<T: FormattedValue> Clone for FormattedSegment<T> {
fn clone(&self) -> Self {
unsafe { Segment(ptr::read(&self.0)) }
unsafe { FormattedSegment(ptr::read(&self.0), PhantomData) }
}
}
impl fmt::Debug for Segment {
impl<T: FormattedValue> AsRef<Segment> for FormattedSegment<T> {
fn as_ref(&self) -> &Segment {
unsafe { mem::transmute(self) }
}
}
impl<T: FormattedValue> fmt::Debug for FormattedSegment<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.get_format() {
let segment = self.as_ref();
match segment.get_format() {
Format::Undefined => f.debug_struct("Segment")
.field("format", &Format::Undefined)
.finish(),
Format::Time => f.debug_struct("Segment")
.field("format", &Format::Time)
.field(
"start",
&self.get_start().try_to_time().unwrap().to_string(),
)
.field(
"offset",
&self.get_offset().try_to_time().unwrap().to_string(),
)
.field("stop", &self.get_stop().try_to_time().unwrap().to_string())
.field("rate", &self.get_rate())
.field("applied_rate", &self.get_applied_rate())
.field("flags", &self.get_flags())
.field("time", &self.get_time().try_to_time().unwrap().to_string())
.field("base", &self.get_base().try_to_time().unwrap().to_string())
.field(
"position",
&self.get_position().try_to_time().unwrap().to_string(),
)
.field(
"duration",
&self.get_duration().try_to_time().unwrap().to_string(),
)
.finish(),
Format::Time => {
let segment = segment.downcast_ref::<::ClockTime>().unwrap();
f.debug_struct("Segment")
.field("format", &Format::Time)
.field("start", &segment.get_start().to_string())
.field("offset", &segment.get_offset().to_string())
.field("stop", &segment.get_stop().to_string())
.field("rate", &segment.get_rate())
.field("applied_rate", &segment.get_applied_rate())
.field("flags", &segment.get_flags())
.field("time", &segment.get_time().to_string())
.field("base", &segment.get_base().to_string())
.field("position", &segment.get_position().to_string())
.field("duration", &segment.get_duration().to_string())
.finish()
}
_ => f.debug_struct("Segment")
.field("format", &self.get_format())
.field("start", &self.get_start())
.field("offset", &self.get_offset())
.field("stop", &self.get_stop())
.field("rate", &self.get_rate())
.field("applied_rate", &self.get_applied_rate())
.field("flags", &self.get_flags())
.field("time", &self.get_time())
.field("base", &self.get_base())
.field("position", &self.get_position())
.field("duration", &self.get_duration())
.field("format", &segment.get_format())
.field("start", &segment.get_start())
.field("offset", &segment.get_offset())
.field("stop", &segment.get_stop())
.field("rate", &segment.get_rate())
.field("applied_rate", &segment.get_applied_rate())
.field("flags", &segment.get_flags())
.field("time", &segment.get_time())
.field("base", &segment.get_base())
.field("position", &segment.get_position())
.field("duration", &segment.get_duration())
.finish(),
}
}
}
impl glib::types::StaticType for Segment {
fn static_type() -> glib::types::Type {
unsafe { glib::translate::from_glib(ffi::gst_segment_get_type()) }
impl<T: FormattedValue> Default for FormattedSegment<T> {
fn default() -> Self {
Self::new()
}
}
impl Default for Segment {
fn default() -> Self {
Self::new()
impl<T: FormattedValue> glib::types::StaticType for FormattedSegment<T> {
fn static_type() -> glib::types::Type {
unsafe { glib::translate::from_glib(ffi::gst_segment_get_type()) }
}
}
@ -470,7 +572,7 @@ impl<'a> glib::value::FromValueOptional<'a> for Segment {
}
#[doc(hidden)]
impl glib::value::SetValue for Segment {
impl<T: FormattedValue> glib::value::SetValue for FormattedSegment<T> {
unsafe fn set_value(value: &mut glib::Value, this: &Self) {
gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0,
@ -481,7 +583,7 @@ impl glib::value::SetValue for Segment {
}
#[doc(hidden)]
impl glib::value::SetValueOptional for Segment {
impl<T: FormattedValue> glib::value::SetValueOptional for FormattedSegment<T> {
unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) {
gobject_ffi::g_value_set_boxed(
value.to_glib_none_mut().0,
@ -492,20 +594,14 @@ impl glib::value::SetValueOptional for Segment {
}
#[doc(hidden)]
impl glib::translate::Uninitialized for Segment {
unsafe fn uninitialized() -> Self {
mem::zeroed()
}
}
#[doc(hidden)]
impl glib::translate::GlibPtrDefault for Segment {
impl<T: FormattedValue> glib::translate::GlibPtrDefault for FormattedSegment<T> {
type GlibType = *mut ffi::GstSegment;
}
#[doc(hidden)]
impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstSegment> for Segment {
type Storage = &'a Segment;
impl<'a, T: FormattedValue> glib::translate::ToGlibPtr<'a, *const ffi::GstSegment>
for FormattedSegment<T> {
type Storage = &'a FormattedSegment<T>;
fn to_glib_none(&'a self) -> glib::translate::Stash<'a, *const ffi::GstSegment, Self> {
glib::translate::Stash(&self.0, self)
@ -517,8 +613,9 @@ impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstSegment> for Segment {
}
#[doc(hidden)]
impl<'a> glib::translate::ToGlibPtrMut<'a, *mut ffi::GstSegment> for Segment {
type Storage = &'a mut Segment;
impl<'a, T: FormattedValue> glib::translate::ToGlibPtrMut<'a, *mut ffi::GstSegment>
for FormattedSegment<T> {
type Storage = &'a mut FormattedSegment<T>;
#[inline]
fn to_glib_none_mut(&'a mut self) -> glib::translate::StashMut<'a, *mut ffi::GstSegment, Self> {
@ -530,7 +627,7 @@ impl<'a> glib::translate::ToGlibPtrMut<'a, *mut ffi::GstSegment> for Segment {
impl glib::translate::FromGlibPtrNone<*const ffi::GstSegment> for Segment {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstSegment) -> Self {
Segment(ptr::read(ptr))
FormattedSegment(ptr::read(ptr), PhantomData)
}
}
@ -538,7 +635,7 @@ impl glib::translate::FromGlibPtrNone<*const ffi::GstSegment> for Segment {
impl glib::translate::FromGlibPtrNone<*mut ffi::GstSegment> for Segment {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstSegment) -> Self {
Segment(ptr::read(ptr))
FormattedSegment(ptr::read(ptr), PhantomData)
}
}
@ -546,7 +643,7 @@ impl glib::translate::FromGlibPtrNone<*mut ffi::GstSegment> for Segment {
impl glib::translate::FromGlibPtrBorrow<*mut ffi::GstSegment> for Segment {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstSegment) -> Self {
Segment(ptr::read(ptr))
FormattedSegment(ptr::read(ptr), PhantomData)
}
}

6
tutorials/src/bin/basic-tutorial-4.rs
View file

@ -57,16 +57,14 @@ fn tutorial_main() {
if custom_data.playing {
let position = custom_data
.playbin
.query_position(gst::Format::Time)
.and_then(|v| v.try_to_time())
.query_position::<gst::ClockTime>()
.expect("Could not query current position.");
// If we didn't know it yet, query the stream duration
if custom_data.duration == gst::CLOCK_TIME_NONE {
custom_data.duration = custom_data
.playbin
.query_duration(gst::Format::Time)
.and_then(|v| v.try_to_time())
.query_duration()
.expect("Could not query current duration.")
}

4
tutorials/src/bin/basic-tutorial-5.rs
View file

@ -147,12 +147,12 @@ mod tutorial5 {
let pipeline = &pipeline;
let lslider = &lslider;
if let Some(gst::FormatValue::Time(dur)) = pipeline.query_duration(gst::Format::Time) {
if let Some(dur) = pipeline.query_duration::<gst::ClockTime>() {
let seconds = dur / gst::SECOND;
lslider.set_range(0.0, seconds.map(|v| v as f64).unwrap_or(0.0));
}
if let Some(gst::FormatValue::Time(pos)) = pipeline.query_position(gst::Format::Time) {
if let Some(pos) = pipeline.query_position::<gst::ClockTime>() {
let seconds = pos / gst::SECOND;
lslider.block_signal(&slider_update_signal_id);
lslider.set_value(seconds.map(|v| v as f64).unwrap_or(0.0));