f67d38b35cc5
probe.rs
//! `filmcraft-cli probe`: media info as JSON, plus container details for MPEG TS / PS (program,
//! streams with their codecs, access units, picture types and timestamp ranges), MXF (operational
//! pattern, tracks, index, timecode), Ogg (logical streams, pre-skip, granules), Broadcast WAV
//! (time reference) and image sequences (frames, missing numbers).
use std::sync::Arc;
use serde_json::{Value, json};
fn rate(r: craft_media::mxf::Rational) -> String {
format!("{}/{}", r.num, r.den)
}
fn mxf_details(src: &filmcraft_codecs::MxfSource) -> Value {
let f = src.file();
let tracks: Vec<Value> = f
.tracks
.iter()
.map(|t| {
let mut v = json!({
"trackId": t.track_id,
"trackNumber": format!("{:08x}", t.track_number),
"kind": format!("{:?}", t.kind),
"codec": t.codec.name(),
"wrapping": format!("{:?}", t.wrapping),
"editRate": rate(t.edit_rate),
"origin": t.origin,
"startPosition": t.start_position,
"duration": t.duration,
});
if t.kind == craft_media::mxf::TrackKind::Picture {
v["pictures"] = json!(t.samples.len());
v["keyFrames"] = json!(t.samples.iter().filter(|s| s.key).count());
v["indexed"] = json!(t.indexed);
v["temporalOffsets"] = json!(t.temporal_offsets);
v["reorderedFromBitstream"] = json!(t.needs_reorder);
}
if let Some(s) = &t.sound {
v["sampleRate"] = json!(rate(s.sample_rate));
v["channels"] = json!(s.channels);
v["bits"] = json!(s.bits);
v["sampleFrames"] = json!(t.stored_sample_frames());
}
v
})
.collect();
json!({
"operationalPattern": f.operational_pattern.name(),
"timecode": f.timecode.map(|t| json!({"start": t.start, "roundedBase": t.rounded_base, "dropFrame": t.drop_frame, "text": t.format()})),
"materialPackage": f.material_package_name,
"product": f.product_name,
"company": f.company_name,
"partitions": f.partitions.len(),
"indexSegments": f.index_segments.len(),
"runIn": f.run_in,
"tracks": tracks,
"warnings": f.warnings,
})
}
fn ogg_details(src: &filmcraft_codecs::OggSource) -> Value {
let f = src.file();
let streams: Vec<Value> = f
.streams
.iter()
.map(|s| {
let mut v = json!({"serial": s.serial, "codec": s.codec.name(), "packets": s.packets.len(), "pages": s.pages, "lastGranule": s.last_granule, "endOfStream": s.saw_eos});
if s.codec == craft_media::ogg::Codec::Opus
&& let Some(h) = s.headers.first()
&& h.len() >= 12
{
let pre_skip = u16::from_le_bytes([h[10], h[11]]);
let t = craft_media::ogg::OpusTiming::of(s, pre_skip as u32);
v["preSkip"] = json!(pre_skip);
v["samples48k"] = json!(t.total);
}
v
})
.collect();
json!({"streams": streams, "warnings": f.warnings})
}
fn mpeg_details(src: &filmcraft_codecs::MpegSource) -> Value {
let Some(f) = src.file() else {
return json!({"format": "MPEG video elementary stream"});
};
let (vi, ai) = src.stream_indices();
let streams: Vec<Value> = f
.streams
.iter()
.enumerate()
.map(|(i, s)| {
let id = match s.id {
craft_media::mpegts::StreamId::Pid(pid) => json!({"pid": pid}),
craft_media::mpegts::StreamId::Ps { stream_id, sub_id } => {
json!({"streamId": format!("0x{stream_id:02x}"), "subStreamId": sub_id.map(|x| format!("0x{x:02x}"))})
}
};
let mut v = json!({
"id": id,
"streamType": format!("0x{:02x}", s.stream_type),
"codec": s.codec.name(),
"kind": format!("{:?}", s.kind()),
"units": s.units.len(),
"keyUnits": s.units.iter().filter(|u| u.key).count(),
"pesPackets": s.pes_packets,
"ptsRange": s.pts_range().map(|(a, b)| json!([a, b])),
"used": Some(i) == vi || Some(i) == ai,
});
if let Some(l) = &s.language {
v["language"] = json!(l);
}
if let Some(l) = s.lpcm {
v["lpcm"] = json!({"sampleRate": l.sample_rate, "channels": l.channels, "bits": l.bits});
}
if s.units.iter().any(|u| u.picture.is_some()) {
let p = |t: u8| s.units.iter().filter(|u| u.picture.is_some_and(|p| p.coding_type == t)).count();
v["pictures"] =
json!({"I": p(1), "P": p(2), "B": p(3), "fieldPairs": s.units.iter().filter(|u| u.picture.is_some_and(|p| p.structure != 3)).count()});
}
v
})
.collect();
json!({
"format": f.format.name(),
"program": f.program,
"pcrRange": f.pcr_range.map(|(a, b)| json!([a, b])),
"streams": streams,
"warnings": f.warnings,
})
}
/// Probe `path`; with `image_sequence`, `path` is the first frame of a numbered still sequence.
pub fn probe(path: &str, image_sequence: bool) -> Result<Value, String> {
if image_sequence {
use filmcraft_media::sequence::{ImageSequenceSource, Numbered, sequence_frames};
let n = Numbered::parse(path).ok_or_else(|| format!("{path}: not a numbered still image"))?;
let dir = if n.dir.is_empty() { ".".to_string() } else { n.dir.clone() };
let names: Vec<String> =
std::fs::read_dir(&dir).map_err(|e| format!("{dir}: {e}"))?.flatten().map(|e| e.file_name().to_string_lossy().to_string()).collect();
let frames = sequence_frames(&n, &names);
let name = std::path::Path::new(path).file_name().map(|s| s.to_string_lossy().to_string()).unwrap_or_default();
let loader: filmcraft_media::sequence::FrameLoader = Arc::new(|p: &str| filmcraft_media::reader::read_regular_file(std::path::Path::new(p)));
// the timebase of a fresh install (Settings ▸ Media ▸ Indeterminate Media Timebase)
let src = ImageSequenceSource::new(&name, frames, filmcraft_time::FrameRate::FPS_29_97, loader).map_err(|e| format!("{path}: {e}"))?;
let mut v = serde_json::to_value(filmcraft_media::MediaSource::info(&src)).unwrap_or_default();
v["imageSequence"] = json!({
"first": src.frame_path(0),
"firstNumber": n.number,
"lastNumber": n.number + src.frame_count() as u64 - 1,
"frames": src.frame_count(),
"missing": src.missing_frames().iter().map(|i| n.number + *i as u64).collect::<Vec<_>>(),
});
return Ok(v);
}
let bytes: Arc<[u8]> = filmcraft_media::reader::read_regular_file(std::path::Path::new(path)).map_err(|e| format!("{path}: {e}"))?.into();
let name = std::path::Path::new(path).file_name().map(|s| s.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string());
let head = &bytes[..bytes.len().min(70_000)];
if craft_media::mxf::sniff(head) {
let src = filmcraft_codecs::MxfSource::open(&name, bytes).map_err(|e| format!("{path}: {e}"))?;
let mut v = serde_json::to_value(filmcraft_media::MediaSource::info(&src)).unwrap_or_default();
v["mxf"] = mxf_details(&src);
return Ok(v);
}
if filmcraft_codecs::mpeg::sniff(head) {
let src = filmcraft_codecs::MpegSource::open(&name, bytes).map_err(|e| format!("{path}: {e}"))?;
let mut v = serde_json::to_value(filmcraft_media::MediaSource::info(&src)).unwrap_or_default();
v["mpeg"] = mpeg_details(&src);
return Ok(v);
}
if craft_media::ogg::sniff(head)
&& let Ok(src) = filmcraft_codecs::OggSource::open(&name, bytes.clone())
{
let mut v = serde_json::to_value(filmcraft_media::MediaSource::info(&src)).unwrap_or_default();
v["ogg"] = ogg_details(&src);
return Ok(v);
}
let src = filmcraft_codecs::open_bytes(&name, bytes.clone()).map_err(|e| format!("{path}: {e}"))?;
let mut v = serde_json::to_value(src.info()).unwrap_or_default();
if filmcraft_media::wav::sniff(head)
&& let Ok(w) = filmcraft_media::wav::WavSource::parse(&name, bytes)
&& let Some(tr) = w.time_reference()
{
v["bwf"] = json!({"timeReference": tr});
}
Ok(v)
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.