f67d38b35cc5
common.rs
use super::{BTreeSet, FrameRate, ItemId, ItemKind, MediaClip, Project, Session, Tick, TimeRange, TrackItem, Value, item_p, json};
// ---------------------------------------------------------------------------------------------
// helpers
// ---------------------------------------------------------------------------------------------
/// The media item behind `id` (subclips resolve to their parent) and the subclip range.
pub(super) fn media_root(p: &Project, id: ItemId) -> Option<(ItemId, &MediaClip, Option<TimeRange>)> {
p.resolve_media(id)
}
/// What the Source monitor shows for an item: the media-time span of its time ruler, its frame
/// rate, In / Out marks and markers.
///
/// A subclip that restricts trims shows only its range (the playhead can't leave it); one that
/// doesn't shows its parent's whole media with the subclip's range as In / Out. Either way a
/// subclip shows the markers of its parent media that fall inside its range (inherited: they
/// belong to the master clip, so adding one there shows on every subclip that covers it).
#[derive(Clone, Debug, PartialEq)]
pub struct SourceView {
pub item: ItemId,
/// The media item whose frames are shown (the parent of a subclip).
pub media: ItemId,
pub start: Tick,
pub end: Tick,
pub rate: FrameRate,
pub mark_in: Option<Tick>,
pub mark_out: Option<Tick>,
pub markers: Vec<filmcraft_project::Marker>,
/// For a subclip: its range and whether trims are restricted to it.
pub subclip: Option<(TimeRange, bool)>,
}
impl SourceView {
/// The marked Source span. Unset marks mean the beginning/end of the source; Out is inclusive.
pub fn selected_range(&self) -> TimeRange {
if self.start.0 < 0 || self.end <= self.start {
return TimeRange::new(self.start, Tick::ZERO);
}
let start = self.mark_in.unwrap_or(self.start).clamp(self.start, self.end);
let end = self.mark_out.map(|o| Tick(o.0.saturating_add(self.rate.frame_duration().0))).unwrap_or(self.end).clamp(start, self.end);
TimeRange::from_bounds(start, end)
}
pub fn to_json(&self, playhead: Tick) -> Value {
json!({
"item": self.item.0, "media": self.media.0, "start": self.start.0, "end": self.end.0, "fps": self.rate.as_f64(),
"playhead": playhead.0, "markIn": self.mark_in.map(|t| t.0), "markOut": self.mark_out.map(|t| t.0),
"markers": self.markers.iter().map(|m| json!({"id": m.id.0, "start": m.start.0, "name": m.name, "duration": m.duration.0, "color":m.color_value(), "author":m.author, "comment":m.comment, "url":m.url, "kind":m.kind})).collect::<Vec<_>>(),
"subclip": self.subclip.map(|(r, restrict)| json!({"start": r.start.0, "end": r.end().0, "restrictTrims": restrict})),
})
}
}
/// The Source monitor view of `item` (see [`SourceView`]).
pub fn source_view(s: &Session, item: ItemId) -> Option<SourceView> {
let pi = s.project.item(item)?;
let still = |m: &MediaClip| matches!(m.info.kind, filmcraft_media::MediaKind::Still) || m.info.duration.0 <= 0;
Some(match &pi.kind {
ItemKind::Media(m) => {
let rate = m.frame_rate();
let end = if still(m) { s.prefs.timeline.still_duration(rate) } else { m.duration() };
SourceView { item, media: item, start: Tick::ZERO, end, rate, mark_in: m.mark_in, mark_out: m.mark_out, markers: m.markers.clone(), subclip: None }
}
ItemKind::Sequence(q) => SourceView {
item,
media: item,
start: Tick::ZERO,
end: q.duration(),
rate: q.settings.frame_rate,
mark_in: q.mark_in,
mark_out: q.mark_out,
markers: q.markers.clone(),
subclip: None,
},
ItemKind::Subclip { range, restrict_trims, .. } => {
let (root, m, _) = media_root(&s.project, item)?;
let rate = m.frame_rate();
let fd = rate.frame_duration();
let markers = m.markers.iter().filter(|k| k.start >= range.start && k.start < range.end()).cloned().collect();
let full = if still(m) { range.end() } else { m.duration().max(range.end()) };
let (start, end, mi, mo) =
if *restrict_trims { (range.start, range.end(), None, None) } else { (Tick::ZERO, full, Some(range.start), Some(range.end() - fd)) };
SourceView { item, media: root, start, end, rate, mark_in: mi, mark_out: mo, markers, subclip: Some((*range, *restrict_trims)) }
}
_ => SourceView {
item,
media: item,
start: Tick::ZERO,
end: pi.duration(),
rate: pi.frame_rate(),
mark_in: None,
mark_out: None,
markers: Vec::new(),
subclip: None,
},
})
}
/// Frame rate of an item, resolving subclips to their media.
pub(super) fn item_rate(p: &Project, id: ItemId) -> FrameRate {
match media_root(p, id) {
Some((_, m, _)) => m.frame_rate(),
None => p.item(id).map(|i| i.frame_rate()).unwrap_or_default(),
}
}
pub(super) fn items_p(s: &Session, p: &Value) -> Vec<ItemId> {
match p.get("items").and_then(Value::as_array) {
Some(a) => a.iter().filter_map(|v| v.as_u64().map(ItemId)).collect(),
None => item_p(p, "item").map(|i| vec![i]).unwrap_or_else(|| s.state.project_selection.clone()),
}
}
/// Fold the undo steps pushed since the history had `n0` entries into one step named `label`.
pub(crate) fn collapse_history(s: &mut Session, n0: usize, label: &str) {
if s.history.undo.len() > n0 {
let (first, origin) = (s.history.undo[n0].1.clone(), s.history.undo[n0].2.clone());
s.history.undo.truncate(n0);
s.history.undo.push((label.to_string(), first, origin));
}
}
/// Every item referenced by a clip in any sequence (subclips pull in their parents, nested
/// sequences count as used).
pub(super) fn used_items(p: &Project) -> BTreeSet<ItemId> {
let mut used = BTreeSet::new();
for it in p.items.values() {
if let ItemKind::Sequence(q) = &it.kind {
for t in q.all_tracks() {
for i in &t.items {
used.insert(i.item);
}
}
if let Some(m) = &q.merged {
let v = serde_json::to_value(m).unwrap_or_default();
collect_ids(&v, &mut used, p);
}
}
}
// subclip parents of anything kept
let mut changed = true;
while changed {
changed = false;
for it in p.items.values() {
if let ItemKind::Subclip { parent, .. } = it.kind
&& (used.contains(&it.id) || !is_removable(p, it.id))
&& used.insert(parent)
{
changed = true;
}
}
}
used
}
/// Item ids mentioned in a JSON value (keys named `item`/`items`/`video`/`audio` holding ids).
pub(crate) fn collect_ids(v: &Value, out: &mut BTreeSet<ItemId>, p: &Project) {
match v {
Value::Object(m) => {
for (k, x) in m {
if matches!(k.as_str(), "item" | "items" | "video" | "audio") {
for n in x.as_array().cloned().unwrap_or_else(|| vec![x.clone()]) {
if let Some(id) = n.as_u64().map(ItemId).filter(|i| p.items.contains_key(i)) {
out.insert(id);
}
}
}
collect_ids(x, out, p);
}
}
Value::Array(a) => a.iter().for_each(|x| collect_ids(x, out, p)),
_ => {}
}
}
/// Remove Unused removes clips only: never sequences or graphic sources.
pub(super) fn is_removable(p: &Project, id: ItemId) -> bool {
p.item(id).is_some_and(|i| matches!(i.kind, ItemKind::Media(_) | ItemKind::Subclip { .. } | ItemKind::AdjustmentLayer { .. }))
}
pub(super) fn remove_items(p: &mut Project, ids: &[ItemId]) {
for i in ids {
p.items.remove(i);
p.root.remove_item(*i);
}
}
/// Keyframe times of an effect instance shifted / scaled from clip `from` to clip `to` (media time).
pub(super) fn retime_effect(e: &mut filmcraft_project::EffectInstance, from: &TrackItem, to: &TrackItem, scale: bool) {
let (f0, f1) = (from.source_in, from.source_out());
let (t0, t1) = (to.source_in, to.source_out());
let map = |k: Tick| -> Tick {
if scale && f1 > f0 {
let r = (k - f0).0 as f64 / (f1 - f0).0 as f64;
t0 + Tick((r * (t1 - t0).0 as f64).round() as i64)
} else {
t0 + (k - f0)
}
};
for p in e.params.values_mut() {
for k in &mut p.keyframes {
k.time = map(k.time);
}
}
for m in &mut e.masks {
for p in [&mut m.path, &mut m.feather, &mut m.opacity, &mut m.expansion] {
for k in &mut p.keyframes {
k.time = map(k.time);
}
}
}
}
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.