clipasm 0.1.0

A strict, typed, stack-based programmatic video compiler
Documentation
use crate::diagnostic::{Diagnostic, Result};
use crate::model::{ValueRef, ValueType};
use crate::program::{
    BodyContract, BodyFinalizer, BodyOutputConstraint, BodyPlan, Cardinality, InputPort,
    ParameterDescriptor, ParameterType, ProgramDefinition, ProgramDescriptor,
    ProgramImplementation, ProgramOutputs, ResolvedCall, StackAccess, ValueTypeSpec,
};
use crate::semantic::{GraphBuilder, require_value_type};
use crate::source::SourceSpan;

const VIDEO: ValueType = ValueType::Video;

pub(crate) fn join() -> ProgramDefinition {
    body(
        generic_descriptor(
            "join",
            3,
            vec![generic_input("before"), generic_input("after")],
        ),
        prepare_join,
        BodyContract {
            initial_values: vec![ValueTypeSpec::Generic, ValueTypeSpec::Generic],
            outputs: BodyOutputConstraint::Variadic {
                value_type: ValueTypeSpec::Generic,
                min: 1,
            },
            count_error_code: "E_EMPTY_JOIN",
        },
    )
}

pub(crate) fn glue() -> ProgramDefinition {
    body(
        generic_descriptor("glue", 2, vec![]),
        prepare_glue,
        BodyContract {
            initial_values: vec![],
            outputs: BodyOutputConstraint::Variadic {
                value_type: ValueTypeSpec::Generic,
                min: 1,
            },
            count_error_code: "E_EMPTY_GLUE",
        },
    )
}

pub(crate) fn during() -> ProgramDefinition {
    body(
        descriptor(
            "during",
            2,
            vec![input("video")],
            vec![ParameterDescriptor {
                name: "range".to_owned(),
                parameter_type: ParameterType::TimeRange,
                required: true,
            }],
        ),
        prepare_during,
        BodyContract {
            initial_values: vec![VIDEO.into()],
            outputs: BodyOutputConstraint::Exactly(vec![VIDEO.into()]),
            count_error_code: "E_BODY_OUTPUT_COUNT",
        },
    )
}

fn generic_descriptor(
    name: &str,
    semantic_version: u32,
    inputs: Vec<InputPort>,
) -> ProgramDescriptor {
    ProgramDescriptor {
        name: name.to_owned(),
        semantic_version,
        default_stack_access: StackAccess::Visible,
        inputs,
        parameters: vec![],
        outputs: vec![ValueTypeSpec::Generic],
    }
}

fn generic_input(name: &str) -> InputPort {
    InputPort {
        name: name.to_owned(),
        value_type: ValueTypeSpec::Generic,
        cardinality: Cardinality::One,
    }
}

fn descriptor(
    name: &str,
    semantic_version: u32,
    inputs: Vec<InputPort>,
    parameters: Vec<ParameterDescriptor>,
) -> ProgramDescriptor {
    ProgramDescriptor {
        name: name.to_owned(),
        semantic_version,
        default_stack_access: StackAccess::Visible,
        inputs,
        parameters,
        outputs: vec![VIDEO.into()],
    }
}

fn input(name: &str) -> InputPort {
    InputPort {
        name: name.to_owned(),
        value_type: VIDEO.into(),
        cardinality: Cardinality::One,
    }
}

fn body(
    descriptor: ProgramDescriptor,
    prepare: crate::program::BodyPrepareFn,
    body_contract: BodyContract,
) -> ProgramDefinition {
    ProgramDefinition {
        descriptor,
        implementation: ProgramImplementation::Body {
            prepare,
            contract: body_contract,
        },
    }
}

fn prepare_join(call: &ResolvedCall, _builder: &mut GraphBuilder<'_>) -> Result<BodyPlan> {
    Ok(BodyPlan {
        initial_values: vec![call.one_input("before")?, call.one_input("after")?],
        requested_frames: call.requested_frames(),
        finalizer: Box::new(FinalizeConcatBody::for_call(call, "E_EMPTY_JOIN")),
    })
}

#[allow(clippy::unnecessary_wraps)]
fn prepare_glue(call: &ResolvedCall, _builder: &mut GraphBuilder<'_>) -> Result<BodyPlan> {
    Ok(BodyPlan {
        initial_values: Vec::new(),
        requested_frames: call.requested_frames(),
        finalizer: Box::new(FinalizeConcatBody::for_call(call, "E_EMPTY_GLUE")),
    })
}

fn prepare_during(call: &ResolvedCall, builder: &mut GraphBuilder<'_>) -> Result<BodyPlan> {
    let base = call.one_input("video")?;
    let (range, span) = call.time_range_parameter("range")?;
    let range = range.to_frames(builder.video_spec().fps(), span)?;
    let selected = builder.at_span(span.clone()).slice(base, range)?;
    Ok(BodyPlan {
        initial_values: vec![selected],
        requested_frames: Some(range.frames()),
        finalizer: Box::new(FinalizeDuring {
            base,
            range,
            span: span.clone(),
        }),
    })
}

struct FinalizeConcatBody {
    owner: String,
    empty_code: &'static str,
    span: SourceSpan,
}

impl FinalizeConcatBody {
    fn for_call(call: &ResolvedCall, empty_code: &'static str) -> Self {
        Self {
            owner: call.program_name().to_owned(),
            empty_code,
            span: call.origin().span.clone(),
        }
    }
}

impl BodyFinalizer for FinalizeConcatBody {
    fn finish(
        self: Box<Self>,
        stack: Vec<ValueRef>,
        builder: &mut GraphBuilder<'_>,
    ) -> Result<ProgramOutputs> {
        if stack.is_empty() {
            return Err(Diagnostic::new(
                self.empty_code,
                format!("{} must produce at least one Video or Audio", self.owner),
                self.span,
            ));
        }
        Ok(vec![builder.concat(stack)?])
    }
}

struct FinalizeDuring {
    base: ValueRef,
    range: crate::model::FrameRange,
    span: SourceSpan,
}

impl BodyFinalizer for FinalizeDuring {
    fn finish(
        self: Box<Self>,
        stack: Vec<ValueRef>,
        builder: &mut GraphBuilder<'_>,
    ) -> Result<ProgramOutputs> {
        let replacement = take_one_video("during", stack, &self.span)?;
        Ok(vec![builder.replace_range(
            self.base,
            self.range,
            replacement,
        )?])
    }
}

fn take_one_video(owner: &str, stack: Vec<ValueRef>, span: &SourceSpan) -> Result<ValueRef> {
    if stack.len() != 1 {
        return Err(Diagnostic::new(
            "E_BODY_OUTPUT_COUNT",
            format!(
                "`{owner}` body must leave exactly one value, but {} values remain",
                stack.len()
            ),
            span.clone(),
        ));
    }
    let output = stack.into_iter().next().expect("one checked body output");
    require_value_type(output, VIDEO, owner, "output", span)?;
    Ok(output)
}