mirror of
https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git
synced 2024-05-12 13:22:46 +00:00
1935 lines
68 KiB
Rust
1935 lines
68 KiB
Rust
//
|
|
// Copyright (C) 2023 Sebastian Dröge <sebastian@centricular.com>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public License, v2.0.
|
|
// If a copy of the MPL was not distributed with this file, You can obtain one at
|
|
// <https://mozilla.org/MPL/2.0/>.
|
|
//
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
use atomic_refcell::AtomicRefCell;
|
|
use gst::{glib, prelude::*, subclass::prelude::*};
|
|
use gst_rtp::prelude::*;
|
|
|
|
use once_cell::sync::Lazy;
|
|
|
|
use std::{
|
|
collections::{BTreeMap, VecDeque},
|
|
ops::{Bound, RangeBounds},
|
|
sync::Mutex,
|
|
};
|
|
|
|
use super::{PacketToBufferRelation, TimestampOffset};
|
|
|
|
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
|
|
gst::DebugCategory::new(
|
|
"rtpbasedepay2",
|
|
gst::DebugColorFlags::empty(),
|
|
Some("RTP Base Depayloader 2"),
|
|
)
|
|
});
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct Settings {
|
|
max_reorder: u32,
|
|
source_info: bool,
|
|
auto_header_extensions: bool,
|
|
}
|
|
|
|
impl Default for Settings {
|
|
fn default() -> Self {
|
|
Self {
|
|
max_reorder: 100,
|
|
source_info: false,
|
|
auto_header_extensions: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Metadata of a pending packet for tracking purposes.
|
|
struct PendingPacket {
|
|
/// Extended sequence number of the packet.
|
|
ext_seqnum: u64,
|
|
/// Extended RTP timestamp of the packet.
|
|
ext_timestamp: u64,
|
|
/// SSRC of the packet.
|
|
ssrc: u32,
|
|
/// CSRC of the packet.
|
|
csrc: [u32; rtp_types::RtpPacket::MAX_N_CSRCS],
|
|
n_csrc: u8,
|
|
/// Packet contains header extensions.
|
|
have_header_extensions: bool,
|
|
/// Buffer containing the packet.
|
|
buffer: gst::Buffer,
|
|
}
|
|
|
|
/// A pending buffer that still has to be sent downstream.
|
|
struct PendingBuffer {
|
|
/// If no metadata is set then this buffer must be pushed together with
|
|
/// the next buffer where it is actually known, or at EOS with the
|
|
/// last known one.
|
|
metadata_set: bool,
|
|
buffer: gst::Buffer,
|
|
}
|
|
|
|
/// Information about the current stream that is handled.
|
|
struct CurrentStream {
|
|
/// SSRC of the last received packet.
|
|
ssrc: u32,
|
|
/// Payload type of the last received packet.
|
|
pt: u8,
|
|
/// Extended sequence number of the last received packet.
|
|
ext_seqnum: u64,
|
|
/// Extended RTP time of the last received packet.
|
|
ext_rtptime: u64,
|
|
}
|
|
|
|
struct State {
|
|
segment: Option<(gst::Seqnum, gst::FormattedSegment<gst::ClockTime>)>,
|
|
/// Set when a new segment event should be sent downstream before the next buffer.
|
|
pending_segment: bool,
|
|
|
|
sink_caps: Option<gst::Caps>,
|
|
src_caps: Option<gst::Caps>,
|
|
|
|
/// Set when the sinkpad caps are known.
|
|
clock_rate: Option<u32>,
|
|
|
|
// NPT start from old-style RTSP caps.
|
|
npt_start: Option<gst::ClockTime>,
|
|
// NPT stop from old-style RTSP caps.
|
|
npt_stop: Option<gst::ClockTime>,
|
|
// Play scale from old-style RTSP caps.
|
|
play_speed: f64,
|
|
// Play speed from old-style RTSP caps.
|
|
play_scale: f64,
|
|
// Clock base from old-style RTSP caps.
|
|
clock_base: Option<u32>,
|
|
// Initial PTS / ext_rtptime after a caps event where NPT start was set.
|
|
npt_start_times: Option<(Option<gst::ClockTime>, u64)>,
|
|
|
|
/// Set when the next outgoing buffer should have the discont flag set.
|
|
discont_pending: bool,
|
|
|
|
/// Current stream configuration. Set on first packet and whenever it changes.
|
|
current_stream: Option<CurrentStream>,
|
|
|
|
/// Last extended seqnum that was used for a buffer.
|
|
last_used_ext_seqnum: Option<u64>,
|
|
|
|
/// PTS of the last outgoing buffer.
|
|
last_pts: Option<gst::ClockTime>,
|
|
/// DTS of the last outgoing buffer.
|
|
last_dts: Option<gst::ClockTime>,
|
|
|
|
/// Pending input packets that were not completely used up for outgoing buffers yet.
|
|
pending_packets: VecDeque<PendingPacket>,
|
|
|
|
/// Pending buffers that have to be pushed downstream. Some of them might not have a PTS yet,
|
|
/// i.e. were created without corresponding seqnums.
|
|
pending_buffers: VecDeque<PendingBuffer>,
|
|
}
|
|
|
|
impl Default for State {
|
|
fn default() -> Self {
|
|
Self {
|
|
segment: None,
|
|
pending_segment: false,
|
|
|
|
sink_caps: None,
|
|
src_caps: None,
|
|
|
|
clock_rate: None,
|
|
|
|
npt_start: None,
|
|
npt_stop: None,
|
|
play_scale: 1.0,
|
|
play_speed: 1.0,
|
|
clock_base: None,
|
|
npt_start_times: None,
|
|
|
|
discont_pending: true,
|
|
|
|
current_stream: None,
|
|
|
|
last_used_ext_seqnum: None,
|
|
|
|
last_pts: None,
|
|
last_dts: None,
|
|
|
|
pending_packets: VecDeque::new(),
|
|
pending_buffers: VecDeque::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct Stats {
|
|
ssrc: u32,
|
|
clock_rate: u32,
|
|
running_time_dts: Option<gst::ClockTime>,
|
|
running_time_pts: Option<gst::ClockTime>,
|
|
seqnum: u16,
|
|
timestamp: u32,
|
|
npt_start: Option<gst::ClockTime>,
|
|
npt_stop: Option<gst::ClockTime>,
|
|
play_speed: f64,
|
|
play_scale: f64,
|
|
}
|
|
|
|
pub struct RtpBaseDepay2 {
|
|
sink_pad: gst::Pad,
|
|
src_pad: gst::Pad,
|
|
state: AtomicRefCell<State>,
|
|
settings: Mutex<Settings>,
|
|
stats: Mutex<Option<Stats>>,
|
|
extensions: Mutex<BTreeMap<u8, gst_rtp::RTPHeaderExtension>>,
|
|
}
|
|
|
|
/// Wrapper around `gst::Caps` that implements `Ord` around the structure name.
|
|
struct CapsOrd(gst::Caps);
|
|
|
|
impl CapsOrd {
|
|
fn new(caps: gst::Caps) -> Self {
|
|
assert!(caps.is_fixed());
|
|
CapsOrd(caps)
|
|
}
|
|
}
|
|
|
|
impl PartialEq for CapsOrd {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.cmp(other) == std::cmp::Ordering::Equal
|
|
}
|
|
}
|
|
|
|
impl Eq for CapsOrd {}
|
|
|
|
impl PartialOrd for CapsOrd {
|
|
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
|
|
Some(self.cmp(other))
|
|
}
|
|
}
|
|
|
|
impl Ord for CapsOrd {
|
|
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
|
self.0
|
|
.structure(0)
|
|
.unwrap()
|
|
.name()
|
|
.cmp(other.0.structure(0).unwrap().name())
|
|
}
|
|
}
|
|
|
|
/// Wrappers for public methods and associated helper functions.
|
|
#[allow(dead_code)]
|
|
impl RtpBaseDepay2 {
|
|
pub(super) fn set_src_caps(&self, src_caps: &gst::Caps) {
|
|
gst::debug!(CAT, imp: self, "Setting caps {src_caps:?}");
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
if Some(src_caps) == state.src_caps.as_ref() {
|
|
gst::debug!(CAT, imp: self, "Setting same caps {src_caps:?} again");
|
|
return;
|
|
}
|
|
|
|
let seqnum = if let Some((seqnum, _)) = state.segment {
|
|
seqnum
|
|
} else {
|
|
gst::Seqnum::next()
|
|
};
|
|
state.src_caps = Some(src_caps.clone());
|
|
let segment_event = self.retrieve_pending_segment_event(&mut state);
|
|
drop(state);
|
|
|
|
// Rely on the actual flow return later when pushing a buffer downstream. The bool
|
|
// return from pushing the event does not allow to distinguish between different kinds of
|
|
// errors.
|
|
let _ = self
|
|
.src_pad
|
|
.push_event(gst::event::Caps::builder(src_caps).seqnum(seqnum).build());
|
|
|
|
if let Some(segment_event) = segment_event {
|
|
let _ = self.src_pad.push_event(segment_event);
|
|
}
|
|
}
|
|
|
|
pub(super) fn drop_packets(&self, ext_seqnum: impl RangeBounds<u64>) {
|
|
gst::trace!(CAT, imp: self, "Dropping packets up to ext seqnum {:?}", ext_seqnum.end_bound());
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
state.discont_pending = true;
|
|
|
|
let end = match ext_seqnum.end_bound() {
|
|
Bound::Included(end) => *end,
|
|
Bound::Excluded(end) if *end == 0 => return,
|
|
Bound::Excluded(end) => *end - 1,
|
|
Bound::Unbounded => {
|
|
state.pending_buffers.clear();
|
|
return;
|
|
}
|
|
};
|
|
|
|
if let Some(back) = state.pending_packets.back() {
|
|
if back.ext_seqnum <= end {
|
|
state.pending_packets.clear();
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
while state
|
|
.pending_packets
|
|
.front()
|
|
.map_or(false, |p| p.ext_seqnum <= end)
|
|
{
|
|
let _ = state.pending_packets.pop_front();
|
|
}
|
|
}
|
|
|
|
fn retrieve_pts_dts(
|
|
&self,
|
|
state: &State,
|
|
ext_seqnum: u64,
|
|
) -> (Option<gst::ClockTime>, Option<gst::ClockTime>) {
|
|
let mut pts = None;
|
|
let mut dts = None;
|
|
|
|
for front in state
|
|
.pending_packets
|
|
.iter()
|
|
.take_while(|p| p.ext_seqnum <= ext_seqnum)
|
|
{
|
|
// Remember first PTS/DTS
|
|
if pts.is_none() || dts.is_none() {
|
|
pts = front.buffer.pts();
|
|
dts = front.buffer.dts();
|
|
}
|
|
|
|
if pts.is_some() || dts.is_some() {
|
|
break;
|
|
}
|
|
}
|
|
|
|
(pts, dts)
|
|
}
|
|
|
|
fn copy_metas(
|
|
&self,
|
|
settings: &Settings,
|
|
state: &mut State,
|
|
ext_seqnum: u64,
|
|
buffer: &mut gst::BufferRef,
|
|
) -> bool {
|
|
let mut extension_wants_caps_update = false;
|
|
let extensions = self.extensions.lock().unwrap();
|
|
|
|
let mut ssrc = None;
|
|
let mut csrc = [0u32; rtp_types::RtpPacket::MAX_N_CSRCS];
|
|
let mut n_csrc = 0;
|
|
|
|
// Copy over metas and other metadata from the packets that made up this buffer
|
|
let obj = self.obj();
|
|
for front in state
|
|
.pending_packets
|
|
.iter()
|
|
.take_while(|p| p.ext_seqnum <= ext_seqnum)
|
|
{
|
|
// Filter out reference timestamp metas that have the same timestamps
|
|
let mut reference_timestamp_metas = BTreeMap::new();
|
|
|
|
front.buffer.foreach_meta(|meta| {
|
|
use std::ops::ControlFlow::*;
|
|
|
|
// Do not copy metas that are memory specific
|
|
if meta.has_tag::<gst::meta::tags::Memory>()
|
|
|| meta.has_tag::<gst::meta::tags::MemoryReference>()
|
|
{
|
|
return Continue(());
|
|
}
|
|
|
|
// Actual filtering of reference timestamp metas with same timestamp
|
|
if let Some(meta) = meta.downcast_ref::<gst::ReferenceTimestampMeta>() {
|
|
let mut same = false;
|
|
reference_timestamp_metas
|
|
.entry(CapsOrd::new(meta.reference_owned()))
|
|
.and_modify(|timestamp| {
|
|
same = *timestamp == meta.timestamp();
|
|
*timestamp = meta.timestamp();
|
|
})
|
|
.or_insert(meta.timestamp());
|
|
|
|
if same {
|
|
return Continue(());
|
|
}
|
|
}
|
|
|
|
(obj.class().as_ref().transform_meta)(&obj, &front.buffer, &meta, buffer);
|
|
|
|
Continue(())
|
|
});
|
|
|
|
if !extensions.is_empty() && front.have_header_extensions {
|
|
let map = front.buffer.map_readable().unwrap();
|
|
let packet = rtp_types::RtpPacket::parse(&map).unwrap();
|
|
let (extension_pattern, mut extensions_data) = packet.extension().unwrap();
|
|
|
|
let extension_flags = match extension_pattern {
|
|
0xBEDE => gst_rtp::RTPHeaderExtensionFlags::ONE_BYTE,
|
|
x if x >> 4 == 0x100 => gst_rtp::RTPHeaderExtensionFlags::TWO_BYTE,
|
|
_ => {
|
|
gst::trace!(CAT, imp: self, "Unknown extension pattern {extension_pattern:04X}");
|
|
continue;
|
|
}
|
|
};
|
|
|
|
while !extensions_data.is_empty() {
|
|
let (id, len) = if extension_flags == gst_rtp::RTPHeaderExtensionFlags::ONE_BYTE
|
|
{
|
|
let b = extensions_data[0];
|
|
extensions_data = &extensions_data[1..];
|
|
|
|
let id = b >> 4;
|
|
let len = (b & 0x0f) + 1;
|
|
|
|
// Padding
|
|
if id == 0 {
|
|
continue;
|
|
}
|
|
if id == 15 {
|
|
// Special ID
|
|
break;
|
|
}
|
|
|
|
(id, len as usize)
|
|
} else {
|
|
let id = extensions_data[0];
|
|
extensions_data = &extensions_data[1..];
|
|
|
|
// Padding
|
|
if id == 0 {
|
|
continue;
|
|
}
|
|
|
|
if extensions_data.is_empty() {
|
|
break;
|
|
}
|
|
|
|
let len = extensions_data[1];
|
|
extensions_data = &extensions_data[1..];
|
|
|
|
(id, len as usize)
|
|
};
|
|
|
|
if extensions_data.len() < len {
|
|
break;
|
|
}
|
|
|
|
gst::trace!(CAT, imp: self, "Handling RTP header extension with id {id} and length {len}");
|
|
|
|
let (extension_data, remainder) = extensions_data.split_at(len);
|
|
extensions_data = remainder;
|
|
|
|
let Some(extension) = extensions.get(&id) else {
|
|
continue;
|
|
};
|
|
|
|
if !extension.read(extension_flags, extension_data, buffer) {
|
|
gst::warning!(CAT, imp: self, "Failed reading RTP header extension with id {id} and length {len}");
|
|
continue;
|
|
}
|
|
|
|
extension_wants_caps_update |= extension.wants_update_non_rtp_src_caps();
|
|
}
|
|
}
|
|
|
|
if settings.source_info {
|
|
if ssrc.is_none() {
|
|
ssrc = Some(front.ssrc);
|
|
}
|
|
|
|
for c in &front.csrc[..front.n_csrc as usize] {
|
|
if !csrc[..n_csrc].contains(c) && n_csrc < rtp_types::RtpPacket::MAX_N_CSRCS {
|
|
csrc[n_csrc] = *c;
|
|
n_csrc += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if settings.source_info && ssrc.is_some() {
|
|
gst_rtp::RTPSourceMeta::add(buffer, ssrc, &csrc[..n_csrc]);
|
|
}
|
|
|
|
extension_wants_caps_update
|
|
}
|
|
|
|
pub(super) fn queue_buffer(
|
|
&self,
|
|
packet_to_buffer_relation: PacketToBufferRelation,
|
|
mut buffer: gst::Buffer,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
let settings = self.settings.lock().unwrap().clone();
|
|
|
|
{
|
|
// Reset some buffer metadata, it shouldn't have been set
|
|
let buffer_ref = buffer.make_mut();
|
|
buffer_ref.set_pts(None);
|
|
buffer_ref.set_dts(None);
|
|
}
|
|
|
|
gst::trace!(CAT, imp: self, "Queueing buffer {buffer:?} for seqnum range {packet_to_buffer_relation:?}");
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
if state.src_caps.is_none() {
|
|
gst::error!(CAT, imp: self, "No source pad caps negotiated yet");
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
}
|
|
|
|
if matches!(packet_to_buffer_relation, PacketToBufferRelation::OutOfBand) {
|
|
gst::trace!(CAT, imp: self, "Keeping buffer without associated seqnums until next buffer or EOS");
|
|
|
|
state.pending_buffers.push_back(PendingBuffer {
|
|
metadata_set: false,
|
|
buffer,
|
|
});
|
|
return Ok(gst::FlowSuccess::Ok);
|
|
};
|
|
|
|
let (seqnums, timestamp_offset) = match packet_to_buffer_relation {
|
|
PacketToBufferRelation::Seqnums(seqnums) => (seqnums.clone(), None),
|
|
PacketToBufferRelation::SeqnumsWithOffset {
|
|
seqnums: ids,
|
|
timestamp_offset,
|
|
} => (ids.clone(), Some(timestamp_offset)),
|
|
PacketToBufferRelation::OutOfBand => unreachable!(),
|
|
};
|
|
|
|
if seqnums.is_empty() {
|
|
gst::error!(CAT, imp: self, "Empty packet ext seqnum range provided");
|
|
return Err(gst::FlowError::Error);
|
|
}
|
|
|
|
let seqnum_start = *seqnums.start();
|
|
let seqnum_end = *seqnums.end();
|
|
|
|
// Drop all older seqnums
|
|
while state
|
|
.pending_packets
|
|
.front()
|
|
.map_or(false, |p| p.ext_seqnum < seqnum_start)
|
|
{
|
|
let p = state.pending_packets.pop_front().unwrap();
|
|
gst::trace!(CAT, imp: self, "Dropping packet with extended seqnum {}", p.ext_seqnum);
|
|
}
|
|
|
|
if state.pending_packets.is_empty() {
|
|
gst::error!(CAT, imp: self, "Queueing buffers for future ext seqnums not allowed");
|
|
return Err(gst::FlowError::Error);
|
|
};
|
|
|
|
if seqnum_end > state.pending_packets.back().unwrap().ext_seqnum {
|
|
gst::error!(CAT, imp: self, "Queueing buffers for future ext seqnums not allowed");
|
|
return Err(gst::FlowError::Error);
|
|
}
|
|
|
|
let mut discont_pending = state.discont_pending;
|
|
state.discont_pending = false;
|
|
|
|
let mut pts = state
|
|
.pending_packets
|
|
.iter()
|
|
.take_while(|p| p.ext_seqnum <= seqnum_end)
|
|
.find_map(|p| p.buffer.pts());
|
|
let mut dts = None;
|
|
|
|
if let Some(timestamp_offset) = timestamp_offset {
|
|
match timestamp_offset {
|
|
TimestampOffset::Pts(pts_offset) => {
|
|
if let Some(ts) = pts {
|
|
let pts_signed = ts.into_positive() + pts_offset;
|
|
if let Some(ts) = pts_signed.positive() {
|
|
pts = Some(ts);
|
|
} else {
|
|
gst::warning!(CAT, imp: self, "Negative PTS {} calculated, not supported", pts_signed);
|
|
}
|
|
}
|
|
}
|
|
TimestampOffset::PtsAndDts(pts_offset, dts_offset) => {
|
|
if let Some(ts) = pts {
|
|
let pts_signed = ts.into_positive() + pts_offset;
|
|
if let Some(ts) = pts_signed.positive() {
|
|
pts = Some(ts);
|
|
} else {
|
|
gst::warning!(CAT, imp: self, "Negative PTS {} calculated, not supported", pts_signed);
|
|
}
|
|
}
|
|
|
|
if let Some(pts) = pts {
|
|
let dts_signed = pts.into_positive() + dts_offset;
|
|
if let Some(ts) = dts_signed.positive() {
|
|
dts = Some(ts);
|
|
} else {
|
|
gst::warning!(CAT, imp: self, "Negative DTS {} calculated, not supported", dts_signed);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if state
|
|
.last_used_ext_seqnum
|
|
.map_or(false, |last_used_ext_seqnum| {
|
|
seqnum_end <= last_used_ext_seqnum
|
|
})
|
|
{
|
|
// If we have no timestamp offset and this is not the first time a buffer for this
|
|
// packet is queued then unset the PTS. It's not going to be correct.
|
|
pts = None;
|
|
}
|
|
|
|
// Decorate all previously queued buffers metadata
|
|
for buffer in state
|
|
.pending_buffers
|
|
.iter_mut()
|
|
.skip_while(|b| b.metadata_set)
|
|
{
|
|
assert!(!buffer.metadata_set);
|
|
buffer.metadata_set = true;
|
|
let buffer = &mut buffer.buffer;
|
|
let buffer_ref = buffer.make_mut();
|
|
buffer_ref.set_pts(pts);
|
|
buffer_ref.set_dts(dts);
|
|
if discont_pending {
|
|
buffer_ref.set_flags(gst::BufferFlags::DISCONT);
|
|
discont_pending = false;
|
|
}
|
|
}
|
|
|
|
// Decorate the new buffer
|
|
{
|
|
let buffer_ref = buffer.make_mut();
|
|
buffer_ref.set_pts(pts);
|
|
buffer_ref.set_dts(dts);
|
|
let needs_caps_update = self.copy_metas(&settings, &mut state, seqnum_end, buffer_ref);
|
|
|
|
if discont_pending {
|
|
buffer_ref.set_flags(gst::BufferFlags::DISCONT);
|
|
}
|
|
|
|
// If a caps update is needed then let's do that *before* outputting this buffer.
|
|
if needs_caps_update {
|
|
let old_src_caps = state.src_caps.as_ref().unwrap();
|
|
let mut src_caps = old_src_caps.copy();
|
|
|
|
{
|
|
let src_caps = src_caps.get_mut().unwrap();
|
|
let extensions = self.extensions.lock().unwrap();
|
|
for extension in extensions.values() {
|
|
if !extension.update_non_rtp_src_caps(src_caps) {
|
|
gst::error!(CAT, imp: self, "RTP header extension {} could not update caps", extension.name());
|
|
return Err(gst::FlowError::Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
if &src_caps != old_src_caps {
|
|
let seqnum = state.segment.as_ref().unwrap().0;
|
|
drop(state);
|
|
self.finish_pending_buffers()?;
|
|
|
|
let _ = self
|
|
.src_pad
|
|
.push_event(gst::event::Caps::builder(&src_caps).seqnum(seqnum).build());
|
|
|
|
state = self.state.borrow_mut();
|
|
state.src_caps = Some(src_caps);
|
|
}
|
|
}
|
|
}
|
|
|
|
state.pending_buffers.push_back(PendingBuffer {
|
|
metadata_set: true,
|
|
buffer,
|
|
});
|
|
|
|
state.last_used_ext_seqnum = Some(seqnum_end);
|
|
if pts.is_some() {
|
|
state.last_pts = pts;
|
|
state.last_dts = dts;
|
|
}
|
|
|
|
Ok(gst::FlowSuccess::Ok)
|
|
}
|
|
|
|
pub(super) fn finish_pending_buffers(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
let mut state = self.state.borrow_mut();
|
|
|
|
// As long as there are buffers that can be finished, take all with the same PTS (or no
|
|
// PTS) and put them into a buffer list.
|
|
while state.pending_buffers.iter().any(|b| b.metadata_set) {
|
|
let pts = state.pending_buffers.front().unwrap().buffer.pts();
|
|
|
|
// First count number of pending packets so we can allocate a buffer list with the correct
|
|
// size instead of re-allocating for every added buffer, or simply push a single buffer
|
|
// downstream instead of allocating a buffer list just for one buffer.
|
|
let num_buffers = state
|
|
.pending_buffers
|
|
.iter()
|
|
.take_while(|b| {
|
|
b.metadata_set && (b.buffer.pts() == pts || b.buffer.pts().is_none())
|
|
})
|
|
.count();
|
|
|
|
assert_ne!(num_buffers, 0);
|
|
|
|
gst::trace!(CAT, imp: self, "Flushing {num_buffers} buffers");
|
|
|
|
let segment_event = self.retrieve_pending_segment_event(&mut state);
|
|
|
|
enum BufferOrList {
|
|
Buffer(gst::Buffer),
|
|
List(gst::BufferList),
|
|
}
|
|
|
|
let buffers = if num_buffers == 1 {
|
|
let buffer = state.pending_buffers.pop_front().unwrap().buffer;
|
|
gst::trace!(CAT, imp: self, "Finishing buffer {buffer:?}");
|
|
BufferOrList::Buffer(buffer)
|
|
} else {
|
|
let mut list = gst::BufferList::new_sized(num_buffers);
|
|
{
|
|
let list = list.get_mut().unwrap();
|
|
while state.pending_buffers.front().map_or(false, |b| {
|
|
b.metadata_set && (b.buffer.pts() == pts || b.buffer.pts().is_none())
|
|
}) {
|
|
let buffer = state.pending_buffers.pop_front().unwrap().buffer;
|
|
gst::trace!(CAT, imp: self, "Finishing buffer {buffer:?}");
|
|
list.add(buffer);
|
|
}
|
|
}
|
|
|
|
BufferOrList::List(list)
|
|
};
|
|
|
|
drop(state);
|
|
|
|
if let Some(segment_event) = segment_event {
|
|
let _ = self.src_pad.push_event(segment_event);
|
|
}
|
|
|
|
let res = match buffers {
|
|
BufferOrList::Buffer(buffer) => self.src_pad.push(buffer),
|
|
BufferOrList::List(list) => self.src_pad.push_list(list),
|
|
};
|
|
|
|
if let Err(err) = res {
|
|
if ![gst::FlowError::Flushing, gst::FlowError::Eos].contains(&err) {
|
|
gst::warning!(CAT, imp: self, "Failed pushing buffers: {err:?}");
|
|
} else {
|
|
gst::debug!(CAT, imp: self, "Failed pushing buffers: {err:?}");
|
|
}
|
|
}
|
|
|
|
state = self.state.borrow_mut();
|
|
}
|
|
|
|
Ok(gst::FlowSuccess::Ok)
|
|
}
|
|
|
|
pub(super) fn sink_pad(&self) -> &gst::Pad {
|
|
&self.sink_pad
|
|
}
|
|
|
|
pub(super) fn src_pad(&self) -> &gst::Pad {
|
|
&self.src_pad
|
|
}
|
|
}
|
|
|
|
/// Default virtual method implementations.
|
|
impl RtpBaseDepay2 {
|
|
fn start_default(&self) -> Result<(), gst::ErrorMessage> {
|
|
Ok(())
|
|
}
|
|
|
|
fn stop_default(&self) -> Result<(), gst::ErrorMessage> {
|
|
Ok(())
|
|
}
|
|
|
|
fn set_sink_caps_default(&self, _caps: &gst::Caps) -> bool {
|
|
true
|
|
}
|
|
|
|
fn handle_packet_default(
|
|
&self,
|
|
_packet: &super::Packet,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn drain_default(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
Ok(gst::FlowSuccess::Ok)
|
|
}
|
|
|
|
fn flush_default(&self) {}
|
|
|
|
fn sink_event_default(&self, event: gst::Event) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
match event.view() {
|
|
gst::EventView::Caps(event) => {
|
|
let caps = event.caps_owned();
|
|
|
|
return self.set_sink_caps(caps);
|
|
}
|
|
gst::EventView::Segment(event) => {
|
|
let segment = event.segment();
|
|
let seqnum = event.seqnum();
|
|
|
|
let state = self.state.borrow();
|
|
if state.sink_caps.is_none() {
|
|
gst::warning!(CAT, imp: self, "Received segment before caps");
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
}
|
|
|
|
let same_segment = state
|
|
.segment
|
|
.as_ref()
|
|
.map(|(old_seqnum, old_segment)| {
|
|
(&seqnum, segment) == (old_seqnum, old_segment.upcast_ref())
|
|
})
|
|
.unwrap_or(false);
|
|
// Only drain if the segment changed and we actually had one before
|
|
let drain = !same_segment && state.segment.is_some();
|
|
drop(state);
|
|
|
|
if !same_segment {
|
|
gst::debug!(CAT, imp: self, "Received segment {segment:?}");
|
|
|
|
if drain {
|
|
if let Err(err) = self.drain() {
|
|
// Just continue here. The depayloader is now flushed and can proceed below,
|
|
// and if there was a serious error downstream it will happen on the next
|
|
// buffer pushed downstream
|
|
gst::debug!(CAT, imp: self, "Draining failed: {err:?}");
|
|
}
|
|
}
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
if let Some(segment) = segment.downcast_ref::<gst::ClockTime>() {
|
|
state.segment = Some((event.seqnum(), segment.clone()));
|
|
state.pending_segment = true;
|
|
} else {
|
|
gst::error!(CAT, imp: self, "Segments in non-TIME format are not supported");
|
|
state.segment = None;
|
|
// FIXME: Forget everything here?
|
|
return Err(gst::FlowError::Error);
|
|
}
|
|
|
|
return Ok(gst::FlowSuccess::Ok);
|
|
}
|
|
}
|
|
gst::EventView::Eos(_) => {
|
|
if let Err(err) = self.drain() {
|
|
gst::debug!(CAT, imp: self, "Draining on EOS failed: {err:?}");
|
|
}
|
|
}
|
|
gst::EventView::FlushStop(_) => {
|
|
self.flush();
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
state.segment = None;
|
|
state.pending_segment = false;
|
|
state.current_stream = None;
|
|
state.last_pts = None;
|
|
state.last_dts = None;
|
|
drop(state);
|
|
|
|
*self.stats.lock().unwrap() = None;
|
|
}
|
|
_ => (),
|
|
}
|
|
|
|
gst::debug!(CAT, imp: self, "Forwarding event: {event:?}");
|
|
if self.src_pad.push_event(event) {
|
|
Ok(gst::FlowSuccess::Ok)
|
|
} else if self.src_pad.pad_flags().contains(gst::PadFlags::FLUSHING) {
|
|
Err(gst::FlowError::Flushing)
|
|
} else {
|
|
Err(gst::FlowError::Error)
|
|
}
|
|
}
|
|
|
|
fn src_event_default(&self, event: gst::Event) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
if gst::Pad::event_default(&self.src_pad, Some(&*self.obj()), event) {
|
|
Ok(gst::FlowSuccess::Ok)
|
|
} else if self.sink_pad.pad_flags().contains(gst::PadFlags::FLUSHING) {
|
|
Err(gst::FlowError::Flushing)
|
|
} else {
|
|
Err(gst::FlowError::Error)
|
|
}
|
|
}
|
|
|
|
fn sink_query_default(&self, query: &mut gst::QueryRef) -> bool {
|
|
gst::Pad::query_default(&self.sink_pad, Some(&*self.obj()), query)
|
|
}
|
|
|
|
fn src_query_default(&self, query: &mut gst::QueryRef) -> bool {
|
|
gst::Pad::query_default(&self.src_pad, Some(&*self.obj()), query)
|
|
}
|
|
|
|
fn transform_meta_default(
|
|
&self,
|
|
_in_buf: &gst::BufferRef,
|
|
meta: &gst::MetaRef<gst::Meta>,
|
|
out_buf: &mut gst::BufferRef,
|
|
) {
|
|
let tags = meta.tags();
|
|
|
|
if tags.len() > 1 {
|
|
gst::trace!(
|
|
CAT,
|
|
imp: self,
|
|
"Not copying meta {}: has multiple tags {tags:?}",
|
|
meta.api(),
|
|
);
|
|
return;
|
|
}
|
|
|
|
let allowed_tags = self.obj().class().as_ref().allowed_meta_tags;
|
|
if tags.len() == 1 {
|
|
let meta_tag = &tags[0];
|
|
|
|
if !allowed_tags.iter().copied().any(|tag| tag == *meta_tag) {
|
|
gst::trace!(
|
|
CAT,
|
|
imp: self,
|
|
"Not copying meta {}: tag '{meta_tag}' not allowed",
|
|
meta.api(),
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
|
|
gst::trace!(CAT, imp: self, "Copying meta {}", meta.api());
|
|
|
|
if let Err(err) = meta.transform(out_buf, &gst::meta::MetaTransformCopy::new(false, ..)) {
|
|
gst::trace!(CAT, imp: self, "Could not copy meta {}: {err}", meta.api());
|
|
}
|
|
}
|
|
|
|
fn add_extension(&self, ext: &gst_rtp::RTPHeaderExtension) {
|
|
assert_ne!(ext.id(), 0);
|
|
|
|
let mut extensions = self.extensions.lock().unwrap();
|
|
extensions.insert(ext.id() as u8, ext.clone());
|
|
// FIXME: Needs caps update!
|
|
drop(extensions);
|
|
|
|
self.obj().notify("extensions");
|
|
}
|
|
|
|
fn clear_extensions(&self) {
|
|
let mut extensions = self.extensions.lock().unwrap();
|
|
extensions.clear();
|
|
// FIXME: Needs caps update!
|
|
drop(extensions);
|
|
|
|
self.obj().notify("extensions");
|
|
}
|
|
|
|
fn request_extension(&self, ext_id: u32, uri: &str) -> Option<gst_rtp::RTPHeaderExtension> {
|
|
let settings = self.settings.lock().unwrap();
|
|
if !settings.auto_header_extensions {
|
|
return None;
|
|
}
|
|
drop(settings);
|
|
|
|
let Some(ext) = gst_rtp::RTPHeaderExtension::create_from_uri(uri) else {
|
|
gst::debug!(
|
|
CAT,
|
|
imp: self,
|
|
"Didn't find any extension implementing URI {uri}",
|
|
);
|
|
return None;
|
|
};
|
|
|
|
gst::debug!(
|
|
CAT,
|
|
imp: self,
|
|
"Automatically enabling extension {} for URI {uri}",
|
|
ext.name(),
|
|
);
|
|
|
|
ext.set_id(ext_id);
|
|
|
|
Some(ext)
|
|
}
|
|
}
|
|
|
|
/// Pad functions and associated helper functions.
|
|
impl RtpBaseDepay2 {
|
|
fn sink_chain(
|
|
&self,
|
|
_pad: &gst::Pad,
|
|
buffer: gst::Buffer,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
gst::trace!(CAT, imp: self, "Received buffer {buffer:?}");
|
|
|
|
let settings = self.settings.lock().unwrap().clone();
|
|
self.handle_buffer(&settings, buffer)
|
|
}
|
|
|
|
fn sink_chain_list(
|
|
&self,
|
|
_pad: &gst::Pad,
|
|
list: gst::BufferList,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
gst::trace!(CAT, imp: self, "Received buffer list {list:?}");
|
|
|
|
let settings = self.settings.lock().unwrap().clone();
|
|
for buffer in list.iter_owned() {
|
|
self.handle_buffer(&settings, buffer)?;
|
|
}
|
|
|
|
Ok(gst::FlowSuccess::Ok)
|
|
}
|
|
|
|
fn sink_event(
|
|
&self,
|
|
pad: &gst::Pad,
|
|
event: gst::Event,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
gst::debug!(CAT, obj: pad, "Received event: {event:?}");
|
|
|
|
let obj = self.obj();
|
|
(obj.class().as_ref().sink_event)(&obj, event)
|
|
}
|
|
|
|
fn src_event(
|
|
&self,
|
|
pad: &gst::Pad,
|
|
event: gst::Event,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
gst::debug!(CAT, obj: pad, "Received event: {event:?}");
|
|
|
|
let obj = self.obj();
|
|
(obj.class().as_ref().src_event)(&obj, event)
|
|
}
|
|
|
|
fn sink_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
|
|
gst::trace!(CAT, obj: pad, "Received query: {query:?}");
|
|
|
|
let obj = self.obj();
|
|
(obj.class().as_ref().sink_query)(&obj, query)
|
|
}
|
|
|
|
fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
|
|
gst::trace!(CAT, obj: pad, "Received query: {query:?}");
|
|
|
|
let obj = self.obj();
|
|
(obj.class().as_ref().src_query)(&obj, query)
|
|
}
|
|
|
|
fn retrieve_pending_segment_event(&self, state: &mut State) -> Option<gst::Event> {
|
|
// If a segment event was pending, take it now and push it out later.
|
|
if !state.pending_segment {
|
|
return None;
|
|
}
|
|
|
|
state.src_caps.as_ref()?;
|
|
|
|
let (seqnum, segment) = state.segment.as_ref().unwrap();
|
|
let mut segment = segment.clone();
|
|
|
|
// If npt-start is set, all the other values are also valid.
|
|
if let Some(npt_start) = state.npt_start {
|
|
let (mut npt_start_pts, npt_start_ext_rtptime) = state.npt_start_times?;
|
|
let clock_rate = state.clock_rate.unwrap();
|
|
|
|
let mut start = segment.start().unwrap();
|
|
|
|
if let Some((clock_base, pts)) = Option::zip(state.clock_base, npt_start_pts) {
|
|
let ext_clock_base = clock_base as u64 + (1 << 32);
|
|
|
|
let gap = npt_start_ext_rtptime
|
|
.saturating_sub(ext_clock_base)
|
|
.mul_div_floor(*gst::ClockTime::SECOND, clock_rate as u64)
|
|
.map(gst::ClockTime::from_nseconds);
|
|
|
|
// Account for lost packets
|
|
if let Some(gap) = gap {
|
|
if pts > gap {
|
|
gst::debug!(
|
|
CAT,
|
|
imp: self,
|
|
"Found gap of {}, adjusting start: {} = {} - {}",
|
|
gap.display(),
|
|
(pts - gap).display(),
|
|
pts.display(),
|
|
gap.display(),
|
|
);
|
|
start = pts - gap;
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut stop = segment.stop();
|
|
if let Some(npt_stop) = state.npt_stop {
|
|
stop = Some(start + npt_stop.saturating_sub(npt_start));
|
|
}
|
|
|
|
if npt_start_pts.is_none() {
|
|
npt_start_pts = Some(start);
|
|
}
|
|
|
|
let running_time = segment.to_running_time(start);
|
|
|
|
segment.reset();
|
|
segment.set_rate(state.play_speed);
|
|
segment.set_applied_rate(state.play_scale);
|
|
segment.set_start(start);
|
|
segment.set_stop(stop);
|
|
segment.set_time(npt_start);
|
|
segment.set_position(npt_start_pts);
|
|
segment.set_base(running_time);
|
|
}
|
|
|
|
let segment_event = gst::event::Segment::builder(&segment)
|
|
.seqnum(*seqnum)
|
|
.build();
|
|
state.pending_segment = false;
|
|
gst::debug!(
|
|
CAT,
|
|
imp: self,
|
|
"Created segment event {segment:?} with seqnum {seqnum:?}",
|
|
);
|
|
|
|
Some(segment_event)
|
|
}
|
|
|
|
fn handle_buffer(
|
|
&self,
|
|
settings: &Settings,
|
|
buffer: gst::Buffer,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
let mut state = self.state.borrow_mut();
|
|
|
|
if state.sink_caps.is_none() {
|
|
gst::error!(CAT, imp: self, "No sink pad caps");
|
|
gst::element_imp_error!(
|
|
self,
|
|
gst::CoreError::Negotiation,
|
|
("No RTP caps were negotiated"),
|
|
[
|
|
"Input buffers need to have RTP caps set on them. This is usually \
|
|
achieved by setting the 'caps' property of the upstream source \
|
|
element (often udpsrc or appsrc), or by putting a capsfilter \
|
|
element before the depayloader and setting the 'caps' property \
|
|
on that. Also see https://gitlab.freedesktop.org/gstreamer/gstreamer/-/ \
|
|
blob/main/subprojects/gst-plugins-good/gst/rtp/README",
|
|
]
|
|
);
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
}
|
|
// Always set if the caps are set.
|
|
let clock_rate = state.clock_rate.unwrap();
|
|
|
|
// Check for too many pending packets
|
|
if let Some((front, back)) =
|
|
Option::zip(state.pending_packets.front(), state.pending_packets.back())
|
|
{
|
|
let rtp_diff = back
|
|
.ext_timestamp
|
|
.saturating_sub(front.ext_timestamp)
|
|
.mul_div_floor(*gst::ClockTime::SECOND, clock_rate as u64)
|
|
.map(gst::ClockTime::from_nseconds);
|
|
let pts_diff = back.buffer.pts().opt_saturating_sub(front.buffer.pts());
|
|
|
|
if let Some(rtp_diff) = rtp_diff {
|
|
if rtp_diff > gst::ClockTime::SECOND {
|
|
gst::warning!(CAT, imp: self, "More than {rtp_diff} of RTP time queued, probably a bug in the subclass");
|
|
}
|
|
}
|
|
|
|
if let Some(pts_diff) = pts_diff {
|
|
if pts_diff > gst::ClockTime::SECOND {
|
|
gst::warning!(CAT, imp: self, "More than {pts_diff} of PTS time queued, probably a bug in the subclass");
|
|
}
|
|
}
|
|
}
|
|
|
|
let buffer = match buffer.into_mapped_buffer_readable() {
|
|
Ok(buffer) => buffer,
|
|
Err(_) => {
|
|
gst::error!(CAT, imp: self, "Failed to map buffer");
|
|
gst::element_imp_error!(self, gst::StreamError::Failed, ["Failed to map buffer"]);
|
|
return Err(gst::FlowError::Error);
|
|
}
|
|
};
|
|
|
|
// Parse RTP packet and extract the relevant fields we will need later.
|
|
let packet = match rtp_types::RtpPacket::parse(&buffer) {
|
|
Ok(packet) => packet,
|
|
Err(err) => {
|
|
gst::warning!(CAT, imp: self, "Failed to parse RTP packet: {err:?}");
|
|
return Ok(gst::FlowSuccess::Ok);
|
|
}
|
|
};
|
|
|
|
let seqnum = packet.sequence_number();
|
|
let ssrc = packet.ssrc();
|
|
let pt = packet.payload_type();
|
|
let rtptime = packet.timestamp();
|
|
let marker = packet.marker_bit();
|
|
let have_header_extensions = packet.extension_len() != 0;
|
|
let csrc = {
|
|
let mut csrc = packet.csrc();
|
|
std::array::from_fn::<u32, { rtp_types::RtpPacket::MAX_N_CSRCS }, _>(|_idx| {
|
|
csrc.next().unwrap_or_default()
|
|
})
|
|
};
|
|
let n_csrc = packet.n_csrcs();
|
|
|
|
let payload_range = {
|
|
let payload = packet.payload();
|
|
if payload.is_empty() {
|
|
0..0
|
|
} else {
|
|
let offset = packet.payload_offset();
|
|
offset..(offset + payload.len())
|
|
}
|
|
};
|
|
|
|
// FIXME: Allow subclasses to decide not to flush on DISCONTs and handle the situation
|
|
// themselves, e.g. to be able to continue reconstructing frames despite missing data.
|
|
if buffer.buffer().flags().contains(gst::BufferFlags::DISCONT) {
|
|
gst::info!(CAT, imp: self, "Discont received");
|
|
state.current_stream = None;
|
|
}
|
|
|
|
// Check if there was a stream discontinuity, e.g. based on the SSRC changing or the seqnum
|
|
// having a gap compared to the previous packet.
|
|
if let Some(ref mut current_stream) = state.current_stream {
|
|
if current_stream.ssrc != ssrc {
|
|
gst::info!(CAT, imp: self, "Stream SSRC changed from {:08x} to {:08x}", current_stream.ssrc, ssrc);
|
|
state.current_stream = None;
|
|
} else if current_stream.pt != pt {
|
|
gst::info!(CAT, imp: self, "Stream payload type changed from {} to {}", current_stream.pt, pt);
|
|
state.current_stream = None;
|
|
} else {
|
|
let expected_seqnum = (current_stream.ext_seqnum + 1) & 0xffff;
|
|
if expected_seqnum != seqnum as u64 {
|
|
gst::info!(CAT, imp: self, "Got seqnum {seqnum} but expected {expected_seqnum}");
|
|
|
|
let mut ext_seqnum = seqnum as u64 + (current_stream.ext_seqnum & !0xffff);
|
|
|
|
if ext_seqnum < current_stream.ext_seqnum {
|
|
let diff = current_stream.ext_seqnum - ext_seqnum;
|
|
if diff > 0x7fff {
|
|
ext_seqnum += 1 << 16;
|
|
}
|
|
} else {
|
|
let diff = ext_seqnum - current_stream.ext_seqnum;
|
|
if diff > 0x7fff {
|
|
ext_seqnum -= 1 << 16;
|
|
}
|
|
}
|
|
let diff = if ext_seqnum > current_stream.ext_seqnum {
|
|
(ext_seqnum - current_stream.ext_seqnum) as i32
|
|
} else {
|
|
-((current_stream.ext_seqnum - ext_seqnum) as i32)
|
|
};
|
|
|
|
if diff > 0 {
|
|
gst::info!(CAT, imp: self, "{diff} missing packets or sender restart");
|
|
state.current_stream = None;
|
|
} else if diff >= -(settings.max_reorder as i32) {
|
|
gst::info!(CAT, imp: self, "Got old packet, dropping");
|
|
return Ok(gst::FlowSuccess::Ok);
|
|
} else {
|
|
gst::info!(CAT, imp: self, "Sender restart");
|
|
state.current_stream = None;
|
|
}
|
|
} else {
|
|
// Calculate extended RTP time
|
|
let ext_rtptime = {
|
|
let mut ext_rtptime =
|
|
rtptime as u64 + (current_stream.ext_rtptime & !0xffff_ffff);
|
|
|
|
// Check for wraparound
|
|
if ext_rtptime < current_stream.ext_rtptime {
|
|
let diff = current_stream.ext_rtptime - ext_rtptime;
|
|
if diff > 0x7fff_ffff {
|
|
ext_rtptime += 1 << 32;
|
|
}
|
|
} else {
|
|
let diff = ext_rtptime - current_stream.ext_rtptime;
|
|
if diff > 0x7fff_ffff {
|
|
ext_rtptime -= 1 << 32;
|
|
}
|
|
}
|
|
|
|
ext_rtptime
|
|
};
|
|
|
|
current_stream.ext_seqnum += 1;
|
|
current_stream.ext_rtptime = ext_rtptime;
|
|
gst::trace!(
|
|
CAT,
|
|
imp: self,
|
|
"Handling packet with extended seqnum {} and extended RTP time {}",
|
|
current_stream.ext_seqnum,
|
|
current_stream.ext_rtptime,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Drain if there was any discontinuity.
|
|
let discont = state.current_stream.is_none();
|
|
if discont && !state.pending_packets.is_empty() {
|
|
drop(state);
|
|
gst::info!(CAT, imp: self, "Got discontinuity, draining");
|
|
|
|
if let Err(err) = self.drain() {
|
|
if ![gst::FlowError::Flushing, gst::FlowError::Eos].contains(&err) {
|
|
gst::warning!(CAT, imp: self, "Error while draining: {err:?}");
|
|
} else {
|
|
gst::debug!(CAT, imp: self, "Error while draining: {err:?}");
|
|
}
|
|
return Err(err);
|
|
}
|
|
state = self.state.borrow_mut();
|
|
}
|
|
|
|
// Update current stream state at this point.
|
|
let ext_seqnum;
|
|
let ext_rtptime;
|
|
if let Some(ref current_stream) = state.current_stream {
|
|
ext_seqnum = current_stream.ext_seqnum;
|
|
ext_rtptime = current_stream.ext_rtptime;
|
|
} else {
|
|
ext_seqnum = seqnum as u64 + (1 << 16);
|
|
ext_rtptime = rtptime as u64 + (1 << 32);
|
|
|
|
gst::info!(
|
|
CAT,
|
|
imp: self,
|
|
"Starting stream with SSRC {ssrc:08x} at extended seqnum {ext_seqnum} with extended RTP time {ext_rtptime}",
|
|
);
|
|
|
|
state.current_stream = Some(CurrentStream {
|
|
ssrc,
|
|
pt,
|
|
ext_seqnum,
|
|
ext_rtptime,
|
|
})
|
|
}
|
|
|
|
// Remember the initial PTS/rtp_time mapping if old-style RTSP caps are used.
|
|
if state.npt_start.is_some() && state.npt_start_times.is_none() {
|
|
state.npt_start_times = Some((buffer.buffer().pts(), ext_rtptime));
|
|
}
|
|
|
|
// If a segment event was pending, take it now and push it out later.
|
|
let segment_event = self.retrieve_pending_segment_event(&mut state);
|
|
|
|
// Remember current packet.
|
|
state.pending_packets.push_back(PendingPacket {
|
|
ext_seqnum,
|
|
ext_timestamp: ext_rtptime,
|
|
ssrc,
|
|
csrc,
|
|
n_csrc,
|
|
have_header_extensions,
|
|
buffer: buffer.buffer_owned(),
|
|
});
|
|
|
|
// Remember if the next buffer that has to be pushed out should have the DISCONT flag set.
|
|
state.discont_pending |= discont;
|
|
|
|
// Update stats with the current packet.
|
|
*self.stats.lock().unwrap() = {
|
|
let (_seqnum, segment) = state.segment.as_ref().unwrap();
|
|
|
|
let running_time_pts = segment.to_running_time(buffer.buffer().pts());
|
|
let running_time_dts = segment.to_running_time(buffer.buffer().dts());
|
|
Some(Stats {
|
|
ssrc,
|
|
clock_rate,
|
|
running_time_dts,
|
|
running_time_pts,
|
|
seqnum,
|
|
timestamp: rtptime,
|
|
npt_start: state.npt_start,
|
|
npt_stop: state.npt_stop,
|
|
play_speed: state.play_speed,
|
|
play_scale: state.play_scale,
|
|
})
|
|
};
|
|
drop(state);
|
|
|
|
if let Some(segment_event) = segment_event {
|
|
let _ = self.src_pad.push_event(segment_event);
|
|
}
|
|
|
|
// Now finally handle the packet.
|
|
let obj = self.obj();
|
|
let mut res = (obj.class().as_ref().handle_packet)(
|
|
&obj,
|
|
&super::Packet {
|
|
buffer,
|
|
discont,
|
|
ext_seqnum,
|
|
ext_timestamp: ext_rtptime,
|
|
marker,
|
|
payload_range,
|
|
},
|
|
);
|
|
if let Err(err) = res {
|
|
gst::error!(CAT, imp: self, "Failed handling packet: {err:?}");
|
|
} else {
|
|
res = self.finish_pending_buffers();
|
|
|
|
if let Err(err) = res {
|
|
gst::debug!(CAT, imp: self, "Failed finishing pending buffers: {err:?}");
|
|
}
|
|
}
|
|
|
|
// Now drop all pending packets that were used for producing buffers
|
|
// except for the very last one as that might still be used.
|
|
let mut state = self.state.borrow_mut();
|
|
if let Some(last_used_ext_seqnum) = state.last_used_ext_seqnum {
|
|
while state
|
|
.pending_packets
|
|
.front()
|
|
.map_or(false, |b| b.ext_seqnum < last_used_ext_seqnum)
|
|
{
|
|
let _ = state.pending_packets.pop_front();
|
|
}
|
|
}
|
|
|
|
res
|
|
}
|
|
}
|
|
|
|
/// Other methods.
|
|
impl RtpBaseDepay2 {
|
|
fn update_extensions_from_sink_caps(
|
|
&self,
|
|
sink_caps: &gst::Caps,
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
let s = sink_caps.structure(0).unwrap();
|
|
|
|
// Check which header extensions to enable/disable based on the caps.
|
|
let mut caps_extensions = BTreeMap::new();
|
|
for (k, v) in s.iter() {
|
|
let Some(ext_id) = k.strip_prefix("extmap-") else {
|
|
continue;
|
|
};
|
|
let Ok(ext_id) = ext_id.parse::<u8>() else {
|
|
gst::error!(CAT, imp: self, "Can't parse RTP header extension id from caps {sink_caps:?}");
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
};
|
|
|
|
let uri = if let Ok(uri) = v.get::<String>() {
|
|
uri
|
|
} else if let Ok(arr) = v.get::<gst::ArrayRef>() {
|
|
if let Some(uri) = arr.get(1).and_then(|v| v.get::<String>().ok()) {
|
|
uri
|
|
} else {
|
|
gst::error!(CAT, imp: self, "Couldn't get URI for RTP header extension id {ext_id} from caps {sink_caps:?}");
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
}
|
|
} else {
|
|
gst::error!(CAT, imp: self, "Couldn't get URI for RTP header extension id {ext_id} from caps {sink_caps:?}");
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
};
|
|
|
|
caps_extensions.insert(ext_id, uri);
|
|
}
|
|
|
|
let mut extensions = self.extensions.lock().unwrap();
|
|
let mut extensions_changed = false;
|
|
for (ext_id, uri) in caps_extensions {
|
|
if let Some(extension) = extensions.get(&ext_id) {
|
|
if extension.uri().as_deref() == Some(&uri) {
|
|
// Same extension, nothing to do here, we will update it with the new caps
|
|
// later
|
|
continue;
|
|
}
|
|
gst::debug!(
|
|
CAT,
|
|
imp: self,
|
|
"Extension ID {ext_id} changed from {:?} to {uri}",
|
|
extension.uri(),
|
|
);
|
|
extensions_changed |= true;
|
|
extensions.remove(&ext_id);
|
|
}
|
|
|
|
gst::debug!(CAT, imp: self, "Requesting extension {uri} for ID {ext_id}");
|
|
let ext = self
|
|
.obj()
|
|
.emit_by_name::<Option<gst_rtp::RTPHeaderExtension>>(
|
|
"request-extension",
|
|
&[&(ext_id as u32), &uri],
|
|
);
|
|
|
|
let Some(ext) = ext else {
|
|
gst::warning!(CAT, imp: self, "Couldn't create extension for {uri} with ID {ext_id}");
|
|
continue;
|
|
};
|
|
|
|
if ext.id() != ext_id as u32 {
|
|
gst::warning!(CAT, imp: self, "Created extension has wrong ID");
|
|
continue;
|
|
}
|
|
|
|
extensions.insert(ext_id, ext);
|
|
extensions_changed |= true;
|
|
}
|
|
|
|
let mut to_remove = vec![];
|
|
for (ext_id, ext) in extensions.iter() {
|
|
if !ext.set_attributes_from_caps(sink_caps) {
|
|
gst::warning!(CAT, imp: self, "Failed to configure extension {ext_id} from caps {sink_caps}");
|
|
to_remove.push(*ext_id);
|
|
}
|
|
}
|
|
for ext_id in to_remove {
|
|
extensions.remove(&ext_id);
|
|
extensions_changed |= true;
|
|
}
|
|
drop(extensions);
|
|
|
|
if extensions_changed {
|
|
self.obj().notify("extensions");
|
|
}
|
|
|
|
Ok(gst::FlowSuccess::Ok)
|
|
}
|
|
|
|
fn set_sink_caps(&self, sink_caps: gst::Caps) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
gst::debug!(CAT, imp: self, "Received caps {sink_caps:?}");
|
|
|
|
let s = sink_caps.structure(0).unwrap();
|
|
|
|
if !s.has_name("application/x-rtp") {
|
|
gst::error!(CAT, imp: self, "Non-RTP caps {sink_caps:?} not supported");
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
}
|
|
|
|
let clock_rate = match s.get::<i32>("clock-rate") {
|
|
Ok(clock_rate) if clock_rate > 0 => clock_rate,
|
|
_ => {
|
|
gst::error!(CAT, imp: self, "RTP caps {sink_caps:?} without 'clock-rate'");
|
|
return Err(gst::FlowError::NotNegotiated);
|
|
}
|
|
};
|
|
|
|
let npt_start = s.get::<gst::ClockTime>("npt-start").ok();
|
|
let npt_stop = s.get::<gst::ClockTime>("npt-stop").ok();
|
|
let play_scale = s.get::<f64>("play-scale").unwrap_or(1.0);
|
|
let play_speed = s.get::<f64>("play-speed").unwrap_or(1.0);
|
|
let clock_base = s.get::<u32>("clock-base").ok();
|
|
let onvif_mode = s.get::<bool>("onvif-mode").unwrap_or_default();
|
|
|
|
self.update_extensions_from_sink_caps(&sink_caps)?;
|
|
|
|
let state = self.state.borrow_mut();
|
|
let same_caps = state
|
|
.sink_caps
|
|
.as_ref()
|
|
.map(|old_caps| &sink_caps == old_caps)
|
|
.unwrap_or(false);
|
|
drop(state);
|
|
|
|
if !same_caps {
|
|
let obj = self.obj();
|
|
|
|
if let Err(err) = self.drain() {
|
|
// Just continue here. The depayloader is now flushed and can proceed below,
|
|
// and if there was a serious error downstream it will happen on the next
|
|
// buffer pushed downstream
|
|
gst::debug!(CAT, imp: self, "Draining failed: {err:?}");
|
|
}
|
|
|
|
let set_sink_caps_res = if (obj.class().as_ref().set_sink_caps)(&obj, &sink_caps) {
|
|
gst::debug!(CAT, imp: self, "Caps {sink_caps:?} accepted");
|
|
Ok(gst::FlowSuccess::Ok)
|
|
} else {
|
|
gst::warning!(CAT, imp: self, "Caps {sink_caps:?} not accepted");
|
|
Err(gst::FlowError::NotNegotiated)
|
|
};
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
if let Err(err) = set_sink_caps_res {
|
|
state.sink_caps = None;
|
|
// FIXME: Forget everything here?
|
|
return Err(err);
|
|
}
|
|
|
|
state.sink_caps = Some(sink_caps);
|
|
state.clock_rate = Some(clock_rate as u32);
|
|
|
|
// If npt-start is set, all the other values are also valid.
|
|
//
|
|
// In ONVIF mode these are all ignored and instead upstream is supposed to provide the
|
|
// correct segment already.
|
|
if npt_start.is_some() && !onvif_mode {
|
|
state.npt_start = npt_start;
|
|
state.npt_stop = npt_stop;
|
|
state.play_speed = play_speed;
|
|
state.play_scale = play_scale;
|
|
state.clock_base = clock_base;
|
|
state.npt_start_times = None;
|
|
state.pending_segment = true;
|
|
} else {
|
|
if state.npt_start.is_some() {
|
|
state.pending_segment = true;
|
|
}
|
|
state.npt_start = None;
|
|
state.npt_stop = None;
|
|
state.play_speed = 1.0;
|
|
state.play_scale = 1.0;
|
|
state.clock_base = None;
|
|
state.npt_start_times = None;
|
|
}
|
|
|
|
drop(state);
|
|
}
|
|
|
|
Ok(gst::FlowSuccess::Ok)
|
|
}
|
|
|
|
fn drain(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
let obj = self.obj();
|
|
if let Err(err) = (obj.class().as_ref().drain)(&obj) {
|
|
if ![gst::FlowError::Flushing, gst::FlowError::Eos].contains(&err) {
|
|
gst::warning!(CAT, imp: self, "Draining failed: {err:?}");
|
|
} else {
|
|
gst::debug!(CAT, imp: self, "Draining failed: {err:?}");
|
|
}
|
|
self.flush();
|
|
return Err(err);
|
|
}
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
state.pending_packets.clear();
|
|
|
|
// Update all pending buffers without metadata with the last buffer's PTS/DTS
|
|
let last_pts = state.last_pts;
|
|
let last_dts = state.last_dts;
|
|
let mut discont_pending = state.discont_pending;
|
|
state.discont_pending = false;
|
|
|
|
for buffer in state
|
|
.pending_buffers
|
|
.iter_mut()
|
|
.skip_while(|b| b.metadata_set)
|
|
{
|
|
assert!(!buffer.metadata_set);
|
|
buffer.metadata_set = true;
|
|
let buffer = &mut buffer.buffer;
|
|
let buffer_ref = buffer.make_mut();
|
|
buffer_ref.set_pts(last_pts);
|
|
buffer_ref.set_dts(last_dts);
|
|
if discont_pending {
|
|
buffer_ref.set_flags(gst::BufferFlags::DISCONT);
|
|
discont_pending = false;
|
|
}
|
|
}
|
|
drop(state);
|
|
|
|
// Forward all buffers
|
|
let res = self.finish_pending_buffers();
|
|
|
|
self.flush();
|
|
|
|
res
|
|
}
|
|
|
|
fn flush(&self) {
|
|
let obj = self.obj();
|
|
(obj.class().as_ref().flush)(&obj);
|
|
|
|
let mut state = self.state.borrow_mut();
|
|
state.pending_packets.clear();
|
|
state.pending_buffers.clear();
|
|
state.discont_pending = true;
|
|
}
|
|
|
|
fn create_stats(&self) -> gst::Structure {
|
|
let stats = self.stats.lock().unwrap().clone();
|
|
if let Some(stats) = stats {
|
|
gst::Structure::builder("application/x-rtp-depayload-stats")
|
|
.field("ssrc", stats.ssrc)
|
|
.field("clock-rate", stats.clock_rate)
|
|
.field("running-time-dts", stats.running_time_dts)
|
|
.field("running-time-pts", stats.running_time_pts)
|
|
.field("seqnum", stats.seqnum as u32)
|
|
.field("timestamp", stats.timestamp)
|
|
.field("npt-start", stats.npt_start)
|
|
.field("npt-stop", stats.npt_stop)
|
|
.field("play-speed", stats.play_speed)
|
|
.field("play-scale", stats.play_scale)
|
|
.build()
|
|
} else {
|
|
gst::Structure::builder("application/x-rtp-depayload-stats").build()
|
|
}
|
|
}
|
|
}
|
|
|
|
#[glib::object_subclass]
|
|
impl ObjectSubclass for RtpBaseDepay2 {
|
|
const NAME: &'static str = "GstRtpBaseDepay2";
|
|
const ABSTRACT: bool = true;
|
|
type Type = super::RtpBaseDepay2;
|
|
type ParentType = gst::Element;
|
|
type Class = super::Class;
|
|
|
|
fn class_init(class: &mut Self::Class) {
|
|
class.start = |obj| obj.imp().start_default();
|
|
class.stop = |obj| obj.imp().stop_default();
|
|
class.set_sink_caps = |obj, caps| obj.imp().set_sink_caps_default(caps);
|
|
class.handle_packet = |obj, packet| obj.imp().handle_packet_default(packet);
|
|
class.drain = |obj| obj.imp().drain_default();
|
|
class.flush = |obj| obj.imp().flush_default();
|
|
class.sink_event = |obj, event| obj.imp().sink_event_default(event);
|
|
class.src_event = |obj, event| obj.imp().src_event_default(event);
|
|
class.sink_query = |obj, query| obj.imp().sink_query_default(query);
|
|
class.src_query = |obj, query| obj.imp().src_query_default(query);
|
|
class.transform_meta =
|
|
|obj, in_buf, meta, out_buf| obj.imp().transform_meta_default(in_buf, meta, out_buf);
|
|
class.allowed_meta_tags = &[];
|
|
}
|
|
|
|
fn with_class(class: &Self::Class) -> Self {
|
|
let templ = class
|
|
.pad_template("sink")
|
|
.expect("Subclass did not provide a \"sink\" pad template");
|
|
let sink_pad = gst::Pad::builder_from_template(&templ)
|
|
.chain_function(|pad, parent, buffer| {
|
|
Self::catch_panic_pad_function(
|
|
parent,
|
|
|| Err(gst::FlowError::Error),
|
|
|imp| imp.sink_chain(pad, buffer),
|
|
)
|
|
})
|
|
.chain_list_function(|pad, parent, list| {
|
|
Self::catch_panic_pad_function(
|
|
parent,
|
|
|| Err(gst::FlowError::Error),
|
|
|imp| imp.sink_chain_list(pad, list),
|
|
)
|
|
})
|
|
.event_full_function(|pad, parent, event| {
|
|
Self::catch_panic_pad_function(
|
|
parent,
|
|
|| Err(gst::FlowError::Error),
|
|
|imp| imp.sink_event(pad, event),
|
|
)
|
|
})
|
|
.query_function(|pad, parent, query| {
|
|
Self::catch_panic_pad_function(parent, || false, |imp| imp.sink_query(pad, query))
|
|
})
|
|
.build();
|
|
|
|
let templ = class
|
|
.pad_template("src")
|
|
.expect("Subclass did not provide a \"src\" pad template");
|
|
let src_pad = gst::Pad::builder_from_template(&templ)
|
|
.event_full_function(|pad, parent, event| {
|
|
Self::catch_panic_pad_function(
|
|
parent,
|
|
|| Err(gst::FlowError::Error),
|
|
|imp| imp.src_event(pad, event),
|
|
)
|
|
})
|
|
.query_function(|pad, parent, query| {
|
|
Self::catch_panic_pad_function(parent, || false, |imp| imp.src_query(pad, query))
|
|
})
|
|
.flags(gst::PadFlags::FIXED_CAPS)
|
|
.build();
|
|
|
|
Self {
|
|
src_pad,
|
|
sink_pad,
|
|
state: AtomicRefCell::default(),
|
|
settings: Mutex::default(),
|
|
stats: Mutex::default(),
|
|
extensions: Mutex::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ObjectImpl for RtpBaseDepay2 {
|
|
fn properties() -> &'static [glib::ParamSpec] {
|
|
static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
|
|
vec![
|
|
glib::ParamSpecBoxed::builder::<gst::Structure>("stats")
|
|
.nick("Statistics")
|
|
.blurb("Various statistics")
|
|
.read_only()
|
|
.build(),
|
|
glib::ParamSpecUInt::builder("max-reorder")
|
|
.nick("Maximum Reorder")
|
|
.blurb("Maximum seqnum reorder before assuming sender has restarted")
|
|
.default_value(Settings::default().max_reorder)
|
|
.minimum(0)
|
|
.maximum(0x7fff)
|
|
.mutable_playing()
|
|
.build(),
|
|
glib::ParamSpecBoolean::builder("source-info")
|
|
.nick("RTP Source Info")
|
|
.blurb("Add RTP source information as buffer metadata")
|
|
.default_value(Settings::default().source_info)
|
|
.mutable_playing()
|
|
.build(),
|
|
glib::ParamSpecBoolean::builder("auto-header-extensions")
|
|
.nick("Automatic RTP Header Extensions")
|
|
.blurb("Whether RTP header extensions should be automatically enabled, if an implementation is available")
|
|
.default_value(Settings::default().auto_header_extensions)
|
|
.mutable_ready()
|
|
.build(),
|
|
gst::ParamSpecArray::builder("extensions")
|
|
.nick("RTP Header Extensions")
|
|
.blurb("List of enabled RTP header extensions")
|
|
.element_spec(&glib::ParamSpecObject::builder::<gst_rtp::RTPHeaderExtension>("extension")
|
|
.nick("RTP Header Extension")
|
|
.blurb("Enabled RTP header extension")
|
|
.read_only()
|
|
.build()
|
|
)
|
|
.read_only()
|
|
.build(),
|
|
]
|
|
});
|
|
|
|
PROPERTIES.as_ref()
|
|
}
|
|
|
|
fn signals() -> &'static [glib::subclass::Signal] {
|
|
static SIGNALS: Lazy<Vec<glib::subclass::Signal>> = Lazy::new(|| {
|
|
vec![
|
|
glib::subclass::Signal::builder("add-extension")
|
|
.action()
|
|
.param_types([gst_rtp::RTPHeaderExtension::static_type()])
|
|
.class_handler(|_token, args| {
|
|
let s = args[0].get::<super::RtpBaseDepay2>().unwrap();
|
|
let ext = args[1].get::<&gst_rtp::RTPHeaderExtension>().unwrap();
|
|
s.imp().add_extension(ext);
|
|
|
|
None
|
|
})
|
|
.build(),
|
|
glib::subclass::Signal::builder("request-extension")
|
|
.param_types([u32::static_type(), String::static_type()])
|
|
.return_type::<gst_rtp::RTPHeaderExtension>()
|
|
.accumulator(|_hint, acc, val| {
|
|
if matches!(val.get::<Option<glib::Object>>(), Ok(Some(_))) {
|
|
*acc = val.clone();
|
|
false
|
|
} else {
|
|
true
|
|
}
|
|
})
|
|
.class_handler(|_token, args| {
|
|
let s = args[0].get::<super::RtpBaseDepay2>().unwrap();
|
|
let ext_id = args[1].get::<u32>().unwrap();
|
|
let uri = args[2].get::<&str>().unwrap();
|
|
let ext = s.imp().request_extension(ext_id, uri);
|
|
|
|
Some(ext.to_value())
|
|
})
|
|
.build(),
|
|
glib::subclass::Signal::builder("clear-extensions")
|
|
.action()
|
|
.class_handler(|_token, args| {
|
|
let s = args[0].get::<super::RtpBaseDepay2>().unwrap();
|
|
s.imp().clear_extensions();
|
|
|
|
None
|
|
})
|
|
.build(),
|
|
]
|
|
});
|
|
|
|
SIGNALS.as_ref()
|
|
}
|
|
|
|
fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
|
|
match pspec.name() {
|
|
"max-reorder" => {
|
|
self.settings.lock().unwrap().max_reorder = value.get().unwrap();
|
|
}
|
|
"source-info" => {
|
|
self.settings.lock().unwrap().source_info = value.get().unwrap();
|
|
}
|
|
"auto-header-extensions" => {
|
|
self.settings.lock().unwrap().auto_header_extensions = value.get().unwrap();
|
|
}
|
|
_ => unimplemented!(),
|
|
};
|
|
}
|
|
|
|
fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
|
|
match pspec.name() {
|
|
"stats" => self.create_stats().to_value(),
|
|
"max-reorder" => self.settings.lock().unwrap().max_reorder.to_value(),
|
|
"source-info" => self.settings.lock().unwrap().source_info.to_value(),
|
|
"auto-header-extensions" => self
|
|
.settings
|
|
.lock()
|
|
.unwrap()
|
|
.auto_header_extensions
|
|
.to_value(),
|
|
"extensions" => gst::Array::new(self.extensions.lock().unwrap().values()).to_value(),
|
|
_ => unimplemented!(),
|
|
}
|
|
}
|
|
|
|
fn constructed(&self) {
|
|
self.parent_constructed();
|
|
|
|
let obj = self.obj();
|
|
obj.add_pad(&self.sink_pad).unwrap();
|
|
obj.add_pad(&self.src_pad).unwrap();
|
|
}
|
|
}
|
|
|
|
impl GstObjectImpl for RtpBaseDepay2 {}
|
|
|
|
impl ElementImpl for RtpBaseDepay2 {
|
|
fn change_state(
|
|
&self,
|
|
transition: gst::StateChange,
|
|
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
|
|
gst::debug!(CAT, imp: self, "Changing state: {transition}");
|
|
|
|
if transition == gst::StateChange::ReadyToPaused {
|
|
*self.state.borrow_mut() = State::default();
|
|
*self.stats.lock().unwrap() = None;
|
|
|
|
let obj = self.obj();
|
|
(obj.class().as_ref().start)(&obj).map_err(|err_msg| {
|
|
self.post_error_message(err_msg);
|
|
gst::StateChangeError
|
|
})?;
|
|
}
|
|
|
|
let ret = self.parent_change_state(transition)?;
|
|
|
|
if transition == gst::StateChange::PausedToReady {
|
|
let obj = self.obj();
|
|
(obj.class().as_ref().stop)(&obj).map_err(|err_msg| {
|
|
self.post_error_message(err_msg);
|
|
gst::StateChangeError
|
|
})?;
|
|
|
|
*self.state.borrow_mut() = State::default();
|
|
*self.stats.lock().unwrap() = None;
|
|
}
|
|
|
|
Ok(ret)
|
|
}
|
|
}
|