clipasm 0.5.0

A strict, typed language for compiling and rendering Video and Audio graphs
Documentation
use crate::compiler::evaluate::Evaluation;
use crate::diagnostic::{BuiltinDiagnostic, Diagnostic, Result};
use crate::model::{FrameCount, NativeRange, ValueRef, ValueType, VideoDomain, VideoSpec};
use crate::semantic::SemanticNodeKind;

#[derive(Clone)]
enum DomainKnowledge {
    NotVideo,
    Deferred,
    Known(VideoDomain),
}

#[expect(
    clippy::too_many_lines,
    reason = "domain inference is one exhaustive semantic-node transfer function with shared memoized knowledge"
)]
pub(super) fn infer_domains(
    evaluation: &Evaluation,
    video: &VideoSpec,
    order: &[ValueRef],
) -> Result<Vec<Option<VideoDomain>>> {
    let mut knowledge = vec![DomainKnowledge::NotVideo; evaluation.nodes.len()];
    for value in order {
        let index = value.id().get() as usize;
        if value.value_type() != ValueType::Video {
            continue;
        }
        let node = &evaluation.nodes[index];
        knowledge[index] = match node.kind() {
            SemanticNodeKind::ImageVideo { frames, .. } => {
                DomainKnowledge::Known(project_domain(video, *frames))
            }
            SemanticNodeKind::DeferredImageVideo { .. }
            | SemanticNodeKind::DeferredSlice { .. }
            | SemanticNodeKind::DeferredReplaceRange { .. } => DomainKnowledge::Deferred,
            SemanticNodeKind::VideoSource { .. } | SemanticNodeKind::AudioOnBlack { .. } => {
                DomainKnowledge::Deferred
            }
            SemanticNodeKind::ExternalVideo { invocation } => {
                let preserved = invocation.inputs[&invocation.preserve_input];
                knowledge[preserved.id().get() as usize].clone()
            }
            SemanticNodeKind::AudioSource { .. } | SemanticNodeKind::ExtractAudio { .. } => {
                DomainKnowledge::NotVideo
            }
            SemanticNodeKind::Reference { symbol, .. } => {
                let target = evaluation.symbols[symbol.index()]
                    .value
                    .expect("references were resolved before domain inference");
                knowledge[target.id().get() as usize].clone()
            }
            SemanticNodeKind::Repeat { input, count } => {
                match &knowledge[input.id().get() as usize] {
                    DomainKnowledge::Known(domain) => DomainKnowledge::Known(project_domain(
                        video,
                        domain
                            .frames()
                            .checked_mul(count.get(), &node.origin().span)?,
                    )),
                    DomainKnowledge::Deferred => DomainKnowledge::Deferred,
                    DomainKnowledge::NotVideo => DomainKnowledge::NotVideo,
                }
            }
            SemanticNodeKind::ZoomIn { input, .. }
            | SemanticNodeKind::SetAudio { video: input, .. } => {
                knowledge[input.id().get() as usize].clone()
            }
            SemanticNodeKind::FlashCut {
                before,
                after,
                frames,
            } => infer_flash_cut_domain(
                &knowledge[before.id().get() as usize],
                &knowledge[after.id().get() as usize],
                *frames,
                video,
                &node.origin().span,
            )?,
            SemanticNodeKind::Crossfade {
                before,
                after,
                frames,
            } => infer_crossfade_domain(
                &knowledge[before.id().get() as usize],
                &knowledge[after.id().get() as usize],
                *frames,
                video,
                &node.origin().span,
            )?,
            SemanticNodeKind::Concat { inputs } => {
                infer_concat_domain(inputs, &knowledge, video, &node.origin().span)?
            }
            SemanticNodeKind::Slice { input, range } => {
                let NativeRange::Frames(range) = range else {
                    unreachable!("Video semantic slice has a frame range")
                };
                if let DomainKnowledge::Known(input_domain) = &knowledge[input.id().get() as usize]
                {
                    validate_range(*range, input_domain.frames(), &node.origin().span)?;
                }
                DomainKnowledge::Known(project_domain(video, range.frames()))
            }
            SemanticNodeKind::ReplaceRange {
                base,
                replacement,
                range,
            } => {
                let NativeRange::Frames(range) = range else {
                    unreachable!("Video semantic replacement has a frame range")
                };
                let base_domain = &knowledge[base.id().get() as usize];
                if let DomainKnowledge::Known(base_domain) = base_domain {
                    validate_range(*range, base_domain.frames(), &node.origin().span)?;
                }
                let replacement_domain = &knowledge[replacement.id().get() as usize];
                match (base_domain, replacement_domain) {
                    (
                        DomainKnowledge::Known(base_domain),
                        DomainKnowledge::Known(replacement_domain),
                    ) => DomainKnowledge::Known(project_domain(
                        video,
                        FrameCount(base_domain.frames().0 - range.frames().0)
                            .checked_add(replacement_domain.frames(), &node.origin().span)?,
                    )),
                    (DomainKnowledge::NotVideo, _) | (_, DomainKnowledge::NotVideo) => {
                        unreachable!("replace-range inputs are typed Video")
                    }
                    _ => DomainKnowledge::Deferred,
                }
            }
        };
    }

    Ok(knowledge
        .into_iter()
        .map(|knowledge| match knowledge {
            DomainKnowledge::Known(domain) => Some(domain),
            DomainKnowledge::NotVideo | DomainKnowledge::Deferred => None,
        })
        .collect())
}

