From 617a3cea3ba6a7fbad366b7e834109d9648376cc Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 21:51:32 +0100 Subject: [PATCH] Add craft-media-source: MediaSource, open_bytes, and open_reader (#1891) --- Cargo.lock | 14 + Cargo.toml | 1 + crates/media-source/Cargo.toml | 23 ++ crates/media-source/src/lib.rs | 563 +++++++++++++++++++++++++++++++++ 4 files changed, 601 insertions(+) create mode 100644 crates/media-source/Cargo.toml create mode 100644 crates/media-source/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 9275d4646..8679e4eac 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2281,6 +2281,20 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-media-source" +version = "0.1.0" +dependencies = [ + "craft-audio", + "craft-color", + "craft-frame", + "craft-media", + "craft-time", + "serde", + "serde_json", + "thiserror 2.0.21", +] + [[package]] name = "craft-media-testkit" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index bdcb8201d..c8ae36287 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -119,6 +119,7 @@ craft-macho = { path = "crates/macho" } craft-math = { path = "crates/math" } # No default features: craft-audio turns on the craft-media modules each of its features needs. craft-media = { path = "crates/media", default-features = false } +craft-media-source = { path = "crates/media-source" } craft-materialx = { path = "crates/materialx" } craft-media-testkit = { path = "crates/media-testkit" } craft-midi = { path = "crates/midi" } diff --git a/crates/media-source/Cargo.toml b/crates/media-source/Cargo.toml new file mode 100644 index 000000000..3edda0b2e --- /dev/null +++ b/crates/media-source/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "craft-media-source" +description = "Compositor MediaSource trait and a pluggable open_bytes / open_reader registry" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +craft-audio = { workspace = true } +craft-color = { workspace = true } +craft-frame = { workspace = true } +craft-media = { workspace = true } +craft-time = { workspace = true } +serde = { workspace = true } +thiserror = { workspace = true } + +[dev-dependencies] +serde_json = { workspace = true } diff --git a/crates/media-source/src/lib.rs b/crates/media-source/src/lib.rs new file mode 100644 index 000000000..c27aea688 --- /dev/null +++ b/crates/media-source/src/lib.rs @@ -0,0 +1,563 @@ +//! Compositor media sources and a pluggable opener registry. +//! +//! This crate is the EffectCraft / FilmCraft opener hub: a [`MediaSource`] yields compositor +//! [`VideoFrame`]s and [`AudioBuffer`]s, and [`open_bytes`] / [`open_reader`] try caller-supplied +//! openers in order. It lives in its own crate rather than `craft-media` so it can depend on +//! `craft-audio` without a cycle (`craft-audio` already depends on `craft-media`). +//! +//! Built-in still-image, WAV, and generator openers stay in the apps. [`open_bytes`] only runs the +//! `extra` openers; [`open_reader`] tries `reader_openers` and otherwise reads the file whole +//! (up to `max_whole`) and falls back to [`open_bytes`]. Container sources register themselves +//! from later PRs. +//! +//! [`SharedSource`] is `Arc`. It is not `craft_audio::SharedSource`, which is a +//! `ByteSource` marker used by the audio decoder. + +#![cfg_attr(not(test), deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable))] + +use std::io; +use std::path::Path; +use std::sync::Arc; + +use craft_audio::AudioBuffer; +use craft_color::{ColorInfo, HdrMetadata}; +use craft_frame::VideoFrame; +use craft_media::ByteSource; +use craft_time::{FrameRate, Tick}; +use serde::{Deserialize, Serialize}; + +/// Errors from opening or reading a media source. +#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq)] +pub enum MediaError { + #[error("unsupported media: {0}")] + Unsupported(String), + #[error("I/O error: {0}")] + Io(String), + #[error("decode error: {0}")] + Decode(String), + #[error("no {0} stream")] + NoStream(&'static str), + #[error("media offline: {0}")] + Offline(String), + /// The request was cancelled. + #[error("cancelled")] + Cancelled, +} + +impl From for MediaError { + fn from(e: io::Error) -> Self { + MediaError::Io(e.to_string()) + } +} + +pub type Result = std::result::Result; + +/// Kind of media a source reports. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub enum MediaKind { + /// Video, possibly with audio. + Movie, + AudioOnly, + Still, + ImageSequence, + Synthetic, +} + +/// Video stream metadata a source reports. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct VideoStreamInfo { + pub width: u32, + pub height: u32, + pub frame_rate: FrameRate, + pub par: (u32, u32), + pub codec: String, + pub pixel_format: String, + pub color: ColorInfo, + pub has_alpha: bool, + /// Bitrate in bits/s when known. + pub bitrate: Option, + /// HDR static metadata when the file carries it. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub hdr: Option, +} + +/// Most audio streams a source reports (the count comes from the file: never trusted). +pub const MAX_AUDIO_STREAMS: usize = 64; + +/// Audio stream metadata a source reports. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct AudioStreamInfo { + pub sample_rate: u32, + pub channels: u32, + pub codec: String, + pub bits_per_sample: Option, +} + +/// Identity and streams of an open source. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct MediaInfo { + pub name: String, + pub kind: MediaKind, + /// Media duration. Stills typically report a default duration chosen by the app. + pub duration: Tick, + pub video: Option, + /// Every audio stream the container carries, in file order. Stream 0 is the one + /// [`MediaSource::audio`] reads; the others are read with [`MediaSource::audio_stream`]. + /// Project files written before multi-stream support hold a single `audio` object (or + /// `null`): both still load. + #[serde(default, alias = "audio", deserialize_with = "deserialize_audio_streams")] + pub audio_streams: Vec, + pub container: String, + /// Timecode of the first frame (in frames at `video.frame_rate`), if the file carries one. + pub start_timecode: Option, + pub file_size: Option, +} + +/// Reads `audio_streams` from a list, or from the single optional stream older project files wrote. +fn deserialize_audio_streams<'de, D: serde::Deserializer<'de>>(d: D) -> std::result::Result, D::Error> { + struct StreamsVisitor; + struct RejectExtra; + impl<'de> serde::de::DeserializeSeed<'de> for RejectExtra { + type Value = (); + fn deserialize>(self, _d: D) -> std::result::Result<(), D::Error> { + Err(serde::de::Error::custom("audio stream count exceeds MAX_AUDIO_STREAMS")) + } + } + impl<'de> serde::de::Visitor<'de> for StreamsVisitor { + type Value = Vec; + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("at most 64 audio streams, a legacy audio object, or null") + } + fn visit_unit(self) -> std::result::Result { + Ok(Vec::new()) + } + fn visit_none(self) -> std::result::Result { + Ok(Vec::new()) + } + fn visit_map>(self, map: A) -> std::result::Result { + AudioStreamInfo::deserialize(serde::de::value::MapAccessDeserializer::new(map)).map(|stream| vec![stream]) + } + fn visit_seq>(self, mut seq: A) -> std::result::Result { + let mut streams = Vec::new(); + // Do not reserve from an untrusted size hint or buffer an untagged sequence. + while streams.len() < MAX_AUDIO_STREAMS { + let Some(stream) = seq.next_element()? else { return Ok(streams) }; + streams.push(stream); + } + // Detect an excess entry without deserializing or allocating its contents. + seq.next_element_seed(RejectExtra)?; + Ok(streams) + } + } + d.deserialize_any(StreamsVisitor) +} + +impl MediaInfo { + pub fn frame_rate(&self) -> FrameRate { + self.video.as_ref().map(|v| v.frame_rate).unwrap_or_default() + } + pub fn has_video(&self) -> bool { + self.video.is_some() + } + pub fn has_audio(&self) -> bool { + !self.audio_streams.is_empty() + } + /// The primary audio stream (stream 0), the one [`MediaSource::audio`] reads. + pub fn audio(&self) -> Option<&AudioStreamInfo> { + self.audio_streams.first() + } +} + +/// A request for a video frame. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct FrameRequest { + /// Media time. + pub time: Tick, + /// Desired scale relative to full resolution (1.0 = full). Sources may return a larger frame. + pub scale: f32, +} + +impl FrameRequest { + pub fn full(time: Tick) -> Self { + Self { time, scale: 1.0 } + } +} + +/// A decoded or generated media source that can yield compositor frames and audio. +pub trait MediaSource: Send + Sync { + fn info(&self) -> &MediaInfo; + /// The frame displayed at media time `req.time`. + fn video_frame(&self, req: FrameRequest) -> Result>; + /// `frames` audio frames starting at sample index `start` (at `sample_rate`, media time). + fn audio(&self, start: i64, frames: usize, sample_rate: u32) -> Result; + /// Like [`audio`](Self::audio) for audio stream `stream` (an index into + /// [`MediaInfo::audio_streams`]). Sources with a single audio stream need not override this: + /// stream 0 is `audio`, any other index is [`MediaError::NoStream`]. + fn audio_stream(&self, stream: usize, start: i64, frames: usize, sample_rate: u32) -> Result { + if stream == 0 { self.audio(start, frames, sample_rate) } else { Err(MediaError::NoStream("audio")) } + } +} + +/// Shared compositor source. Distinct from [`craft_audio::SharedSource`], a `ByteSource` marker. +pub type SharedSource = Arc; + +/// Random-access bytes used by [`open_reader`]. +pub type SharedBytes = Arc; + +/// File extensions recognised at import (the media browser filters on these). +pub const STILL_EXTENSIONS: &[&str] = &["png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "tga", "dpx", "exr", "hdr", "dng"]; +pub const AUDIO_EXTENSIONS: &[&str] = &["wav", "wave", "bwf", "aif", "aiff", "mp3", "mp2", "m4a", "aac", "flac", "ogg", "opus"]; +pub const VIDEO_EXTENSIONS: &[&str] = &[ + "mp4", "m4v", "mov", "mkv", "webm", "avi", "mxf", "mts", "m2ts", "m2t", "ts", "mpg", "mpeg", "vob", "mod", "tod", "m2v", "m1v", "mpv", "3gp", + "y4m", "apv", +]; + +/// True when `path` has a still, audio, or video extension we recognise, ignoring case. +pub fn is_importable(path: &Path) -> bool { + let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase(); + STILL_EXTENSIONS.contains(&ext.as_str()) || AUDIO_EXTENSIONS.contains(&ext.as_str()) || VIDEO_EXTENSIONS.contains(&ext.as_str()) +} + +/// A pluggable in-memory opener. Returns `None` when the format is not this opener's. +pub type Opener = fn(name: &str, bytes: Arc<[u8]>) -> Option>; + +/// Opens a container from a reader: `head` is the first bytes of the file (for sniffing). +/// Returns `None` when the format is not this opener's. +pub type ReaderOpener = fn(name: &str, head: &[u8], reader: &SharedBytes) -> Option>; + +/// Bytes sniffed by [`open_reader`]. +pub const HEAD_LEN: usize = 64 * 1024; + +/// Default ceiling for a whole-file fallback or an offline output buffer (256 MiB). +/// Streaming openers are tried first. Use open_reader_within for an explicit different file budget. +pub const DEFAULT_MAX_MEDIA_BYTES: usize = 256 << 20; + +fn allocate(len: usize, max_bytes: usize) -> io::Result> { + if len.checked_mul(std::mem::size_of::()).is_none_or(|bytes| bytes > max_bytes || bytes > isize::MAX as usize) { + return Err(io::Error::new(io::ErrorKind::InvalidData, "media buffer exceeds allocation limit")); + } + let mut out = Vec::new(); + out.try_reserve_exact(len).map_err(|e| io::Error::other(format!("cannot allocate media buffer: {e}")))?; + out.resize(len, T::default()); + Ok(out) +} + +fn io_named(name: &str, e: io::Error) -> MediaError { + MediaError::Io(format!("{name}: {e}")) +} + +/// Read `len` bytes at `offset` (fewer at the end of the source). +pub fn read_range(r: &dyn ByteSource, offset: u64, len: usize) -> io::Result> { + read_range_within(r, offset, len, DEFAULT_MAX_MEDIA_BYTES) +} + +fn read_range_within(r: &dyn ByteSource, offset: u64, len: usize, max_bytes: usize) -> io::Result> { + let n = usize::try_from(r.len().saturating_sub(offset).min(len as u64)) + .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "media length is not representable"))?; + let mut v = allocate(n, max_bytes)?; + r.read_at(offset, &mut v)?; + Ok(v) +} + +/// Open media from bytes by trying `extra` openers in order. There is no built-in fallback: +/// stills, WAV, and generators stay in the apps and register here. +pub fn open_bytes(name: &str, bytes: Arc<[u8]>, extra: &[Opener]) -> Result { + for o in extra { + if let Some(r) = o(name, bytes.clone()) { + return r; + } + } + Err(MediaError::Unsupported(format!("{name}: unrecognised format"))) +} + +/// Open media from a reader: `reader_openers` first; otherwise read the whole file (if it fits in +/// `max_whole`) and use [`open_bytes`] with `extra`. +pub fn open_reader(name: &str, reader: SharedBytes, reader_openers: &[ReaderOpener], extra: &[Opener]) -> Result { + open_reader_within(name, reader, reader_openers, extra, DEFAULT_MAX_MEDIA_BYTES as u64) +} + +/// Like [`open_reader`], but a file no reader opener takes is read whole only up to `max_whole` +/// bytes; a larger one is refused instead. For looking at files rather than importing them: +/// reading a multi-gigabyte file into memory to show its duration, or to find out it isn't +/// supported, thrashes the disk. +pub fn open_reader_within( + name: &str, + reader: SharedBytes, + reader_openers: &[ReaderOpener], + extra: &[Opener], + max_whole: u64, +) -> Result { + let head = read_range(&*reader, 0, HEAD_LEN).map_err(|e| io_named(name, e))?; + for o in reader_openers { + if let Some(r) = o(name, &head, &reader) { + return r; + } + } + if extra.is_empty() { + return Err(MediaError::Unsupported(format!("{name}: unrecognised format"))); + } + if reader.len() > max_whole { + return Err(MediaError::Unsupported(format!("{name}: no streaming reader for this format, and it is too large to read whole here"))); + } + let len = usize::try_from(reader.len()).map_err(|_| MediaError::Unsupported(format!("{name}: media length is not representable")))?; + let budget = usize::try_from(max_whole).unwrap_or(usize::MAX); + let all = read_range_within(&*reader, 0, len, budget).map_err(|e| io_named(name, e))?; + open_bytes(name, all.into(), extra) +} + +/// Open a regular file through the shared pooled FileReader. Non-files (including FIFOs) +/// are refused without a blocking open, using the same contract as other media readers. +#[cfg(not(target_arch = "wasm32"))] +pub fn open_path(path: &Path, reader_openers: &[ReaderOpener], extra: &[Opener]) -> Result { + let file = craft_media::FileReader::open(path).map_err(|e| MediaError::Io(format!("{}: {e}", path.display())))?; + let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(); + open_reader(&name, Arc::new(file), reader_openers, extra) +} + +fn audio_channels(info: &MediaInfo) -> u16 { + info.audio().map_or(2, |a| u16::try_from(a.channels).unwrap_or(u16::MAX).max(1)) +} + +/// A source that renders a solid slate (used for offline media). +pub struct OfflineSource { + pub info: MediaInfo, +} + +impl MediaSource for OfflineSource { + fn info(&self) -> &MediaInfo { + &self.info + } + fn video_frame(&self, req: FrameRequest) -> Result> { + let v = self.info.video.as_ref().ok_or(MediaError::NoStream("video"))?; + if !req.scale.is_finite() || req.scale <= 0.0 || v.width == 0 || v.height == 0 { + return Err(MediaError::Decode("invalid offline frame dimensions or scale".into())); + } + let s = req.scale.clamp(0.02, 1.0); + let (w, h) = (((v.width as f32 * s) as u32).max(2), ((v.height as f32 * s) as u32).max(2)); + let samples = usize::try_from(w) + .ok() + .and_then(|w| usize::try_from(h).ok().and_then(|h| w.checked_mul(h))) + .and_then(|pixels| pixels.checked_mul(4)) + .ok_or_else(|| MediaError::Decode("offline frame dimensions overflow".into()))?; + let mut px = allocate::(samples, DEFAULT_MAX_MEDIA_BYTES)?; + for p in px.as_chunks_mut::<4>().0 { + p.copy_from_slice(&[140, 16, 16, 255]); + } + Ok(Arc::new(VideoFrame::rgba8(w, h, px).map_err(|e| MediaError::Decode(e.to_string()))?.with_pts(req.time))) + } + fn audio(&self, _start: i64, frames: usize, sample_rate: u32) -> Result { + let channels = usize::from(audio_channels(&self.info)); + let bytes = frames + .checked_mul(channels) + .and_then(|n| n.checked_mul(std::mem::size_of::())) + .ok_or_else(|| MediaError::Decode("offline audio dimensions overflow".into()))?; + if bytes > DEFAULT_MAX_MEDIA_BYTES { + return Err(MediaError::Decode("offline audio exceeds allocation limit".into())); + } + let mut planes = Vec::new(); + planes.try_reserve_exact(channels).map_err(|e| MediaError::Io(e.to_string()))?; + for _ in 0..channels { + planes.push(allocate::(frames, DEFAULT_MAX_MEDIA_BYTES)?); + } + Ok(AudioBuffer { sample_rate, channels: planes }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn silent(name: &str, kind: MediaKind) -> OfflineSource { + OfflineSource { + info: MediaInfo { + name: name.into(), + kind, + duration: Tick::from_seconds_f64(1.0), + video: Some(VideoStreamInfo { + width: 16, + height: 8, + frame_rate: FrameRate::FPS_24, + par: (1, 1), + codec: "slate".into(), + pixel_format: "rgba8".into(), + color: ColorInfo::default(), + has_alpha: false, + bitrate: None, + hdr: None, + }), + audio_streams: vec![AudioStreamInfo { sample_rate: 48000, channels: 2, codec: "pcm".into(), bits_per_sample: Some(32) }], + container: "none".into(), + start_timecode: None, + file_size: None, + }, + } + } + + fn accept_ok(name: &str, _bytes: Arc<[u8]>) -> Option> { + if name.ends_with(".ok") { Some(Ok(Arc::new(silent(name, MediaKind::Synthetic)))) } else { None } + } + + fn reject_all(_name: &str, _bytes: Arc<[u8]>) -> Option> { + None + } + + fn boom(name: &str, _bytes: Arc<[u8]>) -> Option> { + Some(Err(MediaError::Decode(format!("{name}: boom")))) + } + + fn reader_ok(name: &str, head: &[u8], _reader: &SharedBytes) -> Option> { + if head.starts_with(b"OK") { Some(Ok(Arc::new(silent(name, MediaKind::Movie)))) } else { None } + } + + struct HugeSource; + impl ByteSource for HugeSource { + fn len(&self) -> u64 { + u64::MAX + } + fn read_at(&self, _offset: u64, buf: &mut [u8]) -> io::Result<()> { + assert!(buf.len() <= HEAD_LEN, "must reject whole-file allocation before reading"); + buf.fill(0); + Ok(()) + } + } + + #[test] + fn whole_file_fallback_and_explicit_ranges_are_bounded() { + let reader: SharedBytes = Arc::new(HugeSource); + assert!(open_reader("large.ok", reader.clone(), &[], &[accept_ok]).is_err()); + assert!(open_reader_within("large.ok", reader.clone(), &[], &[accept_ok], u64::MAX).is_err()); + assert!(read_range(&HugeSource, 0, usize::MAX).is_err()); + assert!(read_range_within(&HugeSource, 0, 10, 9).is_err()); + assert_eq!(read_range_within(&HugeSource, 0, 10, 10).unwrap(), vec![0; 10]); + } + + struct SniffOnlySource(std::sync::atomic::AtomicUsize); + impl ByteSource for SniffOnlySource { + fn len(&self) -> u64 { + u64::MAX + } + fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> { + assert_eq!(offset, 0); + assert_eq!(buf.len(), HEAD_LEN); + assert_eq!(self.0.fetch_add(1, std::sync::atomic::Ordering::SeqCst), 0, "must only sniff once"); + buf.fill(0); + buf[..2].copy_from_slice(b"OK"); + Ok(()) + } + } + + #[test] + fn no_fallback_stops_after_sniff_and_streaming_opener_precedes_size_cap() { + let reader = Arc::new(SniffOnlySource(std::sync::atomic::AtomicUsize::new(0))); + let error = open_reader("unknown", reader.clone(), &[], &[]).err().unwrap(); + assert!(matches!(error, MediaError::Unsupported(_))); + assert_eq!(reader.0.load(std::sync::atomic::Ordering::SeqCst), 1); + let reader = Arc::new(SniffOnlySource(std::sync::atomic::AtomicUsize::new(0))); + let source = open_reader_within("large.mov", reader.clone(), &[reader_ok], &[accept_ok], 0).unwrap(); + assert_eq!(source.info().kind, MediaKind::Movie); + assert_eq!(reader.0.load(std::sync::atomic::Ordering::SeqCst), 1); + } + + #[test] + fn hostile_offline_metadata_and_requests_are_errors() { + let mut source = silent("bad", MediaKind::Synthetic); + source.info.video.as_mut().unwrap().width = u32::MAX; + source.info.video.as_mut().unwrap().height = u32::MAX; + assert!(source.video_frame(FrameRequest::full(Tick::ZERO)).is_err()); + assert!(source.audio(0, usize::MAX, 48000).is_err()); + let source = silent("bad-scale", MediaKind::Synthetic); + for scale in [f32::NAN, f32::INFINITY, 0.0, -1.0] { + assert!(source.video_frame(FrameRequest { time: Tick::ZERO, scale }).is_err()); + } + } + + #[cfg(unix)] + #[test] + fn open_path_refuses_a_fifo_without_waiting_for_a_writer() { + let root = std::env::temp_dir().join(format!("craft-media-source-fifo-{}", std::process::id())); + std::fs::create_dir(&root).unwrap(); + let path = root.join("fifo"); + if std::process::Command::new("mkfifo").arg(&path).status().is_ok_and(|s| s.success()) { + assert!(open_path(&path, &[], &[]).is_err()); + std::fs::remove_file(&path).unwrap(); + } + std::fs::remove_dir(&root).unwrap(); + } + + #[test] + fn importable_extensions_match_regardless_of_case() { + for name in ["clip.mov", "clip.MOV", "clip.Mov", "shot.MP4", "IMG_0001.JPG", "sound.WAV", "take.M2TS"] { + assert!(is_importable(Path::new(name)), "{name}"); + } + assert!(!is_importable(Path::new("notes.txt"))); + } + + #[test] + fn open_bytes_tries_extra_in_order_and_otherwise_is_unsupported() { + let bytes: Arc<[u8]> = Arc::from(&b"xxxx"[..]); + let err = open_bytes("a.bin", bytes.clone(), &[]).err().expect("expected error"); + assert!(matches!(err, MediaError::Unsupported(_))); + let err = open_bytes("a.bin", bytes.clone(), &[reject_all, accept_ok]).err().expect("expected error"); + assert!(matches!(err, MediaError::Unsupported(_))); + let src = open_bytes("clip.ok", bytes.clone(), &[reject_all, accept_ok]).unwrap(); + assert_eq!(src.info().name, "clip.ok"); + let err = open_bytes("clip.ok", bytes, &[boom, accept_ok]).err().expect("expected error"); + assert!(matches!(err, MediaError::Decode(_))); + } + + #[test] + fn open_reader_uses_reader_openers_then_falls_back_within_max_whole() { + let small: SharedBytes = Arc::new(b"HELLO".to_vec()); + let err = open_reader("a.bin", small.clone(), &[], &[]).err().expect("expected error"); + assert!(matches!(err, MediaError::Unsupported(_))); + + let ok: SharedBytes = Arc::new(b"OK-file".to_vec()); + let src = open_reader("clip.mov", ok, &[reader_ok], &[]).unwrap(); + assert_eq!(src.info().kind, MediaKind::Movie); + + let tagged: SharedBytes = Arc::new(b"xxxx".to_vec()); + let src = open_reader("clip.ok", tagged.clone(), &[], &[accept_ok]).unwrap(); + assert_eq!(src.info().name, "clip.ok"); + + let big = vec![0u8; HEAD_LEN + 8]; + let r: SharedBytes = Arc::new(big); + let e = open_reader_within("a.avi", r, &[], &[accept_ok], HEAD_LEN as u64).err().expect("expected error"); + assert!(matches!(e, MediaError::Unsupported(s) if s.contains("too large"))); + } + + #[test] + fn audio_streams_serde_accepts_legacy_single_object() { + let stream = r#"{"sample_rate":48000,"channels":2,"codec":"pcm","bits_per_sample":null}"#; + let prefix = r#"{"name":"a","kind":"Movie","duration":0,"video":null,"audio_streams":["#; + let suffix = r#"],"container":"wav","start_timecode":null,"file_size":null}"#; + let full = std::iter::repeat_n(stream, MAX_AUDIO_STREAMS).collect::>().join(","); + let info: MediaInfo = serde_json::from_str(&format!("{prefix}{full}{suffix}")).unwrap(); + assert_eq!(info.audio_streams.len(), MAX_AUDIO_STREAMS); + for extra in [stream, r#"{"malformed":"not an audio stream"}"#] { + let error = serde_json::from_str::(&format!("{prefix}{full},{extra}{suffix}")).unwrap_err(); + assert!(error.to_string().contains("MAX_AUDIO_STREAMS"), "{error}"); + } + let many = r#"{"name":"a","kind":"Movie","duration":0,"video":null,"audio_streams":[{"sample_rate":48000,"channels":2,"codec":"pcm","bits_per_sample":null}],"container":"wav","start_timecode":null,"file_size":null}"#; + let info: MediaInfo = serde_json::from_str(many).unwrap(); + assert_eq!(info.audio_streams.len(), 1); + let one = r#"{"name":"a","kind":"AudioOnly","duration":0,"video":null,"audio":{"sample_rate":44100,"channels":1,"codec":"pcm","bits_per_sample":16},"container":"wav","start_timecode":null,"file_size":null}"#; + let info: MediaInfo = serde_json::from_str(one).unwrap(); + assert_eq!(info.audio().map(|a| a.sample_rate), Some(44100)); + let none = r#"{"name":"a","kind":"Still","duration":0,"video":null,"audio":null,"container":"png","start_timecode":null,"file_size":null}"#; + let info: MediaInfo = serde_json::from_str(none).unwrap(); + assert!(info.audio_streams.is_empty()); + } + + #[test] + fn offline_source_returns_slate_and_silence() { + let src = silent("off", MediaKind::Synthetic); + let frame = src.video_frame(FrameRequest::full(Tick::ZERO)).unwrap(); + assert_eq!((frame.width, frame.height), (16, 8)); + assert_eq!(frame.pts, Tick::ZERO); + let audio = src.audio(0, 8, 48000).unwrap(); + assert_eq!(audio.sample_rate, 48000); + assert_eq!(audio.num_channels(), 2); + assert_eq!(audio.frames(), 8); + assert!(src.audio_stream(1, 0, 8, 48000).is_err()); + } +}