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

Change various integers to FormatValue and ClockTime in events/queries/messages

Browse source
This commit is contained in:
Sebastian Dröge 2017-12-05 22:43:37 +02:00
parent 801a7ed43c
commit f1c6c4fd06
3 changed files with 118 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
gstreamer/src/event.rs
View file

@ -340,7 +340,7 @@ impl GstRc<EventRef> {
type_: ::QOSType,
proportion: f64,
diff: i64,
timestamp: u64,
timestamp: ::ClockTime,
) -> QosBuilder<'a> {
assert_initialized_main_thread!();
QosBuilder::new(type_, proportion, diff, timestamp)
@ -367,20 +367,19 @@ impl GstRc<EventRef> {
NavigationBuilder::new(structure)
}
pub fn new_latency<'a>(latency: u64) -> LatencyBuilder<'a> {
pub fn new_latency<'a>(latency: ::ClockTime) -> LatencyBuilder<'a> {
assert_initialized_main_thread!();
LatencyBuilder::new(latency)
}
pub fn new_step<'a>(
format: ::Format,
amount: u64,
pub fn new_step<'a, V: Into<::FormatValue>>(
amount: V,
rate: f64,
flush: bool,
intermediate: bool,
) -> StepBuilder<'a> {
assert_initialized_main_thread!();
StepBuilder::new(format, amount, rate, flush, intermediate)
StepBuilder::new(amount.into(), rate, flush, intermediate)
}
pub fn new_reconfigure<'a>() -> ReconfigureBuilder<'a> {
@ -716,7 +715,7 @@ impl<'a> Gap<'a> {
pub struct Qos<'a>(&'a EventRef);
impl<'a> Qos<'a> {
pub fn get(&self) -> (::QOSType, f64, i64, u64) {
pub fn get(&self) -> (::QOSType, f64, i64, ::ClockTime) {
unsafe {
let mut type_ = mem::uninitialized();
let mut proportion = mem::uninitialized();
@ -731,7 +730,7 @@ impl<'a> Qos<'a> {
&mut timestamp,
);
(from_glib(type_), proportion, diff, timestamp)
(from_glib(type_), proportion, diff, from_glib(timestamp))
}
}
}
@ -785,20 +784,20 @@ pub struct Navigation<'a>(&'a EventRef);
pub struct Latency<'a>(&'a EventRef);
impl<'a> Latency<'a> {
pub fn get_latency(&self) -> u64 {
pub fn get_latency(&self) -> ::ClockTime {
unsafe {
let mut latency = mem::uninitialized();
ffi::gst_event_parse_latency(self.0.as_mut_ptr(), &mut latency);
latency
from_glib(latency)
}
}
}
pub struct Step<'a>(&'a EventRef);
impl<'a> Step<'a> {
pub fn get(&self) -> (::Format, u64, f64, bool, bool) {
pub fn get(&self) -> (::FormatValue, f64, bool, bool) {
unsafe {
let mut fmt = mem::uninitialized();
let mut amount = mem::uninitialized();
@ -816,8 +815,7 @@ impl<'a> Step<'a> {
);
(
from_glib(fmt),
amount,
::FormatValue::new(from_glib(fmt), amount as i64),
rate,
from_glib(flush),
from_glib(intermediate),
@ -1295,10 +1293,10 @@ pub struct QosBuilder<'a> {
type_: ::QOSType,
proportion: f64,
diff: i64,
timestamp: u64,
timestamp: ::ClockTime,
}
impl<'a> QosBuilder<'a> {
fn new(type_: ::QOSType, proportion: f64, diff: i64, timestamp: u64) -> Self {
fn new(type_: ::QOSType, proportion: f64, diff: i64, timestamp: ::ClockTime) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
@ -1312,7 +1310,12 @@ impl<'a> QosBuilder<'a> {
}
event_builder_generic_impl!(|s: &Self| {
ffi::gst_event_new_qos(s.type_.to_glib(), s.proportion, s.diff, s.timestamp)
ffi::gst_event_new_qos(
s.type_.to_glib(),
s.proportion,
s.diff,
s.timestamp.to_glib(),
)
});
}
@ -1393,10 +1396,10 @@ pub struct LatencyBuilder<'a> {
seqnum: Option<Seqnum>,
running_time_offset: Option<i64>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
latency: u64,
latency: ::ClockTime,
}
impl<'a> LatencyBuilder<'a> {
fn new(latency: u64) -> Self {
fn new(latency: ::ClockTime) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
@ -1406,27 +1409,25 @@ impl<'a> LatencyBuilder<'a> {
}
}
event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_latency(s.latency));
event_builder_generic_impl!(|s: &Self| ffi::gst_event_new_latency(s.latency.to_glib()));
}
pub struct StepBuilder<'a> {
seqnum: Option<Seqnum>,
running_time_offset: Option<i64>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
fmt: ::Format,
amount: u64,
amount: ::FormatValue,
rate: f64,
flush: bool,
intermediate: bool,
}
impl<'a> StepBuilder<'a> {
fn new(fmt: ::Format, amount: u64, rate: f64, flush: bool, intermediate: bool) -> Self {
fn new(amount: ::FormatValue, rate: f64, flush: bool, intermediate: bool) -> Self {
skip_assert_initialized!();
Self {
seqnum: None,
running_time_offset: None,
other_fields: Vec::new(),
fmt: fmt,
amount: amount,
rate: rate,
flush: flush,
@ -1436,8 +1437,8 @@ impl<'a> StepBuilder<'a> {
event_builder_generic_impl!(|s: &Self| {
ffi::gst_event_new_step(
s.fmt.to_glib(),
s.amount,
s.amount.to_format().to_glib(),
s.amount.to_value() as u64,
s.rate,
s.flush.to_glib(),
s.intermediate.to_glib(),

153
gstreamer/src/message.rs
View file

@ -156,17 +156,23 @@ impl GstRc<MessageRef> {
StateDirtyBuilder::new()
}
pub fn new_step_done<'a>(
format: ::Format,
amount: u64,
pub fn new_step_done<'a, V: Into<::FormatValue>>(
amount: V,
rate: f64,
flush: bool,
intermediate: bool,
duration: u64,
duration: V,
eos: bool,
) -> StepDoneBuilder<'a> {
assert_initialized_main_thread!();
StepDoneBuilder::new(format, amount, rate, flush, intermediate, duration, eos)
StepDoneBuilder::new(
amount.into(),
rate,
flush,
intermediate,
duration.into(),
eos,
)
}
pub fn new_clock_provide(clock: &::Clock, ready: bool) -> ClockProvideBuilder {
@ -235,7 +241,7 @@ impl GstRc<MessageRef> {
AsyncStartBuilder::new()
}
pub fn new_async_done<'a>(running_time: u64) -> AsyncDoneBuilder<'a> {
pub fn new_async_done<'a>(running_time: ::ClockTime) -> AsyncDoneBuilder<'a> {
assert_initialized_main_thread!();
AsyncDoneBuilder::new(running_time)
}
@ -245,24 +251,23 @@ impl GstRc<MessageRef> {
RequestStateBuilder::new(state)
}
pub fn new_step_start<'a>(
pub fn new_step_start<'a, V: Into<::FormatValue>>(
active: bool,
format: ::Format,
amount: u64,
amount: V,
rate: f64,
flush: bool,
intermediate: bool,
) -> StepStartBuilder<'a> {
assert_initialized_main_thread!();
StepStartBuilder::new(active, format, amount, rate, flush, intermediate)
StepStartBuilder::new(active, amount.into(), rate, flush, intermediate)
}
pub fn new_qos_builder<'a>(
live: bool,
running_time: u64,
stream_time: u64,
timestamp: u64,
duration: u64,
running_time: ::ClockTime,
stream_time: ::ClockTime,
timestamp: ::ClockTime,
duration: ::ClockTime,
) -> QosBuilder<'a> {
assert_initialized_main_thread!();
QosBuilder::new(live, running_time, stream_time, timestamp, duration)
@ -278,7 +283,7 @@ impl GstRc<MessageRef> {
TocBuilder::new(toc, updated)
}
pub fn new_reset_time<'a>(running_time: u64) -> ResetTimeBuilder<'a> {
pub fn new_reset_time<'a>(running_time: ::ClockTime) -> ResetTimeBuilder<'a> {
assert_initialized_main_thread!();
ResetTimeBuilder::new(running_time)
}
@ -622,7 +627,7 @@ pub struct StateDirty<'a>(&'a MessageRef);
pub struct StepDone<'a>(&'a MessageRef);
impl<'a> StepDone<'a> {
pub fn get(&self) -> (::Format, u64, f64, bool, bool, u64, bool) {
pub fn get(&self) -> (::FormatValue, f64, bool, bool, ::FormatValue, bool) {
unsafe {
let mut format = mem::uninitialized();
let mut amount = mem::uninitialized();
@ -644,12 +649,11 @@ impl<'a> StepDone<'a> {
);
(
from_glib(format),
amount,
::FormatValue::new(from_glib(format), amount as i64),
rate,
from_glib(flush),
from_glib(intermediate),
duration,
::FormatValue::new(from_glib(format), duration as i64),
from_glib(eos),
)
}
@ -788,13 +792,13 @@ pub struct AsyncStart<'a>(&'a MessageRef);
pub struct AsyncDone<'a>(&'a MessageRef);
impl<'a> AsyncDone<'a> {
pub fn get_running_time(&self) -> u64 {
pub fn get_running_time(&self) -> ::ClockTime {
unsafe {
let mut running_time = mem::uninitialized();
ffi::gst_message_parse_async_done(self.0.as_mut_ptr(), &mut running_time);
running_time
from_glib(running_time)
}
}
}
@ -814,7 +818,7 @@ impl<'a> RequestState<'a> {
pub struct StepStart<'a>(&'a MessageRef);
impl<'a> StepStart<'a> {
pub fn get(&self) -> (bool, ::Format, u64, f64, bool, bool) {
pub fn get(&self) -> (bool, ::FormatValue, f64, bool, bool) {
unsafe {
let mut active = mem::uninitialized();
let mut format = mem::uninitialized();
@ -835,8 +839,7 @@ impl<'a> StepStart<'a> {
(
from_glib(active),
from_glib(format),
amount,
::FormatValue::new(from_glib(format), amount as i64),
rate,
from_glib(flush),
from_glib(intermediate),
@ -847,7 +850,7 @@ impl<'a> StepStart<'a> {
pub struct Qos<'a>(&'a MessageRef);
impl<'a> Qos<'a> {
pub fn get(&self) -> (bool, u64, u64, u64, u64) {
pub fn get(&self) -> (bool, ::ClockTime, ::ClockTime, ::ClockTime, ::ClockTime) {
unsafe {
let mut live = mem::uninitialized();
let mut running_time = mem::uninitialized();
@ -866,10 +869,10 @@ impl<'a> Qos<'a> {
(
from_glib(live),
running_time,
stream_time,
timestamp,
duration,
from_glib(running_time),
from_glib(stream_time),
from_glib(timestamp),
from_glib(duration),
)
}
}
@ -891,7 +894,7 @@ impl<'a> Qos<'a> {
}
}
pub fn get_stats(&self) -> (::Format, u64, u64) {
pub fn get_stats(&self) -> (::FormatValue, ::FormatValue) {
unsafe {
let mut format = mem::uninitialized();
let mut processed = mem::uninitialized();
@ -904,7 +907,10 @@ impl<'a> Qos<'a> {
&mut dropped,
);
(from_glib(format), processed, dropped)
(
::FormatValue::new(from_glib(format), processed as i64),
::FormatValue::new(from_glib(format), dropped as i64),
)
}
}
}
@ -950,13 +956,13 @@ impl<'a> Toc<'a> {
pub struct ResetTime<'a>(&'a MessageRef);
impl<'a> ResetTime<'a> {
pub fn get_running_time(&self) -> u64 {
pub fn get_running_time(&self) -> ::ClockTime {
unsafe {
let mut running_time = mem::uninitialized();
ffi::gst_message_parse_reset_time(self.0.as_mut_ptr(), &mut running_time);
running_time
from_glib(running_time)
}
}
}
@ -1548,30 +1554,28 @@ pub struct StepDoneBuilder<'a> {
src: Option<Object>,
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
format: ::Format,
amount: u64,
amount: ::FormatValue,
rate: f64,
flush: bool,
intermediate: bool,
duration: u64,
duration: ::FormatValue,
eos: bool,
}
impl<'a> StepDoneBuilder<'a> {
fn new(
format: ::Format,
amount: u64,
amount: ::FormatValue,
rate: f64,
flush: bool,
intermediate: bool,
duration: u64,
duration: ::FormatValue,
eos: bool,
) -> Self {
skip_assert_initialized!();
assert_eq!(amount.to_format(), duration.to_format());
Self {
src: None,
seqnum: None,
other_fields: Vec::new(),
format: format,
amount: amount,
rate: rate,
flush: flush,
@ -1584,12 +1588,12 @@ impl<'a> StepDoneBuilder<'a> {
message_builder_generic_impl!(|s: &mut Self, src| {
ffi::gst_message_new_step_done(
src,
s.format.to_glib(),
s.amount,
s.amount.to_format().to_glib(),
s.amount.to_value() as u64,
s.rate,
s.flush.to_glib(),
s.intermediate.to_glib(),
s.duration,
s.duration.to_value() as u64,
s.eos.to_glib(),
)
});
@ -1886,10 +1890,10 @@ pub struct AsyncDoneBuilder<'a> {
src: Option<Object>,
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
running_time: u64,
running_time: ::ClockTime,
}
impl<'a> AsyncDoneBuilder<'a> {
fn new(running_time: u64) -> Self {
fn new(running_time: ::ClockTime) -> Self {
skip_assert_initialized!();
Self {
src: None,
@ -1900,7 +1904,7 @@ impl<'a> AsyncDoneBuilder<'a> {
}
message_builder_generic_impl!(|s: &mut Self, src| {
ffi::gst_message_new_async_done(src, s.running_time)
ffi::gst_message_new_async_done(src, s.running_time.to_glib())
});
}
@ -1931,8 +1935,7 @@ pub struct StepStartBuilder<'a> {
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
active: bool,
format: ::Format,
amount: u64,
amount: ::FormatValue,
rate: f64,
flush: bool,
intermediate: bool,
@ -1940,8 +1943,7 @@ pub struct StepStartBuilder<'a> {
impl<'a> StepStartBuilder<'a> {
fn new(
active: bool,
format: ::Format,
amount: u64,
amount: ::FormatValue,
rate: f64,
flush: bool,
intermediate: bool,
@ -1952,7 +1954,6 @@ impl<'a> StepStartBuilder<'a> {
seqnum: None,
other_fields: Vec::new(),
active: active,
format: format,
amount: amount,
rate: rate,
flush: flush,
@ -1964,8 +1965,8 @@ impl<'a> StepStartBuilder<'a> {
ffi::gst_message_new_step_start(
src,
s.active.to_glib(),
s.format.to_glib(),
s.amount,
s.amount.to_format().to_glib(),
s.amount.to_value() as u64,
s.rate,
s.flush.to_glib(),
s.intermediate.to_glib(),
@ -1978,15 +1979,21 @@ pub struct QosBuilder<'a> {
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
live: bool,
running_time: u64,
stream_time: u64,
timestamp: u64,
duration: u64,
running_time: ::ClockTime,
stream_time: ::ClockTime,
timestamp: ::ClockTime,
duration: ::ClockTime,
values: Option<(i64, f64, i32)>,
stats: Option<(::Format, u64, u64)>,
stats: Option<(::FormatValue, ::FormatValue)>,
}
impl<'a> QosBuilder<'a> {
fn new(live: bool, running_time: u64, stream_time: u64, timestamp: u64, duration: u64) -> Self {
fn new(
live: bool,
running_time: ::ClockTime,
stream_time: ::ClockTime,
timestamp: ::ClockTime,
duration: ::ClockTime,
) -> Self {
skip_assert_initialized!();
Self {
src: None,
@ -2009,9 +2016,10 @@ impl<'a> QosBuilder<'a> {
}
}
pub fn stats(self, format: ::Format, processed: u64, dropped: u64) -> Self {
pub fn stats(self, processed: ::FormatValue, dropped: ::FormatValue) -> Self {
assert_eq!(processed.to_format(), dropped.to_format());
Self {
stats: Some((format, processed, dropped)),
stats: Some((processed, dropped)),
..self
}
}
@ -2020,16 +2028,21 @@ impl<'a> QosBuilder<'a> {
let msg = ffi::gst_message_new_qos(
src,
s.live.to_glib(),
s.running_time,
s.stream_time,
s.timestamp,
s.duration,
s.running_time.to_glib(),
s.stream_time.to_glib(),
s.timestamp.to_glib(),
s.duration.to_glib(),
);
if let Some((jitter, proportion, quality)) = s.values {
ffi::gst_message_set_qos_values(msg, jitter, proportion, quality);
}
if let Some((format, processed, dropped)) = s.stats {
ffi::gst_message_set_qos_stats(msg, format.to_glib(), processed, dropped);
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,
);
}
msg
});
@ -2108,10 +2121,10 @@ pub struct ResetTimeBuilder<'a> {
src: Option<Object>,
seqnum: Option<Seqnum>,
other_fields: Vec<(&'a str, &'a ToSendValue)>,
running_time: u64,
running_time: ::ClockTime,
}
impl<'a> ResetTimeBuilder<'a> {
fn new(running_time: u64) -> Self {
fn new(running_time: ::ClockTime) -> Self {
skip_assert_initialized!();
Self {
src: None,
@ -2122,7 +2135,7 @@ impl<'a> ResetTimeBuilder<'a> {
}
message_builder_generic_impl!(|s: &mut Self, src| {
ffi::gst_message_new_reset_time(src, s.running_time)
ffi::gst_message_new_reset_time(src, s.running_time.to_glib())
});
}

13
gstreamer/src/query.rs
View file

@ -323,7 +323,7 @@ impl<'a> Duration<&'a mut QueryRef> {
pub struct Latency<T>(T);
impl<'a> Latency<&'a QueryRef> {
pub fn get_result(&self) -> (bool, u64, u64) {
pub fn get_result(&self) -> (bool, ::ClockTime, ::ClockTime) {
unsafe {
let mut live = mem::uninitialized();
let mut min = mem::uninitialized();
@ -331,7 +331,7 @@ impl<'a> Latency<&'a QueryRef> {
ffi::gst_query_parse_latency(self.0.as_mut_ptr(), &mut live, &mut min, &mut max);
(from_glib(live), min, max)
(from_glib(live), from_glib(min), from_glib(max))
}
}
@ -341,9 +341,14 @@ impl<'a> Latency<&'a QueryRef> {
}
impl<'a> Latency<&'a mut QueryRef> {
pub fn set(&mut self, live: bool, min: u64, max: u64) {
pub fn set(&mut self, live: bool, min: ::ClockTime, max: ::ClockTime) {
unsafe {
ffi::gst_query_set_latency(self.0.as_mut_ptr(), live.to_glib(), min, max);
ffi::gst_query_set_latency(
self.0.as_mut_ptr(),
live.to_glib(),
min.to_glib(),
max.to_glib(),
);
}
}