rafaelcaricio/gstreamer-rs
1
0
Fork 0
forked from mirrors/gstreamer-rs
Code Pull requests Activity

Change all values in Segment to FormatValue

Browse source
This commit is contained in:
Sebastian Dröge 2017-12-05 23:16:12 +02:00
parent e6da3554ee
commit 05c51dd778
1 changed files with 173 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

256
gstreamer/src/segment.rs
View file

@ -7,7 +7,7 @@
// except according to those terms.
use Format;
use ClockTime;
use FormatValue;
use SeekFlags;
use SeekType;
use ffi;
@ -27,20 +27,31 @@ impl Segment {
unsafe { Self::uninitialized() }
}
pub fn clip(&self, format: Format, start: u64, stop: u64) -> Option<(u64, u64)> {
pub fn clip<V: Into<FormatValue>>(
&self,
start: V,
stop: V,
) -> Option<(FormatValue, FormatValue)> {
let start = start.into();
let stop = stop.into();
assert_eq!(self.get_format(), start.to_format());
assert_eq!(start.to_format(), stop.to_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,
format.to_glib(),
start,
stop,
start.to_format().to_glib(),
start.to_value() as u64,
stop.to_value() as u64,
&mut clip_start,
&mut clip_stop,
));
if ret {
Some((clip_start, clip_stop))
Some((
FormatValue::new(self.get_format(), clip_start as i64),
FormatValue::new(self.get_format(), clip_stop as i64),
))
} else {
None
}
@ -54,28 +65,31 @@ impl Segment {
}
#[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
pub fn do_seek(
pub fn do_seek<V: Into<FormatValue>>(
&mut self,
rate: f64,
format: Format,
flags: SeekFlags,
start_type: SeekType,
start: u64,
start: V,
stop_type: SeekType,
stop: u64,
stop: V,
) -> Option<bool> {
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());
unsafe {
let mut update = mem::uninitialized();
let ret = from_glib(ffi::gst_segment_do_seek(
self.to_glib_none_mut().0,
rate,
format.to_glib(),
self.get_format().to_glib(),
flags.to_glib(),
start_type.to_glib(),
start,
start.to_value() as u64,
stop_type.to_glib(),
stop,
stop.to_value() as u64,
&mut update,
));
if ret {
@ -111,103 +125,159 @@ impl Segment {
}
}
pub fn position_from_running_time(&self, format: Format, running_time: u64) -> u64 {
pub fn position_from_running_time<V: Into<FormatValue>>(&self, running_time: V) -> FormatValue {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
unsafe {
ffi::gst_segment_position_from_running_time(
self.to_glib_none().0,
format.to_glib(),
running_time,
FormatValue::new(
self.get_format(),
ffi::gst_segment_position_from_running_time(
self.to_glib_none().0,
self.get_format().to_glib(),
running_time.to_value() as u64,
) as i64,
)
}
}
pub fn position_from_running_time_full(&self, format: Format, running_time: u64) -> (i32, u64) {
pub fn position_from_running_time_full<V: Into<FormatValue>>(
&self,
running_time: V,
) -> (i32, FormatValue) {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
unsafe {
let mut position = mem::uninitialized();
let ret = ffi::gst_segment_position_from_running_time_full(
self.to_glib_none().0,
format.to_glib(),
running_time,
self.get_format().to_glib(),
running_time.to_value() as u64,
&mut position,
);
(ret, position)
(ret, FormatValue::new(self.get_format(), position as i64))
}
}
pub fn position_from_stream_time(&self, format: Format, stream_time: u64) -> u64 {
pub fn position_from_stream_time<V: Into<FormatValue>>(&self, stream_time: V) -> FormatValue {
let stream_time = stream_time.into();
assert_eq!(self.get_format(), stream_time.to_format());
unsafe {
ffi::gst_segment_position_from_stream_time(
self.to_glib_none().0,
format.to_glib(),
stream_time,
FormatValue::new(
self.get_format(),
ffi::gst_segment_position_from_stream_time(
self.to_glib_none().0,
self.get_format().to_glib(),
stream_time.to_value() as u64,
) as i64,
)
}
}
pub fn position_from_stream_time_full(&self, format: Format, stream_time: u64) -> (i32, u64) {
pub fn position_from_stream_time_full<V: Into<FormatValue>>(
&self,
stream_time: V,
) -> (i32, FormatValue) {
let stream_time = stream_time.into();
assert_eq!(self.get_format(), stream_time.to_format());
unsafe {
let mut position = mem::uninitialized();
let ret = ffi::gst_segment_position_from_stream_time_full(
self.to_glib_none().0,
format.to_glib(),
stream_time,
self.get_format().to_glib(),
stream_time.to_value() as u64,
&mut position,
);
(ret, position)
(ret, FormatValue::new(self.get_format(), position as i64))
}
}
pub fn set_running_time(&mut self, format: Format, running_time: u64) -> bool {
pub fn set_running_time<V: Into<FormatValue>>(&mut self, running_time: V) -> bool {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
unsafe {
from_glib(ffi::gst_segment_set_running_time(
self.to_glib_none_mut().0,
format.to_glib(),
running_time,
self.get_format().to_glib(),
running_time.to_value() as u64,
))
}
}
pub fn to_position(&self, format: Format, running_time: u64) -> u64 {
pub fn to_position<V: Into<FormatValue>>(&self, running_time: V) -> FormatValue {
let running_time = running_time.into();
assert_eq!(self.get_format(), running_time.to_format());
unsafe {
ffi::gst_segment_to_position(self.to_glib_none().0, format.to_glib(), running_time)
FormatValue::new(
self.get_format(),
ffi::gst_segment_to_position(
self.to_glib_none().0,
self.get_format().to_glib(),
running_time.to_value() as u64,
) as i64,
)
}
}
pub fn to_running_time(&self, format: Format, position: u64) -> u64 {
pub fn to_running_time<V: Into<FormatValue>>(&self, position: V) -> FormatValue {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
unsafe {
ffi::gst_segment_to_running_time(self.to_glib_none().0, format.to_glib(), position)
FormatValue::new(
self.get_format(),
ffi::gst_segment_to_running_time(
self.to_glib_none().0,
self.get_format().to_glib(),
position.to_value() as u64,
) as i64,
)
}
}
pub fn to_running_time_full(&self, format: Format, position: u64) -> (i32, u64) {
pub fn to_running_time_full<V: Into<FormatValue>>(&self, position: V) -> (i32, FormatValue) {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
unsafe {
let mut running_time = mem::uninitialized();
let ret = ffi::gst_segment_to_running_time_full(
self.to_glib_none().0,
format.to_glib(),
position,
self.get_format().to_glib(),
position.to_value() as u64,
&mut running_time,
);
(ret, running_time)
(
ret,
FormatValue::new(self.get_format(), running_time as i64),
)
}
}
pub fn to_stream_time(&self, format: Format, position: u64) -> u64 {
pub fn to_stream_time<V: Into<FormatValue>>(&self, position: V) -> FormatValue {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
unsafe {
ffi::gst_segment_to_stream_time(self.to_glib_none().0, format.to_glib(), position)
FormatValue::new(
self.get_format(),
ffi::gst_segment_to_stream_time(
self.to_glib_none().0,
self.get_format().to_glib(),
position.to_value() as u64,
) as i64,
)
}
}
pub fn to_stream_time_full(&self, format: Format, position: u64) -> (i32, u64) {
pub fn to_stream_time_full<V: Into<FormatValue>>(&self, position: V) -> (i32, FormatValue) {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
unsafe {
let mut stream_time = mem::uninitialized();
let ret = ffi::gst_segment_to_stream_time_full(
self.to_glib_none().0,
format.to_glib(),
position,
self.get_format().to_glib(),
position.to_value() as u64,
&mut stream_time,
);
(ret, stream_time)
(ret, FormatValue::new(self.get_format(), stream_time as i64))
}
}
@ -243,60 +313,74 @@ impl Segment {
self.0.format = format.to_glib();
}
pub fn get_base(&self) -> u64 {
self.0.base
pub fn get_base(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.base as i64)
}
pub fn set_base(&mut self, base: u64) {
self.0.base = base;
pub fn set_base<V: Into<FormatValue>>(&mut self, base: V) {
let base = base.into();
assert_eq!(self.get_format(), base.to_format());
self.0.base = base.to_value() as u64;
}
pub fn get_offset(&self) -> u64 {
self.0.offset
pub fn get_offset(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.offset as i64)
}
pub fn set_offset(&mut self, offset: u64) {
self.0.offset = offset;
pub fn set_offset<V: Into<FormatValue>>(&mut self, offset: V) {
let offset = offset.into();
assert_eq!(self.get_format(), offset.to_format());
self.0.offset = offset.to_value() as u64;
}
pub fn get_start(&self) -> u64 {
self.0.start
pub fn get_start(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.start as i64)
}
pub fn set_start(&mut self, start: u64) {
self.0.start = start;
pub fn set_start<V: Into<FormatValue>>(&mut self, start: V) {
let start = start.into();
assert_eq!(self.get_format(), start.to_format());
self.0.start = start.to_value() as u64;
}
pub fn get_stop(&self) -> u64 {
self.0.stop
pub fn get_stop(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.stop as i64)
}
pub fn set_stop(&mut self, stop: u64) {
self.0.stop = stop;
pub fn set_stop<V: Into<FormatValue>>(&mut self, stop: V) {
let stop = stop.into();
assert_eq!(self.get_format(), stop.to_format());
self.0.stop = stop.to_value() as u64;
}
pub fn get_time(&self) -> u64 {
self.0.time
pub fn get_time(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.time as i64)
}
pub fn set_time(&mut self, time: u64) {
self.0.time = time;
pub fn set_time<V: Into<FormatValue>>(&mut self, time: V) {
let time = time.into();
assert_eq!(self.get_format(), time.to_format());
self.0.time = time.to_value() as u64;
}
pub fn get_position(&self) -> u64 {
self.0.position
pub fn get_position(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.position as i64)
}
pub fn set_position(&mut self, position: u64) {
self.0.position = position;
pub fn set_position<V: Into<FormatValue>>(&mut self, position: V) {
let position = position.into();
assert_eq!(self.get_format(), position.to_format());
self.0.position = position.to_value() as u64;
}
pub fn get_duration(&self) -> u64 {
self.0.duration
pub fn get_duration(&self) -> FormatValue {
FormatValue::new(self.get_format(), self.0.duration as i64)
}
pub fn set_duration(&mut self, duration: u64) {
self.0.duration = duration;
pub fn set_duration<V: Into<FormatValue>>(&mut self, duration: V) {
let duration = duration.into();
assert_eq!(self.get_format(), duration.to_format());
self.0.duration = duration.to_value() as u64;
}
}
@ -325,21 +409,27 @@ impl fmt::Debug for Segment {
.finish(),
Format::Time => f.debug_struct("Segment")
.field("format", &Format::Time)
.field("start", &ClockTime::from(self.get_start()).to_string())
.field("offset", &ClockTime::from(self.get_offset()).to_string())
.field("stop", &ClockTime::from(self.get_stop()).to_string())
.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", &ClockTime::from(self.get_time()).to_string())
.field("base", &ClockTime::from(self.get_base()).to_string())
.field("time", &self.get_time().try_to_time().unwrap().to_string())
.field("base", &self.get_base().try_to_time().unwrap().to_string())
.field(
"position",
&ClockTime::from(self.get_position()).to_string(),
&self.get_position().try_to_time().unwrap().to_string(),
)
.field(
"duration",
&ClockTime::from(self.get_duration()).to_string(),
&self.get_duration().try_to_time().unwrap().to_string(),
)
.finish(),
_ => f.debug_struct("Segment")