2018-12-30 10:03:32 +00:00
|
|
|
// Copyright (C) 2016-2018 Sebastian Dröge <sebastian@centricular.com>
|
2016-05-15 15:54:09 +00:00
|
|
|
//
|
2017-02-16 15:52:27 +00:00
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
2016-05-15 15:54:09 +00:00
|
|
|
|
2018-12-19 12:31:42 +00:00
|
|
|
use hyperx::header::{
|
|
|
|
AcceptRanges, ByteRangeSpec, ContentLength, ContentRange, ContentRangeSpec, Headers, Range,
|
|
|
|
RangeUnit,
|
2018-07-27 10:35:58 +00:00
|
|
|
};
|
2018-04-05 08:35:34 +00:00
|
|
|
use reqwest::{Client, Response};
|
|
|
|
use std::io::Read;
|
2018-12-30 10:03:32 +00:00
|
|
|
use std::sync::Mutex;
|
2018-04-05 08:35:34 +00:00
|
|
|
use std::u64;
|
|
|
|
use url::Url;
|
2016-05-14 14:04:53 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
use glib;
|
|
|
|
use glib::subclass;
|
|
|
|
use glib::subclass::prelude::*;
|
|
|
|
use gst;
|
|
|
|
use gst::prelude::*;
|
|
|
|
use gst::subclass::prelude::*;
|
|
|
|
use gst_base;
|
|
|
|
use gst_base::prelude::*;
|
|
|
|
use gst_base::subclass::prelude::*;
|
2018-05-04 12:16:59 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
const DEFAULT_LOCATION: Option<Url> = None;
|
2016-12-25 11:16:12 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
struct Settings {
|
|
|
|
location: Option<Url>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for Settings {
|
|
|
|
fn default() -> Self {
|
|
|
|
Settings {
|
|
|
|
location: DEFAULT_LOCATION,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static PROPERTIES: [subclass::Property; 1] = [subclass::Property("location", |name| {
|
|
|
|
glib::ParamSpec::string(
|
|
|
|
name,
|
|
|
|
"File Location",
|
|
|
|
"URL to read from",
|
|
|
|
None,
|
|
|
|
glib::ParamFlags::READWRITE,
|
|
|
|
)
|
|
|
|
})];
|
2016-05-14 14:04:53 +00:00
|
|
|
|
2016-08-22 19:25:58 +00:00
|
|
|
#[derive(Debug)]
|
2018-12-30 10:03:32 +00:00
|
|
|
enum State {
|
2016-08-22 19:25:58 +00:00
|
|
|
Stopped,
|
|
|
|
Started {
|
2016-09-01 21:52:28 +00:00
|
|
|
uri: Url,
|
2016-08-22 19:25:58 +00:00
|
|
|
response: Response,
|
|
|
|
seekable: bool,
|
|
|
|
position: u64,
|
2016-09-01 22:01:25 +00:00
|
|
|
size: Option<u64>,
|
2016-08-22 19:25:58 +00:00
|
|
|
start: u64,
|
2016-09-01 22:01:25 +00:00
|
|
|
stop: Option<u64>,
|
2016-08-22 19:25:58 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
impl Default for State {
|
|
|
|
fn default() -> Self {
|
|
|
|
State::Stopped
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-14 14:04:53 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct HttpSrc {
|
2017-09-16 17:35:01 +00:00
|
|
|
cat: gst::DebugCategory,
|
2016-05-14 14:04:53 +00:00
|
|
|
client: Client,
|
2018-12-30 10:03:32 +00:00
|
|
|
settings: Mutex<Settings>,
|
|
|
|
state: Mutex<State>,
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl HttpSrc {
|
2018-12-30 10:03:32 +00:00
|
|
|
fn set_location(
|
|
|
|
&self,
|
|
|
|
_element: &gst_base::BaseSrc,
|
|
|
|
uri: Option<String>,
|
|
|
|
) -> Result<(), glib::Error> {
|
|
|
|
let state = self.state.lock().unwrap();
|
|
|
|
if let State::Started { .. } = *state {
|
|
|
|
return Err(glib::Error::new(
|
|
|
|
gst::URIError::BadState,
|
|
|
|
"Changing the `location` property on a started `httpsrc` is not supported",
|
|
|
|
));
|
2016-07-20 08:28:58 +00:00
|
|
|
}
|
2016-05-14 14:04:53 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
|
|
|
|
let uri = match uri {
|
|
|
|
Some(uri) => uri,
|
|
|
|
None => {
|
|
|
|
settings.location = None;
|
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
let uri = Url::parse(uri.as_str()).map_err(|err| {
|
|
|
|
glib::Error::new(
|
|
|
|
gst::URIError::BadUri,
|
|
|
|
format!("Failed to parse URI '{}': {:?}", uri, err,).as_str(),
|
|
|
|
)
|
|
|
|
})?;
|
|
|
|
|
|
|
|
if uri.scheme() != "http" && uri.scheme() != "https" {
|
|
|
|
return Err(glib::Error::new(
|
|
|
|
gst::URIError::UnsupportedProtocol,
|
|
|
|
format!("Unsupported URI scheme '{}'", uri.scheme(),).as_str(),
|
|
|
|
));
|
|
|
|
}
|
|
|
|
|
|
|
|
settings.location = Some(uri);
|
|
|
|
|
|
|
|
Ok(())
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
2016-05-15 08:48:54 +00:00
|
|
|
|
2017-07-31 13:36:35 +00:00
|
|
|
fn do_request(
|
|
|
|
&self,
|
2018-12-30 10:03:32 +00:00
|
|
|
src: &gst_base::BaseSrc,
|
2017-07-31 13:36:35 +00:00
|
|
|
uri: Url,
|
|
|
|
start: u64,
|
|
|
|
stop: Option<u64>,
|
2018-12-30 10:03:32 +00:00
|
|
|
) -> Result<State, gst::ErrorMessage> {
|
2017-09-16 17:35:01 +00:00
|
|
|
let cat = self.cat;
|
2018-12-19 12:31:42 +00:00
|
|
|
let req = self.client.get(uri.clone());
|
|
|
|
|
|
|
|
let mut headers = Headers::new();
|
2016-08-27 08:16:17 +00:00
|
|
|
|
2016-11-25 12:42:16 +00:00
|
|
|
match (start != 0, stop) {
|
|
|
|
(false, None) => (),
|
2017-07-31 13:29:11 +00:00
|
|
|
(true, None) => {
|
2018-12-19 12:31:42 +00:00
|
|
|
headers.set(Range::Bytes(vec![ByteRangeSpec::AllFrom(start)]));
|
2017-07-31 13:29:11 +00:00
|
|
|
}
|
2016-11-25 12:42:16 +00:00
|
|
|
(_, Some(stop)) => {
|
2018-12-19 12:31:42 +00:00
|
|
|
headers.set(Range::Bytes(vec![ByteRangeSpec::FromTo(start, stop - 1)]));
|
2016-11-25 12:42:16 +00:00
|
|
|
}
|
2016-08-27 08:16:17 +00:00
|
|
|
}
|
|
|
|
|
2018-12-19 12:31:42 +00:00
|
|
|
// Add all headers for the request here
|
|
|
|
let req = req.headers(headers.into());
|
|
|
|
|
2017-09-16 17:35:01 +00:00
|
|
|
gst_debug!(cat, obj: src, "Doing new request {:?}", req);
|
2016-12-27 15:47:39 +00:00
|
|
|
|
2017-07-31 13:36:35 +00:00
|
|
|
let response = try!(req.send().or_else(|err| {
|
2017-09-16 17:35:01 +00:00
|
|
|
gst_error!(cat, obj: src, "Request failed: {:?}", err);
|
2017-12-20 17:53:59 +00:00
|
|
|
Err(gst_error_msg!(
|
2017-09-16 17:35:01 +00:00
|
|
|
gst::ResourceError::Read,
|
2017-07-31 13:36:35 +00:00
|
|
|
["Failed to fetch {}: {}", uri, err.to_string()]
|
|
|
|
))
|
|
|
|
}));
|
2016-08-27 08:16:17 +00:00
|
|
|
|
2016-11-14 18:57:54 +00:00
|
|
|
if !response.status().is_success() {
|
2017-09-16 17:35:01 +00:00
|
|
|
gst_error!(cat, obj: src, "Request status failed: {:?}", response);
|
2017-12-20 17:53:59 +00:00
|
|
|
return Err(gst_error_msg!(
|
2017-09-16 17:35:01 +00:00
|
|
|
gst::ResourceError::Read,
|
2017-07-31 13:36:35 +00:00
|
|
|
["Failed to fetch {}: {}", uri, response.status()]
|
|
|
|
));
|
2016-08-27 08:16:17 +00:00
|
|
|
}
|
|
|
|
|
2018-12-19 12:31:42 +00:00
|
|
|
let headers = Headers::from(response.headers());
|
|
|
|
let size = headers.get().map(|&ContentLength(cl)| cl + start);
|
2016-08-27 08:16:17 +00:00
|
|
|
|
2018-12-19 12:31:42 +00:00
|
|
|
let accept_byte_ranges = if let Some(&AcceptRanges(ref ranges)) = headers.get() {
|
2016-08-27 08:16:17 +00:00
|
|
|
ranges.iter().any(|u| *u == RangeUnit::Bytes)
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
};
|
|
|
|
|
2016-09-01 22:01:25 +00:00
|
|
|
let seekable = size.is_some() && accept_byte_ranges;
|
2016-08-27 08:16:17 +00:00
|
|
|
|
2017-11-20 11:22:26 +00:00
|
|
|
let position = if let Some(&ContentRange(ContentRangeSpec::Bytes {
|
|
|
|
range: Some((range_start, _)),
|
|
|
|
..
|
2018-12-19 12:31:42 +00:00
|
|
|
})) = headers.get()
|
2017-07-31 13:36:35 +00:00
|
|
|
{
|
2016-08-27 08:16:17 +00:00
|
|
|
range_start
|
|
|
|
} else {
|
|
|
|
start
|
|
|
|
};
|
|
|
|
|
|
|
|
if position != start {
|
2017-12-20 17:53:59 +00:00
|
|
|
return Err(gst_error_msg!(
|
2017-09-16 17:35:01 +00:00
|
|
|
gst::ResourceError::Seek,
|
2017-07-31 13:36:35 +00:00
|
|
|
["Failed to seek to {}: Got {}", start, position]
|
|
|
|
));
|
2016-05-15 08:48:54 +00:00
|
|
|
}
|
2016-08-27 08:16:17 +00:00
|
|
|
|
2017-09-16 17:35:01 +00:00
|
|
|
gst_debug!(cat, obj: src, "Request successful: {:?}", response);
|
2016-12-27 15:47:39 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
Ok(State::Started {
|
2018-10-11 10:49:10 +00:00
|
|
|
uri,
|
|
|
|
response,
|
|
|
|
seekable,
|
2017-07-31 13:36:35 +00:00
|
|
|
position: 0,
|
2018-10-11 10:49:10 +00:00
|
|
|
size,
|
|
|
|
start,
|
|
|
|
stop,
|
2017-07-31 13:36:35 +00:00
|
|
|
})
|
2016-05-15 08:48:54 +00:00
|
|
|
}
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
impl ObjectImpl for HttpSrc {
|
|
|
|
glib_object_impl!();
|
|
|
|
|
|
|
|
fn set_property(&self, obj: &glib::Object, id: usize, value: &glib::Value) {
|
|
|
|
let prop = &PROPERTIES[id];
|
|
|
|
match *prop {
|
|
|
|
subclass::Property("location", ..) => {
|
|
|
|
let element = obj.downcast_ref::<gst_base::BaseSrc>().unwrap();
|
|
|
|
|
|
|
|
let location = value.get::<String>();
|
|
|
|
let res = self.set_location(element, location);
|
|
|
|
|
|
|
|
if let Err(err) = res {
|
|
|
|
gst_error!(
|
|
|
|
self.cat,
|
|
|
|
obj: element,
|
|
|
|
"Failed to set property `location`: {:?}",
|
|
|
|
err
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => unimplemented!(),
|
|
|
|
};
|
2016-08-24 21:08:06 +00:00
|
|
|
}
|
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
fn get_property(&self, _obj: &glib::Object, id: usize) -> Result<glib::Value, ()> {
|
|
|
|
let prop = &PROPERTIES[id];
|
|
|
|
match *prop {
|
|
|
|
subclass::Property("location", ..) => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
let location = settings.location.as_ref().map(Url::to_string);
|
|
|
|
|
|
|
|
Ok(location.to_value())
|
|
|
|
}
|
|
|
|
_ => unimplemented!(),
|
|
|
|
}
|
|
|
|
}
|
2016-05-14 14:04:53 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
fn constructed(&self, obj: &glib::Object) {
|
|
|
|
self.parent_constructed(obj);
|
|
|
|
|
|
|
|
let element = obj.downcast_ref::<gst_base::BaseSrc>().unwrap();
|
|
|
|
element.set_format(gst::Format::Bytes);
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
2018-12-30 10:03:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl ElementImpl for HttpSrc {}
|
2016-05-14 14:04:53 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
impl BaseSrcImpl for HttpSrc {
|
|
|
|
fn is_seekable(&self, _src: &gst_base::BaseSrc) -> bool {
|
|
|
|
match *self.state.lock().unwrap() {
|
|
|
|
State::Started { seekable, .. } => seekable,
|
2016-08-22 19:25:58 +00:00
|
|
|
_ => false,
|
|
|
|
}
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
fn get_size(&self, _src: &gst_base::BaseSrc) -> Option<u64> {
|
|
|
|
match *self.state.lock().unwrap() {
|
|
|
|
State::Started { size, .. } => size,
|
2016-09-01 22:01:25 +00:00
|
|
|
_ => None,
|
2016-08-22 19:25:58 +00:00
|
|
|
}
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
|
|
|
|
2019-01-26 15:07:51 +00:00
|
|
|
fn start(&self, src: &gst_base::BaseSrc) -> Result<(), gst::ErrorMessage> {
|
2018-12-30 10:03:32 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2016-08-27 08:16:17 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
*state = State::Stopped;
|
|
|
|
|
2019-01-26 15:07:51 +00:00
|
|
|
let uri = self
|
|
|
|
.settings
|
|
|
|
.lock()
|
|
|
|
.unwrap()
|
|
|
|
.location
|
|
|
|
.as_ref()
|
|
|
|
.ok_or_else(|| {
|
|
|
|
gst_error_msg!(gst::CoreError::StateChange, ["Can't start without an URI"])
|
|
|
|
})
|
|
|
|
.map(|uri| uri.clone())?;
|
2018-12-30 10:03:32 +00:00
|
|
|
|
2019-01-26 15:07:51 +00:00
|
|
|
*state = self.do_request(src, uri, 0, None)?;
|
|
|
|
|
|
|
|
Ok(())
|
2016-08-22 19:25:58 +00:00
|
|
|
}
|
|
|
|
|
2019-01-26 15:07:51 +00:00
|
|
|
fn stop(&self, _src: &gst_base::BaseSrc) -> Result<(), gst::ErrorMessage> {
|
2018-12-30 10:03:32 +00:00
|
|
|
*self.state.lock().unwrap() = State::Stopped;
|
2016-05-14 14:04:53 +00:00
|
|
|
|
2019-01-26 15:07:51 +00:00
|
|
|
Ok(())
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
fn do_seek(&self, src: &gst_base::BaseSrc, segment: &mut gst::Segment) -> bool {
|
|
|
|
let segment = segment.downcast_mut::<gst::format::Bytes>().unwrap();
|
|
|
|
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
let (position, old_stop, uri) = match *state {
|
|
|
|
State::Started {
|
2017-04-12 13:46:11 +00:00
|
|
|
position,
|
|
|
|
stop,
|
|
|
|
ref uri,
|
|
|
|
..
|
|
|
|
} => (position, stop, uri.clone()),
|
2018-12-30 10:03:32 +00:00
|
|
|
State::Stopped => {
|
|
|
|
gst_element_error!(src, gst::LibraryError::Failed, ["Not started yet"]);
|
|
|
|
|
|
|
|
return false;
|
2016-09-01 21:52:28 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
let start = segment.get_start().expect("No start position given");
|
|
|
|
let stop = segment.get_stop();
|
2016-08-22 19:25:58 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
if position == start && old_stop == stop.0 {
|
|
|
|
return true;
|
|
|
|
}
|
2016-08-27 08:16:17 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
*state = State::Stopped;
|
|
|
|
match self.do_request(src, uri, start, stop.0) {
|
|
|
|
Ok(s) => {
|
|
|
|
*state = s;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
Err(err) => {
|
|
|
|
src.post_error_message(&err);
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
2016-05-15 08:48:54 +00:00
|
|
|
}
|
|
|
|
|
2017-09-16 17:35:01 +00:00
|
|
|
fn fill(
|
2018-12-30 10:03:32 +00:00
|
|
|
&self,
|
|
|
|
src: &gst_base::BaseSrc,
|
2017-09-16 17:35:01 +00:00
|
|
|
offset: u64,
|
|
|
|
_: u32,
|
|
|
|
buffer: &mut gst::BufferRef,
|
2019-01-11 23:45:05 +00:00
|
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
2018-12-30 10:03:32 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2016-12-27 15:47:39 +00:00
|
|
|
|
2018-12-30 10:03:32 +00:00
|
|
|
let (response, position) = match *state {
|
|
|
|
State::Started {
|
2017-04-12 13:46:11 +00:00
|
|
|
ref mut response,
|
|
|
|
ref mut position,
|
|
|
|
..
|
|
|
|
} => (response, position),
|
2018-12-30 10:03:32 +00:00
|
|
|
State::Stopped => {
|
|
|
|
gst_element_error!(src, gst::LibraryError::Failed, ["Not started yet"]);
|
|
|
|
|
2019-01-11 23:45:05 +00:00
|
|
|
return Err(gst::FlowError::Error);
|
2016-08-27 08:16:17 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-09-01 21:52:28 +00:00
|
|
|
if *position != offset {
|
2018-12-30 10:03:32 +00:00
|
|
|
gst_element_error!(
|
|
|
|
src,
|
2017-09-16 17:35:01 +00:00
|
|
|
gst::ResourceError::Seek,
|
2017-07-31 13:36:35 +00:00
|
|
|
["Got unexpected offset {}, expected {}", offset, position]
|
2018-12-30 10:03:32 +00:00
|
|
|
);
|
|
|
|
|
2019-01-11 23:45:05 +00:00
|
|
|
return Err(gst::FlowError::Error);
|
2016-09-01 21:52:28 +00:00
|
|
|
}
|
|
|
|
|
2016-09-12 13:00:28 +00:00
|
|
|
let size = {
|
2019-01-11 23:45:05 +00:00
|
|
|
let mut map = buffer.map_writable().ok_or_else(|| {
|
|
|
|
gst_element_error!(src, gst::LibraryError::Failed, ["Failed to map buffer"]);
|
2018-12-30 10:03:32 +00:00
|
|
|
|
2019-01-11 23:45:05 +00:00
|
|
|
gst::FlowError::Error
|
|
|
|
})?;
|
2016-09-12 13:00:28 +00:00
|
|
|
|
|
|
|
let data = map.as_mut_slice();
|
|
|
|
|
2019-01-11 23:45:05 +00:00
|
|
|
response.read(data).map_err(|err| {
|
|
|
|
gst_error!(self.cat, obj: src, "Failed to read: {:?}", err);
|
|
|
|
gst_element_error!(
|
|
|
|
src,
|
|
|
|
gst::ResourceError::Read,
|
|
|
|
["Failed to read at {}: {}", offset, err.to_string()]
|
|
|
|
);
|
2018-12-30 10:03:32 +00:00
|
|
|
|
2019-01-11 23:45:05 +00:00
|
|
|
gst::FlowError::Error
|
|
|
|
})?
|
2016-09-12 13:00:28 +00:00
|
|
|
};
|
2016-08-27 08:16:17 +00:00
|
|
|
|
|
|
|
if size == 0 {
|
2019-01-11 23:45:05 +00:00
|
|
|
return Err(gst::FlowError::Eos);
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
2016-08-27 08:16:17 +00:00
|
|
|
|
|
|
|
*position += size as u64;
|
2016-09-01 21:52:28 +00:00
|
|
|
|
2017-02-03 14:34:17 +00:00
|
|
|
buffer.set_size(size);
|
2016-09-12 13:00:28 +00:00
|
|
|
|
2019-01-11 23:45:05 +00:00
|
|
|
Ok(gst::FlowSuccess::Ok)
|
2018-12-30 10:03:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl URIHandlerImpl for HttpSrc {
|
|
|
|
fn get_uri(&self, _element: &gst::URIHandler) -> Option<String> {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
|
|
|
|
settings.location.as_ref().map(Url::to_string)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn set_uri(&self, element: &gst::URIHandler, uri: Option<String>) -> Result<(), glib::Error> {
|
|
|
|
let element = element.dynamic_cast_ref::<gst_base::BaseSrc>().unwrap();
|
|
|
|
|
|
|
|
self.set_location(&element, uri)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_uri_type() -> gst::URIType {
|
|
|
|
gst::URIType::Src
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_protocols() -> Vec<String> {
|
|
|
|
vec!["http".to_string(), "https".to_string()]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ObjectSubclass for HttpSrc {
|
|
|
|
const NAME: &'static str = "RsHttpSrc";
|
|
|
|
type ParentType = gst_base::BaseSrc;
|
|
|
|
type Instance = gst::subclass::ElementInstanceStruct<Self>;
|
|
|
|
type Class = subclass::simple::ClassStruct<Self>;
|
|
|
|
|
|
|
|
glib_object_subclass!();
|
|
|
|
|
|
|
|
fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
cat: gst::DebugCategory::new(
|
|
|
|
"rshttpsrc",
|
|
|
|
gst::DebugColorFlags::empty(),
|
|
|
|
"Rust HTTP source",
|
|
|
|
),
|
|
|
|
client: Client::new(),
|
|
|
|
settings: Mutex::new(Default::default()),
|
|
|
|
state: Mutex::new(Default::default()),
|
|
|
|
}
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|
2018-12-30 10:03:32 +00:00
|
|
|
|
|
|
|
fn type_init(type_: &mut subclass::InitializingType<Self>) {
|
|
|
|
type_.add_interface::<gst::URIHandler>();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn class_init(klass: &mut subclass::simple::ClassStruct<Self>) {
|
|
|
|
klass.set_metadata(
|
|
|
|
"HTTP Source",
|
|
|
|
"Source/Network/HTTP",
|
|
|
|
"Read stream from an HTTP/HTTPS location",
|
|
|
|
"Sebastian Dröge <sebastian@centricular.com>",
|
|
|
|
);
|
|
|
|
|
|
|
|
let caps = gst::Caps::new_any();
|
|
|
|
let src_pad_template = gst::PadTemplate::new(
|
|
|
|
"src",
|
|
|
|
gst::PadDirection::Src,
|
|
|
|
gst::PadPresence::Always,
|
|
|
|
&caps,
|
2019-01-29 15:26:40 +00:00
|
|
|
)
|
|
|
|
.unwrap();
|
2018-12-30 10:03:32 +00:00
|
|
|
klass.add_pad_template(src_pad_template);
|
|
|
|
|
|
|
|
klass.install_properties(&PROPERTIES);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
|
|
|
|
gst::Element::register(plugin, "rshttpsrc", 256 + 100, HttpSrc::get_type())
|
2016-05-14 14:04:53 +00:00
|
|
|
}
|