From 86776be58c5d7e8607653edcd719ac1f0ba8d992 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Laignel?= Date: Sun, 23 Oct 2022 20:46:18 +0200 Subject: Remove `&` for `obj` in log macros This is no longer necessary. See https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1137 --- generic/threadshare/src/appsrc/imp.rs | 24 ++++++------- generic/threadshare/src/dataqueue.rs | 28 ++++++++-------- generic/threadshare/src/jitterbuffer/imp.rs | 20 +++++------ generic/threadshare/src/proxy/imp.rs | 26 +++++++-------- generic/threadshare/src/queue/imp.rs | 26 +++++++-------- generic/threadshare/src/runtime/pad.rs | 8 ++--- generic/threadshare/src/socket.rs | 14 ++++---- generic/threadshare/src/tcpclientsrc/imp.rs | 26 +++++++-------- generic/threadshare/src/udpsink/imp.rs | 52 ++++++++++++++--------------- generic/threadshare/src/udpsrc/imp.rs | 34 +++++++++---------- 10 files changed, 129 insertions(+), 129 deletions(-) (limited to 'generic/threadshare/src') diff --git a/generic/threadshare/src/appsrc/imp.rs b/generic/threadshare/src/appsrc/imp.rs index a6dd62c9e..f525c9a07 100644 --- a/generic/threadshare/src/appsrc/imp.rs +++ b/generic/threadshare/src/appsrc/imp.rs @@ -170,11 +170,11 @@ impl AppSrcTask { } async fn push_item(&mut self, item: StreamItem) -> Result { - gst::log!(CAT, obj: &self.element, "Handling {:?}", item); + gst::log!(CAT, obj: self.element, "Handling {:?}", item); let appsrc = self.element.imp(); if self.need_initial_events { - gst::debug!(CAT, obj: &self.element, "Pushing initial events"); + gst::debug!(CAT, obj: self.element, "Pushing initial events"); let stream_id = format!("{:08x}{:08x}", rand::random::(), rand::random::()); let stream_start_evt = gst::event::StreamStart::builder(&stream_id) @@ -204,7 +204,7 @@ impl AppSrcTask { match item { StreamItem::Buffer(buffer) => { - gst::log!(CAT, obj: &self.element, "Forwarding {:?}", buffer); + gst::log!(CAT, obj: self.element, "Forwarding {:?}", buffer); appsrc.src_pad.push(buffer).await } StreamItem::Event(event) => { @@ -214,7 +214,7 @@ impl AppSrcTask { Err(gst::FlowError::Eos) } _ => { - gst::log!(CAT, obj: &self.element, "Forwarding {:?}", event); + gst::log!(CAT, obj: self.element, "Forwarding {:?}", event); appsrc.src_pad.push_event(event).await; Ok(gst::FlowSuccess::Ok) } @@ -242,18 +242,18 @@ impl TaskImpl for AppSrcTask { let res = self.push_item(item).await; match res { Ok(_) => { - gst::log!(CAT, obj: &self.element, "Successfully pushed item"); + gst::log!(CAT, obj: self.element, "Successfully pushed item"); } Err(gst::FlowError::Eos) => { - gst::debug!(CAT, obj: &self.element, "EOS"); + gst::debug!(CAT, obj: self.element, "EOS"); let appsrc = self.element.imp(); appsrc.src_pad.push_event(gst::event::Eos::new()).await; } Err(gst::FlowError::Flushing) => { - gst::debug!(CAT, obj: &self.element, "Flushing"); + gst::debug!(CAT, obj: self.element, "Flushing"); } Err(err) => { - gst::error!(CAT, obj: &self.element, "Got error {}", err); + gst::error!(CAT, obj: self.element, "Got error {}", err); gst::element_error!( &self.element, gst::StreamError::Failed, @@ -270,13 +270,13 @@ impl TaskImpl for AppSrcTask { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Stopping task"); + gst::log!(CAT, obj: self.element, "Stopping task"); self.flush(); self.need_initial_events = true; self.need_segment = true; - gst::log!(CAT, obj: &self.element, "Task stopped"); + gst::log!(CAT, obj: self.element, "Task stopped"); Ok(()) } .boxed() @@ -284,12 +284,12 @@ impl TaskImpl for AppSrcTask { fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Starting task flush"); + gst::log!(CAT, obj: self.element, "Starting task flush"); self.flush(); self.need_segment = true; - gst::log!(CAT, obj: &self.element, "Task flush started"); + gst::log!(CAT, obj: self.element, "Task flush started"); Ok(()) } .boxed() diff --git a/generic/threadshare/src/dataqueue.rs b/generic/threadshare/src/dataqueue.rs index bd7544a9e..092cb3814 100644 --- a/generic/threadshare/src/dataqueue.rs +++ b/generic/threadshare/src/dataqueue.rs @@ -127,10 +127,10 @@ impl DataQueue { pub fn start(&self) { let mut inner = self.0.lock().unwrap(); if inner.state == DataQueueState::Started { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue already Started"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Data queue already Started"); return; } - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Starting data queue"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Starting data queue"); inner.state = DataQueueState::Started; inner.wake(); } @@ -138,10 +138,10 @@ impl DataQueue { pub fn stop(&self) { let mut inner = self.0.lock().unwrap(); if inner.state == DataQueueState::Stopped { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue already Stopped"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Data queue already Stopped"); return; } - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Stopping data queue"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Stopping data queue"); inner.state = DataQueueState::Stopped; inner.wake(); } @@ -149,7 +149,7 @@ impl DataQueue { pub fn clear(&self) { let mut inner = self.0.lock().unwrap(); - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Clearing data queue"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Clearing data queue"); let src_pad = inner.src_pad.clone(); for item in inner.queue.drain(..) { @@ -163,7 +163,7 @@ impl DataQueue { } } - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue cleared"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Data queue cleared"); } pub fn push(&self, item: DataQueueItem) -> Result<(), DataQueueItem> { @@ -172,7 +172,7 @@ impl DataQueue { if inner.state == DataQueueState::Stopped { gst::debug!( DATA_QUEUE_CAT, - obj: &inner.element, + obj: inner.element, "Rejecting item {:?} in state {:?}", item, inner.state @@ -180,7 +180,7 @@ impl DataQueue { return Err(item); } - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Pushing item {:?}", item); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Pushing item {:?}", item); let (count, bytes) = item.size(); let queue_ts = inner.queue.iter().filter_map(|i| i.timestamp()).next(); @@ -188,14 +188,14 @@ impl DataQueue { if let Some(max) = inner.max_size_buffers { if max <= inner.cur_size_buffers { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (buffers): {} <= {}", max, inner.cur_size_buffers); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Queue is full (buffers): {} <= {}", max, inner.cur_size_buffers); return Err(item); } } if let Some(max) = inner.max_size_bytes { if max <= inner.cur_size_bytes { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (bytes): {} <= {}", max, inner.cur_size_bytes); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Queue is full (bytes): {} <= {}", max, inner.cur_size_bytes); return Err(item); } } @@ -209,7 +209,7 @@ impl DataQueue { }; if max <= level { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Queue is full (time): {} <= {}", max, level); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Queue is full (time): {} <= {}", max, level); return Err(item); } } @@ -232,10 +232,10 @@ impl DataQueue { match inner.state { DataQueueState::Started => match inner.queue.pop_front() { None => { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue is empty"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Data queue is empty"); } Some(item) => { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Popped item {:?}", item); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Popped item {:?}", item); let (count, bytes) = item.size(); inner.cur_size_buffers -= count; @@ -245,7 +245,7 @@ impl DataQueue { } }, DataQueueState::Stopped => { - gst::debug!(DATA_QUEUE_CAT, obj: &inner.element, "Data queue Stopped"); + gst::debug!(DATA_QUEUE_CAT, obj: inner.element, "Data queue Stopped"); return None; } } diff --git a/generic/threadshare/src/jitterbuffer/imp.rs b/generic/threadshare/src/jitterbuffer/imp.rs index b736aa98d..5614aae92 100644 --- a/generic/threadshare/src/jitterbuffer/imp.rs +++ b/generic/threadshare/src/jitterbuffer/imp.rs @@ -1033,7 +1033,7 @@ impl TaskImpl for JitterBufferTask { fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Starting task"); + gst::log!(CAT, obj: self.element, "Starting task"); self.src_pad_handler.clear(); self.sink_pad_handler.clear(); @@ -1046,7 +1046,7 @@ impl TaskImpl for JitterBufferTask { state.jbuf.set_delay(latency); *jb.state.lock().unwrap() = state; - gst::log!(CAT, obj: &self.element, "Task started"); + gst::log!(CAT, obj: self.element, "Task started"); Ok(()) } .boxed() @@ -1106,9 +1106,9 @@ impl TaskImpl for JitterBufferTask { // Got aborted, reschedule if needed if let Some(delay_fut) = delay_fut { - gst::debug!(CAT, obj: &self.element, "Waiting"); + gst::debug!(CAT, obj: self.element, "Waiting"); if let Err(Aborted) = delay_fut.await { - gst::debug!(CAT, obj: &self.element, "Waiting aborted"); + gst::debug!(CAT, obj: self.element, "Waiting aborted"); return Ok(()); } } @@ -1126,7 +1126,7 @@ impl TaskImpl for JitterBufferTask { gst::debug!( CAT, - obj: &self.element, + obj: self.element, "Woke up at {}, earliest_pts {}", now.display(), state.earliest_pts.display() @@ -1182,13 +1182,13 @@ impl TaskImpl for JitterBufferTask { if let Err(err) = res { match err { gst::FlowError::Eos => { - gst::debug!(CAT, obj: &self.element, "Pushing EOS event"); + gst::debug!(CAT, obj: self.element, "Pushing EOS event"); let _ = jb.src_pad.push_event(gst::event::Eos::new()).await; } gst::FlowError::Flushing => { - gst::debug!(CAT, obj: &self.element, "Flushing") + gst::debug!(CAT, obj: self.element, "Flushing") } - err => gst::error!(CAT, obj: &self.element, "Error {}", err), + err => gst::error!(CAT, obj: self.element, "Error {}", err), } return Err(err); @@ -1204,7 +1204,7 @@ impl TaskImpl for JitterBufferTask { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Stopping task"); + gst::log!(CAT, obj: self.element, "Stopping task"); let jb = self.element.imp(); let mut jb_state = jb.state.lock().unwrap(); @@ -1218,7 +1218,7 @@ impl TaskImpl for JitterBufferTask { *jb_state = State::default(); - gst::log!(CAT, obj: &self.element, "Task stopped"); + gst::log!(CAT, obj: self.element, "Task stopped"); Ok(()) } .boxed() diff --git a/generic/threadshare/src/proxy/imp.rs b/generic/threadshare/src/proxy/imp.rs index 0003dc0ef..404824173 100644 --- a/generic/threadshare/src/proxy/imp.rs +++ b/generic/threadshare/src/proxy/imp.rs @@ -784,15 +784,15 @@ impl ProxySrcTask { match item { DataQueueItem::Buffer(buffer) => { - gst::log!(SRC_CAT, obj: &self.element, "Forwarding {:?}", buffer); + gst::log!(SRC_CAT, obj: self.element, "Forwarding {:?}", buffer); proxysrc.src_pad.push(buffer).await.map(drop) } DataQueueItem::BufferList(list) => { - gst::log!(SRC_CAT, obj: &self.element, "Forwarding {:?}", list); + gst::log!(SRC_CAT, obj: self.element, "Forwarding {:?}", list); proxysrc.src_pad.push_list(list).await.map(drop) } DataQueueItem::Event(event) => { - gst::log!(SRC_CAT, obj: &self.element, "Forwarding {:?}", event); + gst::log!(SRC_CAT, obj: self.element, "Forwarding {:?}", event); proxysrc.src_pad.push_event(event).await; Ok(()) } @@ -805,7 +805,7 @@ impl TaskImpl for ProxySrcTask { fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(SRC_CAT, obj: &self.element, "Starting task"); + gst::log!(SRC_CAT, obj: self.element, "Starting task"); let proxysrc = self.element.imp(); let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap(); @@ -819,7 +819,7 @@ impl TaskImpl for ProxySrcTask { self.dataqueue.start(); - gst::log!(SRC_CAT, obj: &self.element, "Task started"); + gst::log!(SRC_CAT, obj: self.element, "Task started"); Ok(()) } .boxed() @@ -841,25 +841,25 @@ impl TaskImpl for ProxySrcTask { let proxysrc = self.element.imp(); match res { Ok(()) => { - gst::log!(SRC_CAT, obj: &self.element, "Successfully pushed item"); + gst::log!(SRC_CAT, obj: self.element, "Successfully pushed item"); let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap(); let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared(); shared_ctx.last_res = Ok(gst::FlowSuccess::Ok); } Err(gst::FlowError::Flushing) => { - gst::debug!(SRC_CAT, obj: &self.element, "Flushing"); + gst::debug!(SRC_CAT, obj: self.element, "Flushing"); let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap(); let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared(); shared_ctx.last_res = Err(gst::FlowError::Flushing); } Err(gst::FlowError::Eos) => { - gst::debug!(SRC_CAT, obj: &self.element, "EOS"); + gst::debug!(SRC_CAT, obj: self.element, "EOS"); let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap(); let mut shared_ctx = proxy_ctx.as_ref().unwrap().lock_shared(); shared_ctx.last_res = Err(gst::FlowError::Eos); } Err(err) => { - gst::error!(SRC_CAT, obj: &self.element, "Got error {}", err); + gst::error!(SRC_CAT, obj: self.element, "Got error {}", err); gst::element_error!( &self.element, gst::StreamError::Failed, @@ -879,7 +879,7 @@ impl TaskImpl for ProxySrcTask { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(SRC_CAT, obj: &self.element, "Stopping task"); + gst::log!(SRC_CAT, obj: self.element, "Stopping task"); let proxysrc = self.element.imp(); let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap(); @@ -894,7 +894,7 @@ impl TaskImpl for ProxySrcTask { pending_queue.notify_more_queue_space(); } - gst::log!(SRC_CAT, obj: &self.element, "Task stopped"); + gst::log!(SRC_CAT, obj: self.element, "Task stopped"); Ok(()) } .boxed() @@ -902,7 +902,7 @@ impl TaskImpl for ProxySrcTask { fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(SRC_CAT, obj: &self.element, "Starting task flush"); + gst::log!(SRC_CAT, obj: self.element, "Starting task flush"); let proxysrc = self.element.imp(); let proxy_ctx = proxysrc.proxy_ctx.lock().unwrap(); @@ -912,7 +912,7 @@ impl TaskImpl for ProxySrcTask { shared_ctx.last_res = Err(gst::FlowError::Flushing); - gst::log!(SRC_CAT, obj: &self.element, "Task flush started"); + gst::log!(SRC_CAT, obj: self.element, "Task flush started"); Ok(()) } .boxed() diff --git a/generic/threadshare/src/queue/imp.rs b/generic/threadshare/src/queue/imp.rs index 53e933330..3de4930f2 100644 --- a/generic/threadshare/src/queue/imp.rs +++ b/generic/threadshare/src/queue/imp.rs @@ -264,15 +264,15 @@ impl QueueTask { match item { DataQueueItem::Buffer(buffer) => { - gst::log!(CAT, obj: &self.element, "Forwarding {:?}", buffer); + gst::log!(CAT, obj: self.element, "Forwarding {:?}", buffer); queue.src_pad.push(buffer).await.map(drop) } DataQueueItem::BufferList(list) => { - gst::log!(CAT, obj: &self.element, "Forwarding {:?}", list); + gst::log!(CAT, obj: self.element, "Forwarding {:?}", list); queue.src_pad.push_list(list).await.map(drop) } DataQueueItem::Event(event) => { - gst::log!(CAT, obj: &self.element, "Forwarding {:?}", event); + gst::log!(CAT, obj: self.element, "Forwarding {:?}", event); queue.src_pad.push_event(event).await; Ok(()) } @@ -285,7 +285,7 @@ impl TaskImpl for QueueTask { fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Starting task"); + gst::log!(CAT, obj: self.element, "Starting task"); let queue = self.element.imp(); let mut last_res = queue.last_res.lock().unwrap(); @@ -294,7 +294,7 @@ impl TaskImpl for QueueTask { *last_res = Ok(gst::FlowSuccess::Ok); - gst::log!(CAT, obj: &self.element, "Task started"); + gst::log!(CAT, obj: self.element, "Task started"); Ok(()) } .boxed() @@ -316,20 +316,20 @@ impl TaskImpl for QueueTask { let queue = self.element.imp(); match res { Ok(()) => { - gst::log!(CAT, obj: &self.element, "Successfully pushed item"); + gst::log!(CAT, obj: self.element, "Successfully pushed item"); *queue.last_res.lock().unwrap() = Ok(gst::FlowSuccess::Ok); } Err(gst::FlowError::Flushing) => { - gst::debug!(CAT, obj: &self.element, "Flushing"); + gst::debug!(CAT, obj: self.element, "Flushing"); *queue.last_res.lock().unwrap() = Err(gst::FlowError::Flushing); } Err(gst::FlowError::Eos) => { - gst::debug!(CAT, obj: &self.element, "EOS"); + gst::debug!(CAT, obj: self.element, "EOS"); *queue.last_res.lock().unwrap() = Err(gst::FlowError::Eos); queue.src_pad.push_event(gst::event::Eos::new()).await; } Err(err) => { - gst::error!(CAT, obj: &self.element, "Got error {}", err); + gst::error!(CAT, obj: self.element, "Got error {}", err); gst::element_error!( &self.element, gst::StreamError::Failed, @@ -347,7 +347,7 @@ impl TaskImpl for QueueTask { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Stopping task"); + gst::log!(CAT, obj: self.element, "Stopping task"); let queue = self.element.imp(); let mut last_res = queue.last_res.lock().unwrap(); @@ -361,7 +361,7 @@ impl TaskImpl for QueueTask { *last_res = Err(gst::FlowError::Flushing); - gst::log!(CAT, obj: &self.element, "Task stopped"); + gst::log!(CAT, obj: self.element, "Task stopped"); Ok(()) } .boxed() @@ -369,7 +369,7 @@ impl TaskImpl for QueueTask { fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Starting task flush"); + gst::log!(CAT, obj: self.element, "Starting task flush"); let queue = self.element.imp(); let mut last_res = queue.last_res.lock().unwrap(); @@ -382,7 +382,7 @@ impl TaskImpl for QueueTask { *last_res = Err(gst::FlowError::Flushing); - gst::log!(CAT, obj: &self.element, "Task flush started"); + gst::log!(CAT, obj: self.element, "Task flush started"); Ok(()) } .boxed() diff --git a/generic/threadshare/src/runtime/pad.rs b/generic/threadshare/src/runtime/pad.rs index 449a4a052..9889ad5e8 100644 --- a/generic/threadshare/src/runtime/pad.rs +++ b/generic/threadshare/src/runtime/pad.rs @@ -241,7 +241,7 @@ impl PadSrcInner { err })?; - gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks"); + gst::log!(RUNTIME_CAT, obj: self.gst_pad, "Processing any pending sub tasks"); Context::drain_sub_tasks().await?; Ok(success) @@ -260,18 +260,18 @@ impl PadSrcInner { err })?; - gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks"); + gst::log!(RUNTIME_CAT, obj: self.gst_pad, "Processing any pending sub tasks"); Context::drain_sub_tasks().await?; Ok(success) } pub async fn push_event(&self, event: gst::Event) -> bool { - gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Pushing {:?}", event); + gst::log!(RUNTIME_CAT, obj: self.gst_pad, "Pushing {:?}", event); let was_handled = self.gst_pad().push_event(event); - gst::log!(RUNTIME_CAT, obj: &self.gst_pad, "Processing any pending sub tasks"); + gst::log!(RUNTIME_CAT, obj: self.gst_pad, "Processing any pending sub tasks"); if Context::drain_sub_tasks().await.is_err() { return false; } diff --git a/generic/threadshare/src/socket.rs b/generic/threadshare/src/socket.rs index aa53d610e..3ac650d94 100644 --- a/generic/threadshare/src/socket.rs +++ b/generic/threadshare/src/socket.rs @@ -76,7 +76,7 @@ impl Socket { buffer_pool.set_active(true).map_err(|err| { gst::error!( SOCKET_CAT, - obj: &element, + obj: element, "Failed to prepare socket: {}", err ); @@ -124,7 +124,7 @@ impl Socket { pub async fn try_next( &mut self, ) -> Result<(gst::Buffer, Option), SocketError> { - gst::log!(SOCKET_CAT, obj: &self.element, "Trying to read data"); + gst::log!(SOCKET_CAT, obj: self.element, "Trying to read data"); if self.mapped_buffer.is_none() { match self.buffer_pool.acquire_buffer(None) { @@ -132,7 +132,7 @@ impl Socket { self.mapped_buffer = Some(buffer.into_mapped_buffer_writable().unwrap()); } Err(err) => { - gst::debug!(SOCKET_CAT, obj: &self.element, "Failed to acquire buffer {:?}", err); + gst::debug!(SOCKET_CAT, obj: self.element, "Failed to acquire buffer {:?}", err); return Err(SocketError::Gst(err)); } } @@ -151,7 +151,7 @@ impl Socket { // so as to display another message gst::debug!( SOCKET_CAT, - obj: &self.element, + obj: self.element, "Read {} bytes at {} (clock {})", len, running_time.display(), @@ -159,7 +159,7 @@ impl Socket { ); running_time } else { - gst::debug!(SOCKET_CAT, obj: &self.element, "Read {} bytes", len); + gst::debug!(SOCKET_CAT, obj: self.element, "Read {} bytes", len); gst::ClockTime::NONE }; @@ -175,7 +175,7 @@ impl Socket { Ok((buffer, saddr)) } Err(err) => { - gst::debug!(SOCKET_CAT, obj: &self.element, "Read error {:?}", err); + gst::debug!(SOCKET_CAT, obj: self.element, "Read error {:?}", err); Err(SocketError::Io(err)) } @@ -186,7 +186,7 @@ impl Socket { impl Drop for Socket { fn drop(&mut self) { if let Err(err) = self.buffer_pool.set_active(false) { - gst::error!(SOCKET_CAT, obj: &self.element, "Failed to unprepare socket: {}", err); + gst::error!(SOCKET_CAT, obj: self.element, "Failed to unprepare socket: {}", err); } } } diff --git a/generic/threadshare/src/tcpclientsrc/imp.rs b/generic/threadshare/src/tcpclientsrc/imp.rs index ad57b8119..8b4d57be2 100644 --- a/generic/threadshare/src/tcpclientsrc/imp.rs +++ b/generic/threadshare/src/tcpclientsrc/imp.rs @@ -184,12 +184,12 @@ impl TcpClientSrcTask { &mut self, buffer: gst::Buffer, ) -> Result { - gst::log!(CAT, obj: &self.element, "Handling {:?}", buffer); + gst::log!(CAT, obj: self.element, "Handling {:?}", buffer); let tcpclientsrc = self.element.imp(); if self.need_initial_events { - gst::debug!(CAT, obj: &self.element, "Pushing initial events"); + gst::debug!(CAT, obj: self.element, "Pushing initial events"); let stream_id = format!("{:08x}{:08x}", rand::random::(), rand::random::()); let stream_start_evt = gst::event::StreamStart::builder(&stream_id) @@ -228,20 +228,20 @@ impl TcpClientSrcTask { let res = tcpclientsrc.src_pad.push(buffer).await; match res { Ok(_) => { - gst::log!(CAT, obj: &self.element, "Successfully pushed buffer"); + gst::log!(CAT, obj: self.element, "Successfully pushed buffer"); } Err(gst::FlowError::Flushing) => { - gst::debug!(CAT, obj: &self.element, "Flushing"); + gst::debug!(CAT, obj: self.element, "Flushing"); } Err(gst::FlowError::Eos) => { - gst::debug!(CAT, obj: &self.element, "EOS"); + gst::debug!(CAT, obj: self.element, "EOS"); tcpclientsrc .src_pad .push_event(gst::event::Eos::new()) .await; } Err(err) => { - gst::error!(CAT, obj: &self.element, "Got error {}", err); + gst::error!(CAT, obj: self.element, "Got error {}", err); gst::element_error!( self.element, gst::StreamError::Failed, @@ -260,7 +260,7 @@ impl TaskImpl for TcpClientSrcTask { fn prepare(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Preparing task connecting to {:?}", self.saddr); + gst::log!(CAT, obj: self.element, "Preparing task connecting to {:?}", self.saddr); let socket = Async::::connect(self.saddr) .await @@ -285,7 +285,7 @@ impl TaskImpl for TcpClientSrcTask { })?, ); - gst::log!(CAT, obj: &self.element, "Task prepared"); + gst::log!(CAT, obj: self.element, "Task prepared"); Ok(()) } .boxed() @@ -320,7 +320,7 @@ impl TaskImpl for TcpClientSrcTask { .await .map(|(buffer, _saddr)| buffer) .map_err(|err| { - gst::error!(CAT, obj: &self.element, "Got error {:?}", err); + gst::error!(CAT, obj: self.element, "Got error {:?}", err); match err { SocketError::Gst(err) => { gst::element_error!( @@ -351,9 +351,9 @@ impl TaskImpl for TcpClientSrcTask { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Stopping task"); + gst::log!(CAT, obj: self.element, "Stopping task"); self.need_initial_events = true; - gst::log!(CAT, obj: &self.element, "Task stopped"); + gst::log!(CAT, obj: self.element, "Task stopped"); Ok(()) } .boxed() @@ -361,9 +361,9 @@ impl TaskImpl for TcpClientSrcTask { fn flush_stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Stopping task flush"); + gst::log!(CAT, obj: self.element, "Stopping task flush"); self.need_initial_events = true; - gst::log!(CAT, obj: &self.element, "Task flush stopped"); + gst::log!(CAT, obj: self.element, "Task flush stopped"); Ok(()) } .boxed() diff --git a/generic/threadshare/src/udpsink/imp.rs b/generic/threadshare/src/udpsink/imp.rs index 33a0a3f0c..a3e1bb96f 100644 --- a/generic/threadshare/src/udpsink/imp.rs +++ b/generic/threadshare/src/udpsink/imp.rs @@ -141,7 +141,7 @@ impl PadSinkHandler for UdpSinkPadHandler { let sender = elem.imp().clone_item_sender(); async move { if sender.send_async(TaskItem::Buffer(buffer)).await.is_err() { - gst::debug!(CAT, obj: &elem, "Flushing"); + gst::debug!(CAT, obj: elem, "Flushing"); return Err(gst::FlowError::Flushing); } @@ -160,7 +160,7 @@ impl PadSinkHandler for UdpSinkPadHandler { async move { for buffer in list.iter_owned() { if sender.send_async(TaskItem::Buffer(buffer)).await.is_err() { - gst::debug!(CAT, obj: &elem, "Flushing"); + gst::debug!(CAT, obj: elem, "Flushing"); return Err(gst::FlowError::Flushing); } } @@ -182,7 +182,7 @@ impl PadSinkHandler for UdpSinkPadHandler { let imp = elem.imp(); return imp.task.flush_stop().await_maybe_on_context().is_ok(); } else if sender.send_async(TaskItem::Event(event)).await.is_err() { - gst::debug!(CAT, obj: &elem, "Flushing"); + gst::debug!(CAT, obj: elem, "Flushing"); } true @@ -306,7 +306,7 @@ impl UdpSinkTask { }; let saddr = SocketAddr::new(bind_addr, bind_port as u16); - gst::debug!(CAT, obj: &self.element, "Binding to {:?}", saddr); + gst::debug!(CAT, obj: self.element, "Binding to {:?}", saddr); let socket = match family { SocketFamily::Ipv4 => socket2::Socket::new( @@ -326,7 +326,7 @@ impl UdpSinkTask { Err(err) => { gst::warning!( CAT, - obj: &self.element, + obj: self.element, "Failed to create {} socket: {}", match family { SocketFamily::Ipv4 => "IPv4", @@ -378,7 +378,7 @@ impl UdpSinkTask { fn add_client(&mut self, addr: SocketAddr) { if self.clients.contains(&addr) { - gst::warning!(CAT, obj: &self.element, "Not adding client {:?} again", &addr); + gst::warning!(CAT, obj: self.element, "Not adding client {:?} again", &addr); return; } @@ -386,11 +386,11 @@ impl UdpSinkTask { let mut settings = udpsink.settings.lock().unwrap(); match self.configure_client(&settings, &addr) { Ok(()) => { - gst::info!(CAT, obj: &self.element, "Added client {:?}", addr); + gst::info!(CAT, obj: self.element, "Added client {:?}", addr); self.clients.insert(addr); } Err(err) => { - gst::error!(CAT, obj: &self.element, "Failed to add client {:?}: {}", addr, err); + gst::error!(CAT, obj: self.element, "Failed to add client {:?}: {}", addr, err); settings.clients = self.clients.clone(); self.element.post_error_message(err); } @@ -399,7 +399,7 @@ impl UdpSinkTask { fn remove_client(&mut self, addr: &SocketAddr) { if self.clients.take(addr).is_none() { - gst::warning!(CAT, obj: &self.element, "Not removing unknown client {:?}", &addr); + gst::warning!(CAT, obj: self.element, "Not removing unknown client {:?}", &addr); return; } @@ -407,10 +407,10 @@ impl UdpSinkTask { let mut settings = udpsink.settings.lock().unwrap(); match self.unconfigure_client(&settings, addr) { Ok(()) => { - gst::info!(CAT, obj: &self.element, "Removed client {:?}", addr); + gst::info!(CAT, obj: self.element, "Removed client {:?}", addr); } Err(err) => { - gst::error!(CAT, obj: &self.element, "Failed to remove client {:?}: {}", addr, err); + gst::error!(CAT, obj: self.element, "Failed to remove client {:?}: {}", addr, err); settings.clients = self.clients.clone(); self.element.post_error_message(err); } @@ -419,9 +419,9 @@ impl UdpSinkTask { fn replace_with_clients(&mut self, mut clients_to_add: BTreeSet) { if clients_to_add.is_empty() { - gst::info!(CAT, obj: &self.element, "Clearing clients"); + gst::info!(CAT, obj: self.element, "Clearing clients"); } else { - gst::info!(CAT, obj: &self.element, "Replacing clients"); + gst::info!(CAT, obj: self.element, "Replacing clients"); } let old_clients = std::mem::take(&mut self.clients); @@ -435,19 +435,19 @@ impl UdpSinkTask { // client is already configured self.clients.insert(*addr); } else if let Err(err) = self.unconfigure_client(&settings, addr) { - gst::error!(CAT, obj: &self.element, "Failed to remove client {:?}: {}", addr, err); + gst::error!(CAT, obj: self.element, "Failed to remove client {:?}: {}", addr, err); res = Err(err); } else { - gst::info!(CAT, obj: &self.element, "Removed client {:?}", addr); + gst::info!(CAT, obj: self.element, "Removed client {:?}", addr); } } for addr in clients_to_add.into_iter() { if let Err(err) = self.configure_client(&settings, &addr) { - gst::error!(CAT, obj: &self.element, "Failed to add client {:?}: {}", addr, err); + gst::error!(CAT, obj: self.element, "Failed to add client {:?}: {}", addr, err); res = Err(err); } else { - gst::info!(CAT, obj: &self.element, "Added client {:?}", addr); + gst::info!(CAT, obj: self.element, "Added client {:?}", addr); self.clients.insert(addr); } } @@ -627,7 +627,7 @@ impl UdpSinkTask { }; if let Some(socket) = socket.as_mut() { - gst::log!(CAT, obj: &self.element, "Sending to {:?}", &client); + gst::log!(CAT, obj: self.element, "Sending to {:?}", &client); socket.send_to(&data, *client).await.map_err(|err| { element_error!( self.element, @@ -650,7 +650,7 @@ impl UdpSinkTask { gst::log!( CAT, - obj: &self.element, + obj: self.element, "Sent buffer {:?} to all clients", &buffer ); @@ -663,7 +663,7 @@ impl UdpSinkTask { let now = self.element.current_running_time(); if let Ok(Some(delay)) = running_time.opt_checked_sub(now) { - gst::trace!(CAT, obj: &self.element, "sync: waiting {}", delay); + gst::trace!(CAT, obj: self.element, "sync: waiting {}", delay); runtime::timer::delay_for(delay.into()).await; } } @@ -674,7 +674,7 @@ impl TaskImpl for UdpSinkTask { fn prepare(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::info!(CAT, obj: &self.element, "Preparing Task"); + gst::info!(CAT, obj: self.element, "Preparing Task"); assert!(self.clients.is_empty()); let clients = { let udpsink = self.element.imp(); @@ -695,7 +695,7 @@ impl TaskImpl for UdpSinkTask { fn unprepare(&mut self) -> BoxFuture<'_, ()> { async move { - gst::info!(CAT, obj: &self.element, "Unpreparing Task"); + gst::info!(CAT, obj: self.element, "Unpreparing Task"); let udpsink = self.element.imp(); let settings = udpsink.settings.lock().unwrap(); @@ -709,7 +709,7 @@ impl TaskImpl for UdpSinkTask { fn try_next(&mut self) -> BoxFuture<'_, Result> { async move { loop { - gst::info!(CAT, obj: &self.element, "Awaiting next item or command"); + gst::info!(CAT, obj: self.element, "Awaiting next item or command"); futures::select_biased! { cmd = self.cmd_receiver.recv_async() => { self.process_command(cmd.unwrap()); @@ -751,7 +751,7 @@ impl TaskImpl for UdpSinkTask { fn handle_item(&mut self, item: TaskItem) -> BoxFuture<'_, Result<(), gst::FlowError>> { async move { - gst::info!(CAT, obj: &self.element, "Handling {:?}", item); + gst::info!(CAT, obj: self.element, "Handling {:?}", item); match item { TaskItem::Buffer(buffer) => self.render(buffer).await.map_err(|err| { @@ -785,7 +785,7 @@ impl TaskImpl for UdpSinkTask { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async { - gst::info!(CAT, obj: &self.element, "Stopping Task"); + gst::info!(CAT, obj: self.element, "Stopping Task"); self.flush().await; Ok(()) } @@ -794,7 +794,7 @@ impl TaskImpl for UdpSinkTask { fn flush_start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async { - gst::info!(CAT, obj: &self.element, "Starting Task Flush"); + gst::info!(CAT, obj: self.element, "Starting Task Flush"); self.flush().await; Ok(()) } diff --git a/generic/threadshare/src/udpsrc/imp.rs b/generic/threadshare/src/udpsrc/imp.rs index 621244a18..e1a700525 100644 --- a/generic/threadshare/src/udpsrc/imp.rs +++ b/generic/threadshare/src/udpsrc/imp.rs @@ -204,7 +204,7 @@ impl TaskImpl for UdpSrcTask { let udpsrc = self.element.imp(); let mut settings = udpsrc.settings.lock().unwrap(); - gst::debug!(CAT, obj: &self.element, "Preparing Task"); + gst::debug!(CAT, obj: self.element, "Preparing Task"); self.retrieve_sender_address = settings.retrieve_sender_address; @@ -261,7 +261,7 @@ impl TaskImpl for UdpSrcTask { let saddr = SocketAddr::new(bind_addr, port as u16); gst::debug!( CAT, - obj: &self.element, + obj: self.element, "Binding to {:?} for multicast group {:?}", saddr, addr @@ -270,7 +270,7 @@ impl TaskImpl for UdpSrcTask { saddr } else { let saddr = SocketAddr::new(addr, port as u16); - gst::debug!(CAT, obj: &self.element, "Binding to {:?}", saddr); + gst::debug!(CAT, obj: self.element, "Binding to {:?}", saddr); saddr }; @@ -398,7 +398,7 @@ impl TaskImpl for UdpSrcTask { fn unprepare(&mut self) -> BoxFuture<'_, ()> { async move { - gst::debug!(CAT, obj: &self.element, "Unpreparing Task"); + gst::debug!(CAT, obj: self.element, "Unpreparing Task"); let udpsrc = self.element.imp(); udpsrc.settings.lock().unwrap().used_socket = None; self.element.notify("used-socket"); @@ -408,12 +408,12 @@ impl TaskImpl for UdpSrcTask { fn start(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Starting task"); + gst::log!(CAT, obj: self.element, "Starting task"); self.socket .as_mut() .unwrap() .set_clock(self.element.clock(), self.element.base_time()); - gst::log!(CAT, obj: &self.element, "Task started"); + gst::log!(CAT, obj: self.element, "Task started"); Ok(()) } .boxed() @@ -438,7 +438,7 @@ impl TaskImpl for UdpSrcTask { buffer }) .map_err(|err| { - gst::error!(CAT, obj: &self.element, "Got error {:?}", err); + gst::error!(CAT, obj: self.element, "Got error {:?}", err); match err { SocketError::Gst(err) => { gst::element_error!( @@ -465,11 +465,11 @@ impl TaskImpl for UdpSrcTask { fn handle_item(&mut self, buffer: gst::Buffer) -> BoxFuture<'_, Result<(), gst::FlowError>> { async { - gst::log!(CAT, obj: &self.element, "Handling {:?}", buffer); + gst::log!(CAT, obj: self.element, "Handling {:?}", buffer); let udpsrc = self.element.imp(); if self.need_initial_events { - gst::debug!(CAT, obj: &self.element, "Pushing initial events"); + gst::debug!(CAT, obj: self.element, "Pushing initial events"); let stream_id = format!("{:08x}{:08x}", rand::random::(), rand::random::()); @@ -500,14 +500,14 @@ impl TaskImpl for UdpSrcTask { let res = udpsrc.src_pad.push(buffer).await.map(drop); match res { - Ok(_) => gst::log!(CAT, obj: &self.element, "Successfully pushed buffer"), - Err(gst::FlowError::Flushing) => gst::debug!(CAT, obj: &self.element, "Flushing"), + Ok(_) => gst::log!(CAT, obj: self.element, "Successfully pushed buffer"), + Err(gst::FlowError::Flushing) => gst::debug!(CAT, obj: self.element, "Flushing"), Err(gst::FlowError::Eos) => { - gst::debug!(CAT, obj: &self.element, "EOS"); + gst::debug!(CAT, obj: self.element, "EOS"); udpsrc.src_pad.push_event(gst::event::Eos::new()).await; } Err(err) => { - gst::error!(CAT, obj: &self.element, "Got error {}", err); + gst::error!(CAT, obj: self.element, "Got error {}", err); gst::element_error!( self.element, gst::StreamError::Failed, @@ -524,10 +524,10 @@ impl TaskImpl for UdpSrcTask { fn stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Stopping task"); + gst::log!(CAT, obj: self.element, "Stopping task"); self.need_initial_events = true; self.need_segment = true; - gst::log!(CAT, obj: &self.element, "Task stopped"); + gst::log!(CAT, obj: self.element, "Task stopped"); Ok(()) } .boxed() @@ -535,9 +535,9 @@ impl TaskImpl for UdpSrcTask { fn flush_stop(&mut self) -> BoxFuture<'_, Result<(), gst::ErrorMessage>> { async move { - gst::log!(CAT, obj: &self.element, "Stopping task flush"); + gst::log!(CAT, obj: self.element, "Stopping task flush"); self.need_segment = true; - gst::log!(CAT, obj: &self.element, "Stopped task flush"); + gst::log!(CAT, obj: self.element, "Stopped task flush"); Ok(()) } .boxed() -- cgit v1.2.3