2020-11-14 17:09:42 +00:00
|
|
|
// Copyright (C) 2019 Sebastian Dröge <sebastian@centricular.com>
|
2019-08-05 13:19:06 +00:00
|
|
|
//
|
|
|
|
// This library is free software; you can redistribute it and/or
|
|
|
|
// modify it under the terms of the GNU Library General Public
|
|
|
|
// License as published by the Free Software Foundation; either
|
|
|
|
// version 2 of the License, or (at your option) any later version.
|
|
|
|
//
|
|
|
|
// This library is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
// Library General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Library General Public
|
|
|
|
// License along with this library; if not, write to the
|
|
|
|
// Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
|
|
|
|
// Boston, MA 02110-1335, USA.
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
use super::ffi;
|
2019-12-02 09:30:07 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
use std::ptr;
|
2019-11-24 20:12:40 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
use glib::prelude::*;
|
|
|
|
use glib::translate::*;
|
2019-11-24 20:12:40 +00:00
|
|
|
|
2020-03-14 10:34:45 +00:00
|
|
|
use std::mem;
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-12-17 22:44:49 +00:00
|
|
|
glib::wrapper! {
|
2020-11-14 17:09:42 +00:00
|
|
|
pub struct RTPJitterBuffer(Object<ffi::RTPJitterBuffer>);
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
match fn {
|
2021-04-20 15:28:38 +00:00
|
|
|
type_ => || ffi::rtp_jitter_buffer_get_type(),
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe impl glib::SendUnique for RTPJitterBuffer {
|
|
|
|
fn is_unique(&self) -> bool {
|
|
|
|
self.ref_count() == 1
|
2019-12-02 09:30:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl ToGlib for RTPJitterBufferMode {
|
|
|
|
type GlibType = ffi::RTPJitterBufferMode;
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
fn to_glib(&self) -> ffi::RTPJitterBufferMode {
|
|
|
|
match *self {
|
|
|
|
RTPJitterBufferMode::None => ffi::RTP_JITTER_BUFFER_MODE_NONE,
|
|
|
|
RTPJitterBufferMode::Slave => ffi::RTP_JITTER_BUFFER_MODE_SLAVE,
|
|
|
|
RTPJitterBufferMode::Buffer => ffi::RTP_JITTER_BUFFER_MODE_BUFFER,
|
|
|
|
RTPJitterBufferMode::Synced => ffi::RTP_JITTER_BUFFER_MODE_SYNCED,
|
|
|
|
RTPJitterBufferMode::__Unknown(value) => value,
|
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl FromGlib<ffi::RTPJitterBufferMode> for RTPJitterBufferMode {
|
2020-12-08 19:03:20 +00:00
|
|
|
unsafe fn from_glib(value: ffi::RTPJitterBufferMode) -> Self {
|
2020-11-14 17:09:42 +00:00
|
|
|
match value {
|
|
|
|
0 => RTPJitterBufferMode::None,
|
|
|
|
1 => RTPJitterBufferMode::Slave,
|
|
|
|
2 => RTPJitterBufferMode::Buffer,
|
|
|
|
4 => RTPJitterBufferMode::Synced,
|
|
|
|
value => RTPJitterBufferMode::__Unknown(value),
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub struct RTPJitterBufferItem(Option<ptr::NonNull<ffi::RTPJitterBufferItem>>);
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe impl Send for RTPJitterBufferItem {}
|
2020-03-14 10:34:45 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl RTPJitterBufferItem {
|
|
|
|
pub fn new(
|
|
|
|
buffer: gst::Buffer,
|
|
|
|
dts: gst::ClockTime,
|
2019-08-05 13:19:06 +00:00
|
|
|
pts: gst::ClockTime,
|
2020-11-14 17:09:42 +00:00
|
|
|
seqnum: Option<u16>,
|
|
|
|
rtptime: u32,
|
|
|
|
) -> RTPJitterBufferItem {
|
|
|
|
unsafe {
|
2020-11-22 14:24:55 +00:00
|
|
|
let ptr = ptr::NonNull::new(glib::ffi::g_slice_alloc0(mem::size_of::<
|
2020-11-14 17:09:42 +00:00
|
|
|
ffi::RTPJitterBufferItem,
|
|
|
|
>()) as *mut ffi::RTPJitterBufferItem)
|
|
|
|
.expect("Allocation failed");
|
|
|
|
ptr::write(
|
|
|
|
ptr.as_ptr(),
|
|
|
|
ffi::RTPJitterBufferItem {
|
|
|
|
data: buffer.into_ptr() as *mut _,
|
|
|
|
next: ptr::null_mut(),
|
|
|
|
prev: ptr::null_mut(),
|
|
|
|
r#type: 0,
|
|
|
|
dts: dts.to_glib(),
|
|
|
|
pts: pts.to_glib(),
|
|
|
|
seqnum: seqnum.map(|s| s as u32).unwrap_or(std::u32::MAX),
|
|
|
|
count: 1,
|
|
|
|
rtptime,
|
|
|
|
},
|
|
|
|
);
|
2019-09-11 17:25:30 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
RTPJitterBufferItem(Some(ptr))
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn into_buffer(mut self) -> gst::Buffer {
|
|
|
|
unsafe {
|
|
|
|
let item = self.0.take().expect("Invalid wrapper");
|
2020-11-22 14:24:55 +00:00
|
|
|
let buf = item.as_ref().data as *mut gst::ffi::GstBuffer;
|
|
|
|
glib::ffi::g_slice_free1(
|
2020-11-14 17:09:42 +00:00
|
|
|
mem::size_of::<ffi::RTPJitterBufferItem>(),
|
|
|
|
item.as_ptr() as *mut _,
|
|
|
|
);
|
|
|
|
from_glib_full(buf)
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-12 12:49:54 +00:00
|
|
|
pub fn dts(&self) -> gst::ClockTime {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe {
|
|
|
|
let item = self.0.as_ref().expect("Invalid wrapper");
|
2020-11-22 14:24:55 +00:00
|
|
|
if item.as_ref().dts == gst::ffi::GST_CLOCK_TIME_NONE {
|
2020-11-14 17:09:42 +00:00
|
|
|
gst::CLOCK_TIME_NONE
|
2020-04-14 18:53:01 +00:00
|
|
|
} else {
|
2020-11-14 17:09:42 +00:00
|
|
|
gst::ClockTime(Some(item.as_ref().dts))
|
2020-04-14 18:53:01 +00:00
|
|
|
}
|
2019-09-17 14:28:05 +00:00
|
|
|
}
|
2020-11-14 17:09:42 +00:00
|
|
|
}
|
2019-09-17 14:28:05 +00:00
|
|
|
|
2021-04-12 12:49:54 +00:00
|
|
|
pub fn pts(&self) -> gst::ClockTime {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe {
|
|
|
|
let item = self.0.as_ref().expect("Invalid wrapper");
|
2020-11-22 14:24:55 +00:00
|
|
|
if item.as_ref().pts == gst::ffi::GST_CLOCK_TIME_NONE {
|
2020-11-14 17:09:42 +00:00
|
|
|
gst::CLOCK_TIME_NONE
|
2019-09-11 17:25:30 +00:00
|
|
|
} else {
|
2020-11-14 17:09:42 +00:00
|
|
|
gst::ClockTime(Some(item.as_ref().pts))
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-12 12:49:54 +00:00
|
|
|
pub fn seqnum(&self) -> Option<u16> {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe {
|
|
|
|
let item = self.0.as_ref().expect("Invalid wrapper");
|
|
|
|
if item.as_ref().seqnum == std::u32::MAX {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
Some(item.as_ref().seqnum as u16)
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
#[allow(dead_code)]
|
2021-04-12 12:49:54 +00:00
|
|
|
pub fn rtptime(&self) -> u32 {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe {
|
|
|
|
let item = self.0.as_ref().expect("Invalid wrapper");
|
|
|
|
item.as_ref().rtptime
|
2020-01-21 17:26:07 +00:00
|
|
|
}
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
2020-11-14 17:09:42 +00:00
|
|
|
}
|
2020-03-14 10:34:45 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl Drop for RTPJitterBufferItem {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
unsafe {
|
|
|
|
if let Some(ref item) = self.0 {
|
|
|
|
if !item.as_ref().data.is_null() {
|
2020-11-22 14:24:55 +00:00
|
|
|
gst::ffi::gst_mini_object_unref(item.as_ref().data as *mut _);
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
|
|
|
|
2020-11-22 14:24:55 +00:00
|
|
|
glib::ffi::g_slice_free1(
|
2020-11-14 17:09:42 +00:00
|
|
|
mem::size_of::<ffi::RTPJitterBufferItem>(),
|
|
|
|
item.as_ptr() as *mut _,
|
|
|
|
);
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub struct RTPPacketRateCtx(Box<ffi::RTPPacketRateCtx>);
|
2020-03-14 10:34:45 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe impl Send for RTPPacketRateCtx {}
|
2020-03-14 10:34:45 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl RTPPacketRateCtx {
|
|
|
|
pub fn new() -> RTPPacketRateCtx {
|
|
|
|
unsafe {
|
|
|
|
let mut ptr = std::mem::MaybeUninit::uninit();
|
|
|
|
ffi::gst_rtp_packet_rate_ctx_reset(ptr.as_mut_ptr(), -1);
|
|
|
|
RTPPacketRateCtx(Box::new(ptr.assume_init()))
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn reset(&mut self, clock_rate: i32) {
|
|
|
|
unsafe { ffi::gst_rtp_packet_rate_ctx_reset(&mut *self.0, clock_rate) }
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn update(&mut self, seqnum: u16, ts: u32) -> u32 {
|
|
|
|
unsafe { ffi::gst_rtp_packet_rate_ctx_update(&mut *self.0, seqnum, ts) }
|
2019-12-02 09:30:07 +00:00
|
|
|
}
|
2020-03-14 10:34:45 +00:00
|
|
|
|
2021-04-20 12:57:40 +00:00
|
|
|
pub fn max_dropout(&mut self, time_ms: i32) -> u32 {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe { ffi::gst_rtp_packet_rate_ctx_get_max_dropout(&mut *self.0, time_ms) }
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
#[allow(dead_code)]
|
2021-04-20 12:57:40 +00:00
|
|
|
pub fn max_disorder(&mut self, time_ms: i32) -> u32 {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe { ffi::gst_rtp_packet_rate_ctx_get_max_disorder(&mut *self.0, time_ms) }
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl Default for RTPPacketRateCtx {
|
2020-03-14 10:34:45 +00:00
|
|
|
fn default() -> Self {
|
2020-11-14 17:09:42 +00:00
|
|
|
RTPPacketRateCtx::new()
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
|
|
|
pub enum RTPJitterBufferMode {
|
|
|
|
r#None,
|
|
|
|
Slave,
|
|
|
|
Buffer,
|
|
|
|
Synced,
|
|
|
|
__Unknown(i32),
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl RTPJitterBuffer {
|
|
|
|
pub fn new() -> RTPJitterBuffer {
|
|
|
|
unsafe { from_glib_full(ffi::rtp_jitter_buffer_new()) }
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
2020-04-20 19:35:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
#[allow(dead_code)]
|
2021-04-12 12:49:54 +00:00
|
|
|
pub fn mode(&self) -> RTPJitterBufferMode {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe { from_glib(ffi::rtp_jitter_buffer_get_mode(self.to_glib_none().0)) }
|
2020-04-20 19:35:06 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
#[allow(dead_code)]
|
|
|
|
pub fn set_mode(&self, mode: RTPJitterBufferMode) {
|
|
|
|
unsafe { ffi::rtp_jitter_buffer_set_mode(self.to_glib_none().0, mode.to_glib()) }
|
2020-04-20 19:35:06 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
#[allow(dead_code)]
|
2021-04-12 12:49:54 +00:00
|
|
|
pub fn delay(&self) -> gst::ClockTime {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe { from_glib(ffi::rtp_jitter_buffer_get_delay(self.to_glib_none().0)) }
|
2020-04-20 19:35:06 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn set_delay(&self, delay: gst::ClockTime) {
|
|
|
|
unsafe { ffi::rtp_jitter_buffer_set_delay(self.to_glib_none().0, delay.to_glib()) }
|
2020-04-20 19:35:06 +00:00
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn set_clock_rate(&self, clock_rate: u32) {
|
|
|
|
unsafe { ffi::rtp_jitter_buffer_set_clock_rate(self.to_glib_none().0, clock_rate) }
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
2020-01-22 16:16:00 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
#[allow(dead_code)]
|
2021-04-12 12:49:54 +00:00
|
|
|
pub fn clock_rate(&self) -> u32 {
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe { ffi::rtp_jitter_buffer_get_clock_rate(self.to_glib_none().0) }
|
2020-01-22 16:16:00 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn calculate_pts(
|
|
|
|
&self,
|
|
|
|
dts: gst::ClockTime,
|
|
|
|
estimated_dts: bool,
|
|
|
|
rtptime: u32,
|
|
|
|
base_time: gst::ClockTime,
|
|
|
|
gap: i32,
|
|
|
|
is_rtx: bool,
|
|
|
|
) -> gst::ClockTime {
|
|
|
|
unsafe {
|
|
|
|
let pts = ffi::rtp_jitter_buffer_calculate_pts(
|
|
|
|
self.to_glib_none().0,
|
|
|
|
dts.to_glib(),
|
|
|
|
estimated_dts.to_glib(),
|
|
|
|
rtptime,
|
|
|
|
base_time.to_glib(),
|
|
|
|
gap,
|
|
|
|
is_rtx.to_glib(),
|
|
|
|
);
|
2020-01-22 16:16:00 +00:00
|
|
|
|
2020-11-22 14:24:55 +00:00
|
|
|
if pts == gst::ffi::GST_CLOCK_TIME_NONE {
|
2020-11-14 17:09:42 +00:00
|
|
|
gst::CLOCK_TIME_NONE
|
|
|
|
} else {
|
|
|
|
pts.into()
|
|
|
|
}
|
|
|
|
}
|
2020-01-22 16:16:00 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn insert(&self, mut item: RTPJitterBufferItem) -> (bool, bool, i32) {
|
|
|
|
unsafe {
|
|
|
|
let mut head = mem::MaybeUninit::uninit();
|
|
|
|
let mut percent = mem::MaybeUninit::uninit();
|
|
|
|
let ptr = item.0.take().expect("Invalid wrapper");
|
|
|
|
let ret: bool = from_glib(ffi::rtp_jitter_buffer_insert(
|
|
|
|
self.to_glib_none().0,
|
|
|
|
ptr.as_ptr(),
|
|
|
|
head.as_mut_ptr(),
|
|
|
|
percent.as_mut_ptr(),
|
|
|
|
));
|
|
|
|
if !ret {
|
|
|
|
item.0 = Some(ptr);
|
|
|
|
}
|
|
|
|
(ret, from_glib(head.assume_init()), percent.assume_init())
|
|
|
|
}
|
2020-03-14 10:34:45 +00:00
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn find_earliest(&self) -> (gst::ClockTime, Option<u16>) {
|
|
|
|
unsafe {
|
|
|
|
let mut pts = mem::MaybeUninit::uninit();
|
|
|
|
let mut seqnum = mem::MaybeUninit::uninit();
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
ffi::rtp_jitter_buffer_find_earliest(
|
|
|
|
self.to_glib_none().0,
|
|
|
|
pts.as_mut_ptr(),
|
|
|
|
seqnum.as_mut_ptr(),
|
|
|
|
);
|
|
|
|
let pts = pts.assume_init();
|
|
|
|
let seqnum = seqnum.assume_init();
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
let seqnum = if seqnum == std::u32::MAX {
|
2019-08-05 13:19:06 +00:00
|
|
|
None
|
2020-11-14 17:09:42 +00:00
|
|
|
} else {
|
|
|
|
Some(seqnum as u16)
|
|
|
|
};
|
2020-04-29 13:03:43 +00:00
|
|
|
|
2020-11-22 14:24:55 +00:00
|
|
|
if pts == gst::ffi::GST_CLOCK_TIME_NONE {
|
2020-11-14 17:09:42 +00:00
|
|
|
(gst::CLOCK_TIME_NONE, seqnum)
|
|
|
|
} else {
|
|
|
|
(pts.into(), seqnum)
|
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn pop(&self) -> (Option<RTPJitterBufferItem>, i32) {
|
|
|
|
unsafe {
|
|
|
|
let mut percent = mem::MaybeUninit::uninit();
|
|
|
|
let item = ffi::rtp_jitter_buffer_pop(self.to_glib_none().0, percent.as_mut_ptr());
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
(
|
|
|
|
if item.is_null() {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
Some(RTPJitterBufferItem(Some(ptr::NonNull::new_unchecked(item))))
|
|
|
|
},
|
|
|
|
percent.assume_init(),
|
|
|
|
)
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn peek(&self) -> (gst::ClockTime, Option<u16>) {
|
|
|
|
unsafe {
|
|
|
|
let item = ffi::rtp_jitter_buffer_peek(self.to_glib_none().0);
|
|
|
|
if item.is_null() {
|
|
|
|
(gst::CLOCK_TIME_NONE, None)
|
|
|
|
} else {
|
|
|
|
let seqnum = (*item).seqnum;
|
|
|
|
let seqnum = if seqnum == std::u32::MAX {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
Some(seqnum as u16)
|
|
|
|
};
|
|
|
|
((*item).pts.into(), seqnum)
|
2019-08-22 23:04:14 +00:00
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn flush(&self) {
|
2020-11-22 14:24:55 +00:00
|
|
|
unsafe extern "C" fn free_item(item: glib::ffi::gpointer, _: glib::ffi::gpointer) {
|
2020-11-14 17:09:42 +00:00
|
|
|
let _ =
|
|
|
|
RTPJitterBufferItem(Some(ptr::NonNull::new(item as *mut _).expect("NULL item")));
|
2019-08-22 23:04:14 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
unsafe {
|
|
|
|
ffi::rtp_jitter_buffer_flush(self.to_glib_none().0, Some(free_item));
|
2020-01-21 17:34:02 +00:00
|
|
|
}
|
2019-08-22 23:04:14 +00:00
|
|
|
}
|
2020-06-02 17:31:58 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
pub fn reset_skew(&self) {
|
|
|
|
unsafe { ffi::rtp_jitter_buffer_reset_skew(self.to_glib_none().0) }
|
2020-06-02 17:31:58 +00:00
|
|
|
}
|
2019-08-22 23:04:14 +00:00
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
|
2020-11-14 17:09:42 +00:00
|
|
|
impl Default for RTPJitterBuffer {
|
|
|
|
fn default() -> Self {
|
|
|
|
RTPJitterBuffer::new()
|
|
|
|
}
|
2019-08-05 13:19:06 +00:00
|
|
|
}
|