From 7acb520f552bd1edde5c29fbf5baf6643ec4b14e Mon Sep 17 00:00:00 2001 From: metamuffin Date: Sun, 6 Apr 2025 15:40:58 +0200 Subject: a bit more progress on new streaming api --- remuxer/src/lib.rs | 1 + remuxer/src/metadata.rs | 116 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 117 insertions(+) create mode 100644 remuxer/src/metadata.rs (limited to 'remuxer/src') diff --git a/remuxer/src/lib.rs b/remuxer/src/lib.rs index a98ffad..cc4b39b 100644 --- a/remuxer/src/lib.rs +++ b/remuxer/src/lib.rs @@ -9,6 +9,7 @@ pub mod remux; pub mod seek_index; pub mod segment_extractor; pub mod trim_writer; +pub mod metadata; pub use fragment::write_fragment_into; pub use remux::remux_stream_into; diff --git a/remuxer/src/metadata.rs b/remuxer/src/metadata.rs new file mode 100644 index 0000000..4ddad20 --- /dev/null +++ b/remuxer/src/metadata.rs @@ -0,0 +1,116 @@ +/* + This file is part of jellything (https://codeberg.org/metamuffin/jellything) + which is licensed under the GNU Affero General Public License (version 3); see /COPYING. + Copyright (C) 2025 metamuffin +*/ +use anyhow::{Context, Result}; +use bincode::{Decode, Encode}; +use ebml_struct::{ + ids::*, + matroska::*, + read::{EbmlReadExt, TagRead}, +}; +use jellybase::{ + assetfed::AssetInner, + cache::{cache_file, cache_memory}, + common::Asset, +}; +use log::{info, warn}; +use std::{ + fs::File, + io::{BufReader, ErrorKind, Read, Write}, + path::Path, + sync::Arc, +}; + +#[derive(Debug, Encode, Decode, Clone)] +pub struct MatroskaMetadata { + pub info: Option, + pub tracks: Option, + pub cover: Option, + pub chapters: Option, + pub tags: Option, + pub infojson: Option>, +} +pub fn matroska_metadata(path: &Path) -> Result>> { + cache_memory(&["mkmeta-v2", path.to_string_lossy().as_ref()], || { + let mut magic = [0; 4]; + File::open(path)?.read_exact(&mut magic).ok(); + if !matches!(magic, [0x1A, 0x45, 0xDF, 0xA3]) { + return Ok(None); + } + + info!("reading {path:?}"); + let mut file = BufReader::new(File::open(path)?); + let mut file = file.by_ref().take(u64::MAX); + + let (x, mut ebml) = file.read_tag()?; + assert_eq!(x, EL_EBML); + let ebml = Ebml::read(&mut ebml).unwrap(); + assert!(ebml.doc_type == "matroska" || ebml.doc_type == "webm"); + let (x, mut segment) = file.read_tag()?; + assert_eq!(x, EL_SEGMENT); + + let mut info = None; + let mut infojson = None; + let mut tracks = None; + let mut cover = None; + let mut chapters = None; + let mut tags = None; + loop { + let (x, mut seg) = match segment.read_tag() { + Ok(o) => o, + Err(e) if e.kind() == ErrorKind::UnexpectedEof => break, + Err(e) => return Err(e.into()), + }; + match x { + EL_INFO => info = Some(Info::read(&mut seg).context("info")?), + EL_TRACKS => tracks = Some(Tracks::read(&mut seg).context("tracks")?), + EL_CHAPTERS => chapters = Some(Chapters::read(&mut seg).context("chapters")?), + EL_TAGS => tags = Some(Tags::read(&mut seg).context("tags")?), + EL_ATTACHMENTS => { + let attachments = Attachments::read(&mut seg).context("attachments")?; + for f in attachments.files { + match f.name.as_str() { + "info.json" => { + infojson = Some(f.data); + } + "cover.webp" | "cover.png" | "cover.jpg" | "cover.jpeg" + | "cover.avif" => { + cover = Some( + AssetInner::Cache(cache_file( + &["att-cover", path.to_string_lossy().as_ref()], + move |mut file| { + file.write_all(&f.data)?; + Ok(()) + }, + )?) + .ser(), + ) + } + _ => (), + } + } + } + EL_VOID | EL_CRC32 | EL_CUES | EL_SEEKHEAD => { + seg.consume()?; + } + EL_CLUSTER => { + break; + } + id => { + warn!("unknown top-level element {id:x}"); + seg.consume()?; + } + } + } + Ok(Some(MatroskaMetadata { + chapters, + cover, + info, + infojson, + tags, + tracks, + })) + }) +} -- cgit v1.2.3-70-g09d2 From 48a57a52d85d387efe122fb4d9fb113f577a0a98 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Sun, 13 Apr 2025 18:19:03 +0200 Subject: arc mkmeta --- import/src/lib.rs | 4 ++-- remuxer/src/metadata.rs | 27 +++++++++++++++++---------- stream/src/lib.rs | 34 +++++++--------------------------- 3 files changed, 26 insertions(+), 39 deletions(-) (limited to 'remuxer/src') diff --git a/import/src/lib.rs b/import/src/lib.rs index d7f9dd7..5607450 100644 --- a/import/src/lib.rs +++ b/import/src/lib.rs @@ -15,7 +15,7 @@ use jellybase::{ CONF, SECRETS, }; use jellyclient::{Appearance, PeopleGroup, TmdbKind, TraktKind, Visibility}; -use jellyremuxer::metadata::matroska_metadata; +use jellyremuxer::metadata::checked_matroska_metadata; use log::info; use rayon::iter::{ParallelBridge, ParallelIterator}; use regex::Regex; @@ -278,7 +278,7 @@ fn import_media_file( visibility: Visibility, ) -> Result<()> { info!("media file {path:?}"); - let Some(m) = (*matroska_metadata(path)?).to_owned() else { + let Some(m) = (*checked_matroska_metadata(path)?).to_owned() else { return Ok(()); }; let infojson = m diff --git a/remuxer/src/metadata.rs b/remuxer/src/metadata.rs index 4ddad20..c8a5f8f 100644 --- a/remuxer/src/metadata.rs +++ b/remuxer/src/metadata.rs @@ -32,14 +32,21 @@ pub struct MatroskaMetadata { pub tags: Option, pub infojson: Option>, } -pub fn matroska_metadata(path: &Path) -> Result>> { - cache_memory(&["mkmeta-v2", path.to_string_lossy().as_ref()], || { - let mut magic = [0; 4]; - File::open(path)?.read_exact(&mut magic).ok(); - if !matches!(magic, [0x1A, 0x45, 0xDF, 0xA3]) { - return Ok(None); - } - +pub fn checked_matroska_metadata(path: &Path) -> Result>> { + cache_memory( + &["mkmeta-check-v1", path.to_string_lossy().as_ref()], + || { + let mut magic = [0; 4]; + File::open(path)?.read_exact(&mut magic).ok(); + if !matches!(magic, [0x1A, 0x45, 0xDF, 0xA3]) { + return Ok(None); + } + Ok(Some((*matroska_metadata(path)?).clone())) + }, + ) +} +pub fn matroska_metadata(path: &Path) -> Result> { + cache_memory(&["mkmeta-v3", path.to_string_lossy().as_ref()], || { info!("reading {path:?}"); let mut file = BufReader::new(File::open(path)?); let mut file = file.by_ref().take(u64::MAX); @@ -104,13 +111,13 @@ pub fn matroska_metadata(path: &Path) -> Result>> { } } } - Ok(Some(MatroskaMetadata { + Ok(MatroskaMetadata { chapters, cover, info, infojson, tags, tracks, - })) + }) }) } diff --git a/stream/src/lib.rs b/stream/src/lib.rs index 59b4960..d09759f 100644 --- a/stream/src/lib.rs +++ b/stream/src/lib.rs @@ -96,24 +96,22 @@ pub async fn stream( Ok(a) } -async fn async_matroska_metadata(path: PathBuf) -> Result>> { +async fn async_matroska_metadata(path: PathBuf) -> Result> { Ok(spawn_blocking(move || matroska_metadata(&path)).await??) } -struct InternalStreamInfo { - paths: Vec, - metadata: Vec, - track_to_file: Vec, +pub(crate) struct InternalStreamInfo { + pub paths: Vec, + pub metadata: Vec>, + pub track_to_file: Vec, } async fn stream_info(info: Arc) -> Result<(InternalStreamInfo, StreamInfo)> { let mut metadata = Vec::new(); let mut paths = Vec::new(); for path in &info.files { - if let Some(meta) = (*async_matroska_metadata(path.clone()).await?).clone() { - metadata.push(meta); - paths.push(path.clone()); - } + metadata.push(async_matroska_metadata(path.clone()).await?); + paths.push(path.clone()); } let mut tracks = Vec::new(); @@ -232,21 +230,3 @@ async fn copy_stream(mut inp: File, mut out: DuplexStream, mut amount: usize) -> amount -= size; } } - -// // TODO functions to test seekability, get live status and enumate segments -// trait MediaSource { -// fn loaded_range(&self) -> Result>; -// /// Seeks to some position close to, but before, `time` ticks. -// fn seek(&mut self, segment: u64, time: u64) -> Result<()>; -// /// Retrieve headers (info and tracks) for some segment. -// fn segment_headers(&mut self, seg: u64) -> Result<(Info, Tracks)>; -// /// Returns the next block and the current segment index -// fn next(&mut self) -> Result>; -// } -// pub struct AbsBlock { -// track: u64, -// pts: u64, -// keyframe: bool, -// lacing: Option, -// data: Vec, -// } -- cgit v1.2.3-70-g09d2 From a3afc2756a52f7d6fedc928b97c8ff3eb1ade338 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Mon, 14 Apr 2025 13:41:42 +0200 Subject: lots of rewriting and removing dumb code --- base/src/assetfed.rs | 7 - base/src/database.rs | 27 +- common/src/lib.rs | 1 - common/src/stream.rs | 53 ++-- import/src/lib.rs | 10 +- remuxer/src/extract.rs | 17 +- remuxer/src/fragment.rs | 101 ++++---- remuxer/src/lib.rs | 63 ++--- remuxer/src/remux.rs | 572 ++++++++++++++++++++--------------------- server/src/routes/ui/player.rs | 22 +- stream/src/fragment.rs | 45 ++-- stream/src/fragment_index.rs | 32 +++ stream/src/hls.rs | 72 +++--- stream/src/jhls.rs | 47 ---- stream/src/lib.rs | 36 ++- stream/src/webvtt.rs | 3 +- 16 files changed, 542 insertions(+), 566 deletions(-) create mode 100644 stream/src/fragment_index.rs delete mode 100644 stream/src/jhls.rs (limited to 'remuxer/src') diff --git a/base/src/assetfed.rs b/base/src/assetfed.rs index 575188d..697cacb 100644 --- a/base/src/assetfed.rs +++ b/base/src/assetfed.rs @@ -78,11 +78,4 @@ impl AssetInner { pub fn is_federated(&self) -> bool { matches!(self, Self::Federated { .. }) } - - pub fn as_local_track(self) -> Option { - match self { - AssetInner::LocalTrack(x) => Some(x), - _ => None, - } - } } diff --git a/base/src/database.rs b/base/src/database.rs index 407db29..32f1464 100644 --- a/base/src/database.rs +++ b/base/src/database.rs @@ -14,7 +14,8 @@ use redb::{Durability, ReadableTable, StorageError, TableDefinition}; use std::{ fs::create_dir_all, hash::{DefaultHasher, Hasher}, - path::Path, + path::{Path, PathBuf}, + str::FromStr, sync::{Arc, RwLock}, time::SystemTime, }; @@ -38,6 +39,8 @@ const T_NODE_EXTERNAL_ID: TableDefinition<(&str, &str), [u8; 32]> = TableDefinition::new("node_external_id"); const T_IMPORT_FILE_MTIME: TableDefinition<&[u8], u64> = TableDefinition::new("import_file_mtime"); const T_NODE_MTIME: TableDefinition<[u8; 32], u64> = TableDefinition::new("node_mtime"); +const T_NODE_MEDIA_PATHS: TableDefinition<([u8; 32], &str), ()> = + TableDefinition::new("node_media_paths"); #[derive(Clone)] pub struct Database { @@ -67,6 +70,7 @@ impl Database { txn.open_table(T_NODE_MTIME)?; txn.open_table(T_NODE_CHILDREN)?; txn.open_table(T_NODE_EXTERNAL_ID)?; + txn.open_table(T_NODE_MEDIA_PATHS)?; txn.open_table(T_IMPORT_FILE_MTIME)?; txn.commit()?; } @@ -123,17 +127,20 @@ impl Database { let mut t_node_children = txn.open_table(T_NODE_CHILDREN)?; let mut t_node_external_id = txn.open_table(T_NODE_EXTERNAL_ID)?; let mut t_import_file_mtime = txn.open_table(T_IMPORT_FILE_MTIME)?; + let mut t_node_media_paths = txn.open_table(T_NODE_MEDIA_PATHS)?; t_node.retain(|_, _| false)?; t_node_mtime.retain(|_, _| false)?; t_node_children.retain(|_, _| false)?; t_node_external_id.retain(|_, _| false)?; t_import_file_mtime.retain(|_, _| false)?; + t_node_media_paths.retain(|_, _| false)?; drop(( t_node, t_node_mtime, t_node_children, t_node_external_id, t_import_file_mtime, + t_node_media_paths, )); txn.set_durability(Durability::Eventual); txn.commit()?; @@ -189,6 +196,24 @@ impl Database { txn.commit()?; Ok(()) } + pub fn get_node_media_paths(&self, id: NodeID) -> Result> { + let txn = self.inner.begin_read()?; + let table = txn.open_table(T_NODE_MEDIA_PATHS)?; + let mut paths = Vec::new(); + // TODO fix this + for p in table.range((id.0, "\0")..(id.0, "\x7f"))? { + paths.push(PathBuf::from_str(p?.0.value().1)?); + } + Ok(paths) + } + pub fn insert_node_media_path(&self, id: NodeID, path: &Path) -> Result<()> { + let txn = self.inner.begin_write()?; + let mut table = txn.open_table(T_NODE_MEDIA_PATHS)?; + table.insert((id.0, path.to_str().unwrap()), ())?; + drop(table); + txn.commit()?; + Ok(()) + } pub fn update_node_udata( &self, diff --git a/common/src/lib.rs b/common/src/lib.rs index ce333eb..00f07b6 100644 --- a/common/src/lib.rs +++ b/common/src/lib.rs @@ -171,7 +171,6 @@ pub type TrackID = usize; pub struct LocalTrack { pub path: PathBuf, pub track: TrackID, - pub codec_private: Option>, } #[derive(Debug, Clone, Deserialize, Serialize, Encode, Decode)] diff --git a/common/src/stream.rs b/common/src/stream.rs index a06dad5..75349cc 100644 --- a/common/src/stream.rs +++ b/common/src/stream.rs @@ -6,10 +6,15 @@ use serde::{Deserialize, Serialize}; use std::{collections::BTreeMap, fmt::Display, str::FromStr}; +pub type SegmentNum = usize; +pub type TrackNum = usize; +pub type FormatNum = usize; +pub type IndexNum = usize; + #[derive(Debug, Clone, Deserialize, Serialize)] pub enum StreamSpec { Whep { - track: usize, + track: TrackNum, seek: u64, }, WhepControl { @@ -20,34 +25,34 @@ pub enum StreamSpec { container: StreamContainer, }, Original { - track: usize, + track: TrackNum, }, HlsSuperMultiVariant { container: StreamContainer, }, HlsMultiVariant { - segment: u64, + segment: SegmentNum, container: StreamContainer, }, HlsVariant { - segment: u64, - track: usize, + segment: SegmentNum, + track: TrackNum, container: StreamContainer, - format: usize, + format: FormatNum, }, Info { segment: Option, }, FragmentIndex { - segment: u64, - track: usize, + segment: SegmentNum, + track: TrackNum, }, Fragment { - segment: u64, - track: usize, - index: u64, + segment: SegmentNum, + track: TrackNum, + index: IndexNum, container: StreamContainer, - format: usize, + format: FormatNum, }, } @@ -60,7 +65,7 @@ pub struct StreamInfo { #[derive(Debug, Clone, Deserialize, Serialize)] pub struct StreamSegmentInfo { pub name: Option, - pub duration: u64, + pub duration: f64, pub tracks: Vec, } @@ -92,7 +97,7 @@ pub struct StreamFormatInfo { pub bit_depth: Option, } -#[derive(Debug, Clone, Copy, Deserialize, Serialize)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)] #[serde(rename_all = "lowercase")] pub enum StreamContainer { WebM, @@ -164,13 +169,25 @@ impl StreamSpec { Ok(Self::Info { segment: get_num("segment").ok(), }) + } else if query.contains_key("hlsmultivariant") { + Ok(Self::HlsMultiVariant { + segment: get_num("segment")? as SegmentNum, + container: get_container()?, + }) + } else if query.contains_key("hlsvariant") { + Ok(Self::HlsVariant { + segment: get_num("segment")? as SegmentNum, + track: get_num("track")? as TrackNum, + format: get_num("format")? as FormatNum, + container: get_container()?, + }) } else if query.contains_key("fragment") { Ok(Self::Fragment { - segment: get_num("segment")?, - track: get_num("track")? as usize, - index: get_num("index")?, + segment: get_num("segment")? as SegmentNum, + track: get_num("track")? as TrackNum, + format: get_num("format")? as FormatNum, + index: get_num("index")? as IndexNum, container: get_container()?, - format: get_num("format")? as usize, }) } else { Err("invalid stream spec") diff --git a/import/src/lib.rs b/import/src/lib.rs index 5607450..3ea42f1 100644 --- a/import/src/lib.rs +++ b/import/src/lib.rs @@ -7,14 +7,13 @@ use anyhow::{anyhow, bail, Context, Result}; use infojson::YVideo; use jellybase::{ assetfed::AssetInner, - common::{ - Chapter, LocalTrack, MediaInfo, Node, NodeID, NodeKind, Rating, SourceTrack, - SourceTrackKind, TrackSource, - }, + common::{Chapter, MediaInfo, Node, NodeID, NodeKind, Rating, SourceTrack, SourceTrackKind}, database::Database, CONF, SECRETS, }; -use jellyclient::{Appearance, PeopleGroup, TmdbKind, TraktKind, Visibility}; +use jellyclient::{ + Appearance, LocalTrack, PeopleGroup, TmdbKind, TrackSource, TraktKind, Visibility, +}; use jellyremuxer::metadata::checked_matroska_metadata; use log::info; use rayon::iter::{ParallelBridge, ParallelIterator}; @@ -397,7 +396,6 @@ fn import_media_file( }, source: TrackSource::Local( AssetInner::LocalTrack(LocalTrack { - codec_private: track.codec_private, path: path.to_owned(), track: track.track_number as usize, }) diff --git a/remuxer/src/extract.rs b/remuxer/src/extract.rs index 12e4003..15c1e9d 100644 --- a/remuxer/src/extract.rs +++ b/remuxer/src/extract.rs @@ -5,29 +5,22 @@ */ use crate::seek_index::get_seek_index; use anyhow::{anyhow, bail}; -use jellybase::common::LocalTrack; use jellymatroska::{block::Block, read::EbmlReader, Master, MatroskaTag}; use log::debug; use std::{fs::File, io::BufReader, path::PathBuf}; pub type TrackExtract = Vec<(u64, Option, Vec)>; -pub fn extract_track(path_base: PathBuf, track_info: LocalTrack) -> anyhow::Result { - let source_path = path_base.join(track_info.path); - let file = File::open(&source_path)?; +pub fn extract_track(path: PathBuf, track: u64) -> anyhow::Result { + let file = File::open(&path)?; let mut reader = EbmlReader::new(BufReader::new(file)); - let index = get_seek_index(&source_path)?; - let index = index - .get(&(track_info.track as u64)) - .ok_or(anyhow!("track missing"))?; + let index = get_seek_index(&path)?; + let index = index.get(&track).ok_or(anyhow!("track missing"))?; let mut out = Vec::new(); for b in &index.blocks { reader.seek(b.source_off, MatroskaTag::BlockGroup(Master::Start))?; let (duration, block) = read_group(&mut reader)?; - assert_eq!( - track_info.track, block.track as usize, - "seek index is wrong" - ); + assert_eq!(track, block.track, "seek index is wrong"); out.push((b.pts, duration, block.data)) } Ok(out) diff --git a/remuxer/src/fragment.rs b/remuxer/src/fragment.rs index 9fa68f3..73fe046 100644 --- a/remuxer/src/fragment.rs +++ b/remuxer/src/fragment.rs @@ -5,11 +5,10 @@ */ use crate::{ - ebml_header, ebml_segment_info, ebml_track_entry, seek_index::get_seek_index, - segment_extractor::SegmentExtractIter, + ebml_header, ebml_segment_info, ebml_track_entry, metadata::matroska_metadata, + seek_index::get_seek_index, segment_extractor::SegmentExtractIter, }; use anyhow::{anyhow, Context, Result}; -use jellybase::common::{LocalTrack, Node, SourceTrackKind}; use jellymatroska::{read::EbmlReader, write::EbmlWriter, Master, MatroskaTag}; use log::{debug, info}; use std::{ @@ -21,32 +20,33 @@ use std::{ const FRAGMENT_LENGTH: f64 = 2.; -pub fn fragment_index( - path_base: &Path, - item: &Node, - local_track: &LocalTrack, - track_index: usize, -) -> Result>> { - let media_info = item.media.as_ref().unwrap(); - let source_path = path_base.join(&local_track.path); - let index = get_seek_index(&source_path)?; +pub fn fragment_index(path: &Path, track: u64) -> Result>> { + let meta = matroska_metadata(path)?; + let duration = meta.info.as_ref().unwrap().duration.unwrap(); + let force_kf = meta + .as_ref() + .tracks + .as_ref() + .unwrap() + .entries + .iter() + .find(|t| t.track_number == track) + .unwrap() + .track_type + == 17; + + let index = get_seek_index(&path)?; let index = index - .get(&(local_track.track as u64)) + .get(&track) .ok_or(anyhow!("seek index track missing"))?; - // everything is a keyframe (even though nothing is...) - let force_kf = matches!( - media_info.tracks[track_index].kind, - SourceTrackKind::Subtitles { .. } - ); - let n_kf = if force_kf { index.blocks.len() } else { index.keyframes.len() }; - let average_kf_interval = media_info.duration / n_kf as f64; + let average_kf_interval = duration / n_kf as f64; let kf_per_frag = (FRAGMENT_LENGTH / average_kf_interval).ceil() as usize; debug!("average keyframe interval: {average_kf_interval}"); debug!(" => keyframes per frag {kf_per_frag}"); @@ -72,7 +72,7 @@ pub fn fragment_index( index.keyframes.get((i + 1) * kf_per_frag).copied() } .map(|i| index.blocks[i].pts as f64 / 1000.) - .unwrap_or(media_info.duration); + .unwrap_or(duration); start..end }) .collect()) @@ -80,45 +80,45 @@ pub fn fragment_index( pub fn write_fragment_into( writer: impl Write, - path_base: &Path, - item: &Node, - local_track: &LocalTrack, - track: usize, + path: &Path, + track: u64, webm: bool, + title: &str, n: usize, ) -> anyhow::Result<()> { - info!("writing fragment {n} of {:?} (track {track})", item.title); - let mut output = EbmlWriter::new(BufWriter::new(writer), 0); - let media_info = item.media.as_ref().unwrap(); - let info = media_info + let meta = matroska_metadata(path)?; + let duration = meta.info.as_ref().unwrap().duration.unwrap(); + let track_meta = meta + .as_ref() .tracks - .get(track) - .ok_or(anyhow!("track not available"))? - .to_owned(); - let source_path = path_base.join(&local_track.path); + .as_ref() + .unwrap() + .entries + .iter() + .find(|t| t.track_number == track) + .unwrap(); + let force_kf = track_meta.track_type == 17; + + info!("writing fragment {n} of {:?} (track {track})", title); + let mut output = EbmlWriter::new(BufWriter::new(writer), 0); let mapped = 1; - info!( - "\t- {track} {source_path:?} ({} => {mapped})", - local_track.track - ); - info!("\t {}", info); - let file = File::open(&source_path).context("opening source file")?; - let index = get_seek_index(&source_path)?; + info!("\t- {track} {path:?} ({} => {mapped})", track); + // info!("\t {}", info); + let file = File::open(&path).context("opening source file")?; + let index = get_seek_index(&path)?; let index = index - .get(&(local_track.track as u64)) + .get(&track) .ok_or(anyhow!("track missing 2"))? .to_owned(); debug!("\t seek index: {} blocks loaded", index.blocks.len()); let mut reader = EbmlReader::new(BufReader::new(file)); - let force_kf = matches!(info.kind, SourceTrackKind::Subtitles { .. }); let n_kf = if force_kf { index.blocks.len() } else { index.keyframes.len() }; - - let average_kf_interval = media_info.duration / n_kf as f64; + let average_kf_interval = duration / n_kf as f64; let kf_per_frag = (FRAGMENT_LENGTH / average_kf_interval).ceil() as usize; debug!("average keyframe interval: {average_kf_interval}"); debug!(" => keyframes per frag {kf_per_frag}"); @@ -144,25 +144,20 @@ pub fn write_fragment_into( .blocks .get(end_block_index) .map(|b| b.pts) - .unwrap_or((media_info.duration * 1000.) as u64); + .unwrap_or((duration * 1000.) as u64); output.write_tag(&ebml_header(webm))?; output.write_tag(&MatroskaTag::Segment(Master::Start))?; output.write_tag(&ebml_segment_info( - format!("{}: {info}", item.title.clone().unwrap_or_default()), + title.to_string(), (last_block_pts - start_block.pts) as f64 / 1000., ))?; output.write_tag(&MatroskaTag::Tracks(Master::Collected(vec![ - ebml_track_entry( - mapped, - local_track.track as u64 * 100, // TODO something else that is unique to the track - &info, - local_track.codec_private.clone(), - ), + ebml_track_entry(mapped, track_meta), ])))?; reader.seek(start_block.source_off, MatroskaTag::Cluster(Master::Start))?; - let mut reader = SegmentExtractIter::new(&mut reader, local_track.track as u64); + let mut reader = SegmentExtractIter::new(&mut reader, track); { // TODO this one caused fragments to get dropped by MSE for no reason diff --git a/remuxer/src/lib.rs b/remuxer/src/lib.rs index cc4b39b..9ddf7c1 100644 --- a/remuxer/src/lib.rs +++ b/remuxer/src/lib.rs @@ -5,17 +5,16 @@ */ pub mod extract; pub mod fragment; +pub mod metadata; pub mod remux; pub mod seek_index; pub mod segment_extractor; pub mod trim_writer; -pub mod metadata; +use ebml_struct::matroska::TrackEntry; pub use fragment::write_fragment_into; -pub use remux::remux_stream_into; - -use jellybase::common::{SourceTrack, SourceTrackKind}; use jellymatroska::{Master, MatroskaTag}; +pub use remux::remux_stream_into; pub fn ebml_header(webm: bool) -> MatroskaTag { MatroskaTag::Ebml(Master::Collected(vec![ @@ -42,66 +41,56 @@ pub fn ebml_segment_info(title: String, duration: f64) -> MatroskaTag { ])) } -pub fn ebml_track_entry( - number: u64, - uid: u64, - track: &SourceTrack, - codec_private: Option>, -) -> MatroskaTag { +pub fn ebml_track_entry(number: u64, track: &TrackEntry) -> MatroskaTag { let mut els = vec![ MatroskaTag::TrackNumber(number), - MatroskaTag::TrackUID(uid), MatroskaTag::FlagLacing(track.flag_lacing), MatroskaTag::Language(track.language.clone()), - MatroskaTag::CodecID(track.codec.clone()), + MatroskaTag::CodecID(track.codec_id.clone()), MatroskaTag::CodecDelay(track.codec_delay), MatroskaTag::SeekPreRoll(track.seek_pre_roll), ]; if let Some(d) = &track.default_duration { els.push(MatroskaTag::DefaultDuration(*d)); } - match track.kind { - SourceTrackKind::Video { - width, - height, - display_height, - display_width, - display_unit, - fps, - } => { + match track.track_type { + 1 => { + let video = track.video.as_ref().unwrap(); els.push(MatroskaTag::TrackType(1)); let mut props = vec![ - MatroskaTag::PixelWidth(width), - MatroskaTag::PixelHeight(height), + MatroskaTag::PixelWidth(video.pixel_width), + MatroskaTag::PixelHeight(video.pixel_height), ]; - props.push(MatroskaTag::DisplayWidth(display_width.unwrap_or(width))); - props.push(MatroskaTag::DisplayHeight(display_height.unwrap_or(height))); - props.push(MatroskaTag::DisplayUnit(display_unit)); - if let Some(fps) = fps { + props.push(MatroskaTag::DisplayWidth( + video.display_width.unwrap_or(video.pixel_width), + )); + props.push(MatroskaTag::DisplayHeight( + video.display_height.unwrap_or(video.pixel_height), + )); + props.push(MatroskaTag::DisplayUnit(video.display_unit)); + if let Some(fps) = video.frame_rate { props.push(MatroskaTag::FrameRate(fps)) } els.push(MatroskaTag::Video(Master::Collected(props))) } - SourceTrackKind::Audio { - channels, - sample_rate, - bit_depth, - } => { + 2 => { + let audio = track.audio.as_ref().unwrap(); els.push(MatroskaTag::TrackType(2)); let mut props = vec![ - MatroskaTag::SamplingFrequency(sample_rate), - MatroskaTag::Channels(channels.try_into().unwrap()), + MatroskaTag::SamplingFrequency(audio.sampling_frequency), + MatroskaTag::Channels(audio.channels), ]; - if let Some(bit_depth) = bit_depth { + if let Some(bit_depth) = audio.bit_depth { props.push(MatroskaTag::BitDepth(bit_depth.try_into().unwrap())); } els.push(MatroskaTag::Audio(Master::Collected(props))); } - SourceTrackKind::Subtitles => { + 17 => { els.push(MatroskaTag::TrackType(17)); } + _ => unreachable!(), } - if let Some(d) = &codec_private { + if let Some(d) = &track.codec_private { els.push(MatroskaTag::CodecPrivate(d.clone())); } MatroskaTag::TrackEntry(Master::Collected(els)) diff --git a/remuxer/src/remux.rs b/remuxer/src/remux.rs index 0507f1e..a44c58b 100644 --- a/remuxer/src/remux.rs +++ b/remuxer/src/remux.rs @@ -3,333 +3,311 @@ which is licensed under the GNU Affero General Public License (version 3); see /COPYING. Copyright (C) 2025 metamuffin */ -use crate::{ - ebml_header, ebml_track_entry, seek_index::get_seek_index, - segment_extractor::SegmentExtractIter, trim_writer::TrimWriter, -}; -use anyhow::{anyhow, Context}; -use jellybase::common::{ - seek_index::{BlockIndex, SeekIndex}, - LocalTrack, Node, SourceTrack, -}; -use jellymatroska::{ - read::EbmlReader, - write::{bad_vint_length, vint_length, EbmlWriter}, - Master, MatroskaTag, -}; -use log::{debug, info, trace, warn}; -use std::{ - fs::File, - io::{BufReader, BufWriter, Seek, SeekFrom, Write}, - ops::Range, - path::PathBuf, - sync::Arc, - time::Instant, -}; +use jellybase::common::Node; +use std::{io::Write, ops::Range, path::PathBuf}; -struct ClusterLayout { - position: usize, - timestamp: u64, - source_offsets: Vec>, - blocks: Vec<(usize, BlockIndex)>, -} +// struct ClusterLayout { +// position: usize, +// timestamp: u64, +// source_offsets: Vec>, +// blocks: Vec<(usize, BlockIndex)>, +// } pub fn remux_stream_into( - writer: impl Write, - range: Range, - path_base: PathBuf, - item: &Node, - track_sources: Vec, - selection: Vec, - webm: bool, + _writer: impl Write, + _range: Range, + _path_base: PathBuf, + _item: &Node, + _selection: Vec, + _webm: bool, ) -> anyhow::Result<()> { - info!("remuxing {:?} to have tracks {selection:?}", item.title); - let writer = TrimWriter::new(BufWriter::new(writer), range.clone()); - let mut output = EbmlWriter::new(writer, 0); + // info!("remuxing {:?} to have tracks {selection:?}", item.title); + // let writer = TrimWriter::new(BufWriter::new(writer), range.clone()); + // let mut output = EbmlWriter::new(writer, 0); - struct ReaderC { - info: SourceTrack, - reader: EbmlReader, - mapped: u64, - index: Arc, - source_track_index: usize, - codec_private: Option>, - layouting_progress_index: usize, - } + // struct ReaderC { + // info: SourceTrack, + // reader: EbmlReader, + // mapped: u64, + // index: Arc, + // source_track_index: usize, + // codec_private: Option>, + // layouting_progress_index: usize, + // } - let timing_cp = Instant::now(); + // let timing_cp = Instant::now(); - let mut inputs = selection - .iter() - .enumerate() - .map(|(index, sel)| { - let info = item - .media - .as_ref() - .unwrap() - .tracks - .get(*sel) - .ok_or(anyhow!("track not available"))? - .to_owned(); - let private = &track_sources[index]; - let source_path = path_base.join(&private.path); - let mapped = index as u64 + 1; - info!("\t- {sel} {source_path:?} ({} => {mapped})", private.track); - info!("\t {}", info); - let file = File::open(&source_path).context("opening source file")?; - let index = get_seek_index(&source_path)?; - let index = index - .get(&(private.track as u64)) - .ok_or(anyhow!("track missing 3"))? - .to_owned(); - debug!("\t seek index: {} blocks loaded", index.blocks.len()); - let reader = EbmlReader::new(BufReader::new(file)); - Ok(ReaderC { - index, - reader, - info, - mapped, - source_track_index: private.track, - codec_private: private.codec_private.clone(), - layouting_progress_index: 0, - }) - }) - .collect::>>()?; + // let mut inputs = selection + // .iter() + // .enumerate() + // .map(|(index, sel)| { + // let info = item + // .media + // .as_ref() + // .unwrap() + // .tracks + // .get(*sel) + // .ok_or(anyhow!("track not available"))? + // .to_owned(); + // let source_path = path_base.join(&private.path); + // let mapped = index as u64 + 1; + // info!("\t- {sel} {source_path:?} ({} => {mapped})", private.track); + // info!("\t {}", info); + // let file = File::open(&source_path).context("opening source file")?; + // let index = get_seek_index(&source_path)?; + // let index = index + // .get(&(private.track as u64)) + // .ok_or(anyhow!("track missing 3"))? + // .to_owned(); + // debug!("\t seek index: {} blocks loaded", index.blocks.len()); + // let reader = EbmlReader::new(BufReader::new(file)); + // Ok(ReaderC { + // index, + // reader, + // info, + // mapped, + // source_track_index: private.track, + // codec_private: private.codec_private.clone(), + // layouting_progress_index: 0, + // }) + // }) + // .collect::>>()?; - info!("(perf) prepare inputs: {:?}", Instant::now() - timing_cp); - let timing_cp = Instant::now(); + // info!("(perf) prepare inputs: {:?}", Instant::now() - timing_cp); + // let timing_cp = Instant::now(); - output.write_tag(&ebml_header(webm))?; + // output.write_tag(&ebml_header(webm))?; - output.write_tag(&MatroskaTag::Segment(Master::Start))?; - let segment_offset = output.position(); + // output.write_tag(&MatroskaTag::Segment(Master::Start))?; + // let segment_offset = output.position(); - output.write_tag(&MatroskaTag::Info(Master::Collected(vec![ - MatroskaTag::TimestampScale(1_000_000), - MatroskaTag::Duration(item.media.as_ref().unwrap().duration * 1000.0), - MatroskaTag::Title(item.title.clone().unwrap_or_default()), - MatroskaTag::MuxingApp("jellyremux".to_string()), - MatroskaTag::WritingApp("jellything".to_string()), - ])))?; + // output.write_tag(&MatroskaTag::Info(Master::Collected(vec![ + // MatroskaTag::TimestampScale(1_000_000), + // MatroskaTag::Duration(item.media.as_ref().unwrap().duration * 1000.0), + // MatroskaTag::Title(item.title.clone().unwrap_or_default()), + // MatroskaTag::MuxingApp("jellyremux".to_string()), + // MatroskaTag::WritingApp("jellything".to_string()), + // ])))?; - let tracks_header = inputs - .iter_mut() - .map(|rc| ebml_track_entry(rc.mapped, rc.mapped, &rc.info, rc.codec_private.take())) - .collect(); - output.write_tag(&MatroskaTag::Tracks(Master::Collected(tracks_header)))?; + // let tracks_header = inputs + // .iter_mut() + // .map(|rc| ebml_track_entry(rc.mapped, rc.mapped, &rc.info, rc.codec_private.take())) + // .collect(); + // output.write_tag(&MatroskaTag::Tracks(Master::Collected(tracks_header)))?; - let mut segment_layout: Vec = { - let mut cluster_pts = 0; - let mut clusters = vec![]; - let mut cluster = vec![]; - let mut source_offsets = vec![None; inputs.len()]; - let mut gp = 0usize; // cluster position (in the segment) - let mut p = 0usize; // block position (in the cluster) - loop { - let (track, block) = { - let mut best_block = BlockIndex { - pts: u64::MAX, - size: 0, - source_off: 0, - }; - let mut best_track = 0; - for (i, r) in inputs.iter().enumerate() { - if let Some(v) = r.index.blocks.get(r.layouting_progress_index) { - if v.pts < best_block.pts { - best_block = v.to_owned(); - best_track = i; - } - }; - } - (best_track, best_block) - }; - inputs[track].layouting_progress_index += 1; - source_offsets[track].get_or_insert(block.source_off); - if block.pts > cluster_pts + 1_000 { - let cluster_content_size = 1 + 1 // timestamp {tag, size} - + bad_vint_length(cluster_pts) // timestamp tag value - + p; - let cluster_size = 4 // tag length - + vint_length(cluster_content_size as u64) // size varint - + cluster_content_size; - clusters.push(ClusterLayout { - position: gp, // relative to the first cluster - timestamp: cluster_pts, - source_offsets, - blocks: std::mem::take(&mut cluster), - }); + // let mut segment_layout: Vec = { + // let mut cluster_pts = 0; + // let mut clusters = vec![]; + // let mut cluster = vec![]; + // let mut source_offsets = vec![None; inputs.len()]; + // let mut gp = 0usize; // cluster position (in the segment) + // let mut p = 0usize; // block position (in the cluster) + // loop { + // let (track, block) = { + // let mut best_block = BlockIndex { + // pts: u64::MAX, + // size: 0, + // source_off: 0, + // }; + // let mut best_track = 0; + // for (i, r) in inputs.iter().enumerate() { + // if let Some(v) = r.index.blocks.get(r.layouting_progress_index) { + // if v.pts < best_block.pts { + // best_block = v.to_owned(); + // best_track = i; + // } + // }; + // } + // (best_track, best_block) + // }; + // inputs[track].layouting_progress_index += 1; + // source_offsets[track].get_or_insert(block.source_off); + // if block.pts > cluster_pts + 1_000 { + // let cluster_content_size = 1 + 1 // timestamp {tag, size} + // + bad_vint_length(cluster_pts) // timestamp tag value + // + p; + // let cluster_size = 4 // tag length + // + vint_length(cluster_content_size as u64) // size varint + // + cluster_content_size; + // clusters.push(ClusterLayout { + // position: gp, // relative to the first cluster + // timestamp: cluster_pts, + // source_offsets, + // blocks: std::mem::take(&mut cluster), + // }); - cluster_pts = block.pts; - source_offsets = vec![None; inputs.len()]; - gp += cluster_size; - p = 0; - } - if block.pts == u64::MAX { - break; - } + // cluster_pts = block.pts; + // source_offsets = vec![None; inputs.len()]; + // gp += cluster_size; + // p = 0; + // } + // if block.pts == u64::MAX { + // break; + // } - let simpleblock_size = 1 + 2 + 1 // block {tracknum, pts_off, flags} - // TODO does not work, if more than 127 tracks are present - + block.size; // block payload - p += 1; // simpleblock tag - p += vint_length(simpleblock_size as u64); // simpleblock size vint - p += simpleblock_size; + // let simpleblock_size = 1 + 2 + 1 // block {tracknum, pts_off, flags} + // // TODO does not work, if more than 127 tracks are present + // + block.size; // block payload + // p += 1; // simpleblock tag + // p += vint_length(simpleblock_size as u64); // simpleblock size vint + // p += simpleblock_size; - cluster.push((track, block)) - } - info!("segment layout computed ({} clusters)", clusters.len()); - clusters - }; - info!( - "(perf) compute segment layout: {:?}", - Instant::now() - timing_cp - ); - let timing_cp = Instant::now(); + // cluster.push((track, block)) + // } + // info!("segment layout computed ({} clusters)", clusters.len()); + // clusters + // }; + // info!( + // "(perf) compute segment layout: {:?}", + // Instant::now() - timing_cp + // ); + // let timing_cp = Instant::now(); - let max_cue_size = 4 // cues id - + 8 // cues len - + ( // cues content - 1 // cp id - + 1 // cp len - + ( // cp content - 1 // ctime id, - + 1 // ctime len - + 8 // ctime content uint - + ( // ctps - 1 // ctp id - + 8 // ctp len - + (// ctp content - 1 // ctrack id - + 1 // ctrack size - + 1 // ctrack content int - // TODO this breaks if inputs.len() >= 127 - + 1 // ccp id - + 1 // ccp len - + 8 // ccp content offset - ) - ) - ) * inputs.len() - ) * segment_layout.len() - + 1 // void id - + 8; // void len + // let max_cue_size = 4 // cues id + // + 8 // cues len + // + ( // cues content + // 1 // cp id + // + 1 // cp len + // + ( // cp content + // 1 // ctime id, + // + 1 // ctime len + // + 8 // ctime content uint + // + ( // ctps + // 1 // ctp id + // + 8 // ctp len + // + (// ctp content + // 1 // ctrack id + // + 1 // ctrack size + // + 1 // ctrack content int + // // TODO this breaks if inputs.len() >= 127 + // + 1 // ccp id + // + 1 // ccp len + // + 8 // ccp content offset + // ) + // ) + // ) * inputs.len() + // ) * segment_layout.len() + // + 1 // void id + // + 8; // void len - let first_cluster_offset_predict = max_cue_size + output.position(); + // let first_cluster_offset_predict = max_cue_size + output.position(); - // make the cluster position relative to the segment start as they should - segment_layout - .iter_mut() - .for_each(|e| e.position += first_cluster_offset_predict - segment_offset); + // // make the cluster position relative to the segment start as they should + // segment_layout + // .iter_mut() + // .for_each(|e| e.position += first_cluster_offset_predict - segment_offset); - output.write_tag(&MatroskaTag::Cues(Master::Collected( - segment_layout - .iter() - .map(|cluster| { - MatroskaTag::CuePoint(Master::Collected( - Some(MatroskaTag::CueTime(cluster.timestamp)) - .into_iter() - // TODO: Subtitles should not have cues for every cluster - .chain(inputs.iter().map(|i| { - MatroskaTag::CueTrackPositions(Master::Collected(vec![ - MatroskaTag::CueTrack(i.mapped), - MatroskaTag::CueClusterPosition(cluster.position as u64), - ])) - })) - .collect(), - )) - }) - .collect(), - )))?; - output.write_padding(first_cluster_offset_predict)?; - let first_cluster_offset = output.position(); - assert_eq!(first_cluster_offset, first_cluster_offset_predict); + // output.write_tag(&MatroskaTag::Cues(Master::Collected( + // segment_layout + // .iter() + // .map(|cluster| { + // MatroskaTag::CuePoint(Master::Collected( + // Some(MatroskaTag::CueTime(cluster.timestamp)) + // .into_iter() + // // TODO: Subtitles should not have cues for every cluster + // .chain(inputs.iter().map(|i| { + // MatroskaTag::CueTrackPositions(Master::Collected(vec![ + // MatroskaTag::CueTrack(i.mapped), + // MatroskaTag::CueClusterPosition(cluster.position as u64), + // ])) + // })) + // .collect(), + // )) + // }) + // .collect(), + // )))?; + // output.write_padding(first_cluster_offset_predict)?; + // let first_cluster_offset = output.position(); + // assert_eq!(first_cluster_offset, first_cluster_offset_predict); - let mut skip = 0; - // TODO binary search - for (i, cluster) in segment_layout.iter().enumerate() { - if (cluster.position + segment_offset) >= range.start { - break; - } - skip = i; - } + // let mut skip = 0; + // // TODO binary search + // for (i, cluster) in segment_layout.iter().enumerate() { + // if (cluster.position + segment_offset) >= range.start { + // break; + // } + // skip = i; + // } - if skip != 0 { - info!("skipping {skip} clusters"); - output.seek(SeekFrom::Start( - (segment_layout[skip].position + segment_offset) as u64, - ))?; - } + // if skip != 0 { + // info!("skipping {skip} clusters"); + // output.seek(SeekFrom::Start( + // (segment_layout[skip].position + segment_offset) as u64, + // ))?; + // } - struct ReaderD<'a> { - stream: SegmentExtractIter<'a>, - mapped: u64, - } + // struct ReaderD<'a> { + // stream: SegmentExtractIter<'a>, + // mapped: u64, + // } - let mut track_readers = inputs - .iter_mut() - .enumerate() - .map(|(i, inp)| { - inp.reader - .seek( - // the seek target might be a hole; we continue until the next cluster of that track. - // this should be fine since tracks are only read according to segment_layout - find_first_cluster_with_off(&segment_layout, skip, i) - .ok_or(anyhow!("cluster hole at eof"))?, - MatroskaTag::Cluster(Master::Start), // TODO shouldn't this be a child of cluster? - ) - .context("seeking in input")?; - let stream = SegmentExtractIter::new(&mut inp.reader, inp.source_track_index as u64); + // let mut track_readers = inputs + // .iter_mut() + // .enumerate() + // .map(|(i, inp)| { + // inp.reader + // .seek( + // // the seek target might be a hole; we continue until the next cluster of that track. + // // this should be fine since tracks are only read according to segment_layout + // find_first_cluster_with_off(&segment_layout, skip, i) + // .ok_or(anyhow!("cluster hole at eof"))?, + // MatroskaTag::Cluster(Master::Start), // TODO shouldn't this be a child of cluster? + // ) + // .context("seeking in input")?; + // let stream = SegmentExtractIter::new(&mut inp.reader, inp.source_track_index as u64); - Ok(ReaderD { - mapped: inp.mapped, - stream, - }) - }) - .collect::>>()?; + // Ok(ReaderD { + // mapped: inp.mapped, + // stream, + // }) + // }) + // .collect::>>()?; - info!("(perf) seek inputs: {:?}", Instant::now() - timing_cp); + // info!("(perf) seek inputs: {:?}", Instant::now() - timing_cp); - for (cluster_index, cluster) in segment_layout.into_iter().enumerate().skip(skip) { - debug!( - "writing cluster {cluster_index} (pts_base={}) with {} blocks", - cluster.timestamp, - cluster.blocks.len() - ); - { - let cue_error = cluster.position as i64 - (output.position() - segment_offset) as i64; - if cue_error != 0 { - warn!("calculation was {} bytes off", cue_error); - } - } + // for (cluster_index, cluster) in segment_layout.into_iter().enumerate().skip(skip) { + // debug!( + // "writing cluster {cluster_index} (pts_base={}) with {} blocks", + // cluster.timestamp, + // cluster.blocks.len() + // ); + // { + // let cue_error = cluster.position as i64 - (output.position() - segment_offset) as i64; + // if cue_error != 0 { + // warn!("calculation was {} bytes off", cue_error); + // } + // } - let mut cluster_blocks = vec![MatroskaTag::Timestamp(cluster.timestamp)]; - for (block_track, index_block) in cluster.blocks { - let track_reader = &mut track_readers[block_track]; - // TODO handle duration - let mut block = track_reader.stream.next_block()?.0; + // let mut cluster_blocks = vec![MatroskaTag::Timestamp(cluster.timestamp)]; + // for (block_track, index_block) in cluster.blocks { + // let track_reader = &mut track_readers[block_track]; + // // TODO handle duration + // let mut block = track_reader.stream.next_block()?.0; - assert_eq!(index_block.size, block.data.len(), "seek index is wrong"); + // assert_eq!(index_block.size, block.data.len(), "seek index is wrong"); - block.track = track_reader.mapped; - block.timestamp_off = (index_block.pts - cluster.timestamp).try_into().unwrap(); - trace!("n={} tso={}", block.track, block.timestamp_off); + // block.track = track_reader.mapped; + // block.timestamp_off = (index_block.pts - cluster.timestamp).try_into().unwrap(); + // trace!("n={} tso={}", block.track, block.timestamp_off); - cluster_blocks.push(MatroskaTag::SimpleBlock(block)) - } - output.write_tag(&MatroskaTag::Cluster(Master::Collected(cluster_blocks)))?; - } - // output.write_tag(&MatroskaTag::Segment(Master::End))?; - Ok(()) + // cluster_blocks.push(MatroskaTag::SimpleBlock(block)) + // } + // output.write_tag(&MatroskaTag::Cluster(Master::Collected(cluster_blocks)))?; + // } + // // output.write_tag(&MatroskaTag::Segment(Master::End))?; + // Ok(()) + todo!() } -fn find_first_cluster_with_off( - segment_layout: &[ClusterLayout], - skip: usize, - track: usize, -) -> Option { - for cluster in segment_layout.iter().skip(skip) { - if let Some(off) = cluster.source_offsets[track] { - return Some(off); - } - } - None -} +// fn find_first_cluster_with_off( +// segment_layout: &[ClusterLayout], +// skip: usize, +// track: usize, +// ) -> Option { +// for cluster in segment_layout.iter().skip(skip) { +// if let Some(off) = cluster.source_offsets[track] { +// return Some(off); +// } +// } +// None +// } diff --git a/server/src/routes/ui/player.rs b/server/src/routes/ui/player.rs index aa567ab..2cc2dd4 100644 --- a/server/src/routes/ui/player.rs +++ b/server/src/routes/ui/player.rs @@ -15,9 +15,10 @@ use crate::{ uri, }; use anyhow::anyhow; -use jellybase::{permission::PermissionSetExt, CONF}; +use jellybase::CONF; use jellycommon::{ - user::{PermissionSet, PlayerKind, UserPermission}, + stream::{StreamContainer, StreamSpec}, + user::{PermissionSet, PlayerKind}, Node, NodeID, SourceTrackKind, TrackID, }; use markup::DynRender; @@ -45,15 +46,14 @@ impl PlayerConfig { fn jellynative_url(action: &str, seek: f64, secret: &str, node: &str, session: &str) -> String { let protocol = if CONF.tls { "https" } else { "http" }; let host = &CONF.hostname; - let stream_url = ""; - // TODO - // uri!(r_stream( - // node, - // StreamSpec { - // format: StreamFormat::HlsMaster, - // ..Default::default() - // } - // )); + let stream_url = format!( + "/n/{node}/stream{}", + StreamSpec::HlsMultiVariant { + segment: 0, + container: StreamContainer::Matroska + } + .to_query() + ); format!("jellynative://{action}/{secret}/{session}/{seek}/{protocol}://{host}{stream_url}",) } diff --git a/stream/src/fragment.rs b/stream/src/fragment.rs index a34bb8d..52d32f4 100644 --- a/stream/src/fragment.rs +++ b/stream/src/fragment.rs @@ -3,37 +3,29 @@ which is licensed under the GNU Affero General Public License (version 3); see /COPYING. Copyright (C) 2025 metamuffin */ +use crate::{stream_info, SMediaInfo}; use anyhow::{anyhow, Result}; -use jellybase::{ - common::{ - stream::StreamSpec, - user::{PermissionSet, UserPermission}, - LocalTrack, Node, - }, - permission::PermissionSetExt, - CONF, -}; -use jellytranscoder::fragment::transcode; +use jellybase::common::stream::StreamContainer; use log::warn; use std::sync::Arc; -use tokio::{fs::File, io::DuplexStream}; +use tokio::io::DuplexStream; use tokio_util::io::SyncIoBridge; pub async fn fragment_stream( - node: Arc, - local_tracks: Vec, - spec: StreamSpec, mut b: DuplexStream, - perms: &PermissionSet, - webm: bool, - track: u64, - segment: u64, + info: Arc, + track: usize, + segment: usize, index: usize, + format: usize, + container: StreamContainer, ) -> Result<()> { - let local_track = local_tracks - .first() - .ok_or(anyhow!("track missing"))? - .to_owned(); + let (iinfo, info) = stream_info(info).await?; + let (file_index, track_num) = *iinfo + .track_to_file + .get(track) + .ok_or(anyhow!("track not found"))?; + let path = iinfo.paths[file_index].clone(); // if let Some(profile) = None { // perms.assert(&UserPermission::Transcode)?; @@ -70,11 +62,10 @@ pub async fn fragment_stream( tokio::task::spawn_blocking(move || { if let Err(err) = jellyremuxer::write_fragment_into( b, - &CONF.media_path, - &node, - &local_track, - track as usize, - webm, + &path, + track_num, + container == StreamContainer::WebM, + &info.name.unwrap_or_default(), index, ) { warn!("segment stream error: {err}"); diff --git a/stream/src/fragment_index.rs b/stream/src/fragment_index.rs new file mode 100644 index 0000000..6fbddc6 --- /dev/null +++ b/stream/src/fragment_index.rs @@ -0,0 +1,32 @@ +/* + This file is part of jellything (https://codeberg.org/metamuffin/jellything) + which is licensed under the GNU Affero General Public License (version 3); see /COPYING. + Copyright (C) 2025 metamuffin +*/ +use crate::{stream_info, SMediaInfo}; +use anyhow::{anyhow, Result}; +use jellybase::common::stream::{SegmentNum, TrackNum}; +use std::sync::Arc; +use tokio::io::{AsyncWriteExt, DuplexStream}; + +pub async fn fragment_index_stream( + mut b: DuplexStream, + info: Arc, + _segment: SegmentNum, + track: TrackNum, +) -> Result<()> { + let (iinfo, _info) = stream_info(info).await?; + let (file_index, track_num) = *iinfo + .track_to_file + .get(track) + .ok_or(anyhow!("track not found"))?; + + let fragments = tokio::task::spawn_blocking(move || { + jellyremuxer::fragment::fragment_index(&iinfo.paths[file_index], track_num) + }) + .await??; + + let out = serde_json::to_string(&fragments)?; + tokio::spawn(async move { b.write_all(out.as_bytes()).await }); + Ok(()) +} diff --git a/stream/src/hls.rs b/stream/src/hls.rs index 27630b2..f06ac72 100644 --- a/stream/src/hls.rs +++ b/stream/src/hls.rs @@ -4,13 +4,10 @@ Copyright (C) 2025 metamuffin */ +use crate::{stream_info, SMediaInfo}; use anyhow::{anyhow, Result}; -use jellybase::{ - common::{ - stream::{StreamContainer, StreamSpec}, - LocalTrack, Node, SourceTrackKind, - }, - CONF, +use jellybase::common::stream::{ + FormatNum, SegmentNum, StreamContainer, StreamSpec, TrackKind, TrackNum, }; use std::{fmt::Write, ops::Range, sync::Arc}; use tokio::{ @@ -19,20 +16,24 @@ use tokio::{ }; pub async fn hls_master_stream( - node: Arc, - _local_tracks: Vec, - segment: u64, - container: StreamContainer, mut b: DuplexStream, + info: Arc, + segment: SegmentNum, + container: StreamContainer, ) -> Result<()> { - let media = node.media.as_ref().ok_or(anyhow!("no media"))?; + let (_iinfo, info) = stream_info(info).await?; + let seg = info + .segments + .get(segment) + .ok_or(anyhow!("segment not found"))?; + let mut out = String::new(); writeln!(out, "#EXTM3U")?; writeln!(out, "#EXT-X-VERSION:4")?; // writeln!(out, "#EXT-X-INDEPENDENT-SEGMENTS")?; - for (i, t) in media.tracks.iter().enumerate() { + for (i, t) in seg.tracks.iter().enumerate() { let uri = format!( - "stream?{}", + "stream{}", StreamSpec::HlsVariant { segment, track: i, @@ -42,10 +43,11 @@ pub async fn hls_master_stream( .to_query() ); let r#type = match t.kind { - SourceTrackKind::Video { .. } => "VIDEO", - SourceTrackKind::Audio { .. } => "AUDIO", - SourceTrackKind::Subtitles => "SUBTITLES", + TrackKind::Video => "VIDEO", + TrackKind::Audio => "AUDIO", + TrackKind::Subtitle => "SUBTITLES", }; + // TODO bw writeln!(out, "#EXT-X-STREAM-INF:BANDWIDTH=5000000,TYPE={type}")?; writeln!(out, "{uri}")?; } @@ -54,42 +56,44 @@ pub async fn hls_master_stream( } pub async fn hls_variant_stream( - node: Arc, - local_tracks: Vec, - segment: u64, - track: usize, - format: usize, - container: StreamContainer, mut b: DuplexStream, + info: Arc, + segment: SegmentNum, + track: TrackNum, + format: FormatNum, + container: StreamContainer, ) -> Result<()> { - let local_track = local_tracks.first().ok_or(anyhow!("no track"))?.to_owned(); - let media_info = node.media.to_owned().ok_or(anyhow!("no media?"))?; + let (iinfo, info) = stream_info(info).await?; + let (file_index, track_num) = *iinfo + .track_to_file + .get(track) + .ok_or(anyhow!("track not found"))?; + let seg = info + .segments + .get(segment) + .ok_or(anyhow!("segment not found"))?; + let frags = spawn_blocking(move || { - jellyremuxer::fragment::fragment_index( - &CONF.media_path, - &node, - &local_track, - track as usize, - ) + jellyremuxer::fragment::fragment_index(&iinfo.paths[file_index], track_num) }) .await??; let mut out = String::new(); writeln!(out, "#EXTM3U")?; writeln!(out, "#EXT-X-PLAYLIST-TYPE:VOD")?; - writeln!(out, "#EXT-X-TARGETDURATION:{}", media_info.duration)?; + writeln!(out, "#EXT-X-TARGETDURATION:{}", seg.duration)?; writeln!(out, "#EXT-X-VERSION:4")?; writeln!(out, "#EXT-X-MEDIA-SEQUENCE:0")?; - for (i, Range { start, end }) in frags.iter().enumerate() { + for (index, Range { start, end }) in frags.iter().enumerate() { writeln!(out, "#EXTINF:{:},", end - start)?; writeln!( out, - "stream?{}", + "stream{}", StreamSpec::Fragment { segment, track, - index: i as u64, + index, container, format, } diff --git a/stream/src/jhls.rs b/stream/src/jhls.rs deleted file mode 100644 index 2a2faec..0000000 --- a/stream/src/jhls.rs +++ /dev/null @@ -1,47 +0,0 @@ -/* - This file is part of jellything (https://codeberg.org/metamuffin/jellything) - which is licensed under the GNU Affero General Public License (version 3); see /COPYING. - Copyright (C) 2025 metamuffin -*/ -use anyhow::{anyhow, Result}; -use jellybase::{ - common::{ - jhls::JhlsTrackIndex, - stream::StreamSpec, - user::{PermissionSet, UserPermission}, - LocalTrack, Node, - }, - permission::PermissionSetExt, - CONF, -}; -use std::sync::Arc; -use tokio::io::{AsyncWriteExt, DuplexStream}; - -pub async fn jhls_index( - node: Arc, - local_tracks: &[LocalTrack], - spec: StreamSpec, - mut b: DuplexStream, - perms: &PermissionSet, -) -> Result<()> { - // let local_track = local_tracks - // .first() - // .ok_or(anyhow!("track missing"))? - // .to_owned(); - - // let fragments = tokio::task::spawn_blocking(move || { - // jellyremuxer::fragment::fragment_index(&CONF.media_path, &node, &local_track, spec.track[0]) - // }) - // .await??; - - // let out = serde_json::to_string(&JhlsTrackIndex { - // extra_profiles: if perms.check(&UserPermission::Transcode) { - // CONF.transcoding_profiles.clone() - // } else { - // vec![] - // }, - // fragments, - // })?; - // tokio::spawn(async move { b.write_all(out.as_bytes()).await }); - Ok(()) -} diff --git a/stream/src/lib.rs b/stream/src/lib.rs index d09759f..a6faf54 100644 --- a/stream/src/lib.rs +++ b/stream/src/lib.rs @@ -5,17 +5,20 @@ */ #![feature(iterator_try_collect)] pub mod fragment; +pub mod fragment_index; pub mod hls; -pub mod jhls; pub mod webvtt; use anyhow::{anyhow, Context, Result}; +use fragment::fragment_stream; +use fragment_index::fragment_index_stream; +use hls::{hls_master_stream, hls_variant_stream}; use jellybase::common::{ stream::{ StreamContainer, StreamFormatInfo, StreamInfo, StreamSegmentInfo, StreamSpec, StreamTrackInfo, TrackKind, }, - LocalTrack, Node, + Node, }; use jellyremuxer::metadata::{matroska_metadata, MatroskaMetadata}; use std::{collections::BTreeSet, io::SeekFrom, ops::Range, path::PathBuf, sync::Arc}; @@ -75,22 +78,26 @@ pub async fn stream( StreamSpec::Remux { tracks, container } => todo!(), StreamSpec::Original { track } => original_stream(info, track, range, b).await?, StreamSpec::HlsSuperMultiVariant { container } => todo!(), - StreamSpec::HlsMultiVariant { segment, container } => todo!(), + StreamSpec::HlsMultiVariant { segment, container } => { + hls_master_stream(b, info, segment, container).await? + } StreamSpec::HlsVariant { segment, track, container, format, - } => todo!(), - StreamSpec::Info { segment } => write_stream_info(info, b).await?, - StreamSpec::FragmentIndex { segment, track } => todo!(), + } => hls_variant_stream(b, info, segment, track, format, container).await?, + StreamSpec::Info { segment: _ } => write_stream_info(info, b).await?, + StreamSpec::FragmentIndex { segment, track } => { + fragment_index_stream(b, info, segment, track).await? + } StreamSpec::Fragment { segment, track, index, container, format, - } => todo!(), + } => fragment_stream(b, info, track, segment, index, format, container).await?, } Ok(a) @@ -103,7 +110,7 @@ async fn async_matroska_metadata(path: PathBuf) -> Result> pub(crate) struct InternalStreamInfo { pub paths: Vec, pub metadata: Vec>, - pub track_to_file: Vec, + pub track_to_file: Vec<(usize, u64)>, } async fn stream_info(info: Arc) -> Result<(InternalStreamInfo, StreamInfo)> { @@ -142,14 +149,19 @@ async fn stream_info(info: Arc) -> Result<(InternalStreamInfo, Strea }, formats, }); - track_to_file.push(i); + track_to_file.push((i, t.track_number)); } } } let segment = StreamSegmentInfo { name: None, - duration: 0, + duration: metadata[0] + .info + .as_ref() + .unwrap() + .duration + .unwrap_or_default(), tracks, }; Ok(( @@ -173,7 +185,6 @@ async fn write_stream_info(info: Arc, mut b: DuplexStream) -> Result async fn remux_stream( node: Arc, - local_tracks: Vec, spec: StreamSpec, range: Range, b: DuplexStream, @@ -202,8 +213,7 @@ async fn original_stream( b: DuplexStream, ) -> Result<()> { let (iinfo, _info) = stream_info(info).await?; - - let file_index = *iinfo + let (file_index, _) = *iinfo .track_to_file .get(track) .ok_or(anyhow!("unknown track"))?; diff --git a/stream/src/webvtt.rs b/stream/src/webvtt.rs index fbd6382..960849c 100644 --- a/stream/src/webvtt.rs +++ b/stream/src/webvtt.rs @@ -6,7 +6,7 @@ use anyhow::{anyhow, Context, Result}; use jellybase::{ cache::async_cache_memory, - common::{stream::StreamSpec, LocalTrack, Node}, + common::{stream::StreamSpec, Node}, CONF, }; use jellyremuxer::extract::extract_track; @@ -17,7 +17,6 @@ use tokio::io::{AsyncWriteExt, DuplexStream}; pub async fn vtt_stream( json: bool, node: Arc, - local_tracks: Vec, spec: StreamSpec, mut b: DuplexStream, ) -> Result<()> { -- cgit v1.2.3-70-g09d2 From 92b119f95dd1cb24054f2440533208c140b66e46 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Mon, 14 Apr 2025 13:52:16 +0200 Subject: fix duration from mkmeta in fragment --- remuxer/src/fragment.rs | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) (limited to 'remuxer/src') diff --git a/remuxer/src/fragment.rs b/remuxer/src/fragment.rs index 73fe046..0da1ed5 100644 --- a/remuxer/src/fragment.rs +++ b/remuxer/src/fragment.rs @@ -5,8 +5,10 @@ */ use crate::{ - ebml_header, ebml_segment_info, ebml_track_entry, metadata::matroska_metadata, - seek_index::get_seek_index, segment_extractor::SegmentExtractIter, + ebml_header, ebml_segment_info, ebml_track_entry, + metadata::{matroska_metadata, MatroskaMetadata}, + seek_index::get_seek_index, + segment_extractor::SegmentExtractIter, }; use anyhow::{anyhow, Context, Result}; use jellymatroska::{read::EbmlReader, write::EbmlWriter, Master, MatroskaTag}; @@ -18,11 +20,11 @@ use std::{ path::Path, }; -const FRAGMENT_LENGTH: f64 = 2.; +const FRAGMENT_LENGTH: f64 = 5.; pub fn fragment_index(path: &Path, track: u64) -> Result>> { let meta = matroska_metadata(path)?; - let duration = meta.info.as_ref().unwrap().duration.unwrap(); + let duration = media_duration(&meta); let force_kf = meta .as_ref() .tracks @@ -87,7 +89,7 @@ pub fn write_fragment_into( n: usize, ) -> anyhow::Result<()> { let meta = matroska_metadata(path)?; - let duration = meta.info.as_ref().unwrap().duration.unwrap(); + let duration = media_duration(&meta); let track_meta = meta .as_ref() .tracks @@ -118,6 +120,7 @@ pub fn write_fragment_into( } else { index.keyframes.len() }; + debug!("{duration} {n_kf}"); let average_kf_interval = duration / n_kf as f64; let kf_per_frag = (FRAGMENT_LENGTH / average_kf_interval).ceil() as usize; debug!("average keyframe interval: {average_kf_interval}"); @@ -209,3 +212,8 @@ pub fn write_fragment_into( debug!("wrote {} bytes", output.position()); Ok(()) } + +fn media_duration(m: &MatroskaMetadata) -> f64 { + let info = m.info.as_ref().unwrap(); + (info.duration.unwrap_or_default() * info.timestamp_scale as f64) / 1_000_000_000. +} -- cgit v1.2.3-70-g09d2 From 39dee6820db4581fa41cfac8bcfdd399a96f5319 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Wed, 16 Apr 2025 00:09:35 +0200 Subject: transcode impl but broken --- common/src/stream.rs | 4 ++-- remuxer/src/lib.rs | 3 +++ remuxer/src/mpeg4.rs | 34 ++++++++++++++++++++++++++++++++++ stream/src/fragment.rs | 32 ++++++++++++++++++++++++-------- stream/src/stream_info.rs | 13 +++++++++---- transcoder/src/fragment.rs | 31 +++++++++++-------------------- web/script/player/mediacaps.ts | 11 ++++++----- web/script/player/track/mse.ts | 20 ++++++++++++++++---- 8 files changed, 105 insertions(+), 43 deletions(-) create mode 100644 remuxer/src/mpeg4.rs (limited to 'remuxer/src') diff --git a/common/src/stream.rs b/common/src/stream.rs index ba91ff5..55f2f49 100644 --- a/common/src/stream.rs +++ b/common/src/stream.rs @@ -209,7 +209,7 @@ impl Display for StreamContainer { StreamContainer::Matroska => "matroska", StreamContainer::WebVTT => "webvtt", StreamContainer::JVTT => "jvtt", - StreamContainer::MPEG4 => "mp4", + StreamContainer::MPEG4 => "mpeg4", }) } } @@ -221,7 +221,7 @@ impl FromStr for StreamContainer { "matroska" => StreamContainer::Matroska, "webvtt" => StreamContainer::WebVTT, "jvtt" => StreamContainer::JVTT, - "mp4" => StreamContainer::MPEG4, + "mpeg4" => StreamContainer::MPEG4, _ => return Err(()), }) } diff --git a/remuxer/src/lib.rs b/remuxer/src/lib.rs index 9ddf7c1..c20197f 100644 --- a/remuxer/src/lib.rs +++ b/remuxer/src/lib.rs @@ -3,9 +3,11 @@ which is licensed under the GNU Affero General Public License (version 3); see /COPYING. Copyright (C) 2025 metamuffin */ +#![feature(random, exit_status_error)] pub mod extract; pub mod fragment; pub mod metadata; +pub mod mpeg4; pub mod remux; pub mod seek_index; pub mod segment_extractor; @@ -14,6 +16,7 @@ pub mod trim_writer; use ebml_struct::matroska::TrackEntry; pub use fragment::write_fragment_into; use jellymatroska::{Master, MatroskaTag}; +pub use mpeg4::matroska_to_mpeg4; pub use remux::remux_stream_into; pub fn ebml_header(webm: bool) -> MatroskaTag { diff --git a/remuxer/src/mpeg4.rs b/remuxer/src/mpeg4.rs new file mode 100644 index 0000000..9e59514 --- /dev/null +++ b/remuxer/src/mpeg4.rs @@ -0,0 +1,34 @@ +/* + This file is part of jellything (https://codeberg.org/metamuffin/jellything) + which is licensed under the GNU Affero General Public License (version 3); see /COPYING. + Copyright (C) 2025 metamuffin +*/ +use anyhow::Result; +use std::{ + fs::{remove_file, File}, + io::{copy, Read, Write}, + process::{Command, Stdio}, + random::random, +}; + +pub fn matroska_to_mpeg4( + mut input: impl Read + Send + 'static, + mut output: impl Write, +) -> Result<()> { + let path = format!("/tmp/jellything-tc-hack-{:016x}", random::()); + let args = format!("-f matroska -i pipe:0 -c copy -map 0 -f mp4 {path}"); + let mut child = Command::new("ffmpeg") + .args(args.split(" ")) + .stdin(Stdio::piped()) + .stderr(Stdio::inherit()) + .spawn()?; + + let mut stdin = child.stdin.take().unwrap(); + copy(&mut input, &mut stdin)?; + drop(stdin); + child.wait()?.exit_ok()?; + copy(&mut File::open(&path)?, &mut output)?; + remove_file(path)?; + + Ok(()) +} diff --git a/stream/src/fragment.rs b/stream/src/fragment.rs index 26746fc..2ce3c78 100644 --- a/stream/src/fragment.rs +++ b/stream/src/fragment.rs @@ -4,8 +4,9 @@ Copyright (C) 2025 metamuffin */ use crate::{stream_info, SMediaInfo}; -use anyhow::{anyhow, Result}; +use anyhow::{anyhow, bail, Result}; use jellybase::common::stream::StreamContainer; +use jellyremuxer::matroska_to_mpeg4; use jellytranscoder::fragment::transcode; use log::warn; use std::sync::Arc; @@ -55,14 +56,13 @@ pub async fn fragment_stream( &format!("{path:?} {track_num} {index} {format_num} {container}"), // TODO maybe not use the entire source track.kind, format, - container, move |b| { tokio::task::spawn_blocking(move || { if let Err(err) = jellyremuxer::write_fragment_into( SyncIoBridge::new(b), &path, track_num, - container == StreamContainer::WebM, + false, &info.name.unwrap_or_default(), index, ) { @@ -72,12 +72,28 @@ pub async fn fragment_stream( }, ) .await?; - let mut output = File::open(location.abs()).await?; - tokio::task::spawn(async move { - if let Err(err) = tokio::io::copy(&mut output, &mut b).await { - warn!("cannot write stream: {err}") + eprintln!("{:?}", location.abs()); + let mut frag = File::open(location.abs()).await?; + match container { + StreamContainer::WebM => {} + StreamContainer::Matroska => { + tokio::task::spawn(async move { + if let Err(err) = tokio::io::copy(&mut frag, &mut b).await { + warn!("cannot write stream: {err}") + } + }); } - }); + StreamContainer::MPEG4 => { + tokio::task::spawn_blocking(move || { + if let Err(err) = + matroska_to_mpeg4(SyncIoBridge::new(frag), SyncIoBridge::new(b)) + { + warn!("mpeg4 transmux failed: {err}"); + } + }); + } + _ => bail!("unsupported"), + } } Ok(()) diff --git a/stream/src/stream_info.rs b/stream/src/stream_info.rs index 43c536a..c3746c6 100644 --- a/stream/src/stream_info.rs +++ b/stream/src/stream_info.rs @@ -79,7 +79,12 @@ fn stream_formats(t: &TrackEntry) -> Vec { codec: t.codec_id.to_string(), remux: true, bitrate: 10_000_000., // TODO - containers: containers_by_codec(&t.codec_id), + containers: { + let mut x = containers_by_codec(&t.codec_id); + // TODO remove this + x.retain_mut(|x| *x != StreamContainer::MPEG4); + x + }, bit_depth: t.audio.as_ref().and_then(|a| a.bit_depth.map(|e| e as u8)), samplerate: t.audio.as_ref().map(|a| a.sampling_frequency), channels: t.audio.as_ref().map(|a| a.channels as usize), @@ -101,8 +106,8 @@ fn stream_formats(t: &TrackEntry) -> Vec { ("V_AV1", CONF.encoders.av1.is_some()), ("V_VP8", CONF.encoders.vp8.is_some()), ("V_VP9", CONF.encoders.vp9.is_some()), - ("V_AVC", CONF.encoders.avc.is_some()), - ("V_HEVC", CONF.encoders.hevc.is_some()), + ("V_MPEG4/ISO/AVC", CONF.encoders.avc.is_some()), + ("V_MPEGH/ISO/HEVC", CONF.encoders.hevc.is_some()), ] { if enable { formats.push(StreamFormatInfo { @@ -146,7 +151,7 @@ fn containers_by_codec(codec: &str) -> Vec { use StreamContainer::*; match codec { "V_VP8" | "V_VP9" | "V_AV1" | "A_OPUS" | "A_VORBIS" => vec![Matroska, WebM], - "V_AVC" | "A_AAC" => vec![Matroska, MPEG4], + "V_MPEG4/ISO/AVC" | "A_AAC" => vec![Matroska, MPEG4], "S_TEXT/UTF8" | "S_TEXT/WEBVTT" => vec![Matroska, WebVTT, WebM, JVTT], _ => vec![Matroska], } diff --git a/transcoder/src/fragment.rs b/transcoder/src/fragment.rs index 1d06e9a..8692423 100644 --- a/transcoder/src/fragment.rs +++ b/transcoder/src/fragment.rs @@ -7,7 +7,7 @@ use crate::LOCAL_VIDEO_TRANSCODING_TASKS; use jellybase::{ cache::{async_cache_file, CachePath}, - common::stream::{StreamContainer, StreamFormatInfo, TrackKind}, + common::stream::{StreamFormatInfo, TrackKind}, CONF, }; use log::{debug, info}; @@ -24,7 +24,6 @@ pub async fn transcode( key: &str, kind: TrackKind, format: &StreamFormatInfo, - container: StreamContainer, input: impl FnOnce(ChildStdin), ) -> anyhow::Result { async_cache_file( @@ -34,8 +33,8 @@ pub async fn transcode( debug!("transcoding fragment with {format:?}"); let template = match format.codec.as_str() { - "V_AVC" => CONF.encoders.avc.as_ref(), - "V_HEVC" => CONF.encoders.hevc.as_ref(), + "V_MPEG4/ISO/AVC" => CONF.encoders.avc.as_ref(), + "V_MPEGH/ISO/HEVC" => CONF.encoders.hevc.as_ref(), "V_VP8" => CONF.encoders.vp8.as_ref(), "V_VP9" => CONF.encoders.vp9.as_ref(), "V_AV1" => CONF.encoders.av1.as_ref(), @@ -57,35 +56,27 @@ pub async fn transcode( }; let fallback_encoder = match format.codec.as_str() { "A_OPUS" => "libopus", - _ => unreachable!(), + "V_MPEG4/ISO/AVC" => "libx264", + "V_MPEGH/ISO/HEVC" => "libx265", + _ => "", }; let args = template .replace("%i", "-f matroska -i pipe:0") - .replace("%o", "-f %C pipe:1") + .replace("%o", "-f matroska pipe:1") .replace("%f", &filter) .replace("%e", "-c:%t %c -b:%t %r") .replace("%t", typechar) .replace("%c", fallback_encoder) - .replace("%r", &(format.bitrate as i64).to_string()) - .replace("%C", &container.to_string()); + .replace("%r", &(format.bitrate as i64).to_string()); info!("encoding with {:?}", args); - let container = match container { - StreamContainer::WebM => "webm", - StreamContainer::Matroska => "matroska", - StreamContainer::WebVTT => "vtt", - StreamContainer::MPEG4 => "mp4", - StreamContainer::JVTT => unreachable!(), - }; - - let mut proc = Command::new("ffmpeg") + let mut args = args.split(" "); + let mut proc = Command::new(args.next().unwrap()) .stdin(Stdio::piped()) .stdout(Stdio::piped()) - .args(["-f", "matroska", "-i", "pipe:0"]) - .args(args.split(" ")) - .args(["-f", container, "pipe:1"]) + .args(args) .spawn()?; let stdin = proc.stdin.take().unwrap(); diff --git a/web/script/player/mediacaps.ts b/web/script/player/mediacaps.ts index 037a84b..29cd64a 100644 --- a/web/script/player/mediacaps.ts +++ b/web/script/player/mediacaps.ts @@ -22,9 +22,9 @@ export async function test_media_capability(format: FormatInfo, container: Strea return r } async function test_media_capability_inner(format: FormatInfo, container: StreamContainer) { - if (format.codec.startsWith("S_") || format.codec.startsWith("V_") || format.codec.startsWith("D_")) { + if (format.codec.startsWith("S_") || format.codec.startsWith("D_")) { // TODO do we need to check this? - return format.codec == "V_TEXT/WEBVTT" || format.codec == "D_WEBVTT/SUBTITLES" + return format.codec == "S_TEXT/WEBVTT" || format.codec == "S_TEXT/UTF8" || format.codec == "D_WEBVTT/SUBTITLES" } let res; if (format.codec.startsWith("A_")) { @@ -50,19 +50,20 @@ async function test_media_capability_inner(format: FormatInfo, container: Stream } }) } - console.log(format, res); return res?.supported ?? false } export function track_to_content_type(format: FormatInfo, container: StreamContainer): string { - return `${CONTAINER_TO_MIME_TYPE[container]}; codecs="${MASTROSKA_CODEC_MAP[format.codec]}"` + let c = CONTAINER_TO_MIME_TYPE[container]; + if (format.codec.startsWith("A_")) c = c.replace("video/", "audio/") + return `${c}; codecs="${MASTROSKA_CODEC_MAP[format.codec]}"` } const MASTROSKA_CODEC_MAP: { [key: string]: string } = { "V_VP9": "vp9", "V_VP8": "vp8", "V_AV1": "av1", - "V_MPEG4/ISO/AVC": "h264", + "V_MPEG4/ISO/AVC": "avc1.4d002a", "V_MPEGH/ISO/HEVC": "h265", "A_OPUS": "opus", "A_VORBIS": "vorbis", diff --git a/web/script/player/track/mse.ts b/web/script/player/track/mse.ts index 9fa5e42..199aa14 100644 --- a/web/script/player/track/mse.ts +++ b/web/script/player/track/mse.ts @@ -4,7 +4,7 @@ Copyright (C) 2025 metamuffin */ import { OVar } from "../../jshelper/mod.ts"; -import { track_to_content_type } from "../mediacaps.ts"; +import { test_media_capability, track_to_content_type } from "../mediacaps.ts"; import { BufferRange, Player } from "../player.ts"; import { PlayerTrack, AppendRange, TARGET_BUFFER_DURATION, MIN_BUFFER_DURATION } from "./mod.ts"; import { e } from "../../jshelper/src/element.ts"; @@ -49,7 +49,19 @@ export class MSEPlayerTrack extends PlayerTrack { } this.buffered.value = [] - this.active_format.value = { usable_index: 0, format_index: 0, container: "webm", format: this.trackinfo.formats[0] } + console.log(this.trackinfo); + + for (let i = 0; i < this.trackinfo.formats.length; i++) { + const format = this.trackinfo.formats[i]; + for (const container of format.containers) { + if (container != "webm" && container != "mpeg4") continue; + if (await test_media_capability(format, container)) + this.usable_formats.push({ container, format, format_index: i, usable_index: this.usable_formats.length }) + } + } + if (!this.usable_formats.length) + return this.player.logger?.log("No availble format is supported by this device. The track can't be played back.") + this.active_format.value = this.usable_formats[0] const ct = track_to_content_type(this.active_format.value!.format, this.active_format.value!.container); this.source_buffer = this.player.media_source.addSourceBuffer(ct); @@ -142,8 +154,8 @@ export class MSEPlayerTrack extends PlayerTrack { this.current_load = frag; // TODO why is appending so unreliable?! sometimes it does not add it this.source_buffer.changeType(track_to_content_type(this.active_format.value!.format, this.active_format.value!.container)); - this.source_buffer.timestampOffset = 0 // TODO send if relative PTS //this.active_format.value !== undefined ? frag.start : 0 - console.log(`append track ${this.track_index}`); + this.source_buffer.timestampOffset = this.active_format.value?.format.remux ? 0 : frag.start + console.log(`append track at ${this.source_buffer.timestampOffset} ${this.trackinfo.kind} ${this.track_index}`); this.source_buffer.appendBuffer(frag.buf); } } -- cgit v1.2.3-70-g09d2 From a9c897c7d7df5509a195055e95dfa821fe7aa274 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Wed, 16 Apr 2025 14:39:27 +0200 Subject: the typical mse problems again... --- remuxer/src/mpeg4.rs | 2 +- transcoder/src/fragment.rs | 8 ++++++-- web/script/player/download.ts | 2 +- web/script/player/mediacaps.ts | 4 ++-- web/script/player/track/mse.ts | 3 ++- 5 files changed, 12 insertions(+), 7 deletions(-) (limited to 'remuxer/src') diff --git a/remuxer/src/mpeg4.rs b/remuxer/src/mpeg4.rs index 9e59514..da66fe2 100644 --- a/remuxer/src/mpeg4.rs +++ b/remuxer/src/mpeg4.rs @@ -16,7 +16,7 @@ pub fn matroska_to_mpeg4( mut output: impl Write, ) -> Result<()> { let path = format!("/tmp/jellything-tc-hack-{:016x}", random::()); - let args = format!("-f matroska -i pipe:0 -c copy -map 0 -f mp4 {path}"); + let args = format!("-f matroska -i pipe:0 -copyts -c copy -f mp4 {path}"); let mut child = Command::new("ffmpeg") .args(args.split(" ")) .stdin(Stdio::piped()) diff --git a/transcoder/src/fragment.rs b/transcoder/src/fragment.rs index 8692423..88a311e 100644 --- a/transcoder/src/fragment.rs +++ b/transcoder/src/fragment.rs @@ -56,19 +56,23 @@ pub async fn transcode( }; let fallback_encoder = match format.codec.as_str() { "A_OPUS" => "libopus", + "V_VP8" => "libvpx", + "V_VP9" => "libvpx-vp9", + "V_AV1" => "libaom", // svtav1 is x86 only :( "V_MPEG4/ISO/AVC" => "libx264", "V_MPEGH/ISO/HEVC" => "libx265", _ => "", }; let args = template - .replace("%i", "-f matroska -i pipe:0") + .replace("%i", "-f matroska -i pipe:0 -copyts") .replace("%o", "-f matroska pipe:1") .replace("%f", &filter) .replace("%e", "-c:%t %c -b:%t %r") .replace("%t", typechar) .replace("%c", fallback_encoder) - .replace("%r", &(format.bitrate as i64).to_string()); + .replace("%r", &(format.bitrate as i64).to_string()) + .replace(" ", " "); info!("encoding with {:?}", args); diff --git a/web/script/player/download.ts b/web/script/player/download.ts index 18f1e8d..8294d2a 100644 --- a/web/script/player/download.ts +++ b/web/script/player/download.ts @@ -20,7 +20,7 @@ export class SegmentDownloader { const dl_start = performance.now(); const res = await fetch(url) const dl_header = performance.now(); - if (!res.ok) throw new Error("aaaaa"); + if (!res.ok) throw new Error("aaaaaa"); const buf = await res.arrayBuffer() const dl_body = performance.now(); diff --git a/web/script/player/mediacaps.ts b/web/script/player/mediacaps.ts index 29cd64a..3c55aa9 100644 --- a/web/script/player/mediacaps.ts +++ b/web/script/player/mediacaps.ts @@ -63,8 +63,8 @@ const MASTROSKA_CODEC_MAP: { [key: string]: string } = { "V_VP9": "vp9", "V_VP8": "vp8", "V_AV1": "av1", - "V_MPEG4/ISO/AVC": "avc1.4d002a", - "V_MPEGH/ISO/HEVC": "h265", + "V_MPEG4/ISO/AVC": "avc1.42C01F", + "V_MPEGH/ISO/HEVC": "hev1.1.6.L93.90", "A_OPUS": "opus", "A_VORBIS": "vorbis", "S_TEXT/WEBVTT": "webvtt", diff --git a/web/script/player/track/mse.ts b/web/script/player/track/mse.ts index 199aa14..6bb77e0 100644 --- a/web/script/player/track/mse.ts +++ b/web/script/player/track/mse.ts @@ -154,7 +154,8 @@ export class MSEPlayerTrack extends PlayerTrack { this.current_load = frag; // TODO why is appending so unreliable?! sometimes it does not add it this.source_buffer.changeType(track_to_content_type(this.active_format.value!.format, this.active_format.value!.container)); - this.source_buffer.timestampOffset = this.active_format.value?.format.remux ? 0 : frag.start + // this.source_buffer.timestampOffset = this.active_format.value?.format.remux ? 0 : frag.start + this.source_buffer.timestampOffset = 0 console.log(`append track at ${this.source_buffer.timestampOffset} ${this.trackinfo.kind} ${this.track_index}`); this.source_buffer.appendBuffer(frag.buf); } -- cgit v1.2.3-70-g09d2 From edfd710c055621d7ef0c8d0e9c6668b4aa2283d7 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Wed, 16 Apr 2025 14:53:58 +0200 Subject: move seek index types to remuxer --- common/src/lib.rs | 1 - common/src/seek_index.rs | 33 --------------------------------- remuxer/src/seek_index.rs | 33 +++++++++++++++++++++++++++++---- web/script/player/track/mse.ts | 1 - 4 files changed, 29 insertions(+), 39 deletions(-) delete mode 100644 common/src/seek_index.rs (limited to 'remuxer/src') diff --git a/common/src/lib.rs b/common/src/lib.rs index 00f07b6..4480db5 100644 --- a/common/src/lib.rs +++ b/common/src/lib.rs @@ -9,7 +9,6 @@ pub mod config; pub mod helpers; pub mod r#impl; pub mod jhls; -pub mod seek_index; pub mod stream; pub mod user; diff --git a/common/src/seek_index.rs b/common/src/seek_index.rs deleted file mode 100644 index 20cf394..0000000 --- a/common/src/seek_index.rs +++ /dev/null @@ -1,33 +0,0 @@ -/* - This file is part of jellything (https://codeberg.org/metamuffin/jellything) - which is licensed under the GNU Affero General Public License (version 3); see /COPYING. - Copyright (C) 2025 metamuffin -*/ -use bincode::{Decode, Encode}; - -pub const SEEK_INDEX_VERSION: u32 = 0x5eef1de4; - -#[derive(Debug, Clone, Decode, Encode)] -pub struct SeekIndex { - pub version: u32, - pub blocks: Vec, - pub keyframes: Vec, -} - -#[derive(Debug, Clone, Decode, Encode)] -pub struct BlockIndex { - pub pts: u64, - // pub duration: Option, - pub source_off: u64, // points to start of SimpleBlock or BlockGroup (not the Block inside it) - pub size: usize, -} - -impl Default for SeekIndex { - fn default() -> Self { - Self { - version: SEEK_INDEX_VERSION, - blocks: Vec::new(), - keyframes: Vec::new(), - } - } -} diff --git a/remuxer/src/seek_index.rs b/remuxer/src/seek_index.rs index bd351d9..7296d93 100644 --- a/remuxer/src/seek_index.rs +++ b/remuxer/src/seek_index.rs @@ -4,10 +4,8 @@ Copyright (C) 2025 metamuffin */ use anyhow::{Context, Result}; -use jellybase::{ - cache::cache_memory, - common::seek_index::{BlockIndex, SeekIndex}, -}; +use bincode::{Decode, Encode}; +use jellybase::cache::cache_memory; use jellymatroska::{ block::Block, read::EbmlReader, @@ -17,6 +15,33 @@ use jellymatroska::{ use log::{debug, info, trace, warn}; use std::{collections::BTreeMap, fs::File, io::BufReader, path::Path, sync::Arc}; +pub const SEEK_INDEX_VERSION: u32 = 0x5eef1de4; + +#[derive(Debug, Clone, Decode, Encode)] +pub struct SeekIndex { + pub version: u32, + pub blocks: Vec, + pub keyframes: Vec, +} + +#[derive(Debug, Clone, Decode, Encode)] +pub struct BlockIndex { + pub pts: u64, + // pub duration: Option, + pub source_off: u64, // points to start of SimpleBlock or BlockGroup (not the Block inside it) + pub size: usize, +} + +impl Default for SeekIndex { + fn default() -> Self { + Self { + version: SEEK_INDEX_VERSION, + blocks: Vec::new(), + keyframes: Vec::new(), + } + } +} + pub fn get_seek_index(path: &Path) -> anyhow::Result>>> { cache_memory(&["seekindex", path.to_str().unwrap()], move || { info!("generating seek index for {path:?}"); diff --git a/web/script/player/track/mse.ts b/web/script/player/track/mse.ts index 6bb77e0..5565a6b 100644 --- a/web/script/player/track/mse.ts +++ b/web/script/player/track/mse.ts @@ -156,7 +156,6 @@ export class MSEPlayerTrack extends PlayerTrack { this.source_buffer.changeType(track_to_content_type(this.active_format.value!.format, this.active_format.value!.container)); // this.source_buffer.timestampOffset = this.active_format.value?.format.remux ? 0 : frag.start this.source_buffer.timestampOffset = 0 - console.log(`append track at ${this.source_buffer.timestampOffset} ${this.trackinfo.kind} ${this.track_index}`); this.source_buffer.appendBuffer(frag.buf); } } -- cgit v1.2.3-70-g09d2 From cdf95d7b80bd2b78895671da8f462145bb5db522 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Wed, 16 Apr 2025 17:24:08 +0200 Subject: webm and mpeg4 fragments semi fixed --- remuxer/src/lib.rs | 5 ++- remuxer/src/matroska_to_mpeg4.rs | 36 +++++++++++++++++ remuxer/src/matroska_to_webm.rs | 84 ++++++++++++++++++++++++++++++++++++++++ remuxer/src/mpeg4.rs | 34 ---------------- stream/src/fragment.rs | 14 +++++-- web/script/jshelper | 2 +- 6 files changed, 135 insertions(+), 40 deletions(-) create mode 100644 remuxer/src/matroska_to_mpeg4.rs create mode 100644 remuxer/src/matroska_to_webm.rs delete mode 100644 remuxer/src/mpeg4.rs (limited to 'remuxer/src') diff --git a/remuxer/src/lib.rs b/remuxer/src/lib.rs index c20197f..931d5e6 100644 --- a/remuxer/src/lib.rs +++ b/remuxer/src/lib.rs @@ -7,16 +7,17 @@ pub mod extract; pub mod fragment; pub mod metadata; -pub mod mpeg4; +pub mod matroska_to_mpeg4; pub mod remux; pub mod seek_index; pub mod segment_extractor; pub mod trim_writer; +pub mod matroska_to_webm; use ebml_struct::matroska::TrackEntry; pub use fragment::write_fragment_into; use jellymatroska::{Master, MatroskaTag}; -pub use mpeg4::matroska_to_mpeg4; +pub use matroska_to_mpeg4::matroska_to_mpeg4; pub use remux::remux_stream_into; pub fn ebml_header(webm: bool) -> MatroskaTag { diff --git a/remuxer/src/matroska_to_mpeg4.rs b/remuxer/src/matroska_to_mpeg4.rs new file mode 100644 index 0000000..e8268e7 --- /dev/null +++ b/remuxer/src/matroska_to_mpeg4.rs @@ -0,0 +1,36 @@ +/* + This file is part of jellything (https://codeberg.org/metamuffin/jellything) + which is licensed under the GNU Affero General Public License (version 3); see /COPYING. + Copyright (C) 2025 metamuffin +*/ +use anyhow::Result; +use std::{ + fs::{remove_file, File}, + io::{copy, Read, Write}, + process::{Command, Stdio}, + random::random, +}; + +pub fn matroska_to_mpeg4( + mut input: impl Read + Send + 'static, + mut output: impl Write, +) -> Result<()> { + let path = format!("/tmp/jellything-tc-hack-{:016x}", random::()); + let args = format!( + "-hide_banner -loglevel warning -f matroska -i pipe:0 -copyts -c copy -f mp4 -movflags frag_keyframe+empty_moov {path}" + ); + let mut child = Command::new("ffmpeg") + .args(args.split(" ")) + .stdin(Stdio::piped()) + .stderr(Stdio::inherit()) + .spawn()?; + + let mut stdin = child.stdin.take().unwrap(); + copy(&mut input, &mut stdin)?; + drop(stdin); + child.wait()?.exit_ok()?; + copy(&mut File::open(&path)?, &mut output)?; + remove_file(path)?; + + Ok(()) +} diff --git a/remuxer/src/matroska_to_webm.rs b/remuxer/src/matroska_to_webm.rs new file mode 100644 index 0000000..b9a1819 --- /dev/null +++ b/remuxer/src/matroska_to_webm.rs @@ -0,0 +1,84 @@ +use crate::ebml_track_entry; +use anyhow::Context; +use ebml_struct::{ + ids::*, + matroska::{Cluster, Ebml, Info, Tracks}, + read::{EbmlReadExt, TagRead}, + write::TagWrite, +}; +use jellymatroska::{read::EbmlReader, write::EbmlWriter, Master, MatroskaTag}; +use log::warn; +use std::io::{BufReader, BufWriter, ErrorKind, Read, Seek, Write}; + +pub fn matroska_to_webm( + input: impl Read + Seek + 'static, + output: impl Write, +) -> anyhow::Result<()> { + let mut output = EbmlWriter::new(BufWriter::new(output), 0); + let mut input = EbmlReader::new(BufReader::new(input)); + + Ebml { + ebml_version: 1, + ebml_read_version: 1, + ebml_max_id_length: 4, + ebml_max_size_length: 8, + doc_type: "webm".to_string(), + doc_type_version: 4, + doc_type_read_version: 2, + doc_type_extensions: vec![], + } + .write(&mut output)?; + output.write_tag(&MatroskaTag::Segment(Master::Start))?; + + let (x, mut ebml) = input.read_tag()?; + assert_eq!(x, EL_EBML); + let ebml = Ebml::read(&mut ebml).unwrap(); + assert!(ebml.doc_type == "matroska" || ebml.doc_type == "webm"); + let (x, mut segment) = input.read_tag()?; + assert_eq!(x, EL_SEGMENT); + + loop { + let (x, mut seg) = match segment.read_tag() { + Ok(o) => o, + Err(e) if e.kind() == ErrorKind::UnexpectedEof => break, + Err(e) => return Err(e.into()), + }; + match x { + EL_INFO => { + let info = Info::read(&mut seg).context("info")?; + output.write_tag(&{ + MatroskaTag::Info(Master::Collected(vec![ + MatroskaTag::TimestampScale(info.timestamp_scale), + MatroskaTag::Duration(info.duration.unwrap_or_default()), + MatroskaTag::Title(info.title.unwrap_or_default()), + MatroskaTag::MuxingApp("jellyremux".to_string()), + MatroskaTag::WritingApp("jellything".to_string()), + ])) + })?; + } + EL_TRACKS => { + let tracks = Tracks::read(&mut seg).context("tracks")?; + output.write_tag(&MatroskaTag::Tracks(Master::Collected( + tracks + .entries + .into_iter() + .map(|t| ebml_track_entry(t.track_number, &t)) + .collect(), + )))?; + } + EL_VOID | EL_CRC32 | EL_CUES | EL_SEEKHEAD | EL_ATTACHMENTS | EL_TAGS => { + seg.consume()?; + } + EL_CLUSTER => { + let cluster = Cluster::read(&mut seg).context("cluster")?; + // TODO mixing both ebml libraries :))) + cluster.write(&mut output)?; + } + id => { + warn!("unknown top-level element {id:x}"); + seg.consume()?; + } + } + } + Ok(()) +} diff --git a/remuxer/src/mpeg4.rs b/remuxer/src/mpeg4.rs deleted file mode 100644 index da66fe2..0000000 --- a/remuxer/src/mpeg4.rs +++ /dev/null @@ -1,34 +0,0 @@ -/* - This file is part of jellything (https://codeberg.org/metamuffin/jellything) - which is licensed under the GNU Affero General Public License (version 3); see /COPYING. - Copyright (C) 2025 metamuffin -*/ -use anyhow::Result; -use std::{ - fs::{remove_file, File}, - io::{copy, Read, Write}, - process::{Command, Stdio}, - random::random, -}; - -pub fn matroska_to_mpeg4( - mut input: impl Read + Send + 'static, - mut output: impl Write, -) -> Result<()> { - let path = format!("/tmp/jellything-tc-hack-{:016x}", random::()); - let args = format!("-f matroska -i pipe:0 -copyts -c copy -f mp4 {path}"); - let mut child = Command::new("ffmpeg") - .args(args.split(" ")) - .stdin(Stdio::piped()) - .stderr(Stdio::inherit()) - .spawn()?; - - let mut stdin = child.stdin.take().unwrap(); - copy(&mut input, &mut stdin)?; - drop(stdin); - child.wait()?.exit_ok()?; - copy(&mut File::open(&path)?, &mut output)?; - remove_file(path)?; - - Ok(()) -} diff --git a/stream/src/fragment.rs b/stream/src/fragment.rs index 2ce3c78..dfe101e 100644 --- a/stream/src/fragment.rs +++ b/stream/src/fragment.rs @@ -6,7 +6,7 @@ use crate::{stream_info, SMediaInfo}; use anyhow::{anyhow, bail, Result}; use jellybase::common::stream::StreamContainer; -use jellyremuxer::matroska_to_mpeg4; +use jellyremuxer::{matroska_to_mpeg4, matroska_to_webm::matroska_to_webm}; use jellytranscoder::fragment::transcode; use log::warn; use std::sync::Arc; @@ -72,10 +72,18 @@ pub async fn fragment_stream( }, ) .await?; - eprintln!("{:?}", location.abs()); + let mut frag = File::open(location.abs()).await?; match container { - StreamContainer::WebM => {} + StreamContainer::WebM => { + tokio::task::spawn_blocking(move || { + if let Err(err) = + matroska_to_webm(SyncIoBridge::new(frag), SyncIoBridge::new(b)) + { + warn!("webm transmux failed: {err}"); + } + }); + } StreamContainer::Matroska => { tokio::task::spawn(async move { if let Err(err) = tokio::io::copy(&mut frag, &mut b).await { diff --git a/web/script/jshelper b/web/script/jshelper index b2bcdcc..ef36d50 160000 --- a/web/script/jshelper +++ b/web/script/jshelper @@ -1 +1 @@ -Subproject commit b2bcdcc99e42015085b4d0d63e7c94b2d4f84e24 +Subproject commit ef36d50d7858a56cbc08bfb4f272bab9476bb977 -- cgit v1.2.3-70-g09d2