/* 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) 2023 metamuffin */ pub mod seek_index; use anyhow::{anyhow, bail, Result}; use jellycommon::{LocalTrack, SourceTrack, SourceTrackKind}; use jellymatroska::{ matroska::MatroskaTag, read::EbmlReader, unflatten::{IterWithPos, Unflat, Unflatten}, }; use log::{debug, error, info, warn}; use std::path::PathBuf; #[derive(Default)] pub struct MatroskaMetadata { pub title: Option, pub description: Option, pub tagline: Option, pub tracks: Vec, pub track_sources: Vec, pub image: Option<(String, Vec)>, pub duration: f64, } pub fn import_metadata(input: &mut EbmlReader) -> Result { let mut m = None; while let Some(item) = input.next() { let item = match item { Ok(item) => item, Err(e) => { warn!("{e}"); break; } }; match item { MatroskaTag::Ebml(_) => { let mut iter = Unflatten::new_with_end(input, item); while let Some(Ok(Unflat { children: _, item, .. })) = iter.n() { match item { MatroskaTag::DocType(t) => { if !matches!(t.as_str(), "matroska" | "webm") { error!("file is neither matroska nor webm but {:?}", t) } } _ => debug!("(re) tag ignored: {item:?}"), } } } MatroskaTag::Segment(_) => { info!("segment start"); let mut children = Unflatten::new_with_end(input, item); m = Some(import_read_segment(&mut children)?); info!("segment end"); } _ => debug!("(r) tag ignored: {item:?}"), } } Ok(m.ok_or(anyhow!("no segment"))?) } fn import_read_segment(segment: &mut Unflatten) -> Result { let (mut timestamp_scale, mut duration) = (None, None); let mut m = MatroskaMetadata::default(); while let Some(Ok(Unflat { children, item, .. })) = segment.n() { match item { MatroskaTag::SeekHead(_) => {} MatroskaTag::Info(_) => { let mut children = children.unwrap(); while let Some(Ok(Unflat { children: _, item, .. })) = children.n() { match item { MatroskaTag::Title(t) => m.title = Some(t), MatroskaTag::TimestampScale(v) => timestamp_scale = Some(v), MatroskaTag::Duration(v) => duration = Some(v), _ => debug!("(rsi) tag ignored: {item:?}"), } } } MatroskaTag::Tags(_) => { let mut children = children.unwrap(); while let Some(Ok(Unflat { children, item, .. })) = children.n() { match item { MatroskaTag::Tag(_) => { let mut children = children.unwrap(); while let Some(Ok(Unflat { children, item, .. })) = children.n() { match item { MatroskaTag::SimpleTag(_) => { let (mut key, mut value) = (None, None); let mut children = children.unwrap(); while let Some(Ok(Unflat { children: _, item, .. })) = children.n() { match item { MatroskaTag::TagName(k) => key = Some(k), MatroskaTag::TagString(v) => value = Some(v), _ => debug!("(rstts) tag ignored: {item:?}"), } } match (key, value) { (Some(key), Some(value)) => match key.as_str() { "DESCRIPTION" => m.description = Some(value), "COMMENT" => m.tagline = Some(value), _ => debug!("simple tag ignored: {key:?}"), }, (None, None) => (), _ => warn!("simple tag with only one of name/string"), } } _ => debug!("(rstt) tag ignored: {item:?}"), } } } _ => debug!("(rst) tag ignored: {item:?}"), } } } MatroskaTag::Cues(_) => {} MatroskaTag::Chapters(_) => {} MatroskaTag::Tracks(_) => { let mut children = children.unwrap(); while let Some(Ok(Unflat { children, item, .. })) = children.n() { match item { MatroskaTag::TrackEntry(_) => { let mut children = children.unwrap(); let ( mut index, mut language, mut codec, mut kind, mut sample_rate, mut channels, mut width, mut height, mut name, mut fps, mut bit_depth, mut codec_private, mut default_duration, ) = ( None, None, None, None, None, None, None, None, None, None, None, None, None, ); while let Some(Ok(Unflat { children, item, .. })) = children.n() { match item { MatroskaTag::CodecID(b) => codec = Some(b), MatroskaTag::Language(v) => language = Some(v), MatroskaTag::TrackNumber(v) => index = Some(v), MatroskaTag::TrackType(v) => kind = Some(v), MatroskaTag::Name(v) => name = Some(v), MatroskaTag::CodecPrivate(v) => codec_private = Some(v), MatroskaTag::DefaultDuration(v) => default_duration = Some(v), MatroskaTag::Audio(_) => { let mut children = children.unwrap(); while let Some(Ok(Unflat { item, .. })) = children.n() { match item { MatroskaTag::Channels(v) => { channels = Some(v as usize) } MatroskaTag::SamplingFrequency(v) => { sample_rate = Some(v) } MatroskaTag::BitDepth(v) => bit_depth = Some(v), _ => (), } } } MatroskaTag::Video(_) => { let mut children = children.unwrap(); while let Some(Ok(Unflat { item, .. })) = children.n() { match item { MatroskaTag::PixelWidth(v) => width = Some(v), MatroskaTag::PixelHeight(v) => height = Some(v), MatroskaTag::FrameRate(v) => fps = Some(v), _ => (), } } } _ => (), } } let track_index = index.unwrap(); let kind = match kind.ok_or(anyhow!("track type required"))? { 1 => SourceTrackKind::Video { fps: fps.unwrap_or(0.0), // TODO width: width.unwrap(), height: height.unwrap(), }, 2 => SourceTrackKind::Audio { bit_depth: bit_depth.unwrap_or(0) as usize, // TODO channels: channels.unwrap(), sample_rate: sample_rate.unwrap(), }, 17 => SourceTrackKind::Subtitles, _ => bail!("invalid track type"), }; m.tracks.push(SourceTrack { default_duration, name: name.unwrap_or_else(|| "unnamed".to_string()), codec: codec.unwrap(), language: language.unwrap_or_else(|| "none".to_string()), kind, }); m.track_sources.push(LocalTrack { track: track_index as usize, path: PathBuf::new(), codec_private, }) } _ => debug!("(rst) tag ignored: {item:?}"), } } } MatroskaTag::Cluster(_) => {} _ => debug!("(rs) tag ignored: {item:?}"), }; } if let Some(duration) = duration { m.duration = (duration * timestamp_scale.unwrap_or(1_000_000) as f64) / 1_000_000_000_f64; } Ok(m) }