f67d38b35cc5
file.rs
use super::common::{collapse_history, item_rate, items_p, media_root};
use super::enabled::is_clip_item;
use super::{
AudioChannels, BTreeMap, BinEntry, EngineError, FrameRate, ItemId, ItemKind, Label, MediaClip, MediaRef, Project, Result, Session, Tick, TimeRange, Value,
bad, bool_p, f64_p, json, parse_timecode, place_item, str_p, u64_p,
};
// ---------------------------------------------------------------------------------------------
// File
// ---------------------------------------------------------------------------------------------
pub(super) fn sequence_from_clip(s: &mut Session, p: &Value) -> Result<Value> {
let items: Vec<ItemId> = items_p(s, p).into_iter().filter(|i| is_clip_item(&s.project, *i)).collect();
let first = *items.first().ok_or_else(|| bad("file.newSequenceFromClip", "select a clip in the Project panel"))?;
let pi = s.project.item(first).ok_or_else(|| bad("file.newSequenceFromClip", "no such item"))?.clone();
let mut settings = match &pi.kind {
ItemKind::Sequence(q) => q.settings.clone(),
_ => media_root(&s.project, first).map(|(_, m, _)| crate::commands::default_seq_settings_for(m)).unwrap_or_default(),
};
if let ItemKind::AdjustmentLayer { width, height, rate, .. } = &pi.kind {
settings.width = *width;
settings.height = *height;
settings.frame_rate = *rate;
}
let channels = media_root(&s.project, first).and_then(|(_, m, _)| m.info.audio().map(|a| a.channels)).unwrap_or(2);
let n_audio = media_root(&s.project, first)
.map(|(_, m, _)| {
crate::commands::audio_placement_specs(m.interpret.audio_channels.as_ref().map_or(&[], |a| a.clips.as_slice()), m.info.audio_streams.len()).len()
})
.unwrap_or(1);
let n0 = s.history.undo.len();
let name = pi.name.clone();
let bin = s.project.root.parent_of(first).filter(|b| *b != s.project.root.id);
let seq = s.edit("New Sequence From Clip", |pr, st| {
let id = pr.new_sequence(&name, settings, 1, n_audio.max(1), bin);
if channels == 1
&& let Some(q) = pr.sequence_mut(id)
{
q.settings.audio_master = AudioChannels::Stereo;
}
st.active_sequence = Some(id);
if !st.open_sequences.contains(&id) {
st.open_sequences.push(id);
}
Ok(id)
})?;
let mut at = Tick::ZERO;
let mut placed = Vec::new();
for item in items {
let still = s.prefs.timeline.still_duration(item_rate(&s.project, item));
let Some(range) = item_range(&s.project, item, still) else { continue };
let tg = s.targeting();
let ids = place_item(
s,
crate::commands::ItemPlacement {
item,
range,
at,
vdest: tg.video_dest,
adest: tg.audio_dest,
insert: false,
label: "New Sequence From Clip",
audio_split: None,
},
)?;
at = s.active_sequence().map(|q| q.duration()).unwrap_or(at);
placed.extend(ids.iter().map(|c| c.0));
}
collapse_history(s, n0, "New Sequence From Clip");
s.state.selection.clear();
s.events.push(crate::Event::OpenSequence(seq));
Ok(json!({"sequence": seq.0, "clips": placed}))
}
/// The media range an item edits in with: its In/Out marks, a subclip's range, or the whole item.
pub(crate) fn item_range(p: &Project, id: ItemId, still: Tick) -> Option<TimeRange> {
let it = p.item(id)?;
let rate = item_rate(p, id);
Some(match &it.kind {
ItemKind::Media(m) => {
let is_still = matches!(m.info.kind, filmcraft_media::MediaKind::Still);
let full = if m.info.duration.0 > 0 && !is_still { m.info.duration } else { still };
let a = m.mark_in.unwrap_or(Tick::ZERO);
let b = m.mark_out.map(|o| o + rate.frame_duration()).unwrap_or(full);
TimeRange::from_bounds(a, b.max(a + rate.frame_duration()))
}
ItemKind::Subclip { range, .. } => *range,
ItemKind::Sequence(q) => {
let a = q.mark_in.unwrap_or(Tick::ZERO);
let b = q.mark_out.map(|o| o + q.settings.frame_rate.frame_duration()).unwrap_or(q.duration());
TimeRange::from_bounds(a, b.max(a + q.settings.frame_rate.frame_duration()))
}
_ => TimeRange::new(Tick::ZERO, it.duration()),
})
}
pub(super) fn bin_from_selection(s: &mut Session, p: &Value) -> Result<Value> {
let items = items_p(s, p);
if items.is_empty() {
return Err(bad("file.newBinFromSelection", "select items in the Project panel"));
}
let parent = s.project.root.parent_of(items[0]).filter(|b| *b != s.project.root.id);
let name = match str_p(p, "name") {
Some(n) => n.to_string(),
None => {
let mut n = 1;
let mut names = Vec::new();
bin_names(&s.project.root, &mut names);
while names.contains(&format!("Bin {n:02}")) {
n += 1;
}
format!("Bin {n:02}")
}
};
let bin = s.edit("New Bin From Selection", |pr, _| {
let b = pr.add_bin(&name, parent);
pr.move_to_bin(&items, Some(b));
Ok(b)
})?;
Ok(json!({"bin": bin.0, "moved": items.len()}))
}
fn bin_names(b: &filmcraft_project::Bin, out: &mut Vec<String>) {
for c in &b.children {
if let BinEntry::Bin(x) = c {
out.push(x.name.clone());
bin_names(x, out);
}
}
}
pub(super) fn offline_file(s: &mut Session, p: &Value) -> Result<Value> {
let st = s.active_sequence().map(|q| q.settings.clone()).unwrap_or_default();
let has_v = bool_p(p, "video").unwrap_or(true);
let has_a = bool_p(p, "audio").unwrap_or(true);
if !has_v && !has_a {
return Err(bad("file.newOfflineFile", "an offline file needs video or audio"));
}
let rate = f64_p(p, "fps").map(FrameRate::from_f64).unwrap_or(st.frame_rate);
let width = u64_p(p, "width").map(|v| v as u32).unwrap_or(st.width);
let height = u64_p(p, "height").map(|v| v as u32).unwrap_or(st.height);
let secs = f64_p(p, "seconds").unwrap_or(10.0).max(rate.frame_duration().seconds());
let duration = rate.snap_nearest(Tick::from_seconds_f64(secs)).max(rate.frame_duration());
let start_tc = match str_p(p, "timecode") {
Some(tc) => Some(parse_timecode(tc, rate, false, 0).map_err(|e| bad("file.newOfflineFile", format!("timecode: {e:?}")))?),
None => None,
};
// A name, never a path: the item's media path is what Make Offline ▸ delete would remove.
let file_name = str_p(p, "fileName")
.and_then(|n| n.rsplit(['/', '\\', ':']).next())
.filter(|n| !n.is_empty() && *n != "." && *n != "..")
.map(str::to_string)
.unwrap_or_else(|| "Offline.mov".into());
let name = str_p(p, "name").map(str::to_string).filter(|n| !n.is_empty()).unwrap_or_else(|| file_name.clone());
let info = filmcraft_media::MediaInfo {
name: file_name.clone(),
kind: if has_v { filmcraft_media::MediaKind::Movie } else { filmcraft_media::MediaKind::AudioOnly },
duration,
video: has_v.then(|| filmcraft_media::VideoStreamInfo {
width,
height,
frame_rate: rate,
par: (1, 1),
codec: String::new(),
pixel_format: String::new(),
color: Default::default(),
has_alpha: false,
bitrate: None,
hdr: None,
color_assumed: None,
}),
audio_streams: has_a
.then(|| filmcraft_media::AudioStreamInfo {
sample_rate: u64_p(p, "sampleRate").unwrap_or(48_000) as u32,
channels: u64_p(p, "channels").unwrap_or(2).max(1) as u32,
codec: String::new(),
bits_per_sample: None,
})
.into_iter()
.collect(),
container: String::new(),
start_timecode: start_tc,
file_size: None,
};
let mut meta = BTreeMap::new();
if let Some(t) = str_p(p, "tapeName").filter(|t| !t.is_empty()) {
meta.insert("Tape Name".to_string(), t.to_string());
}
if let Some(d) = str_p(p, "description").filter(|t| !t.is_empty()) {
meta.insert("Description".to_string(), d.to_string());
}
let id = s.edit("New Offline File", |pr, stt| {
let id = pr.add_item(
&name,
if has_v { Label::Iris } else { Label::Caribbean },
ItemKind::Media(Box::new(MediaClip {
media: MediaRef::File { path: file_name },
info,
interpret: Default::default(),
mark_in: None,
mark_out: None,
markers: vec![],
offline: true,
proxy: None,
identity: None,
})),
None,
);
if let Some(it) = pr.item_mut(id) {
it.metadata = meta;
}
stt.project_selection = vec![id];
Ok(id)
})?;
Ok(json!({"item": id.0}))
}
pub(super) fn close_project(s: &mut Session, p: &Value) -> Result<Value> {
if s.is_dirty() && !bool_p(p, "force").unwrap_or(false) {
return Err(EngineError::Other("the project has unsaved changes: save it first, or pass {\"force\": true} to discard them".into()));
}
s.project = std::sync::Arc::new(Project::new("Untitled"));
s.project_instance = std::sync::Arc::new(());
s.document_epoch = s.document_epoch.wrapping_add(1);
s.history = Default::default();
s.history.limit = 200;
s.state = Session::default().state;
if s.path.take().is_some() {
s.previews.reset_temp();
}
s.revision += 1;
s.saved_revision = s.revision;
s.events.push(crate::Event::ProjectChanged { revision: s.revision });
Ok(json!({"closed": true}))
}
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.