diff --git a/src/rtsp/gst/factory.rs b/src/rtsp/gst/factory.rs index 75901a3..3272db0 100644 --- a/src/rtsp/gst/factory.rs +++ b/src/rtsp/gst/factory.rs @@ -323,11 +323,20 @@ impl NeoMediaFactoryImpl { .enough_data(move |_appsrc| { let _ = enough_command.blocking_send(NeoMediaSenderCommand::Pause); }) - .seek_data(move |_appsrc, seek_pos| { + .seek_data(move |appsrc, seek_pos| { debug!("Send seek H265"); - let _ = - seek_command.blocking_send(NeoMediaSenderCommand::Seek(seek_pos)); - true + let runtime = appsrc.clock().and_then(|clock| { + clock.time().and_then(|time| { + appsrc.base_time().map(|base_time| { + time.saturating_sub(base_time).useconds() as i64 + }) + }) + }); + let res = seek_command + .blocking_send(NeoMediaSenderCommand::Seek(runtime, seek_pos)) + .is_ok(); + debug!("Sent seek H265: {}", res); + res }) .build(), ); @@ -371,15 +380,22 @@ impl NeoMediaFactoryImpl { source.set_callbacks( AppSrcCallbacks::builder() .need_data(move |_appsrc, _amt| { - let _ = need_command.try_send(NeoMediaSenderCommand::Resume); + let _ = need_command.blocking_send(NeoMediaSenderCommand::Resume); }) .enough_data(move |_appsrc| { - let _ = enough_command.try_send(NeoMediaSenderCommand::Pause); + let _ = enough_command.blocking_send(NeoMediaSenderCommand::Pause); }) - .seek_data(move |_appsrc, seek_pos| { + .seek_data(move |appsrc, seek_pos| { debug!("Send seek H264: {}", seek_pos); + let runtime = appsrc.clock().and_then(|clock| { + clock.time().and_then(|time| { + appsrc.base_time().map(|base_time| { + time.saturating_sub(base_time).useconds() as i64 + }) + }) + }); let result = seek_command - .try_send(NeoMediaSenderCommand::Seek(seek_pos)) + .blocking_send(NeoMediaSenderCommand::Seek(runtime, seek_pos)) .is_ok(); debug!(" - Sent seek H264: {}", result); result diff --git a/src/rtsp/gst/sender.rs b/src/rtsp/gst/sender.rs index e6c9ba0..641f035 100644 --- a/src/rtsp/gst/sender.rs +++ b/src/rtsp/gst/sender.rs @@ -100,14 +100,14 @@ impl NeoBuffer { // .map(|i| i as FrameTime) // } - // fn start_time(&self) -> Option { - // let (fronts, backs) = self.buf.as_slices(); - // fronts - // .iter() - // .chain(&mut backs.iter()) - // .map(|frame| frame.time) - // .next() - // } + fn start_time(&self) -> Option { + let (fronts, backs) = self.buf.as_slices(); + fronts + .iter() + .chain(&mut backs.iter()) + .map(|frame| frame.time) + .next() + } fn end_time(&self) -> Option { let (fronts, backs) = self.buf.as_slices(); @@ -385,7 +385,7 @@ impl NeoMediaSenders { } pub(super) enum NeoMediaSenderCommand { - Seek(u64), + Seek(Option, u64), Pause, Resume, } @@ -401,19 +401,12 @@ pub(super) struct NeoMediaSender { playing: bool, } -#[allow(dead_code)] -enum JumpMethod { - MiddleIFrame, - BufferPerunit(f32), -} - impl NeoMediaSender { pub(super) fn new() -> Self { let (tx, rx) = channel(30); Self { - start_time: Spring::new(0.0, 0.0, 2.5), + start_time: Spring::new(0.0, 0.0, 5.5), buffer: NeoBuffer::default(), - vid: None, aud: None, command_reciever: rx, @@ -461,9 +454,28 @@ impl NeoMediaSender { async fn update_starttime(&mut self) -> AnyResult<()> { self.start_time.update().await; - let target_frame = self.buffer.buf.len().saturating_sub(BUFFER_SIZE / 3); - let target_time = self.buffer.buf.get(target_frame).map(|frame| frame.time); - if let (Some(runtime), Some(target_time)) = (self.get_runtime(), target_time) { + let target_idx = BUFFER_SIZE / 3; + let target_time_target_frame = if self.buffer.buf.len() >= target_idx { + let target_frame = self.buffer.buf.len().saturating_sub(target_idx); + self.buffer + .buf + .get(target_frame) + .map(|frame| (frame.time, target_frame as i64)) + } else { + // Approximate it's location + let fraction = target_idx as f64 / self.buffer.buf.len() as f64; + if let (Some(st), Some(et)) = (self.buffer.start_time(), self.buffer.end_time()) { + Some(( + et - ((et - st) as f64 * fraction) as FrameTime, + -((target_idx - self.buffer.buf.len()) as i64), + )) + } else { + None + } + }; + if let (Some(runtime), Some((target_time, target_frame))) = + (self.get_runtime(), target_time_target_frame) + { debug!( "Target frame: {}, Target time: {}, Target start time: {}, Current start time: {}", target_frame, @@ -478,22 +490,31 @@ impl NeoMediaSender { async fn seek( &mut self, + _original_runtime: Option, target_runtime: FrameTime, - master_buffer: &NeoBuffer, + _master_buffer: &NeoBuffer, ) -> AnyResult<()> { - let target_buftime = self.runtime_to_buftime(target_runtime); - self.buffer.buf.clear(); - - // Master buffer has historical data - // Refill our buffer with the frames it wants - for master_frame in master_buffer - .buf - .iter() - .filter(|frame| frame.time >= target_buftime) - { - self.buffer.push(master_frame.clone()); + if let Some(appsrc) = self.vid.as_ref() { + if let Some(clock) = appsrc.clock() { + if let Some(time) = clock.time() { + if appsrc.base_time().is_some() { + // let current_runtime = time.saturating_sub(base_time); + let target_runtime = ClockTime::from_useconds(target_runtime as u64); + appsrc.set_base_time(time.saturating_sub(target_runtime)); + } + } + } + } + if let Some(appsrc) = self.aud.as_ref() { + if let Some(clock) = appsrc.clock() { + if let Some(time) = clock.time() { + if appsrc.base_time().is_some() { + let target_runtime = ClockTime::from_useconds(target_runtime as u64); + appsrc.set_base_time(time.saturating_sub(target_runtime)); + } + } + } } - // Then accelerate us to to live self.jump_to_live().await?; Ok(()) } @@ -502,9 +523,9 @@ impl NeoMediaSender { if self.inited { if let Ok(command) = self.command_reciever.try_recv() { match command { - NeoMediaSenderCommand::Seek(dest) => { + NeoMediaSenderCommand::Seek(runtime, dest) => { debug!("Got Seek Request: {:?}", Duration::from_micros(dest)); - self.seek(dest as FrameTime, master_buffer).await?; + self.seek(runtime, dest as FrameTime, master_buffer).await?; } NeoMediaSenderCommand::Pause => { if self.playing { @@ -658,6 +679,7 @@ impl NeoMediaSender { tokio::try_join!( async { if !vid_buffers.is_empty() { + debug!("Sending video buffers: {}", vid_buffers.len()); if let Some(appsrc) = self.vid.clone() { let buffers = { let mut buffers = @@ -665,9 +687,17 @@ impl NeoMediaSender { { let buffers_ref = buffers.get_mut().unwrap(); for (time, buf) in vid_buffers.drain(..) { - debug!("Sending vid frame at time {}", time); tokio::task::yield_now().await; let runtime = self.buftime_to_runtime(time); + let actual_runtime = self + .get_runtime() + .map(|i| Duration::from_micros(i as u64)); + debug!( + " - Sending vid frame at time {} ({:?} Expect: {:?})", + time, + Duration::from_micros(runtime as u64), + actual_runtime + ); let gst_buf = { let mut gst_buf = @@ -692,6 +722,7 @@ impl NeoMediaSender { }; let res = tokio::task::spawn_blocking(move || { + debug!(" - Pushing buffer: {}", buffers.len()); appsrc .push_buffer_list(buffers.copy()) .map(|_| ()) diff --git a/src/rtsp/mod.rs b/src/rtsp/mod.rs index b5da075..4d9295e 100644 --- a/src/rtsp/mod.rs +++ b/src/rtsp/mod.rs @@ -199,19 +199,28 @@ async fn camera_main(camera: Camera) -> Result<(), CameraFailureKi .map_err(CameraFailureKind::Retry)?; // Wait for buffers to be prepared - let mut waiter = tokio::time::interval(Duration::from_micros(500)); - loop { - waiter.tick().await; - if tags - .iter() - .map(|tag| rtsp_thread.buffer_ready(tag)) - .collect::>() - .all(|f| f.unwrap_or(false)) - .await - { - break; - } + tokio::select! { + v = async { + let mut waiter = tokio::time::interval(Duration::from_micros(500)); + loop { + waiter.tick().await; + if tags + .iter() + .map(|tag| rtsp_thread.buffer_ready(tag)) + .collect::>() + .all(|f| f.unwrap_or(false)) + .await + { + break; + } + } + Ok(()) + } => v, + // Or for stream to error + v = streaming.join() => {v}, } + .with_context(|| format!("{}: Error while waiting for buffers", name)) + .map_err(CameraFailureKind::Retry)?; tags.iter() .map(|tag| rtsp_thread.jump_to_live(tag))