Commit 9665a899 authored by Sebastian Dröge's avatar Sebastian Dröge 🍵

adapter: Add a UniqueAdapter wrapper

This implements Send/Sync and for allowing this safely it provides no
reference counting and requires a mutable reference for all mutable
operations.

It also provides safe access to the Adapter::map() function as without
reference counting we can ensure that nothing else is invalidating the
returned memory while it's still being accessed.
parent 90c86e00
Pipeline #13764 passed with stages
in 9 minutes and 25 seconds
......@@ -10,6 +10,7 @@ use ffi;
use glib::translate::*;
use gst;
use std::io;
use std::ops;
use Adapter;
impl Adapter {
......@@ -56,3 +57,182 @@ impl io::Read for Adapter {
Ok(len)
}
}
#[derive(Debug)]
pub struct UniqueAdapter(Adapter);
unsafe impl Send for UniqueAdapter {}
unsafe impl Sync for UniqueAdapter {}
impl UniqueAdapter {
pub fn new() -> UniqueAdapter {
UniqueAdapter(Adapter::new())
}
pub fn available(&self) -> usize {
self.0.available()
}
pub fn available_fast(&self) -> usize {
self.0.available_fast()
}
pub fn clear(&mut self) {
self.0.clear();
}
pub fn copy_bytes(&self, offset: usize, size: usize) -> Option<glib::Bytes> {
self.0.copy_bytes(offset, size)
}
pub fn distance_from_discont(&self) -> u64 {
self.0.distance_from_discont()
}
#[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn dts_at_discont(&self) -> gst::ClockTime {
self.0.dts_at_discont()
}
pub fn flush(&mut self, flush: usize) {
self.0.flush(flush);
}
pub fn get_buffer(&self, nbytes: usize) -> Option<gst::Buffer> {
self.0.get_buffer(nbytes)
}
pub fn get_buffer_fast(&self, nbytes: usize) -> Option<gst::Buffer> {
self.0.get_buffer_fast(nbytes)
}
pub fn get_buffer_list(&self, nbytes: usize) -> Option<gst::BufferList> {
self.0.get_buffer_list(nbytes)
}
pub fn get_list(&self, nbytes: usize) -> Vec<gst::Buffer> {
self.0.get_list(nbytes)
}
pub fn masked_scan_uint32(&self, mask: u32, pattern: u32, offset: usize, size: usize) -> isize {
self.0.masked_scan_uint32(mask, pattern, offset, size)
}
pub fn masked_scan_uint32_peek(
&self,
mask: u32,
pattern: u32,
offset: usize,
size: usize,
) -> (isize, u32) {
self.0.masked_scan_uint32_peek(mask, pattern, offset, size)
}
#[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn offset_at_discont(&self) -> u64 {
self.0.offset_at_discont()
}
pub fn prev_dts(&self) -> (gst::ClockTime, u64) {
self.0.prev_dts()
}
pub fn prev_dts_at_offset(&self, offset: usize) -> (gst::ClockTime, u64) {
self.0.prev_dts_at_offset(offset)
}
#[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn prev_offset(&self) -> (u64, u64) {
self.0.prev_offset()
}
pub fn prev_pts(&self) -> (gst::ClockTime, u64) {
self.0.prev_pts()
}
pub fn prev_pts_at_offset(&self, offset: usize) -> (gst::ClockTime, u64) {
self.0.prev_pts_at_offset(offset)
}
#[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn pts_at_discont(&self) -> gst::ClockTime {
self.0.pts_at_discont()
}
pub fn take_buffer(&mut self, nbytes: usize) -> Option<gst::Buffer> {
self.0.take_buffer(nbytes)
}
pub fn take_buffer_fast(&mut self, nbytes: usize) -> Option<gst::Buffer> {
self.0.take_buffer_fast(nbytes)
}
pub fn take_buffer_list(&mut self, nbytes: usize) -> Option<gst::BufferList> {
self.0.take_buffer_list(nbytes)
}
pub fn take_list(&mut self, nbytes: usize) -> Vec<gst::Buffer> {
self.0.take_list(nbytes)
}
pub fn copy(&self, offset: usize, dest: &mut [u8]) {
self.0.copy(offset, dest);
}
pub fn push(&mut self, buf: gst::Buffer) {
self.0.push(buf);
}
pub fn map(&mut self, nbytes: usize) -> Option<UniqueAdapterMap> {
use std::slice;
unsafe {
let ptr = ffi::gst_adapter_map(self.0.to_glib_none().0, nbytes);
if ptr.is_null() {
None
} else {
Some(UniqueAdapterMap(
self,
slice::from_raw_parts(ptr as *const u8, nbytes),
))
}
}
}
}
#[derive(Debug)]
pub struct UniqueAdapterMap<'a>(&'a UniqueAdapter, &'a [u8]);
impl<'a> Drop for UniqueAdapterMap<'a> {
fn drop(&mut self) {
unsafe {
ffi::gst_adapter_unmap((self.0).0.to_glib_none().0);
}
}
}
impl<'a> ops::Deref for UniqueAdapterMap<'a> {
type Target = [u8];
fn deref(&self) -> &[u8] {
self.1
}
}
impl<'a> AsRef<[u8]> for UniqueAdapterMap<'a> {
fn as_ref(&self) -> &[u8] {
self.1
}
}
impl Default for UniqueAdapter {
fn default() -> Self {
Self::new()
}
}
impl io::Read for UniqueAdapter {
fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
self.0.read(buf)
}
}
......@@ -41,6 +41,7 @@ pub mod functions;
pub use functions::*;
mod adapter;
pub use adapter::*;
mod flow_combiner;
pub use flow_combiner::*;
#[cfg(any(feature = "v1_14", feature = "dox"))]
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment