clipasm 0.2.1

A strict, typed, stack-based programmatic video compiler
Documentation
use std::path::{Path, PathBuf};

use crate::diagnostic::{Diagnostic, Result};
use crate::model::{NodeId, ValueType};
use crate::preflight::tools::verify_external_tool;
use crate::preflight::{
    PreparedAudioKind, PreparedExternalArgument, PreparedExternalParameterValue, PreparedNode,
    PreparedNodeMedia, PreparedPlan, PreparedVideoKind, verify_prepared_asset,
};
use crate::source::SourceSpan;

use super::artifact::verify_prepared_artifact;
use super::cache;
use super::execute::Executor;
use super::lock::{FileLock, sibling_lock_path};

pub(super) struct ExecutionPlan {
    actions: Vec<ExecutionAction>,
    slot_count: usize,
}

struct ExecutionAction {
    node: NodeId,
    artifact: PathBuf,
    disposition: CacheDisposition,
}

#[derive(Clone, Copy)]
enum CacheDisposition {
    ReuseVerified,
    Render,
}

pub(super) struct ExecutionResult {
    artifacts: Vec<Option<PathBuf>>,
    cache_hits: usize,
    cache_misses: usize,
}

impl ExecutionPlan {
    pub(super) fn build(plan: &PreparedPlan, cache_directory: &Path) -> Result<Self> {
        validate_prepared_order(plan)?;
        let mut seen = vec![false; plan.nodes().len()];
        let mut pending = vec![plan.result()];
        let mut actions = Vec::new();

        while let Some(id) = pending.pop() {
            let index = id.get() as usize;
            if seen[index] {
                continue;
            }
            seen[index] = true;
            let node = &plan.nodes()[index];
            let artifact = cache_artifact_path(plan, cache_directory, node);
            let disposition = if probe_cache(plan, node, &artifact)? {
                verify_node_resources(node)?;
                CacheDisposition::ReuseVerified
            } else {
                node.visit_inputs(|input| pending.push(input));
                CacheDisposition::Render
            };
            actions.push(ExecutionAction {
                node: id,
                artifact,
                disposition,
            });
        }

        actions.sort_unstable_by_key(|action| action.node.get());
        Ok(Self {
            actions,
            slot_count: plan.nodes().len(),
        })
    }

    pub(super) fn execute(self, plan: &PreparedPlan) -> Result<ExecutionResult> {
        let executor = Executor::new(plan);
        let mut artifacts = vec![None; self.slot_count];
        let mut cache_hits = 0;
        let mut cache_misses = 0;

        for action in self.actions {
            let index = action.node.get() as usize;
            let node = &plan.nodes()[index];
            match action.disposition {
                CacheDisposition::ReuseVerified => {
                    cache_hits += 1;
                }
                CacheDisposition::Render => {
                    let lock_path = sibling_lock_path(&action.artifact, "cache");
                    let _lock = FileLock::acquire(
                        &lock_path,
                        "E_CACHE_LOCK",
                        "cache artifact",
                        &node.origin().span,
                    )?;
                    let cache_hit = cache_is_valid(plan, node, &action.artifact);
                    verify_node_resources(node)?;
                    if cache_hit {
                        cache_hits += 1;
                    } else {
                        cache::remove_entry(&action.artifact)?;
                        let staged = executor.render_node(node, &artifacts, &action.artifact)?;
                        verify_prepared_artifact(
                            plan.ffprobe().executable(),
                            staged.path(),
                            node,
                            plan.audio(),
                            plan.render_policy().working_pixel_format(),
                        )?;
                        staged.commit(node.fingerprint())?;
                        cache_misses += 1;
                    }
                }
            }
            artifacts[index] = Some(action.artifact);
        }

        Ok(ExecutionResult {
            artifacts,
            cache_hits,
            cache_misses,
        })
    }
}

impl ExecutionResult {
    pub(super) fn artifact(&self, id: NodeId, span: &SourceSpan) -> Result<&Path> {
        self.artifacts
            .get(id.get() as usize)
            .and_then(Option::as_deref)
            .ok_or_else(|| {
                Diagnostic::new(
                    "E_INVALID_PLAN",
                    "prepared result does not identify an executed artifact",
                    span.clone(),
                )
            })
    }

