mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2024-05-14 14:22:40 +00:00
Code Issues Projects Releases Wiki Activity

Update for event/message/query view API changes

Browse source
This commit is contained in:
Sebastian Dröge 2022-01-19 15:07:45 +02:00
parent 763ad0cb18
commit 65fcd55160
39 changed files with 104 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
audio/audiofx/src/audioloudnorm/imp.rs
View file

@ -1689,11 +1689,11 @@ impl AudioLoudNorm {
element: &super::AudioLoudNorm,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let mut peer_query = gst::query::Latency::new();
if self.sinkpad.peer_query(&mut peer_query) {
let (live, min_latency, max_latency) = peer_query.result();

2
audio/audiofx/src/audiornnoise/imp.rs
View file

@ -352,7 +352,7 @@ impl BaseTransformImpl for AudioRNNoise {
query: &mut gst::QueryRef,
) -> bool {
if direction == gst::PadDirection::Src {
if let gst::QueryView::Latency(ref mut q) = query.view_mut() {
if let gst::QueryViewMut::Latency(q) = query.view_mut() {
let sink_pad = element.static_pad("sink").expect("Sink pad not found");
let mut upstream_query = gst::query::Latency::new();
if sink_pad.peer_query(&mut upstream_query) {

10
generic/fmp4/src/fmp4mux/imp.rs
View file

@ -950,12 +950,12 @@ impl FMP4Mux {
element: &super::FMP4Mux,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_trace!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Caps(mut q) => {
QueryViewMut::Caps(q) => {
let state = self.state.lock().unwrap();
let allowed_caps = if let Some(ref caps) = state.caps {
@ -996,17 +996,17 @@ impl FMP4Mux {
element: &super::FMP4Mux,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_trace!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Seeking(mut q) => {
QueryViewMut::Seeking(q) => {
// We can't really handle seeking, it would break everything
q.set(false, gst::ClockTime::ZERO.into(), gst::ClockTime::NONE);
true
}
QueryView::Latency(mut q) => {
QueryViewMut::Latency(q) => {
if !self.sinkpad.peer_query(q.query_mut()) {
return false;
}

6
generic/sodium/src/decrypter/imp.rs
View file

@ -285,12 +285,12 @@ impl Decrypter {
element: &super::Decrypter,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Scheduling(mut q) => {
QueryViewMut::Scheduling(q) => {
let mut peer_query = gst::query::Scheduling::new();
let res = self.sinkpad.peer_query(&mut peer_query);
if !res {
@ -305,7 +305,7 @@ impl Decrypter {
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true
}
QueryView::Duration(ref mut q) => {
QueryViewMut::Duration(q) => {
if q.format() != gst::Format::Bytes {
return pad.query_default(Some(element), query);
}

6
generic/sodium/src/encrypter/imp.rs
View file

@ -268,12 +268,12 @@ impl Encrypter {
element: &super::Encrypter,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Seeking(mut q) => {
QueryViewMut::Seeking(q) => {
let format = q.format();
q.set(
false,
@ -283,7 +283,7 @@ impl Encrypter {
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true
}
QueryView::Duration(ref mut q) => {
QueryViewMut::Duration(q) => {
if q.format() != gst::Format::Bytes {
return pad.query_default(Some(element), query);
}

8
generic/threadshare/src/appsrc/imp.rs
View file

@ -220,20 +220,20 @@ impl PadSrcHandler for AppSrcPadHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
q.set(true, gst::ClockTime::ZERO, gst::ClockTime::NONE);
true
}
QueryView::Scheduling(ref mut q) => {
QueryViewMut::Scheduling(q) => {
q.set(gst::SchedulingFlags::SEQUENTIAL, 1, -1, 0);
q.add_scheduling_modes(&[gst::PadMode::Push]);
true
}
QueryView::Caps(ref mut q) => {
QueryViewMut::Caps(q) => {
let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() {
q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))

4
generic/threadshare/src/inputselector/imp.rs
View file

@ -287,12 +287,12 @@ impl PadSrcHandler for InputSelectorPadSrcHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let mut ret = true;
let mut min_latency = gst::ClockTime::ZERO;
let mut max_latency = gst::ClockTime::NONE;

6
generic/threadshare/src/jitterbuffer/imp.rs
View file

@ -933,12 +933,12 @@ impl PadSrcHandler for SrcHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Forwarding {:?}", query);
match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let mut peer_query = gst::query::Latency::new();
let ret = jb.sink_pad.gst_pad().peer_query(&mut peer_query);
@ -954,7 +954,7 @@ impl PadSrcHandler for SrcHandler {
ret
}
QueryView::Position(ref mut q) => {
QueryViewMut::Position(q) => {
if q.format() != gst::Format::Time {
jb.sink_pad.gst_pad().peer_query(query)
} else {

8
generic/threadshare/src/proxy/imp.rs
View file

@ -810,20 +810,20 @@ impl PadSrcHandler for ProxySrcPadHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(SRC_CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
q.set(true, gst::ClockTime::ZERO, gst::ClockTime::NONE);
true
}
QueryView::Scheduling(ref mut q) => {
QueryViewMut::Scheduling(q) => {
q.set(gst::SchedulingFlags::SEQUENTIAL, 1, -1, 0);
q.add_scheduling_modes(&[gst::PadMode::Push]);
true
}
QueryView::Caps(ref mut q) => {
QueryViewMut::Caps(q) => {
let caps = if let Some(ref caps) = pad.gst_pad().current_caps() {
q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))

4
generic/threadshare/src/queue/imp.rs
View file

@ -288,11 +288,11 @@ impl PadSrcHandler for QueuePadSrcHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
if let QueryView::Scheduling(ref mut q) = query.view_mut() {
if let QueryViewMut::Scheduling(q) = query.view_mut() {
let mut new_query = gst::query::Scheduling::new();
let res = queue.sink_pad.gst_pad().peer_query(&mut new_query);
if !res {

8
generic/threadshare/src/tcpclientsrc/imp.rs
View file

@ -221,20 +221,20 @@ impl PadSrcHandler for TcpClientSrcPadHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
q.set(false, gst::ClockTime::ZERO, gst::ClockTime::NONE);
true
}
QueryView::Scheduling(ref mut q) => {
QueryViewMut::Scheduling(q) => {
q.set(gst::SchedulingFlags::SEQUENTIAL, 1, -1, 0);
q.add_scheduling_modes(&[gst::PadMode::Push]);
true
}
QueryView::Caps(ref mut q) => {
QueryViewMut::Caps(q) => {
let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() {
q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))

8
generic/threadshare/src/udpsrc/imp.rs
View file

@ -234,21 +234,21 @@ impl PadSrcHandler for UdpSrcPadHandler {
_element: &gst::Element,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad.gst_pad(), "Handling {:?}", query);
let ret = match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
q.set(true, gst::ClockTime::ZERO, gst::ClockTime::NONE);
true
}
QueryView::Scheduling(ref mut q) => {
QueryViewMut::Scheduling(q) => {
q.set(gst::SchedulingFlags::SEQUENTIAL, 1, -1, 0);
q.add_scheduling_modes(&[gst::PadMode::Push]);
true
}
QueryView::Caps(ref mut q) => {
QueryViewMut::Caps(q) => {
let caps = if let Some(caps) = self.0.configured_caps.lock().unwrap().as_ref() {
q.filter()
.map(|f| f.intersect_with_mode(caps, gst::CapsIntersectMode::First))

2
net/hlssink3/src/imp.rs
View file

@ -362,7 +362,7 @@ impl BinImpl for HlsSink3 {
use gst::MessageView;
match msg.view() {
MessageView::Element(ref msg) => {
MessageView::Element(msg) => {
let event_is_from_splitmuxsink = {
let settings = self.settings.lock().unwrap();

4
net/reqwest/src/reqwesthttpsrc/imp.rs
View file

@ -1077,10 +1077,10 @@ impl BaseSrcImpl for ReqwestHttpSrc {
}
fn query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
match query.view_mut() {
QueryView::Scheduling(ref mut q) => {
QueryViewMut::Scheduling(q) => {
q.set(
gst::SchedulingFlags::SEQUENTIAL | gst::SchedulingFlags::BANDWIDTH_LIMITED,
1,

6
net/rusoto/src/aws_transcriber/imp.rs
View file

@ -642,12 +642,12 @@ impl Transcriber {
element: &super::Transcriber,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let mut peer_query = gst::query::Latency::new();
let ret = self.sinkpad.peer_query(&mut peer_query);
@ -659,7 +659,7 @@ impl Transcriber {
}
ret
}
QueryView::Position(ref mut q) => {
QueryViewMut::Position(q) => {
if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap();
q.set(

2
net/rusoto/src/s3src/imp.rs
View file

@ -426,7 +426,7 @@ impl BaseSrcImpl for S3Src {
}
fn query(&self, src: &Self::Type, query: &mut gst::QueryRef) -> bool {
if let gst::QueryView::Scheduling(ref mut q) = query.view_mut() {
if let gst::QueryViewMut::Scheduling(q) = query.view_mut() {
q.set(
gst::SchedulingFlags::SEQUENTIAL | gst::SchedulingFlags::BANDWIDTH_LIMITED,
1,

12
text/json/src/jsongstparse/imp.rs
View file

@ -683,7 +683,7 @@ impl JsonGstParse {
fn perform_seek(
&self,
event: &gst::event::Seek<&gst::EventRef>,
event: &gst::event::Seek<gst::EventRef>,
element: &super::JsonGstParse,
) -> bool {
if self.state.lock().unwrap().pull.is_none() {
@ -783,7 +783,7 @@ impl JsonGstParse {
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() {
EventView::Seek(e) => self.perform_seek(&e, element),
EventView::Seek(e) => self.perform_seek(e, element),
_ => pad.event_default(Some(element), event),
}
}
@ -794,12 +794,12 @@ impl JsonGstParse {
element: &super::JsonGstParse,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Seeking(mut q) => {
QueryViewMut::Seeking(q) => {
let state = self.state.lock().unwrap();
let fmt = q.format();
@ -819,7 +819,7 @@ impl JsonGstParse {
false
}
}
QueryView::Position(ref mut q) => {
QueryViewMut::Position(q) => {
// For Time answer ourselfs, otherwise forward
if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap();
@ -829,7 +829,7 @@ impl JsonGstParse {
self.sinkpad.peer_query(query)
}
}
QueryView::Duration(ref mut q) => {
QueryViewMut::Duration(q) => {
// For Time answer ourselfs, otherwise forward
let state = self.state.lock().unwrap();
if q.format() == gst::Format::Time {

4
text/wrap/src/gsttextwrap/imp.rs
View file

@ -406,12 +406,12 @@ impl TextWrap {
element: &super::TextWrap,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let mut peer_query = gst::query::Latency::new();
let ret = self.sinkpad.peer_query(&mut peer_query);

2
tutorial/src/progressbin/imp.rs
View file

@ -225,7 +225,7 @@ impl BinImpl for ProgressBin {
// to stdout. Otherwise we pass through to the default message
// handling of the parent class, i.e. forwarding to the parent
// bins and the application.
MessageView::Element(ref msg)
MessageView::Element(msg)
if msg.src().as_ref() == Some(self.progress.upcast_ref())
&& msg
.structure()

4
tutorial/src/sinesrc/imp.rs
View file

@ -488,13 +488,13 @@ impl BaseSrcImpl for SineSrc {
}
fn query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
match query.view_mut() {
// In Live mode we will have a latency equal to the number of samples in each buffer.
// We can't output samples before they were produced, and the last sample of a buffer
// is produced that much after the beginning, leading to this latency calculation
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let settings = *self.settings.lock().unwrap();
let state = self.state.lock().unwrap();

4
tutorial/tutorial-2.md
View file

@ -769,13 +769,13 @@ This querying is done with the `LATENCY` query, which we will have to handle i
```rust
fn query(&self, element: &Self::Type, query: &mut gst::QueryRef) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
match query.view_mut() {
// In Live mode we will have a latency equal to the number of samples in each buffer.
// We can't output samples before they were produced, and the last sample of a buffer
// is produced that much after the beginning, leading to this latency calculation
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let settings = *self.settings.lock().unwrap();
let state = self.state.lock().unwrap();

8
utils/fallbackswitch/src/fallbacksrc/imp.rs
View file

@ -783,18 +783,18 @@ impl BinImpl for FallbackSrc {
use gst::MessageView;
match msg.view() {
MessageView::Buffering(ref m) => {
MessageView::Buffering(m) => {
// Don't forward upwards, we handle this internally
self.handle_buffering(bin, m);
}
MessageView::StreamsSelected(ref m) => {
MessageView::StreamsSelected(m) => {
// Don't forward upwards, we are exposing streams based on properties
// TODO: Do stream configuration via our own stream collection and handling
// of stream select events
// TODO: Also needs updating of StreamCollection handling in CustomSource
self.handle_streams_selected(bin, m);
}
MessageView::Error(ref m) => {
MessageView::Error(m) => {
if !self.handle_error(bin, m) {
self.parent_handle_message(bin, msg);
}
@ -1440,7 +1440,7 @@ impl FallbackSrc {
let pts = match info.data {
Some(gst::PadProbeData::Buffer(ref buffer)) => buffer.pts(),
Some(gst::PadProbeData::Event(ref ev)) => match ev.view() {
gst::EventView::Gap(ref ev) => Some(ev.get().0),
gst::EventView::Gap(ev) => Some(ev.get().0),
_ => return gst::PadProbeReturn::Pass,
},
_ => unreachable!(),

10
utils/togglerecord/src/togglerecord/imp.rs
View file

@ -1578,7 +1578,7 @@ impl ToggleRecord {
element: &super::ToggleRecord,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
let stream = match self.pads.lock().get(pad) {
None => {
@ -1594,7 +1594,7 @@ impl ToggleRecord {
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Scheduling(ref mut q) => {
QueryViewMut::Scheduling(q) => {
let mut new_query = gst::query::Scheduling::new();
let res = stream.sinkpad.peer_query(&mut new_query);
if !res {
@ -1616,7 +1616,7 @@ impl ToggleRecord {
gst_log!(CAT, obj: pad, "Returning {:?}", q.query_mut());
true
}
QueryView::Seeking(ref mut q) => {
QueryViewMut::Seeking(q) => {
// Seeking is not possible here
let format = q.format();
q.set(
@ -1629,7 +1629,7 @@ impl ToggleRecord {
true
}
// Position and duration is always the current recording position
QueryView::Position(ref mut q) => {
QueryViewMut::Position(q) => {
if q.format() == gst::Format::Time {
let state = stream.state.lock();
let rec_state = self.state.lock();
@ -1663,7 +1663,7 @@ impl ToggleRecord {
false
}
}
QueryView::Duration(ref mut q) => {
QueryViewMut::Duration(q) => {
if q.format() == gst::Format::Time {
let state = stream.state.lock();
let rec_state = self.state.lock();

4
utils/togglerecord/tests/tests.rs
View file

@ -229,7 +229,7 @@ fn recv_buffers(
use gst::EventView;
match event.view() {
EventView::Gap(ref e) => {
EventView::Gap(e) => {
let (ts, duration) = e.get();
res.push((segment.to_running_time(ts), Some(ts), duration));
@ -242,7 +242,7 @@ fn recv_buffers(
saw_eos = true;
return (res, saw_eos);
}
EventView::Segment(ref e) => {
EventView::Segment(e) => {
*segment = e.segment().clone().downcast().unwrap();
}
_ => (),

8
utils/uriplaylistbin/src/uriplaylistbin/imp.rs
View file

@ -436,7 +436,7 @@ impl Item {
// from the WaitingForStreamCollection state, called when we received the item stream collection
// and its stream topology matches what is currently being processed by the element.
fn set_waiting_for_pads(&self, n_streams: u32, msg: gst::message::StreamCollection) {
fn set_waiting_for_pads(&self, n_streams: u32, msg: &gst::message::StreamCollection) {
let mut inner = self.inner.lock().unwrap();
assert!(matches!(
inner.state,
@ -463,7 +463,7 @@ impl Item {
// from the WaitingForStreamCollection state, called when we received the item stream collection
// but its stream topology does not match what is currently being processed by the element,
// having to wait until streamsynchronizer is flushed to internally reorganize the element.
fn set_waiting_for_ss_eos(&self, waiting_eos: u32, msg: gst::message::StreamCollection) {
fn set_waiting_for_ss_eos(&self, waiting_eos: u32, msg: &gst::message::StreamCollection) {
let mut inner = self.inner.lock().unwrap();
let (sender, receiver) = crossbeam_channel::unbounded::<bool>();
@ -1111,7 +1111,7 @@ impl UriPlaylistBin {
fn handle_stream_collection(
&self,
element: &super::UriPlaylistBin,
stream_collection_msg: gst::message::StreamCollection,
stream_collection_msg: &gst::message::StreamCollection,
) -> Result<(), PlaylistError> {
let mut state_guard = self.state.lock().unwrap();
let state = state_guard.as_mut().unwrap();
@ -1168,7 +1168,7 @@ impl UriPlaylistBin {
fn handle_stream_selected(
&self,
element: &super::UriPlaylistBin,
stream_selected_msg: gst::message::StreamsSelected,
stream_selected_msg: &gst::message::StreamsSelected,
) -> bool {
let mut state_guard = self.state.lock().unwrap();
let state = state_guard.as_mut().unwrap();

2
video/cdg/src/cdgdec/imp.rs
View file

@ -202,7 +202,7 @@ impl VideoDecoderImpl for CdgDec {
fn decide_allocation(
&self,
element: &Self::Type,
query: gst::query::Allocation<&mut gst::QueryRef>,
query: &mut gst::query::Allocation<gst::QueryRef>,
) -> Result<(), gst::LoggableError> {
if query
.find_allocation_meta::<gst_video::VideoMeta>()

4
video/closedcaption/src/jsontovtt/imp.rs
View file

@ -299,7 +299,7 @@ impl State {
Ok(ret)
}
fn handle_gap(&mut self, gap: gst::event::Gap<&gst::EventRef>) -> Vec<gst::Buffer> {
fn handle_gap(&mut self, gap: &gst::event::Gap<gst::EventRef>) -> Vec<gst::Buffer> {
let mut ret = vec![];
let (pts, duration) = gap.get();
@ -362,7 +362,7 @@ impl JsonToVtt {
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() {
EventView::CustomUpstream(ref ev) => {
EventView::CustomUpstream(ev) => {
if gst_video::ForceKeyUnitEvent::is(ev) {
match gst_video::UpstreamForceKeyUnitEvent::parse(ev) {
Ok(fku_event) => {

4
video/closedcaption/src/mcc_enc/imp.rs
View file

@ -401,12 +401,12 @@ impl MccEnc {
element: &super::MccEnc,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Seeking(mut q) => {
QueryViewMut::Seeking(q) => {
// We don't support any seeking at all
let fmt = q.format();
q.set(

12
video/closedcaption/src/mcc_parse/imp.rs
View file

@ -945,7 +945,7 @@ impl MccParse {
fn perform_seek(
&self,
event: &gst::event::Seek<&gst::EventRef>,
event: &gst::event::Seek<gst::EventRef>,
element: &super::MccParse,
) -> bool {
if self.state.lock().unwrap().pull.is_none() {
@ -1045,7 +1045,7 @@ impl MccParse {
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() {
EventView::Seek(e) => self.perform_seek(&e, element),
EventView::Seek(e) => self.perform_seek(e, element),
_ => pad.event_default(Some(element), event),
}
}
@ -1056,12 +1056,12 @@ impl MccParse {
element: &super::MccParse,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Seeking(mut q) => {
QueryViewMut::Seeking(q) => {
let state = self.state.lock().unwrap();
let fmt = q.format();
@ -1081,7 +1081,7 @@ impl MccParse {
false
}
}
QueryView::Position(ref mut q) => {
QueryViewMut::Position(q) => {
// For Time answer ourselfs, otherwise forward
if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap();
@ -1091,7 +1091,7 @@ impl MccParse {
self.sinkpad.peer_query(query)
}
}
QueryView::Duration(ref mut q) => {
QueryViewMut::Duration(q) => {
// For Time answer ourselfs, otherwise forward
let state = self.state.lock().unwrap();
if q.format() == gst::Format::Time {

4
video/closedcaption/src/scc_enc/imp.rs
View file

@ -337,12 +337,12 @@ impl SccEnc {
element: &super::SccEnc,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Seeking(mut q) => {
QueryViewMut::Seeking(q) => {
// We don't support any seeking at all
let fmt = q.format();
q.set(

12
video/closedcaption/src/scc_parse/imp.rs
View file

@ -820,7 +820,7 @@ impl SccParse {
fn perform_seek(
&self,
event: &gst::event::Seek<&gst::EventRef>,
event: &gst::event::Seek<gst::EventRef>,
element: &super::SccParse,
) -> bool {
if self.state.lock().unwrap().pull.is_none() {
@ -920,7 +920,7 @@ impl SccParse {
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
match event.view() {
EventView::Seek(e) => self.perform_seek(&e, element),
EventView::Seek(e) => self.perform_seek(e, element),
_ => pad.event_default(Some(element), event),
}
}
@ -931,12 +931,12 @@ impl SccParse {
element: &super::SccParse,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Seeking(mut q) => {
QueryViewMut::Seeking(q) => {
let state = self.state.lock().unwrap();
let fmt = q.format();
@ -956,7 +956,7 @@ impl SccParse {
false
}
}
QueryView::Position(ref mut q) => {
QueryViewMut::Position(q) => {
// For Time answer ourselfs, otherwise forward
if q.format() == gst::Format::Time {
let state = self.state.lock().unwrap();
@ -966,7 +966,7 @@ impl SccParse {
self.sinkpad.peer_query(query)
}
}
QueryView::Duration(ref mut q) => {
QueryViewMut::Duration(q) => {
// For Time answer ourselfs, otherwise forward
let state = self.state.lock().unwrap();
if q.format() == gst::Format::Time {

6
video/closedcaption/src/transcriberbin/imp.rs
View file

@ -384,12 +384,12 @@ impl TranscriberBin {
element: &super::TranscriberBin,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
match query.view_mut() {
QueryView::Latency(ref mut q) => {
QueryViewMut::Latency(q) => {
let mut upstream_query = gst::query::Latency::new();
let ret = pad.query_default(Some(element), &mut upstream_query);
@ -840,7 +840,7 @@ impl BinImpl for TranscriberBin {
use gst::MessageView;
match msg.view() {
MessageView::Error(ref m) => {
MessageView::Error(m) => {
/* We must have a state here */
let s = self.state.lock().unwrap();

2
video/dav1d/src/dav1ddec/imp.rs
View file

@ -463,7 +463,7 @@ impl VideoDecoderImpl for Dav1dDec {
fn decide_allocation(
&self,
element: &Self::Type,
query: gst::query::Allocation<&mut gst::QueryRef>,
query: &mut gst::query::Allocation<gst::QueryRef>,
) -> Result<(), gst::LoggableError> {
self.negotiation_infos.lock().unwrap().video_meta_supported = query
.find_allocation_meta::<gst_video::VideoMeta>()

2
video/ffv1/src/ffv1dec/imp.rs
View file

@ -458,7 +458,7 @@ impl VideoDecoderImpl for Ffv1Dec {
fn decide_allocation(
&self,
element: &Self::Type,
query: gst::query::Allocation<&mut gst::QueryRef>,
query: &mut gst::query::Allocation<gst::QueryRef>,
) -> Result<(), gst::LoggableError> {
let supported = query
.find_allocation_meta::<gst_video::VideoMeta>()

6
video/flavors/src/flvdemux/imp.rs
View file

@ -406,10 +406,10 @@ impl FlvDemux {
element: &super::FlvDemux,
query: &mut gst::QueryRef,
) -> bool {
use gst::QueryView;
use gst::QueryViewMut;
match query.view_mut() {
QueryView::Position(ref mut q) => {
QueryViewMut::Position(q) => {
let fmt = q.format();
if fmt == gst::Format::Time {
if self.sinkpad.peer_query(q.query_mut()) {
@ -428,7 +428,7 @@ impl FlvDemux {
false
}
}
QueryView::Duration(ref mut q) => {
QueryViewMut::Duration(q) => {
let fmt = q.format();
if fmt == gst::Format::Time {
if self.sinkpad.peer_query(q.query_mut()) {

2
video/gif/src/gifenc/imp.rs
View file

@ -275,7 +275,7 @@ impl VideoEncoderImpl for GifEnc {
fn propose_allocation(
&self,
element: &Self::Type,
mut query: gst::query::Allocation<&mut gst::QueryRef>,
query: &mut gst::query::Allocation<gst::QueryRef>,
) -> Result<(), gst::LoggableError> {
query.add_allocation_meta::<gst_video::VideoMeta>(None);
self.parent_propose_allocation(element, query)

2
video/gtk4/src/sink/imp.rs
View file

@ -225,7 +225,7 @@ impl BaseSinkImpl for PaintableSink {
fn propose_allocation(
&self,
element: &Self::Type,
mut query: gst::query::Allocation<&mut gst::QueryRef>,
query: &mut gst::query::Allocation<gst::QueryRef>,
) -> Result<(), gst::LoggableError> {
query.add_allocation_meta::<gst_video::VideoMeta>(None);

2
video/rav1e/src/rav1enc/imp.rs
View file

@ -488,7 +488,7 @@ impl VideoEncoderImpl for Rav1Enc {
fn propose_allocation(
&self,
element: &Self::Type,
mut query: gst::query::Allocation<&mut gst::QueryRef>,
query: &mut gst::query::Allocation<gst::QueryRef>,
) -> Result<(), gst::LoggableError> {
query.add_allocation_meta::<gst_video::VideoMeta>(None);
self.parent_propose_allocation(element, query)

4
video/videofx/src/border/roundedcorners.rs
View file

@ -610,8 +610,8 @@ impl BaseTransformImpl for RoundedCorners {
fn propose_allocation(
&self,
element: &Self::Type,
decide_query: Option<gst::query::Allocation<&gst::QueryRef>>,
mut query: gst::query::Allocation<&mut gst::QueryRef>,
decide_query: Option<&gst::query::Allocation<gst::QueryRef>>,
query: &mut gst::query::Allocation<gst::QueryRef>,
) -> Result<(), gst::LoggableError> {
query.add_allocation_meta::<gst_video::VideoMeta>(None);
self.parent_propose_allocation(element, decide_query, query)