fn project_domain(video: &VideoSpec, frames: FrameCount) -> VideoDomain {
    VideoDomain::new(frames, *video)
}

fn validate_range(
    range: crate::model::FrameRange,
    input: FrameCount,
    span: &crate::source::SourceSpan,
) -> Result<()> {
    if range.end() > input.0 {
        return Err(Diagnostic::builtin(
            BuiltinDiagnostic::InvalidTimeRange,
            format!(
                "frame range {}..{} is outside the base Video domain of {} frames",
                range.start(),
                range.end(),
                input.0
            ),
            span.clone(),
        ));
    }
    Ok(())
}

fn validate_flash_cut_frames(
    frames: FrameCount,
    after: FrameCount,
    span: &crate::source::SourceSpan,
) -> Result<()> {
    if frames > after {
        return Err(Diagnostic::builtin(
            BuiltinDiagnostic::InvalidFlashCutDuration,
            format!(
                "`flash_cut.duration` covers {} frames, but `after` contains only {} frames",
                frames.0, after.0
            ),
            span.clone(),
        ));
    }
    Ok(())
}

fn infer_flash_cut_domain(
    before: &DomainKnowledge,
    after: &DomainKnowledge,
    frames: FrameCount,
    video: &VideoSpec,
    span: &crate::source::SourceSpan,
) -> Result<DomainKnowledge> {
    if let DomainKnowledge::Known(after) = after {
        validate_flash_cut_frames(frames, after.frames(), span)?;
    }
    Ok(match (before, after) {
        (DomainKnowledge::Known(before), DomainKnowledge::Known(after)) => DomainKnowledge::Known(
            project_domain(video, before.frames().checked_add(after.frames(), span)?),
        ),
        (DomainKnowledge::NotVideo, _) | (_, DomainKnowledge::NotVideo) => {
            unreachable!("flash_cut inputs are typed Video")
        }
        _ => DomainKnowledge::Deferred,
    })
}

fn validate_crossfade_frames(
    frames: FrameCount,
    before: Option<FrameCount>,
    after: Option<FrameCount>,
    span: &crate::source::SourceSpan,
) -> Result<()> {
    if frames.0 == 0 {
        return Err(Diagnostic::builtin(
            BuiltinDiagnostic::InvalidCrossfadeDuration,
            "`crossfade.duration` must cover at least one project frame",
            span.clone(),
        ));
    }
    for (name, available) in [("before", before), ("after", after)] {
        if let Some(available) = available
            && frames > available
        {
            return Err(Diagnostic::builtin(
                BuiltinDiagnostic::InvalidCrossfadeDuration,
                format!(
                    "`crossfade.duration` covers {} frames, but `{name}` contains only {} frames",
                    frames.0, available.0
                ),
                span.clone(),
            ));
        }
    }
    Ok(())
}

fn infer_crossfade_domain(
    before: &DomainKnowledge,
    after: &DomainKnowledge,
    frames: FrameCount,
    video: &VideoSpec,
    span: &crate::source::SourceSpan,
) -> Result<DomainKnowledge> {
    let known_before = match before {
        DomainKnowledge::Known(domain) => Some(domain.frames()),
        DomainKnowledge::Deferred => None,
        DomainKnowledge::NotVideo => unreachable!("crossfade inputs are typed Video"),
    };
    let known_after = match after {
        DomainKnowledge::Known(domain) => Some(domain.frames()),
        DomainKnowledge::Deferred => None,
        DomainKnowledge::NotVideo => unreachable!("crossfade inputs are typed Video"),
    };
    validate_crossfade_frames(frames, known_before, known_after, span)?;
    Ok(match (known_before, known_after) {
        (Some(before), Some(after)) => {
            let combined = before.checked_add(after, span)?;
            DomainKnowledge::Known(project_domain(video, FrameCount(combined.0 - frames.0)))
        }
        _ => DomainKnowledge::Deferred,
    })
}

fn infer_concat_domain(
    inputs: &[ValueRef],
    knowledge: &[DomainKnowledge],
    video: &VideoSpec,
    span: &crate::source::SourceSpan,
) -> Result<DomainKnowledge> {
    if inputs.iter().any(|input| {
        matches!(
            knowledge[input.id().get() as usize],
            DomainKnowledge::Deferred
        )
    }) {
        return Ok(DomainKnowledge::Deferred);
    }
    let mut total = FrameCount(0);
    for input in inputs {
        match &knowledge[input.id().get() as usize] {
            DomainKnowledge::Known(domain) => {
                total = total.checked_add(domain.frames(), span)?;
            }
            DomainKnowledge::Deferred => unreachable!("deferred concat handled before summing"),
            DomainKnowledge::NotVideo => unreachable!("concat inputs are typed Video"),
        }
    }
    Ok(DomainKnowledge::Known(project_domain(video, total)))
}