use m3u8_rs::{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());
#[derive(Debug, Clone)]
pub struct Playlist {
inner: MediaPlaylist,
playlist_index: u64,
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: Some(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,
unknown_tags: vec![],
},
playlist_index: 0,
status: PlaylistRenderState::Init,
turn_vod,
}
}
pub fn add_segment(&mut self, uri: String, duration: f32) {
self.start();
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![],
});
}
pub fn update_playlist_state(&mut self, max_playlist_length: usize) {
if !self.is_type_undefined() {
return;
}
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 - self.inner.segments.len() as u64;
}
fn start(&mut self) {
self.status = PlaylistRenderState::Started;
self.inner.end_list = false;
}
pub fn stop(&mut self) {
match &self.inner.playlist_type {
None => self.inner.end_list = false,
Some(defined) => match defined {
MediaPlaylistType::Other(_) => unreachable!(),
MediaPlaylistType::Event => {
if self.turn_vod {
self.inner.playlist_type = Some(MediaPlaylistType::Vod);
}
self.inner.end_list = true
}
MediaPlaylistType::Vod => self.inner.end_list = false,
},
}
}
pub fn is_type_undefined(&self) -> bool {
self.inner.playlist_type.is_none()
}
pub fn is_rendering(&self) -> bool {
self.status == PlaylistRenderState::Started
}
pub fn len(&self) -> usize {
self.inner.segments.len()
}
pub fn write_to<T: Write>(&self, w: &mut T) -> std::io::Result<()> {
self.inner.write_to(w)
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum PlaylistRenderState {
Init,
Started,
}
pub struct SegmentFormatter {
prefix: String,
suffix: String,
padding_len: u32,
}
impl SegmentFormatter {
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,
})
}
#[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)
}
}
#[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));
}
}