f67d38b35cc5
previews.rs
//! Render previews (Sequence ▸ Render Effects In to Out, Render In to Out, Render Selection,
//! Delete Render Files…) and the timeline render bar.
//!
//! Segments, content hashes and the yellow/red cost estimate come from
//! [`filmcraft_render::preview`]. A rendered segment is a ProRes 422 QuickTime file named
//! `<hash>.mov` in the project's preview cache directory, and a rendered part of a segment (In/Out
//! inside it: Render In to Out renders only In to Out, like Premiere) is `<hash>-<off>-<len>.mov`,
//! frames `off..off + len` counted from the segment start. Because the offsets are relative to the
//! segment, a ripple edit that moves the segment keeps its parts, as it keeps whole previews. The
//! render bar is green over the rendered frames only; later renders fill the gaps.
//!
//! The folder:
//!
//! * saved project `/path/Film.fcproj` → `/path/FilmCraft Previews/Film/`;
//! * unsaved project → a per-process folder in the system temp dir; its files move into the
//! project's folder on the first save.
//!
//! Because files are named by content, an edit simply changes the hash of the segments it touches
//! (their bar turns yellow/red again) while every other preview stays valid; undo brings the old
//! hash back and the segment is green again. Files are written as `<hash>.mov.part` and renamed
//! when complete, so an interrupted render never leaves a bad preview behind.
//!
//! Playback asks [`PreviewStore::frame`] first: when the frame lies in a segment with a preview, the
//! decoded preview frame replaces the live render.
use filmcraft_audio_dsp::channels::{Layout, Mixdown};
use filmcraft_render::audio::to_layout;
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, RwLock};
use filmcraft_frame::{AudioBuffer, VideoFrame};
use filmcraft_media::{FrameRequest, SharedSource};
use filmcraft_project::{ItemId, Project};
use filmcraft_render::preview::{AudioSegment, Need, Segment, segment_at, video_segments};
use filmcraft_time::{FrameRate, Tick, TimeRange};
use serde::Serialize;
use serde_json::{Value, json};
use crate::{EngineError, MediaPool, Result, Session};
/// Render-bar colour of one segment.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum BarState {
/// Plays natively, nothing drawn.
None,
Yellow,
Red,
/// A preview file exists.
Green,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct BarSpan {
pub start: Tick,
pub end: Tick,
pub state: BarState,
}
/// Which segments a render command picks.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RenderMode {
/// Red segments in In/Out (Enter), as in Premiere: yellow ones should play in real time, and
/// rendering them too can take hours of encoding on a long sequence (#1220).
EffectsInToOut,
/// Every segment in In/Out, including no-bar ones.
InToOut,
/// Segments showing a selected clip.
Selection,
}
impl RenderMode {
/// Whether this mode renders a segment whose playback needs `need` (In/Out and the selection
/// aside).
pub fn renders(self, need: Need) -> bool {
match self {
RenderMode::EffectsInToOut => need == Need::Render,
RenderMode::InToOut | RenderMode::Selection => true,
}
}
}
type Memo = (Arc<Project>, ItemId, Arc<Vec<Segment>>);
type AudioMemo = (Arc<Project>, ItemId, Arc<Vec<AudioSegment>>);
/// Preview files of one project, plus memoized segments for the latest project snapshots.
#[derive(Default)]
pub struct PreviewStore {
dir: RwLock<Option<PathBuf>>,
/// Where unsaved projects' previews go (Settings ▸ Media Cache); None = the system temp dir.
temp_root: RwLock<Option<PathBuf>>,
/// File names present: `<hash>.mov` / `<hash>-<off>-<len>.mov` (video) and `<hash>.wav` (audio).
files: RwLock<HashSet<String>>,
/// The video files of `files` by segment hash (rebuilt whenever `files` changes).
video: RwLock<HashMap<String, Vec<Part>>>,
/// Opened preview files by file name (most recent last).
sources: Mutex<Vec<(String, SharedSource)>>,
/// Loaded audio previews: interleaved stereo f32 (most recent last).
audio: Mutex<Vec<(String, Arc<Vec<f32>>)>>,
memo: Mutex<Vec<Memo>>,
audio_memo: Mutex<Vec<AudioMemo>>,
/// Bumped whenever the set of preview files changes.
pub generation: AtomicU64,
/// Live mixer state shared with playback: held controls, meters, newest project snapshot.
pub live: Arc<filmcraft_render::mixer::LiveMix>,
}
fn video_name(hash: &str) -> String {
format!("{hash}.mov")
}
/// A rendered stretch of one segment: frames `off..off + len` counted from the segment start, in
/// file `name`. A whole-segment preview has `off` 0 and `len` [`WHOLE`].
#[derive(Clone, Debug, PartialEq, Eq)]
struct Part {
off: i64,
len: i64,
name: String,
}
const WHOLE: i64 = i64::MAX;
/// File name of the preview of frames `off..off + len` of a segment of `frames` frames.
fn part_name(hash: &str, off: i64, len: i64, frames: i64) -> String {
if off == 0 && len >= frames { video_name(hash) } else { format!("{hash}-{off}-{len}.mov") }
}
/// `(hash, off, len)` of a video preview file name (`<hash>.mov` or `<hash>-<off>-<len>.mov`).
fn parse_video_name(name: &str) -> Option<(&str, i64, i64)> {
let stem = name.strip_suffix(".mov")?;
if is_hash(stem) {
return Some((stem, 0, WHOLE));
}
let mut it = stem.split('-');
let (hash, off, len) = (it.next()?, it.next()?, it.next()?);
if it.next().is_some() || !is_hash(hash) {
return None;
}
let (off, len) = (off.parse::<u32>().ok()?, len.parse::<u32>().ok()?);
(len > 0).then_some((hash, i64::from(off), i64::from(len)))
}
/// The parts of `[a, b)` not covered by the sorted, merged intervals `cov`.
fn gaps(cov: &[(i64, i64)], a: i64, b: i64) -> Vec<(i64, i64)> {
let mut out = Vec::new();
let mut pos = a;
for &(x, y) in cov {
if y <= pos {
continue;
}
if x >= b {
break;
}
if x > pos {
out.push((pos, x));
}
pos = pos.max(y);
}
if pos < b {
out.push((pos, b));
}
out
}
/// First frame whose start is at or after `t`.
fn frame_ceil(rate: FrameRate, t: Tick) -> i64 {
let f = rate.frame_at(t);
if rate.tick_of(f) < t { f.saturating_add(1) } else { f }
}
/// Frames of In/Out (`range`) inside `seg`, counted from the segment start (empty when apart).
fn rel_range(seg: &Segment, rate: FrameRate, range: &TimeRange) -> (i64, i64) {
let a = rate.frame_at(range.start).saturating_sub(seg.first_frame).clamp(0, seg.frames.max(0));
let b = frame_ceil(rate, range.end()).saturating_sub(seg.first_frame).clamp(0, seg.frames.max(0));
(a, b.max(a))
}
fn audio_name(hash: &str) -> String {
format!("{hash}.wav")
}
/// The speaker layout a mix is rendered for and how a 5.1 Mix is folded down to stereo.
#[derive(Clone, Copy, Debug)]
pub struct MixOutput {
pub layout: Layout,
pub mixdown: Mixdown,
}
impl PreviewStore {
/// A store using a fresh per-process temp folder (unsaved projects).
pub fn temp() -> Self {
let s = Self::default();
s.set_dir(default_temp_dir());
s
}
/// Switch to a fresh temp folder (new unsaved project).
pub fn reset_temp(&self) {
let root = self.temp_root();
self.set_dir(match root {
Some(r) => Some(untitled_dir(&r)),
None => default_temp_dir(),
});
}
/// The folder unsaved projects' previews go into (None = the system temp dir).
pub fn temp_root(&self) -> Option<PathBuf> {
self.temp_root.read().unwrap_or_else(|e| e.into_inner()).clone()
}
pub fn set_temp_root(&self, root: Option<PathBuf>) {
*self.temp_root.write().unwrap_or_else(|e| e.into_inner()) = root;
}
pub fn dir(&self) -> Option<PathBuf> {
self.dir.read().unwrap_or_else(|e| e.into_inner()).clone()
}
/// Point the store at `dir` and index the previews already there.
pub fn set_dir(&self, dir: Option<PathBuf>) {
let mut files = HashSet::new();
if let Some(d) = &dir
&& let Ok(rd) = std::fs::read_dir(d)
{
for e in rd.flatten() {
let name = e.file_name().to_string_lossy().to_string();
if parse_video_name(&name).is_some() || name.strip_suffix(".wav").is_some_and(is_hash) {
files.insert(name);
}
}
}
*self.dir.write().unwrap_or_else(|e| e.into_inner()) = dir;
*self.files.write().unwrap_or_else(|e| e.into_inner()) = files;
self.reindex();
self.sources.lock().unwrap_or_else(|e| e.into_inner()).clear();
self.audio.lock().unwrap_or_else(|e| e.into_inner()).clear();
self.bump();
}
/// Move to `dir`, taking this store's preview files along (first save of a project). The folder is
/// created only when there are files to take along: a render creates it when it needs it (#2343).
pub fn move_to(&self, dir: PathBuf) {
let old = self.dir();
if old.as_deref() == Some(dir.as_path()) {
return;
}
let files = self.files.read().unwrap_or_else(|e| e.into_inner()).clone();
if let Some(old) = &old
&& !files.is_empty()
&& (old.starts_with(crate::temp_dir()) || self.temp_root().is_some_and(|r| old.starts_with(r)))
{
let _ = std::fs::create_dir_all(&dir);
for name in &files {
let (a, b) = (old.join(name), dir.join(name));
if !b.exists() && std::fs::rename(&a, &b).is_err() {
let _ = std::fs::copy(&a, &b).map(|_| std::fs::remove_file(&a));
}
}
}
self.set_dir(Some(dir));
}
/// Rebuild the by-hash index of the video previews from the file names.
fn reindex(&self) {
let mut video: HashMap<String, Vec<Part>> = HashMap::new();
for name in self.files.read().unwrap_or_else(|e| e.into_inner()).iter() {
if let Some((hash, off, len)) = parse_video_name(name) {
video.entry(hash.to_string()).or_default().push(Part { off, len, name: name.clone() });
}
}
*self.video.write().unwrap_or_else(|e| e.into_inner()) = video;
}
/// The rendered frames of `seg`, counted from its start: sorted, merged, within the segment.
pub fn coverage(&self, seg: &Segment) -> Vec<(i64, i64)> {
let video = self.video.read().unwrap_or_else(|e| e.into_inner());
let Some(parts) = video.get(&seg.hash) else { return Vec::new() };
let n = seg.frames.max(0);
let mut iv: Vec<(i64, i64)> = parts.iter().map(|p| (p.off.clamp(0, n), p.off.saturating_add(p.len).clamp(0, n))).filter(|(a, b)| a < b).collect();
iv.sort_unstable();
let mut out: Vec<(i64, i64)> = Vec::new();
for (a, b) in iv {
match out.last_mut() {
Some(l) if a <= l.1 => l.1 = l.1.max(b),
_ => out.push((a, b)),
}
}
out
}
/// Whether previews cover every frame of `seg`.
pub fn is_rendered(&self, seg: &Segment) -> bool {
matches!(self.coverage(seg).as_slice(), [(0, b)] if *b == seg.frames)
}
/// Names of the video preview files of `seg` that hold frames of `a..b` (from the segment start).
fn parts_in(&self, seg: &Segment, a: i64, b: i64) -> Vec<String> {
if a >= b {
return Vec::new();
}
let video = self.video.read().unwrap_or_else(|e| e.into_inner());
let Some(parts) = video.get(&seg.hash) else { return Vec::new() };
parts.iter().filter(|p| p.off < b && a < p.off.saturating_add(p.len)).map(|p| p.name.clone()).collect()
}
/// Whether the audio preview of audio segment `hash` exists.
pub fn has_audio(&self, hash: &str) -> bool {
self.files.read().unwrap_or_else(|e| e.into_inner()).contains(&audio_name(hash))
}
/// Number of preview files (video and audio).
pub fn count(&self) -> usize {
self.files.read().unwrap_or_else(|e| e.into_inner()).len()
}
pub fn audio_path_for(&self, hash: &str) -> Option<PathBuf> {
self.dir().map(|d| d.join(audio_name(hash)))
}
/// Register a finished video preview file (`<hash>.mov` or `<hash>-<off>-<len>.mov`).
fn add_video(&self, name: &str) {
self.files.write().unwrap_or_else(|e| e.into_inner()).insert(name.to_string());
self.reindex();
self.bump();
}
/// Register a finished audio preview file.
pub fn add_audio(&self, hash: &str) {
self.files.write().unwrap_or_else(|e| e.into_inner()).insert(audio_name(hash));
self.bump();
}
/// Delete the preview files (video and audio) of `hashes`, or every file when None. Returns
/// how many files were removed.
pub fn delete(&self, hashes: Option<&[String]>) -> usize {
let victims: Vec<String> = {
let files = self.files.read().unwrap_or_else(|e| e.into_inner());
match hashes {
Some(h) => files
.iter()
.filter(|n| {
let owner = parse_video_name(n).map(|(hash, _, _)| hash).or_else(|| n.strip_suffix(".wav"));
owner.is_some_and(|o| h.iter().any(|h| h == o))
})
.cloned()
.collect(),
None => files.iter().cloned().collect(),
}
};
self.delete_files(&victims)
}
/// Delete the preview files named `names`. Returns how many were removed.
fn delete_files(&self, names: &[String]) -> usize {
let Some(dir) = self.dir() else { return 0 };
let victims: Vec<String> = {
let files = self.files.read().unwrap_or_else(|e| e.into_inner());
names.iter().filter(|n| files.contains(*n)).cloned().collect()
};
self.sources.lock().unwrap_or_else(|e| e.into_inner()).retain(|(n, _)| !victims.contains(n));
self.audio.lock().unwrap_or_else(|e| e.into_inner()).retain(|(h, _)| !victims.contains(&audio_name(h)));
let mut files = self.files.write().unwrap_or_else(|e| e.into_inner());
for n in &victims {
let _ = std::fs::remove_file(dir.join(n));
files.remove(n);
}
drop(files);
self.reindex();
self.bump();
victims.len()
}
/// Audio segments of `seq` in this project snapshot (memoized per snapshot).
pub fn audio_segments(&self, project: &Arc<Project>, seq: ItemId) -> Arc<Vec<AudioSegment>> {
let mut memo = self.audio_memo.lock().unwrap_or_else(|e| e.into_inner());
if let Some((_, _, s)) = memo.iter().find(|(p, q, _)| Arc::ptr_eq(p, project) && *q == seq) {
return s.clone();
}
let segs = Arc::new(filmcraft_render::preview::audio_segments(project, seq));
memo.push((project.clone(), seq, segs.clone()));
if memo.len() > 4 {
memo.remove(0);
}
segs
}
fn load_audio(&self, hash: &str) -> Option<Arc<Vec<f32>>> {
{
let mut g = self.audio.lock().unwrap_or_else(|e| e.into_inner());
if let Some(i) = g.iter().position(|(h, _)| h == hash) {
let e = g.remove(i);
let s = e.1.clone();
g.push(e);
return Some(s);
}
}
let bytes = filmcraft_media::reader::read_regular_file(&self.audio_path_for(hash)?).ok()?;
let samples = Arc::new(read_wav_f32(&bytes)?);
let mut g = self.audio.lock().unwrap_or_else(|e| e.into_inner());
g.push((hash.to_string(), samples.clone()));
if g.len() > 32 {
g.remove(0);
}
Some(samples)
}
/// Sequence audio for playback and meters, as stereo (a 5.1 Mix folded with the BS.775
/// downmix): rendered audio previews where they are valid, the live mix everywhere else.
pub fn mix(&self, project: &Arc<Project>, seq: ItemId, start: i64, frames: usize, sources: &dyn filmcraft_render::SourceProvider) -> AudioBuffer {
self.mix_layout(project, seq, start, frames, sources, MixOutput { layout: Layout::Stereo, mixdown: Mixdown::FrontRear })
}
/// [`PreviewStore::mix`] in `layout`: a 5.1 Mix is folded to stereo with `mixdown` (Preferences ▸
/// Audio ▸ 5.1 Mixdown Type) or played as six channels on a 5.1 device; a stereo Mix is placed
/// on the front speakers of a 5.1 device. Rendered audio previews are stereo BS.775 folds, so
/// they are used only for stereo output of a stereo Mix or with the BS.775 mixdown.
pub fn mix_layout(
&self,
project: &Arc<Project>,
seq: ItemId,
start: i64,
frames: usize,
sources: &dyn filmcraft_render::SourceProvider,
output: MixOutput,
) -> AudioBuffer {
let MixOutput { layout, mixdown } = output;
let Some(q) = project.sequence(seq) else { return AudioBuffer::silence(48_000, layout.channels(), frames) };
let live = Some(&*self.live);
let has_audio = self.files.read().unwrap_or_else(|e| e.into_inner()).iter().any(|n| n.ends_with(".wav"));
let surround = q.settings.audio_master == filmcraft_project::AudioChannels::Surround51;
let previews_ok = layout == Layout::Stereo && (!surround || mixdown == Mixdown::FrontRear);
// held mixer controls are heard live (rendered previews don't know them)
if !has_audio || self.live.is_active() || !previews_ok {
return to_layout(filmcraft_render::mixer::mix_graph(project, q, start, frames, sources, live), layout, mixdown);
}
let segs = self.audio_segments(project, seq);
let mut out = AudioBuffer::silence(q.settings.sample_rate, 2, frames);
let end = start + frames as i64;
let mut pos = start;
while pos < end {
let i = segs.partition_point(|g| g.first_sample <= pos);
let seg = i.checked_sub(1).map(|i| &segs[i]).filter(|g| pos < g.first_sample + g.samples);
let preview = seg.filter(|g| self.has_audio(&g.hash)).and_then(|g| self.load_audio(&g.hash).map(|a| (g, a)));
let next = match seg {
Some(g) => (g.first_sample + g.samples).min(end),
None => segs.get(i).map(|g| g.first_sample).unwrap_or(end).min(end),
};
let n = (next - pos).max(1) as usize;
let off = (pos - start) as usize;
match preview {
Some((g, a)) if a.len() >= (g.samples as usize) * 2 => {
let k0 = (pos - g.first_sample) as usize;
for k in 0..n {
out.channels[0][off + k] = a[(k0 + k) * 2];
out.channels[1][off + k] = a[(k0 + k) * 2 + 1];
}
}
_ => {
let b = to_layout(filmcraft_render::mixer::mix_graph(project, q, pos, n, sources, live), Layout::Stereo, mixdown);
for c in 0..2 {
out.channels[c][off..off + n].copy_from_slice(&b.channels[c.min(b.channels.len() - 1)][..n]);
}
}
}
pos += n as i64;
}
out
}
fn bump(&self) {
self.generation.fetch_add(1, Ordering::Relaxed);
}
/// Segments of `seq` in this project snapshot (memoized per snapshot).
pub fn segments(&self, project: &Arc<Project>, seq: ItemId) -> Arc<Vec<Segment>> {
let mut memo = self.memo.lock().unwrap_or_else(|e| e.into_inner());
if let Some((_, _, s)) = memo.iter().find(|(p, q, _)| Arc::ptr_eq(p, project) && *q == seq) {
return s.clone();
}
let segs = Arc::new(video_segments(project, seq));
memo.push((project.clone(), seq, segs.clone()));
if memo.len() > 4 {
memo.remove(0);
}
segs
}
/// Green when previews cover the whole segment, else its colour without a preview.
pub fn state_of(&self, seg: &Segment) -> BarState {
if self.is_rendered(seg) { BarState::Green } else { need_state(seg) }
}
/// The render bar: per segment, green over its rendered frames and its own colour elsewhere;
/// adjacent spans of the same colour merged.
pub fn bar(&self, project: &Arc<Project>, seq: ItemId) -> Vec<BarSpan> {
let Some(rate) = project.sequence(seq).map(|q| q.settings.frame_rate) else { return Vec::new() };
let mut out: Vec<BarSpan> = Vec::new();
for s in self.segments(project, seq).iter() {
let need = need_state(s);
let mut spans = Vec::new();
let mut pos = 0;
for (a, b) in self.coverage(s) {
if a > pos {
spans.push((pos, a, need));
}
spans.push((a, b, BarState::Green));
pos = b;
}
if pos < s.frames {
spans.push((pos, s.frames, need));
}
let at = |f: i64| match f {
0 => s.start,
f if f >= s.frames => s.end,
f => rate.tick_of(s.first_frame.saturating_add(f)),
};
for (a, b, state) in spans {
let (start, end) = (at(a), at(b));
match out.last_mut() {
Some(l) if l.end == start && l.state == state => l.end = end,
_ => out.push(BarSpan { start, end, state }),
}
}
}
out
}
/// The preview frame for sequence frame `frame`, if its segment has been rendered.
pub fn frame(&self, pool: &MediaPool, project: &Arc<Project>, seq: ItemId, frame: i64, scale: f32) -> Option<Arc<VideoFrame>> {
if self.files.read().unwrap_or_else(|e| e.into_inner()).is_empty() {
return None;
}
let segs = self.segments(project, seq);
let seg = segment_at(&segs, frame)?;
let rel = frame.checked_sub(seg.first_frame)?;
let (name, off) = {
let video = self.video.read().unwrap_or_else(|e| e.into_inner());
let p = video.get(&seg.hash)?.iter().find(|p| p.off <= rel && rel < p.off.saturating_add(p.len))?;
(p.name.clone(), p.off)
};
let src = self.open(pool, &name)?;
let rate = project.sequence(seq)?.settings.frame_rate;
src.video_frame(FrameRequest { time: rate.tick_of(rel - off), scale }).ok()
}
/// The opened preview file `name` (`<hash>.mov` or a part).
fn open(&self, pool: &MediaPool, name: &str) -> Option<SharedSource> {
{
let mut g = self.sources.lock().unwrap_or_else(|e| e.into_inner());
if let Some(i) = g.iter().position(|(n, _)| n == name) {
let e = g.remove(i);
let s = e.1.clone();
g.push(e);
return Some(s);
}
}
let path = self.dir()?.join(name);
let src = open_preview_file(pool, name, &path)?;
let mut g = self.sources.lock().unwrap_or_else(|e| e.into_inner());
g.push((name.to_string(), src.clone()));
if g.len() > 6 {
g.remove(0);
}
Some(src)
}
}
/// Open a rendered preview file. Native builds read it in place (the container's index now,
/// frames on demand): previews are full-resolution ProRes, gigabytes a minute, and reading each
/// one whole filled memory during render and playback (#2185).
#[cfg(any(unix, windows))]
pub(crate) fn open_preview_file(_pool: &MediaPool, name: &str, path: &std::path::Path) -> Option<SharedSource> {
let reader = filmcraft_media::reader::FileReader::open(path).ok()?;
filmcraft_media::reader::open_reader_within(name, std::sync::Arc::new(reader), &filmcraft_codecs::reader_openers(), &[], 0).ok()
}
#[cfg(not(any(unix, windows)))]
pub(crate) fn open_preview_file(pool: &MediaPool, name: &str, path: &std::path::Path) -> Option<SharedSource> {
let bytes = filmcraft_media::reader::read_regular_file(path).ok()?;
pool.open_bytes(name, bytes.into()).ok()
}
fn need_state(seg: &Segment) -> BarState {
match seg.need {
Need::None => BarState::None,
Need::Realtime => BarState::Yellow,
Need::Render => BarState::Red,
}
}
fn is_hash(s: &str) -> bool {
s.len() == 32 && s.bytes().all(|b| b.is_ascii_hexdigit())
}
fn default_temp_dir() -> Option<PathBuf> {
if cfg!(target_arch = "wasm32") {
return None;
}
Some(untitled_dir(&crate::temp_dir().join("FilmCraft Previews")))
}
/// A fresh per-process folder for an unsaved project's previews under `root`.
fn untitled_dir(root: &Path) -> PathBuf {
let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
root.join(format!("untitled-{}-{nanos:x}", std::process::id()))
}
/// The preview folder of a project saved at `project_path`.
pub fn dir_for_project(project_path: &str) -> PathBuf {
let p = Path::new(project_path);
let stem = p.file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_else(|| "Untitled".into());
p.parent().unwrap_or(Path::new(".")).join("FilmCraft Previews").join(stem)
}
// ---------------------------------------------------------------- commands
/// In/Out of the active sequence (whole sequence when neither is set).
fn in_out(s: &Session) -> Result<(ItemId, TimeRange)> {
let id = s.state.active_sequence.ok_or(EngineError::NoSequence)?;
let q = s.project.sequence(id).ok_or(EngineError::NoSequence)?;
let fd = q.settings.frame_rate.frame_duration();
let a = q.mark_in.unwrap_or(Tick::ZERO);
let b = q.mark_out.map(|o| o + fd).unwrap_or(q.duration());
Ok((id, TimeRange::from_bounds(a, b.max(a))))
}
/// One preview file to render: frames `off..off + len` of segment `seg` (from its start).
struct Todo {
seg: Segment,
off: i64,
len: i64,
}
/// Start rendering previews as a background job. `{"wait": true}` renders synchronously.
///
/// The In/Out modes render only the frames between In and Out (a segment that extends past them
/// gets a partial preview), and every mode renders only frames that have no preview yet.
pub fn render(s: &mut Session, mode: RenderMode, p: &Value) -> Result<Value> {
let (seq, range) = in_out(s)?;
let rate = s.project.sequence(seq).ok_or(EngineError::NoSequence)?.settings.frame_rate;
let store = s.previews.clone();
let dir = store.dir().ok_or_else(|| EngineError::Other("render previews are not available here (no preview folder)".into()))?;
let segs = store.segments(&s.project, seq);
let selection: HashSet<_> = s.state.selection.iter().copied().collect();
let mut todo: Vec<Todo> = Vec::new();
for g in segs.iter().filter(|g| mode.renders(g.need)) {
let (a, b) = match mode {
RenderMode::EffectsInToOut | RenderMode::InToOut => rel_range(g, rate, &range),
RenderMode::Selection if g.clips.iter().any(|c| selection.contains(c)) => (0, g.frames.max(0)),
RenderMode::Selection => continue,
};
for (off, end) in gaps(&store.coverage(g), a, b) {
todo.push(Todo { seg: g.clone(), off, len: end - off });
}
}
if todo.is_empty() {
s.toast(if mode == RenderMode::EffectsInToOut {
"Nothing to render: no red segments without previews between In and Out"
} else {
"Nothing to render: previews are up to date"
});
return Ok(json!({"job": null, "segments": 0}));
}
std::fs::create_dir_all(&dir).map_err(|e| EngineError::Other(format!("preview folder {}: {e}", dir.display())))?;
let frames: i64 = todo.iter().map(|t| t.len).fold(0, i64::saturating_add);
let id = s.jobs.len() as u64 + 1;
let job = crate::Job {
id,
label: format!("Rendering {} preview segment{}", todo.len(), if todo.len() == 1 { "" } else { "s" }),
progress: Default::default(),
result: Default::default(),
};
job.progress.total.store(frames.max(1) as u64, Ordering::Relaxed);
let project = s.project.clone();
// Previews are cached by content and reused with proxies on or off: always full resolution,
// from their own copies of the files so the monitors keep their decoders.
let provider = s.media.full_res_provider(project.clone(), s.services.clone()).own_sources();
let (prog, res) = (job.progress.clone(), job.result.clone());
let nseg = todo.len();
let run = move || {
let t0 = web_time::Instant::now();
let mut bytes = 0u64;
let mut done_frames = 0u64;
let mut outcome: std::result::Result<(), String> = Ok(());
for (k, t) in todo.iter().enumerate() {
if prog.cancel.load(Ordering::Relaxed) {
outcome = Err("cancelled".into());
break;
}
*prog.status.lock().unwrap_or_else(|e| e.into_inner()) = format!("Rendering segment {} of {nseg}", k + 1);
let name = part_name(&t.seg.hash, t.off, t.len, t.seg.frames);
let part = dir.join(format!("{name}.part"));
let first = t.seg.first_frame.saturating_add(t.off);
let settings = filmcraft_export::ExportSettings {
format: filmcraft_export::Format::ProRes,
path: part.to_string_lossy().to_string(),
range: Some(TimeRange::from_bounds(rate.tick_of(first), rate.tick_of(first.saturating_add(t.len)))),
scale: 1.0,
include_audio: false,
quality: 90,
bitrate_kbps: 0,
// Captions stay live over previews and are not part of the preview hash.
burn_captions: false,
part_of_batch: true,
// previews stand in for the monitor picture: display-referred SDR
sdr: true,
..Default::default()
};
match filmcraft_export::export(&project, seq, &settings, &provider, &prog) {
Ok(r) => {
bytes += r.bytes;
done_frames += r.frames;
let fin = dir.join(&name);
if let Err(e) = std::fs::rename(&part, &fin) {
outcome = Err(e.to_string());
break;
}
store.add_video(&name);
}
Err(e) => {
let _ = std::fs::remove_file(&part);
outcome = Err(e.to_string());
break;
}
}
}
let secs = t0.elapsed().as_secs_f64();
let r = outcome.map(|_| filmcraft_export::Report {
path: dir.to_string_lossy().to_string(),
frames: done_frames,
seconds: secs,
bytes,
render_fps: done_frames as f64 / secs.max(1e-6),
..Default::default()
});
if let Err(e) = &r {
*prog.error.lock().unwrap_or_else(|x| x.into_inner()) = Some(e.clone());
}
*prog.status.lock().unwrap_or_else(|e| e.into_inner()) =
if r.is_ok() { format!("Rendered {done_frames} frames in {secs:.1}s") } else { "Render stopped".into() };
prog.finished.store(true, Ordering::Relaxed);
*res.lock().unwrap_or_else(|x| x.into_inner()) = Some(r);
};
let run = crate::export_tools::guard_job(job.progress.clone(), job.result.clone(), run);
s.jobs.push(job);
let wait = p.get("wait").and_then(Value::as_bool).unwrap_or(false);
if wait || cfg!(target_arch = "wasm32") {
run();
} else {
std::thread::Builder::new().name("filmcraft-render-previews".into()).spawn(run).map_err(|e| EngineError::Other(e.to_string()))?;
}
Ok(json!({"job": id, "segments": nseg, "frames": frames}))
}
/// Render Audio: mix the audio segments in In/Out (or the whole sequence) to float WAV previews.
pub fn render_audio(s: &mut Session, p: &Value) -> Result<Value> {
let (seq, range) = in_out(s)?;
let store = s.previews.clone();
let dir = store.dir().ok_or_else(|| EngineError::Other("render previews are not available here (no preview folder)".into()))?;
let sr = s.project.sequence(seq).map(|q| q.settings.sample_rate).unwrap_or(48_000) as i64;
let (a, b) = (range.start.to_units_floor(sr), range.end().to_units_floor(sr));
let todo: Vec<AudioSegment> = store
.audio_segments(&s.project, seq)
.iter()
.filter(|g| g.first_sample < b && a < g.first_sample + g.samples && !store.has_audio(&g.hash))
.cloned()
.collect();
if todo.is_empty() {
s.toast("Nothing to render: audio previews are up to date");
return Ok(json!({"job": null, "segments": 0}));
}
std::fs::create_dir_all(&dir).map_err(|e| EngineError::Other(format!("preview folder {}: {e}", dir.display())))?;
let total: i64 = todo.iter().map(|g| g.samples).sum();
let id = s.jobs.len() as u64 + 1;
let job = crate::Job { id, label: "Rendering audio previews".into(), progress: Default::default(), result: Default::default() };
job.progress.total.store(total.max(1) as u64, Ordering::Relaxed);
let project = s.project.clone();
let provider = s.media.full_res_provider(project.clone(), s.services.clone()).own_sources();
let (prog, res) = (job.progress.clone(), job.result.clone());
let nseg = todo.len();
let run = move || {
let t0 = web_time::Instant::now();
let mut bytes = 0u64;
let mut outcome: std::result::Result<(), String> = Ok(());
let Some(q) = project.sequence(seq) else { return };
'segs: for g in &todo {
// Streamed to the part file one second at a time: the segment's length comes from the
// project, so it must not size a buffer.
let Some(header) = u64::try_from(g.samples).ok().and_then(|n| wav_header_f32(n, sr as u32)) else {
outcome = Err("an audio segment is too long for a WAV preview".into());
break;
};
// its own part file: two jobs rendering one segment must not share (or remove) each other's
static PART: AtomicU64 = AtomicU64::new(0);
let part = dir.join(format!("{}.wav.{}-{}.part", g.hash, std::process::id(), PART.fetch_add(1, Ordering::Relaxed)));
let fin = dir.join(audio_name(&g.hash));
let written = (|| -> std::io::Result<Option<u64>> {
use std::io::Write;
let mut file = std::io::BufWriter::new(std::fs::File::create(&part)?);
file.write_all(&header)?;
let mut pos = g.first_sample;
let mut chunk = Vec::new();
while pos < g.first_sample + g.samples {
if prog.cancel.load(Ordering::Relaxed) {
return Ok(None);
}
let n = (g.first_sample + g.samples - pos).min(sr) as usize;
let buf = filmcraft_render::audio::mix_sequence(&project, q, pos, n, &provider);
chunk.clear();
for i in 0..n {
chunk.extend_from_slice(&buf.channels[0][i].to_le_bytes());
chunk.extend_from_slice(&buf.channels[buf.channels.len().min(2) - 1][i].to_le_bytes());
}
file.write_all(&chunk)?;
pos += n as i64;
prog.done.fetch_add(n as u64, Ordering::Relaxed);
}
file.flush()?;
Ok(Some(header.len() as u64 + g.samples as u64 * 8))
})();
let data_len = match written {
Ok(Some(len)) => len,
Ok(None) => {
let _ = std::fs::remove_file(&part);
outcome = Err("cancelled".into());
break 'segs;
}
Err(e) => {
let _ = std::fs::remove_file(&part);
outcome = Err(e.to_string());
break;
}
};
if let Err(e) = std::fs::rename(&part, &fin) {
let _ = std::fs::remove_file(&part);
outcome = Err(e.to_string());
break;
}
bytes += data_len;
store.add_audio(&g.hash);
}
let secs = t0.elapsed().as_secs_f64();
let r = outcome.map(|_| filmcraft_export::Report {
path: dir.to_string_lossy().to_string(),
frames: 0,
seconds: secs,
bytes,
render_fps: 0.0,
..Default::default()
});
if let Err(e) = &r {
*prog.error.lock().unwrap_or_else(|x| x.into_inner()) = Some(e.clone());
}
*prog.status.lock().unwrap_or_else(|e| e.into_inner()) =
if r.is_ok() { format!("Rendered audio for {nseg} segment(s) in {secs:.1}s") } else { "Render stopped".into() };
prog.finished.store(true, Ordering::Relaxed);
*res.lock().unwrap_or_else(|x| x.into_inner()) = Some(r);
};
let run = crate::export_tools::guard_job(job.progress.clone(), job.result.clone(), run);
s.jobs.push(job);
if p.get("wait").and_then(Value::as_bool).unwrap_or(false) || cfg!(target_arch = "wasm32") {
run();
} else {
std::thread::Builder::new().name("filmcraft-render-audio".into()).spawn(run).map_err(|e| EngineError::Other(e.to_string()))?;
}
Ok(json!({"job": id, "segments": nseg, "samples": total}))
}
/// The 44-byte header of a 32-bit float stereo WAV (WAVE_FORMAT_IEEE_FLOAT) of `frames` frames, or
/// None when its data would not fit the format's 32-bit sizes.
pub(crate) fn wav_header_f32(frames: u64, rate: u32) -> Option<[u8; 44]> {
let data_len = u32::try_from(frames.checked_mul(8)?).ok().filter(|&n| n <= u32::MAX - 36)?;
let mut v = [0u8; 44];
v[0..4].copy_from_slice(b"RIFF");
v[4..8].copy_from_slice(&(36 + data_len).to_le_bytes());
v[8..16].copy_from_slice(b"WAVEfmt ");
v[16..20].copy_from_slice(&16u32.to_le_bytes());
v[20..22].copy_from_slice(&3u16.to_le_bytes()); // IEEE float
v[22..24].copy_from_slice(&2u16.to_le_bytes());
v[24..28].copy_from_slice(&rate.to_le_bytes());
v[28..32].copy_from_slice(&rate.wrapping_mul(8).to_le_bytes());
v[32..34].copy_from_slice(&8u16.to_le_bytes());
v[34..36].copy_from_slice(&32u16.to_le_bytes());
v[36..40].copy_from_slice(b"data");
v[40..44].copy_from_slice(&data_len.to_le_bytes());
Some(v)
}
/// 32-bit float stereo WAV (WAVE_FORMAT_IEEE_FLOAT) from interleaved samples.
pub fn write_wav_f32(interleaved: &[f32], rate: u32) -> Vec<u8> {
let frames = (interleaved.len() / 2) as u64;
let mut v = wav_header_f32(frames, rate).map(|h| h.to_vec()).unwrap_or_default();
v.reserve(interleaved.len() * 4);
for s in interleaved {
v.extend_from_slice(&s.to_le_bytes());
}
v
}
/// Read the interleaved stereo samples of a file written by [`write_wav_f32`].
pub fn read_wav_f32(b: &[u8]) -> Option<Vec<f32>> {
if b.len() < 12 || &b[0..4] != b"RIFF" || &b[8..12] != b"WAVE" {
return None;
}
let mut i = 12;
let mut float_stereo = false;
while i + 8 <= b.len() {
let id = &b[i..i + 4];
let len = u32::from_le_bytes(b[i + 4..i + 8].try_into().ok()?) as usize;
let body = b.get(i + 8..(i + 8 + len).min(b.len()))?;
if id == b"fmt " && body.len() >= 16 {
let fmt = u16::from_le_bytes([body[0], body[1]]);
let ch = u16::from_le_bytes([body[2], body[3]]);
let bits = u16::from_le_bytes([body[14], body[15]]);
float_stereo = fmt == 3 && ch == 2 && bits == 32;
} else if id == b"data" {
if !float_stereo {
return None;
}
return Some(body.as_chunks::<4>().0.iter().map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]])).collect());
}
i += 8 + len + (len & 1);
}
None
}
/// Delete Render Files (all of the project's previews) or Delete Render Files In to Out.
pub fn delete(s: &mut Session, in_to_out: bool) -> Result<Value> {
let n = if in_to_out {
let (seq, range) = in_out(s)?;
let rate = s.project.sequence(seq).ok_or(EngineError::NoSequence)?.settings.frame_rate;
// the files holding frames between In and Out (a partial preview outside them stays)
let names: Vec<String> = s
.previews
.segments(&s.project, seq)
.iter()
.flat_map(|g| {
let (a, b) = rel_range(g, rate, &range);
s.previews.parts_in(g, a, b)
})
.collect();
s.previews.delete_files(&names)
} else {
s.previews.delete(None)
};
s.toast(format!("Deleted {n} render file{}", if n == 1 { "" } else { "s" }));
Ok(json!({"deleted": n}))
}
/// The render bar of the active sequence as JSON (for agents and tests).
pub fn bar_json(s: &Session) -> Result<Value> {
let seq = s.state.active_sequence.ok_or(EngineError::NoSequence)?;
let rate = s.sequence_rate();
let segs = s.previews.segments(&s.project, seq);
Ok(json!({
"dir": s.previews.dir().map(|d| d.to_string_lossy().to_string()),
"files": s.previews.count(),
"segments": segs.iter().map(|g| json!({
"start": g.start.0,
"end": g.end.0,
"startFrame": g.first_frame,
"frames": g.frames,
"startSeconds": g.start.seconds(),
"endSeconds": g.end.seconds(),
"state": s.previews.state_of(g),
"renderedFrames": s.previews.coverage(g).iter().map(|(a, b)| b - a).sum::<i64>(),
"costMs": (g.cost_ms * 10.0).round() / 10.0,
"budgetMs": (rate.frame_duration().seconds() * 1000.0 * filmcraft_render::preview::REALTIME_BUDGET * 10.0).round() / 10.0,
"hash": g.hash,
})).collect::<Vec<_>>(),
}))
}
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.