    pub(super) const fn cache_hits(&self) -> usize {
        self.cache_hits
    }

    pub(super) const fn cache_misses(&self) -> usize {
        self.cache_misses
    }
}

fn validate_prepared_order(plan: &PreparedPlan) -> Result<()> {
    for (index, node) in plan.nodes().iter().enumerate() {
        if node.id().get() as usize != index {
            return Err(Diagnostic::new(
                "E_INVALID_PLAN",
                "prepared nodes are not in stable topological order",
                node.origin().span.clone(),
            ));
        }
        let mut invalid_input = None;
        node.visit_inputs(|input| {
            if input.get() as usize >= index {
                invalid_input = Some(input);
            }
        });
        if let Some(input) = invalid_input {
            return Err(Diagnostic::new(
                "E_INVALID_PLAN",
                format!(
                    "prepared node {} has non-topological input {}",
                    node.id().get(),
                    input.get()
                ),
                node.origin().span.clone(),
            ));
        }
    }

    let result = plan
        .nodes()
        .get(plan.result().get() as usize)
        .ok_or_else(|| {
            Diagnostic::new(
                "E_INVALID_PLAN",
                "prepared result does not identify an existing node",
                SourceSpan::source_start(plan.entrypoint_source().clone()),
            )
        })?;
    if result.value_type() != ValueType::Video {
        return Err(Diagnostic::new(
            "E_INVALID_PLAN",
            "prepared result is Audio, but rendering requires Video",
            result.origin().span.clone(),
        ));
    }
    Ok(())
}

fn probe_cache(plan: &PreparedPlan, node: &PreparedNode, artifact: &Path) -> Result<bool> {
    let lock_path = sibling_lock_path(artifact, "cache");
    let _lock = FileLock::acquire(
        &lock_path,
        "E_CACHE_LOCK",
        "cache artifact",
        &node.origin().span,
    )?;
    Ok(cache_is_valid(plan, node, artifact))
}

fn cache_artifact_path(
    plan: &PreparedPlan,
    cache_directory: &Path,
    node: &PreparedNode,
) -> PathBuf {
    let extension = match node.value_type() {
        ValueType::Video => plan.render_policy().working_video_extension(),
        ValueType::Audio => plan.render_policy().working_audio_extension(),
    };
    cache_directory.join(format!("{}.{}", node.fingerprint(), extension))
}

fn cache_is_valid(plan: &PreparedPlan, node: &PreparedNode, artifact: &Path) -> bool {
    cache::verify_entry(artifact, node.fingerprint()).is_ok()
        && verify_prepared_artifact(
            plan.ffprobe().executable(),
            artifact,
            node,
            plan.audio(),
            plan.render_policy().working_pixel_format(),
        )
        .is_ok()
}

fn verify_node_resources(node: &PreparedNode) -> Result<()> {
    match node.media() {
        PreparedNodeMedia::Video {
            kind:
                PreparedVideoKind::ImageVideo { asset, .. }
                | PreparedVideoKind::VideoSource { asset, .. },
            ..
        }
        | PreparedNodeMedia::Audio {
            kind: PreparedAudioKind::AudioSource { asset },
            ..
        } => verify_prepared_asset(asset, &node.origin().span),
        PreparedNodeMedia::Video {
            kind:
                PreparedVideoKind::ExternalVideo {
                    executable,
                    arguments,
                    parameters,
                    ..
                },
            ..
        } => {
            verify_external_tool(executable, &node.origin().span)?;
            for asset in arguments.iter().filter_map(|argument| match argument {
                PreparedExternalArgument::File(asset) => Some(asset),
                PreparedExternalArgument::Text(_) => None,
            }) {
                verify_prepared_asset(asset, &node.origin().span)?;
            }
            for asset in parameters.values().filter_map(|value| match value {
                PreparedExternalParameterValue::File(asset) => Some(asset),
                PreparedExternalParameterValue::Integer(_)
                | PreparedExternalParameterValue::Keyword(_) => None,
            }) {
                verify_prepared_asset(asset, &node.origin().span)?;
            }
            Ok(())
        }
        PreparedNodeMedia::Video { .. } | PreparedNodeMedia::Audio { .. } => Ok(()),
    }
}