Commit e87a7afe authored by Rafael Carício's avatar Rafael Carício 🏠 Committed by Sebastian Dröge
Browse files

Add hlssink3 plugin

parent b738d593
Pipeline #447624 passed with stages
in 19 minutes and 53 seconds
......@@ -11,6 +11,7 @@ members = [
"generic/file",
"generic/sodium",
"generic/threadshare",
"net/hlssink3",
"net/reqwest",
"net/rusoto",
"utils/fallbackswitch",
......
......@@ -44,6 +44,7 @@ plugins = {
'gst-plugin-lewton': 'libgstlewton',
'gst-plugin-rav1e': 'libgstrav1e',
'gst-plugin-reqwest': 'libgstreqwest',
'gst-plugin-hlssink3': 'libgsthlssink3',
'gst-plugin-rspng': 'libgstrspng',
'gst-plugin-rusoto': 'libgstrusoto',
'gst-plugin-textwrap': 'libgstrstextwrap',
......
[package]
name = "gst-plugin-hlssink3"
description = "HLS (HTTP Live Streaming) Plugin"
repository = "https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs"
version = "0.1.0"
authors = ["Rafael Caricio <rafael@caricio.com>"]
edition = "2021"
license = "MPL-2.0"
rust-version = "1.56"
[dependencies]
gst = { package = "gstreamer", git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs", features = ["v1_10"] }
gst-base = { package = "gstreamer-base", git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs" }
gst-app = { package = "gstreamer-app", git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs" }
glib = { git = "https://github.com/gtk-rs/gtk-rs-core" }
gio = { git = "https://github.com/gtk-rs/gtk-rs-core" }
once_cell = "1.7.2"
m3u8-rs = "2.0.0"
regex = "1"
[dev-dependencies]
gst-audio = { package = "gstreamer-audio", git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs" }
gst-check = { package = "gstreamer-check", git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs" }
[build-dependencies]
gst-plugin-version-helper = { git = "https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs" }
[lib]
name = "gsthlssink3"
crate-type = ["cdylib", "rlib"]
path = "src/lib.rs"
[features]
# GStreamer 1.14 is required for static linking
static = ["gst/v1_14"]
capi = []
[package.metadata.capi]
min_version = "0.8.0"
[package.metadata.capi.header]
enabled = false
[package.metadata.capi.library]
install_subdir = "gstreamer-1.0"
versioning = false
[package.metadata.capi.pkg_config]
requires_private = "gstreamer-1.0, gstreamer-base-1.0, gobject-2.0, glib-2.0, gmodule-2.0"
LICENSE-MPL-2.0
\ No newline at end of file
# GStreamer HTTP Live Streaming Plugin
A GStreamer HLS sink plugin. Based on the
["hlssink2"](https://gstreamer.freedesktop.org/documentation/hls/hlssink2.html?gi-language=c)
element.
The "hlssink3" is feature-equivalent to the "hlssink2" element. Any pipeline that uses "hlssink2" can use the
"hlssink3" element and the result should be the same.
The "hlssink3" element has a `playlist-type` property used to control the behavior of the HLS playlist file. The
available values for this property are:
- `null` (default): The tag `#EXT-X-PLAYLIST-TYPE` won't be present in the playlist during the pipeline processing. The
playlist will be updated in sync as new segments are available, old segments are removed, keeping N segments as
defined in the property `playlist-length`. This is the default behavior, and is compatible with how "hlssink2" works;
- `"event"`: The playlist is updated as new segments are available, and the tag `#EXT-X-PLAYLIST-TYPE:EVENT` is present
during processing. No segments will be removed from the playlist. At the end of the processing, the tag
`#EXT-X-ENDLIST` is added to the playlist;
- `"vod"`: The playlist behaves like the `event` option (a live event), but at the end of the processing, the playlist
will be set to `#EXT-X-PLAYLIST-TYPE:VOD`.
//
// Copyright (C) 2021 Rafael Caricio <rafael@caricio.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
fn main() {
gst_plugin_version_helper::info()
}
This diff is collapsed.
//
// Copyright (C) 2021 Rafael Caricio <rafael@caricio.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 glib::prelude::*;
mod imp;
mod playlist;
glib::wrapper! {
pub struct HlsSink3(ObjectSubclass<imp::HlsSink3>) @extends gst::Bin, gst::Element, gst::Object;
}
unsafe impl Send for HlsSink3 {}
unsafe impl Sync for HlsSink3 {}
pub fn plugin_init(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
gst::Element::register(
Some(plugin),
"hlssink3",
gst::Rank::None,
HlsSink3::static_type(),
)?;
Ok(())
}
gst::plugin_define!(
hlssink3,
env!("CARGO_PKG_DESCRIPTION"),
plugin_init,
concat!(env!("CARGO_PKG_VERSION"), "-", env!("COMMIT_ID")),
"MIT/X11",
env!("CARGO_PKG_NAME"),
env!("CARGO_PKG_NAME"),
env!("CARGO_PKG_REPOSITORY"),
env!("BUILD_REL_DATE")
);
//
// Copyright (C) 2021 Rafael Caricio <rafael@caricio.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 m3u8_rs::playlist::{MediaPlaylist, MediaPlaylistType, MediaSegment};
use once_cell::sync::Lazy;
use regex::Regex;
use std::io::Write;
const GST_M3U8_PLAYLIST_VERSION: usize = 3;
static SEGMENT_IDX_PATTERN: Lazy<regex::Regex> = Lazy::new(|| Regex::new(r"(%0(\d+)d)").unwrap());
/// An HLS playlist.
///
/// Controls the changes that needs to happen in the playlist as new segments are added. This
/// includes maintaining the number of segments present in the playlist and setting the final
/// state of the playlist.
#[derive(Debug, Clone)]
pub struct Playlist {
inner: MediaPlaylist,
playlist_index: i32,
status: PlaylistRenderState,
turn_vod: bool,
}
impl Playlist {
pub fn new(target_duration: f32, playlist_type: Option<MediaPlaylistType>) -> Self {
let mut turn_vod = false;
let playlist_type = if playlist_type == Some(MediaPlaylistType::Vod) {
turn_vod = true;
Some(MediaPlaylistType::Event)
} else {
playlist_type
};
Self {
inner: MediaPlaylist {
version: GST_M3U8_PLAYLIST_VERSION,
target_duration,
media_sequence: 0,
segments: vec![],
discontinuity_sequence: 0,
end_list: false,
playlist_type,
i_frames_only: false,
start: None,
independent_segments: false,
},
playlist_index: 0,
status: PlaylistRenderState::Init,
turn_vod,
}
}
/// Adds a new segment to the playlist.
pub fn add_segment(&mut self, uri: String, duration: f32) {
self.inner.segments.push(MediaSegment {
uri,
duration,
title: None,
byte_range: None,
discontinuity: false,
key: None,
map: None,
program_date_time: None,
daterange: None,
unknown_tags: vec![],
});
}
/// Updates the playlist based on current state.
///
/// The playlist will be updated based on it's type. The playlist status is set to started.
/// When a playlist type is defined, the number of segments is updated to match the max
/// playlist length value. The playlist index and current media sequence is also kept up
/// to date.
pub fn update_playlist_state(&mut self, max_playlist_length: usize) {
self.start();
if !self.is_type_undefined() {
return;
}
// Remove oldest segments if playlist is at maximum expected capacity
if self.inner.segments.len() > max_playlist_length {
for _ in 0..self.inner.segments.len() - max_playlist_length {
let _ = self.inner.segments.remove(0);
}
}
self.playlist_index += 1;
self.inner.media_sequence = self.playlist_index as i32 - self.inner.segments.len() as i32;
}
/// Sets the playlist to started state.
fn start(&mut self) {
self.status = PlaylistRenderState::Started;
self.inner.end_list = false;
}
/// Sets the playlist to stopped state.
pub fn stop(&mut self) {
match &self.inner.playlist_type {
None => self.inner.end_list = false,
Some(defined) => match defined {
MediaPlaylistType::Event => {
if self.turn_vod {
self.inner.playlist_type = Some(MediaPlaylistType::Vod);
self.inner.end_list = false
} else {
self.inner.end_list = true
}
}
MediaPlaylistType::Vod => self.inner.end_list = false,
},
}
}
/// Returns true if the playlist type is not specified.
pub fn is_type_undefined(&self) -> bool {
self.inner.playlist_type.is_none()
}
/// Returns true if the playlist internal status started.
pub fn is_rendering(&self) -> bool {
self.status == PlaylistRenderState::Started
}
/// Returns the number of segments in the playlist.
pub fn len(&self) -> usize {
self.inner.segments.len()
}
/// Writes the playlist in textual format to the provided `Write` reference.
pub fn write_to<T: Write>(&self, w: &mut T) -> std::io::Result<()> {
self.inner.write_to(w)
}
}
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum PlaylistRenderState {
Init,
Started,
}
/// A formatter for segment locations.
///
/// The formatting is based on a string that must contain the placeholder `%0Xd` where `X` is a
/// the number of zero prefixes you want to have in the segment name. The placeholder is only
/// replaced once in the string, other placements are not going to be processed.
///
/// # Examples
///
/// In this example we want to have segment files with the following names:
/// ```text
/// part001.ts
/// part002.ts
/// part003.ts
/// part004.ts
/// ```
/// Then we can use the segment pattern value as `"part%03.ts"`:
///
/// ```rust,ignore
/// let formatter = SegmentFormatter::new("part%03.ts").unwrap();
/// assert_eq!(formatter.segment(1), "part001.ts");
/// assert_eq!(formatter.segment(2), "part002.ts");
/// assert_eq!(formatter.segment(3), "part003.ts");
/// assert_eq!(formatter.segment(4), "part004.ts");
/// ```
pub struct SegmentFormatter {
prefix: String,
suffix: String,
padding_len: u32,
}
impl SegmentFormatter {
/// Processes the segment name containing a placeholder. It can be used
/// repeatedly to format segment names.
///
/// If an invalid placeholder is provided, then `None` is returned.
pub fn new<S: AsRef<str>>(segment_pattern: S) -> Option<Self> {
let segment_pattern = segment_pattern.as_ref();
let caps = SEGMENT_IDX_PATTERN.captures(segment_pattern)?;
let number_placement_match = caps.get(1)?;
let zero_pad_match = caps.get(2)?;
let padding_len = zero_pad_match
.as_str()
.parse::<u32>()
.expect("valid number matched by regex");
let prefix = segment_pattern[..number_placement_match.start()].to_string();
let suffix = segment_pattern[number_placement_match.end()..].to_string();
Some(Self {
prefix,
suffix,
padding_len,
})
}
/// Returns the segment location formatted for the provided id.
#[inline]
pub fn segment(&self, id: u32) -> String {
let padded_number = left_pad_zeroes(self.padding_len, id);
format!("{}{}{}", self.prefix, padded_number, self.suffix)
}
}
/// Transforms a number to a zero padded string representation.
///
/// The zero padding is added to the left of the number which is converted to a string. For the
/// case that the length number converted to string is larger than the requested padding, the
/// number representation is returned and no padding is added. The length of the returned string is
/// the maximum value between the desired padding and the length of the number.
///
/// # Examples
///
/// ```rust,ignore
/// let padded_number = left_pad_zeroes(4, 10);
/// assert_eq!(padded_number, "0010");
/// ```
#[inline]
pub(crate) fn left_pad_zeroes(padding: u32, number: u32) -> String {
let numerical_repr = number.to_string();
let mut padded = String::with_capacity(padding.max(numerical_repr.len() as u32) as usize);
let pad_zeroes = padding as i32 - numerical_repr.len() as i32;
if pad_zeroes > 0 {
for _ in 0..pad_zeroes {
padded.push('0');
}
}
padded.push_str(&numerical_repr);
padded
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn segment_is_correctly_formatted() {
let formatter = SegmentFormatter::new("segment%05d.ts").unwrap();
assert_eq!("segment00001.ts", formatter.segment(1));
assert_eq!("segment00016.ts", formatter.segment(16));
assert_eq!("segment01827.ts", formatter.segment(1827));
assert_eq!("segment98765.ts", formatter.segment(98765));
let formatter = SegmentFormatter::new("part-%03d.ts").unwrap();
assert_eq!("part-010.ts", formatter.segment(10));
assert_eq!("part-9999.ts", formatter.segment(9999));
}
#[test]
fn padding_numbers() {
assert_eq!("001", left_pad_zeroes(3, 1));
assert_eq!("010", left_pad_zeroes(3, 10));
assert_eq!("100", left_pad_zeroes(3, 100));
assert_eq!("1000", left_pad_zeroes(3, 1000));
assert_eq!("987654321", left_pad_zeroes(3, 987654321));
}
}
//
// Copyright (C) 2021 Rafael Caricio <rafael@caricio.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 gio::prelude::*;
use gst::gst_info;
use gst::prelude::*;
use once_cell::sync::Lazy;
use std::sync::mpsc;
use std::time::Duration;
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
gst::DebugCategory::new(
"hlssink3-test",
gst::DebugColorFlags::empty(),
Some("Flex HLS sink test"),
)
});
macro_rules! try_or_pause {
($l:expr) => {
match $l {
Ok(v) => v,
Err(err) => {
eprintln!("Skipping Test: {:?}", err);
return Ok(());
}
}
};
}
macro_rules! try_create_element {
($l:expr, $n:expr) => {
match gst::ElementFactory::find($l) {
Some(factory) => factory.create(Some($n)).unwrap(),
None => {
eprintln!("Could not find {} ({}) plugin, skipping test", $l, $n);
return Ok(());
}
}
};
($l:expr) => {{
let alias: String = format!("test_{}", $l);
try_create_element!($l, <std::string::String as AsRef<str>>::as_ref(&alias))
}};
}
fn init() {
use std::sync::Once;
static INIT: Once = Once::new();
INIT.call_once(|| {
gst::init().unwrap();
gsthlssink3::plugin_register_static().expect("hlssink3 test");
});
}
#[derive(Debug, Clone, Eq, PartialEq)]
enum HlsSinkEvent {
GetPlaylistStream(String),
GetFragmentStream(String),
DeleteFragment(String),
}
#[test]
fn test_hlssink3_element_with_video_content() -> Result<(), ()> {
init();
const BUFFER_NB: i32 = 250;
let pipeline = gst::Pipeline::new(Some("video_pipeline"));
let video_src = try_create_element!("videotestsrc");
video_src.set_property("is-live", &true);
video_src.set_property("num-buffers", &BUFFER_NB);
let x264enc = try_create_element!("x264enc");
let h264parse = try_create_element!("h264parse");
let hlssink3 = gst::ElementFactory::make("hlssink3", Some("test_hlssink3"))
.expect("Must be able to instantiate hlssink3");
hlssink3.set_property("target-duration", &2u32);
hlssink3.set_property("playlist-length", &2u32);
hlssink3.set_property("max-files", &2u32);
let (hls_events_sender, hls_events_receiver) = mpsc::sync_channel(20);
hlssink3.connect("get-playlist-stream", false, {
let hls_events_sender = hls_events_sender.clone();
move |args| {
let location = args[1].get::<String>().expect("No location given");
hls_events_sender
.try_send(HlsSinkEvent::GetPlaylistStream(location))
.expect("Send playlist event");
let stream = gio::MemoryOutputStream::new_resizable();
Some(stream.to_value())
}
});
hlssink3.connect("get-fragment-stream", false, {
let hls_events_sender = hls_events_sender.clone();
move |args| {
let location = args[1].get::<String>().expect("No location given");
hls_events_sender
.try_send(HlsSinkEvent::GetFragmentStream(location))
.expect("Send fragment event");
let stream = gio::MemoryOutputStream::new_resizable();
Some(stream.to_value())
}
});
hlssink3.connect("delete-fragment", false, move |args| {
let location = args[1].get::<String>().expect("No location given");
hls_events_sender
.try_send(HlsSinkEvent::DeleteFragment(location))
.expect("Send delete fragment event");
Some(true.to_value())
});
try_or_pause!(pipeline.add_many(&[&video_src, &x264enc, &h264parse, &hlssink3,]));
try_or_pause!(gst::Element::link_many(&[
&video_src, &x264enc, &h264parse, &hlssink3
]));
pipeline.set_state(gst::State::Playing).unwrap();
gst_info!(
CAT,
"hlssink3_video_pipeline: waiting for {} buffers",
BUFFER_NB
);
let mut eos = false;
let bus = pipeline.bus().unwrap();
while let Some(msg) = bus.timed_pop(gst::ClockTime::NONE) {
use gst::MessageView;
match msg.view() {
MessageView::Eos(..) => {
eos = true;
break;
}
MessageView::Error(..) => unreachable!(),
_ => (),
}
}
pipeline.set_state(gst::State::Null).unwrap();
assert!(eos);
// Collect all events triggered during execution of the pipeline
let mut actual_events = Vec::new();
while let Ok(event) = hls_events_receiver.recv_timeout(Duration::from_millis(1)) {
actual_events.push(event);
}
let expected_ordering_of_events = {
use self::HlsSinkEvent::*;
vec![
GetFragmentStream("segment00000.ts".to_string()),
GetPlaylistStream("playlist.m3u8".to_string()),
GetFragmentStream("segment00001.ts".to_string()),
GetPlaylistStream("playlist.m3u8".to_string()),
GetFragmentStream("segment00002.ts".to_string()),
GetPlaylistStream("playlist.m3u8".to_string()),
DeleteFragment("segment00000.ts".to_string()),
GetFragmentStream("segment00003.ts".to_string()),
GetPlaylistStream("playlist.m3u8".to_string()),
DeleteFragment("segment00001.ts".into()),
GetFragmentStream("segment00004.ts".to_string()),
GetPlaylistStream("playlist.m3u8".to_string()),
DeleteFragment("segment00002.ts".to_string()),
GetPlaylistStream("playlist.m3u8".to_string()),
]
};
assert_eq!(expected_ordering_of_events, actual_events);
Ok(())
}
#[test]
fn test_hlssink3_element_with_audio_content() -> Result<(), ()> {
init();
const BUFFER_NB: i32 = 100;
let pipeline = gst::Pipeline::new(Some("audio_pipeline"));