mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2025-02-20 22:56:20 +00:00
Code Issues Projects Releases Wiki Activity

Various further cleanups

Browse source
This commit is contained in:
Sebastian Dröge 2016-08-22 23:03:06 +03:00
parent bb8072c4d8
commit 6f6e56a5e3
6 changed files with 176 additions and 149 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

142
src/lib.rs
View file

@ -31,10 +31,8 @@ pub mod rshttpsrc;
pub mod rsfilesink;
use utils::*;
use rssource::{Source, SourceController};
use rsfilesrc::FileSrc;
use rshttpsrc::HttpSrc;
use rssink::{Sink, SinkController};
use rsfilesink::FileSink;
use std::os::raw::c_void;
@ -49,7 +47,7 @@ extern "C" {
classification: *const c_char,
author: *const c_char,
rank: i32,
create_instance: fn(controller: SourceController) -> Box<Source>,
create_instance: *const c_void,
protocols: *const c_char,
push_only: GBoolean)
-> GBoolean;
@ -63,60 +61,106 @@ extern "C" {
classification: *const c_char,
author: *const c_char,
rank: i32,
create_instance: fn(controller: SinkController) -> Box<Sink>,
create_instance: *const c_void,
protocols: *const c_char)
-> GBoolean;
}
#[no_mangle]
pub extern "C" fn sources_register(plugin: *const c_void) -> GBoolean {
unsafe fn source_register(plugin: *const c_void,
name: &str,
long_name: &str,
description: &str,
classification: &str,
author: &str,
rank: i32,
create_instance: *const c_void,
protocols: &str,
push_only: bool) {
let cname = CString::new(name).unwrap();
let clong_name = CString::new(long_name).unwrap();
let cdescription = CString::new(description).unwrap();
let cclassification = CString::new(classification).unwrap();
let cauthor = CString::new(author).unwrap();
let cprotocols = CString::new(protocols).unwrap();
unsafe {
gst_rs_source_register(plugin,
CString::new("rsfilesrc").unwrap().as_ptr(),
CString::new("File Source").unwrap().as_ptr(),
CString::new("Reads local files").unwrap().as_ptr(),
CString::new("Source/File").unwrap().as_ptr(),
CString::new("Sebastian Dröge <sebastian@centricular.com>")
.unwrap()
.as_ptr(),
256 + 100,
FileSrc::new_boxed,
CString::new("file").unwrap().as_ptr(),
GBoolean::False);
gst_rs_source_register(plugin,
cname.as_ptr(),
clong_name.as_ptr(),
cdescription.as_ptr(),
cclassification.as_ptr(),
cauthor.as_ptr(),
rank,
create_instance,
cprotocols.as_ptr(),
GBoolean::from_bool(push_only));
gst_rs_source_register(plugin,
CString::new("rshttpsrc").unwrap().as_ptr(),
CString::new("HTTP Source").unwrap().as_ptr(),
CString::new("Read HTTP/HTTPS files").unwrap().as_ptr(),
CString::new("Source/Network/HTTP").unwrap().as_ptr(),
CString::new("Sebastian Dröge <sebastian@centricular.com>")
.unwrap()
.as_ptr(),
256 + 100,
HttpSrc::new_boxed,
CString::new("http:https").unwrap().as_ptr(),
GBoolean::True);
}
return GBoolean::True;
}
#[no_mangle]
pub extern "C" fn sinks_register(plugin: *const c_void) -> GBoolean {
pub unsafe extern "C" fn sources_register(plugin: *const c_void) -> GBoolean {
source_register(plugin,
"rsfilesrc",
"File Source",
"Reads local files",
"Source/File",
"Sebastian Dröge <sebastian@centricular.com>",
256 + 100,
FileSrc::new_boxed as *const c_void,
"file",
false);
unsafe {
gst_rs_sink_register(plugin,
CString::new("rsfilesink").unwrap().as_ptr(),
CString::new("File Sink").unwrap().as_ptr(),
CString::new("Writes to local files").unwrap().as_ptr(),
CString::new("Sink/File").unwrap().as_ptr(),
CString::new("Luis de Bethencourt <luisbg@osg.samsung.com>")
.unwrap()
.as_ptr(),
256 + 100,
FileSink::new_boxed,
CString::new("file").unwrap().as_ptr());
}
return GBoolean::True;
source_register(plugin,
"rshttpsrc",
"HTTP Source",
"Read HTTP/HTTPS files",
"Source/Network/HTTP",
"Sebastian Dröge <sebastian@centricular.com>",
256 + 100,
HttpSrc::new_boxed as *const c_void,
"http:https",
true);
GBoolean::True
}
unsafe fn sink_register(plugin: *const c_void,
name: &str,
long_name: &str,
description: &str,
classification: &str,
author: &str,
rank: i32,
create_instance: *const c_void,
protocols: &str) {
let cname = CString::new(name).unwrap();
let clong_name = CString::new(long_name).unwrap();
let cdescription = CString::new(description).unwrap();
let cclassification = CString::new(classification).unwrap();
let cauthor = CString::new(author).unwrap();
let cprotocols = CString::new(protocols).unwrap();
gst_rs_sink_register(plugin,
cname.as_ptr(),
clong_name.as_ptr(),
cdescription.as_ptr(),
cclassification.as_ptr(),
cauthor.as_ptr(),
rank,
create_instance,
cprotocols.as_ptr());
}
#[no_mangle]
pub unsafe extern "C" fn sinks_register(plugin: *const c_void) -> GBoolean {
sink_register(plugin,
"rsfilesink",
"File Sink",
"Writes to local files",
"Sink/File",
"Luis de Bethencourt <luisbg@osg.samsung.com>",
256 + 100,
FileSink::new_boxed as *const c_void,
"file");
GBoolean::True
}

29
src/rssink.c
View file

@ -37,13 +37,12 @@ static GHashTable *sinks;
/* Declarations for Rust code */
extern gboolean sinks_register (void *plugin);
extern void *sink_new (GstRsSink * sink, void *create_instance);
extern GstFlowReturn sink_render (GstRsSink * sink, void *rssink, void *data,
size_t data_len);
extern gboolean sink_set_uri (GstRsSink * sink, void *rssink, const char *uri);
extern char *sink_get_uri (GstRsSink * sink, void *rssink);
extern gboolean sink_start (GstRsSink * sink, void *rssink);
extern gboolean sink_stop (GstRsSink * sink, void *rssink);
extern void sink_drop (GstRsSink * sink, void *rssink);
extern GstFlowReturn sink_render (void *rssink, void *data, size_t data_len);
extern gboolean sink_set_uri (void *rssink, const char *uri);
extern char *sink_get_uri (void *rssink);
extern gboolean sink_start (void *rssink);
extern gboolean sink_stop (void *rssink);
extern void sink_drop (void *rssink);
extern void cstring_drop (void *str);
@ -128,7 +127,7 @@ gst_rs_sink_finalize (GObject * object)
{
GstRsSink *sink = GST_RS_SINK (object);
sink_drop (sink, sink->instance);
sink_drop (sink->instance);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
@ -141,7 +140,7 @@ gst_rs_sink_set_property (GObject * object, guint prop_id,
switch (prop_id) {
case PROP_URI:
sink_set_uri (sink, sink->instance, g_value_get_string (value));
sink_set_uri (sink->instance, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -157,7 +156,7 @@ gst_rs_sink_get_property (GObject * object, guint prop_id, GValue * value,
switch (prop_id) {
case PROP_URI:{
gchar *str = sink_get_uri (sink, sink->instance);
gchar *str = sink_get_uri (sink->instance);
g_value_set_string (value, str);
if (str)
cstring_drop (str);
@ -177,7 +176,7 @@ gst_rs_sink_render (GstBaseSink * basesink, GstBuffer * buffer)
GstFlowReturn ret;
gst_buffer_map (buffer, &map, GST_MAP_READ);
ret = sink_render (sink, sink->instance, map.data, map.size);
ret = sink_render (sink->instance, map.data, map.size);
gst_buffer_unmap (buffer, &map);
return ret;
@ -189,7 +188,7 @@ gst_rs_sink_start (GstBaseSink * basesink)
{
GstRsSink *sink = GST_RS_SINK (basesink);
return sink_start (sink, sink->instance);
return sink_start (sink->instance);
}
/* unmap and close the rs */
@ -198,7 +197,7 @@ gst_rs_sink_stop (GstBaseSink * basesink)
{
GstRsSink *sink = GST_RS_SINK (basesink);
return sink_stop (sink, sink->instance);
return sink_stop (sink->instance);
}
static GstURIType
@ -221,7 +220,7 @@ gst_rs_sink_uri_get_uri (GstURIHandler * handler)
{
GstRsSink *sink = GST_RS_SINK (handler);
return sink_get_uri (sink, sink->instance);
return sink_get_uri (sink->instance);
}
static gboolean
@ -230,7 +229,7 @@ gst_rs_sink_uri_set_uri (GstURIHandler * handler, const gchar * uri,
{
GstRsSink *sink = GST_RS_SINK (handler);
if (!sink_set_uri (sink, sink->instance, uri)) {
if (!sink_set_uri (sink->instance, uri)) {
g_set_error (err, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
"Can't handle URI '%s'", uri);
return FALSE;

39
src/rssink.rs
View file

@ -57,21 +57,19 @@ pub extern "C" fn sink_new(sink: *mut c_void,
}
#[no_mangle]
pub extern "C" fn sink_drop(sink: *mut c_void, ptr: *mut Box<Sink>) {
unsafe { Box::from_raw(ptr) };
pub unsafe extern "C" fn sink_drop(ptr: *mut Box<Sink>) {
Box::from_raw(ptr);
}
#[no_mangle]
pub extern "C" fn sink_set_uri(sink: *mut c_void,
ptr: *mut Box<Sink>,
uri_ptr: *const c_char)
-> GBoolean {
let sink: &mut Box<Sink> = unsafe { &mut *ptr };
pub unsafe extern "C" fn sink_set_uri(ptr: *mut Box<Sink>, uri_ptr: *const c_char) -> GBoolean {
let sink: &mut Box<Sink> = &mut *ptr;
if uri_ptr.is_null() {
GBoolean::from_bool(sink.set_uri(None))
} else {
let uri_str = unsafe { CStr::from_ptr(uri_ptr) }.to_str().unwrap();
let uri_str = CStr::from_ptr(uri_ptr).to_str().unwrap();
match Url::parse(uri_str) {
Ok(uri) => GBoolean::from_bool(sink.set_uri(Some(uri))),
Err(err) => {
@ -84,8 +82,8 @@ pub extern "C" fn sink_set_uri(sink: *mut c_void,
}
#[no_mangle]
pub extern "C" fn sink_get_uri(sink: *mut c_void, ptr: *const Box<Sink>) -> *mut c_char {
let sink: &Box<Sink> = unsafe { &*ptr };
pub unsafe extern "C" fn sink_get_uri(ptr: *const Box<Sink>) -> *mut c_char {
let sink: &Box<Sink> = &*ptr;
match sink.get_uri() {
Some(uri) => CString::new(uri.into_string().into_bytes()).unwrap().into_raw(),
@ -94,27 +92,26 @@ pub extern "C" fn sink_get_uri(sink: *mut c_void, ptr: *const Box<Sink>) -> *mut
}
#[no_mangle]
pub extern "C" fn sink_render(sink: *mut c_void,
ptr: *mut Box<Sink>,
data_ptr: *const u8,
data_len: usize)
-> GstFlowReturn {
let sink: &mut Box<Sink> = unsafe { &mut *ptr };
pub unsafe extern "C" fn sink_render(ptr: *mut Box<Sink>,
data_ptr: *const u8,
data_len: usize)
-> GstFlowReturn {
let sink: &mut Box<Sink> = &mut *ptr;
let data = slice::from_raw_parts(data_ptr, data_len);
let data = unsafe { slice::from_raw_parts(data_ptr, data_len) };
sink.render(data)
}
#[no_mangle]
pub extern "C" fn sink_start(sink: *mut c_void, ptr: *mut Box<Sink>) -> GBoolean {
let sink: &mut Box<Sink> = unsafe { &mut *ptr };
pub unsafe extern "C" fn sink_start(ptr: *mut Box<Sink>) -> GBoolean {
let sink: &mut Box<Sink> = &mut *ptr;
GBoolean::from_bool(sink.start())
}
#[no_mangle]
pub extern "C" fn sink_stop(sink: *mut c_void, ptr: *mut Box<Sink>) -> GBoolean {
let sink: &mut Box<Sink> = unsafe { &mut *ptr };
pub unsafe extern "C" fn sink_stop(ptr: *mut Box<Sink>) -> GBoolean {
let sink: &mut Box<Sink> = &mut *ptr;
GBoolean::from_bool(sink.stop())
}

42
src/rssource.c
View file

@ -35,18 +35,16 @@ static GHashTable *sources;
/* Declarations for Rust code */
extern gboolean sources_register (void *plugin);
extern void *source_new (GstRsSrc * source, void *create_instance);
extern void source_drop (GstRsSrc * source, void *rssource);
extern GstFlowReturn source_fill (GstRsSrc * source, void *rssource,
extern void source_drop (void *rssource);
extern GstFlowReturn source_fill (void *rssource,
uint64_t offset, void *data, size_t * data_len);
extern gboolean source_do_seek (GstRsSrc * source, void *rssource,
uint64_t start, uint64_t stop);
extern gboolean source_set_uri (GstRsSrc * source, void *rssource,
const char *uri);
extern char *source_get_uri (GstRsSrc * source, void *rssource);
extern uint64_t source_get_size (GstRsSrc * source, void *rssource);
extern gboolean source_is_seekable (GstRsSrc * source, void *rssource);
extern gboolean source_start (GstRsSrc * source, void *rssource);
extern gboolean source_stop (GstRsSrc * source, void *rssource);
extern gboolean source_do_seek (void *rssource, uint64_t start, uint64_t stop);
extern gboolean source_set_uri (void *rssource, const char *uri);
extern char *source_get_uri (void *rssource);
extern uint64_t source_get_size (void *rssource);
extern gboolean source_is_seekable (void *rssource);
extern gboolean source_start (void *rssource);
extern gboolean source_stop (void *rssource);
extern void cstring_drop (void *str);
@ -138,7 +136,7 @@ gst_rs_src_finalize (GObject * object)
{
GstRsSrc *src = GST_RS_SRC (object);
source_drop (src, src->instance);
source_drop (src->instance);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
@ -151,7 +149,7 @@ gst_rs_src_set_property (GObject * object, guint prop_id,
switch (prop_id) {
case PROP_URI:
source_set_uri (src, src->instance, g_value_get_string (value));
source_set_uri (src->instance, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -167,7 +165,7 @@ gst_rs_src_get_property (GObject * object, guint prop_id, GValue * value,
switch (prop_id) {
case PROP_URI:{
gchar *str = source_get_uri (src, src->instance);
gchar *str = source_get_uri (src->instance);
g_value_set_string (value, str);
if (str)
cstring_drop (str);
@ -191,7 +189,7 @@ gst_rs_src_fill (GstBaseSrc * basesrc, guint64 offset, guint length,
gst_buffer_map (buf, &map, GST_MAP_READWRITE);
size = length;
map_size = map.size;
ret = source_fill (src, src->instance, offset, map.data, &size);
ret = source_fill (src->instance, offset, map.data, &size);
gst_buffer_unmap (buf, &map);
if (ret == GST_FLOW_OK && size != map_size)
gst_buffer_resize (buf, 0, size);
@ -204,7 +202,7 @@ gst_rs_src_is_seekable (GstBaseSrc * basesrc)
{
GstRsSrc *src = GST_RS_SRC (basesrc);
return source_is_seekable (src, src->instance);
return source_is_seekable (src->instance);
}
static gboolean
@ -212,7 +210,7 @@ gst_rs_src_get_size (GstBaseSrc * basesrc, guint64 * size)
{
GstRsSrc *src = GST_RS_SRC (basesrc);
*size = source_get_size (src, src->instance);
*size = source_get_size (src->instance);
return TRUE;
}
@ -223,7 +221,7 @@ gst_rs_src_start (GstBaseSrc * basesrc)
{
GstRsSrc *src = GST_RS_SRC (basesrc);
return source_start (src, src->instance);
return source_start (src->instance);
}
static gboolean
@ -231,7 +229,7 @@ gst_rs_src_stop (GstBaseSrc * basesrc)
{
GstRsSrc *src = GST_RS_SRC (basesrc);
return source_stop (src, src->instance);
return source_stop (src->instance);
}
static gboolean
@ -240,7 +238,7 @@ gst_rs_src_do_seek (GstBaseSrc * basesrc, GstSegment * segment)
GstRsSrc *src = GST_RS_SRC (basesrc);
gboolean ret;
ret = source_do_seek (src, src->instance, segment->start, segment->stop);
ret = source_do_seek (src->instance, segment->start, segment->stop);
if (!ret)
return FALSE;
@ -267,7 +265,7 @@ gst_rs_src_uri_get_uri (GstURIHandler * handler)
{
GstRsSrc *src = GST_RS_SRC (handler);
return source_get_uri (src, src->instance);
return source_get_uri (src->instance);
}
static gboolean
@ -276,7 +274,7 @@ gst_rs_src_uri_set_uri (GstURIHandler * handler, const gchar * uri,
{
GstRsSrc *src = GST_RS_SRC (handler);
if (!source_set_uri (src, src->instance, uri)) {
if (!source_set_uri (src->instance, uri)) {
g_set_error (err, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
"Can't handle URI '%s'", uri);
return FALSE;

62
src/rssource.rs
View file

@ -61,21 +61,19 @@ pub extern "C" fn source_new(source: *mut c_void,
}
#[no_mangle]
pub extern "C" fn source_drop(source: *mut c_void, ptr: *mut Box<Source>) {
unsafe { Box::from_raw(ptr) };
pub unsafe extern "C" fn source_drop(ptr: *mut Box<Source>) {
Box::from_raw(ptr);
}
#[no_mangle]
pub extern "C" fn source_set_uri(source: *mut c_void,
ptr: *mut Box<Source>,
uri_ptr: *const c_char)
-> GBoolean {
let source: &mut Box<Source> = unsafe { &mut *ptr };
pub unsafe extern "C" fn source_set_uri(ptr: *mut Box<Source>, uri_ptr: *const c_char) -> GBoolean {
let source: &mut Box<Source> = &mut *ptr;
if uri_ptr.is_null() {
GBoolean::from_bool(source.set_uri(None))
} else {
let uri_str = unsafe { CStr::from_ptr(uri_ptr) }.to_str().unwrap();
let uri_str = CStr::from_ptr(uri_ptr).to_str().unwrap();
match Url::parse(uri_str) {
Ok(uri) => GBoolean::from_bool(source.set_uri(Some(uri))),
Err(err) => {
@ -88,8 +86,8 @@ pub extern "C" fn source_set_uri(source: *mut c_void,
}
#[no_mangle]
pub extern "C" fn source_get_uri(source: *mut c_void, ptr: *mut Box<Source>) -> *mut c_char {
let source: &mut Box<Source> = unsafe { &mut *ptr };
pub unsafe extern "C" fn source_get_uri(ptr: *mut Box<Source>) -> *mut c_char {
let source: &mut Box<Source> = &mut *ptr;
match source.get_uri() {
Some(uri) => CString::new(uri.into_string().into_bytes()).unwrap().into_raw(),
@ -98,16 +96,16 @@ pub extern "C" fn source_get_uri(source: *mut c_void, ptr: *mut Box<Source>) ->
}
#[no_mangle]
pub extern "C" fn source_fill(source: *mut c_void,
ptr: *mut Box<Source>,
offset: u64,
data_ptr: *mut u8,
data_len_ptr: *mut usize)
-> GstFlowReturn {
let source: &mut Box<Source> = unsafe { &mut *ptr };
pub unsafe extern "C" fn source_fill(ptr: *mut Box<Source>,
offset: u64,
data_ptr: *mut u8,
data_len_ptr: *mut usize)
-> GstFlowReturn {
let source: &mut Box<Source> = &mut *ptr;
let mut data_len: &mut usize = &mut *data_len_ptr;
let mut data = slice::from_raw_parts_mut(data_ptr, *data_len);
let mut data_len: &mut usize = unsafe { &mut *data_len_ptr };
let mut data = unsafe { slice::from_raw_parts_mut(data_ptr, *data_len) };
match source.fill(offset, data) {
Ok(actual_len) => {
*data_len = actual_len;
@ -118,40 +116,36 @@ pub extern "C" fn source_fill(source: *mut c_void,
}
#[no_mangle]
pub extern "C" fn source_get_size(source: *mut c_void, ptr: *const Box<Source>) -> u64 {
let source: &Box<Source> = unsafe { &*ptr };
pub unsafe extern "C" fn source_get_size(ptr: *const Box<Source>) -> u64 {
let source: &Box<Source> = &*ptr;
return source.get_size();
source.get_size()
}
#[no_mangle]
pub extern "C" fn source_start(source: *mut c_void, ptr: *mut Box<Source>) -> GBoolean {
let source: &mut Box<Source> = unsafe { &mut *ptr };
pub unsafe extern "C" fn source_start(ptr: *mut Box<Source>) -> GBoolean {
let source: &mut Box<Source> = &mut *ptr;
GBoolean::from_bool(source.start())
}
#[no_mangle]
pub extern "C" fn source_stop(source: *mut c_void, ptr: *mut Box<Source>) -> GBoolean {
let source: &mut Box<Source> = unsafe { &mut *ptr };
pub unsafe extern "C" fn source_stop(ptr: *mut Box<Source>) -> GBoolean {
let source: &mut Box<Source> = &mut *ptr;
GBoolean::from_bool(source.stop())
}
#[no_mangle]
pub extern "C" fn source_is_seekable(source: *mut c_void, ptr: *const Box<Source>) -> GBoolean {
let source: &Box<Source> = unsafe { &*ptr };
pub unsafe extern "C" fn source_is_seekable(ptr: *const Box<Source>) -> GBoolean {
let source: &Box<Source> = &*ptr;
GBoolean::from_bool(source.is_seekable())
}
#[no_mangle]
pub extern "C" fn source_do_seek(source: *mut c_void,
ptr: *mut Box<Source>,
start: u64,
stop: u64)
-> GBoolean {
let source: &mut Box<Source> = unsafe { &mut *ptr };
pub unsafe extern "C" fn source_do_seek(ptr: *mut Box<Source>, start: u64, stop: u64) -> GBoolean {
let source: &mut Box<Source> = &mut *ptr;
GBoolean::from_bool(source.do_seek(start, stop))
}

11
src/utils.rs
View file

@ -46,16 +46,11 @@ pub enum GBoolean {
impl GBoolean {
pub fn from_bool(v: bool) -> GBoolean {
match v {
true => GBoolean::True,
false => GBoolean::False,
}
if v { GBoolean::True } else { GBoolean::False }
}
}
#[no_mangle]
pub extern "C" fn cstring_drop(ptr: *mut c_char) {
unsafe {
CString::from_raw(ptr);
}
pub unsafe extern "C" fn cstring_drop(ptr: *mut c_char) {
CString::from_raw(ptr);
}