clipasm 0.2.1

A strict, typed, stack-based programmatic video compiler
Documentation
use crate::model::{ImageFit, NodeId};

use super::tools::FfmpegRequirements;
use super::{PreparedAudioKind, PreparedNode, PreparedNodeMedia, PreparedVideoKind, RenderPolicy};

pub(super) fn ffmpeg_requirements(
    render_policy: RenderPolicy,
    nodes: &[PreparedNode],
    result: NodeId,
) -> FfmpegRequirements {
    let result = nodes
        .get(result.get() as usize)
        .expect("prepared result identifies an existing node");
    let mut requirements = FfmpegRequirements::for_export(render_policy, result.has_audio());
    for node in nodes {
        match node.media() {
            PreparedNodeMedia::Video {
                kind, has_audio, ..
            } => add_video_requirements(render_policy, kind, has_audio, &mut requirements),
            PreparedNodeMedia::Audio { kind, .. } => {
                add_audio_requirements(render_policy, kind, &mut requirements);
            }
        }
    }
    requirements
}

fn add_video_requirements(
    render_policy: RenderPolicy,
    kind: &PreparedVideoKind,
    has_audio: bool,
    requirements: &mut FfmpegRequirements,
) {
    if !matches!(kind, PreparedVideoKind::ExternalVideo { .. }) {
        requirements.require_native_video_output(render_policy);
    }
    match kind {
        PreparedVideoKind::ImageVideo { fit, .. } => {
            require_image_filter(*fit, requirements);
            requirements.require_filters(["trim", "setpts", "anullsrc"]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::VideoSource { fit, .. } => {
            require_image_filter(*fit, requirements);
            requirements.require_filters(["setpts", "tpad", "trim"]);
            if !has_audio {
                requirements.require_filters(["anullsrc"]);
            }
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::Slice { .. } => {
            requirements.require_filters(["trim", "setpts", "atrim", "asetpts"]);
        }
        PreparedVideoKind::Repeat { .. } => {
            requirements.require_filters(["trim", "setpts", "asetnsamples"]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::ZoomIn { .. } => {
            requirements.require_filters(["perspective", "setpts"]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::FlashCut { .. } => {
            requirements.require_filters(["fade", "concat"]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::Crossfade { .. } => {
            requirements.require_filters([
                "split", "trim", "setpts", "blend", "concat", "asplit", "atrim", "asetpts",
                "afade", "adelay", "apad", "amix",
            ]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::Concat { .. } => {
            requirements.require_filters(["concat"]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::SetAudio { .. } => {
            requirements.require_filters(["trim", "setpts"]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::AudioOnBlack { .. } => {
            requirements.require_filters(["color", "trim", "setpts", "format"]);
            require_normalized_audio(requirements);
        }
        PreparedVideoKind::ExternalVideo { .. } => {}
    }
}

fn add_audio_requirements(
    render_policy: RenderPolicy,
    kind: &PreparedAudioKind,
    requirements: &mut FfmpegRequirements,
) {
    requirements.require_native_audio_output(render_policy);
    match kind {
        PreparedAudioKind::AudioSource { .. }
        | PreparedAudioKind::AudioRepeat { .. }
        | PreparedAudioKind::ExtractAudio { .. } => require_normalized_audio(requirements),
        PreparedAudioKind::AudioSlice { .. } => {
            requirements.require_filters(["atrim", "asetpts"]);
        }
        PreparedAudioKind::AudioConcat { .. } => {
            requirements.require_filters(["concat"]);
            require_normalized_audio(requirements);
        }
    }
}

fn require_image_filter(fit: ImageFit, requirements: &mut FfmpegRequirements) {
    requirements.require_filters(["scale", "fps", "setsar", "format"]);
    match fit {
        ImageFit::Cover => requirements.require_filters(["crop"]),
        ImageFit::Contain => requirements.require_filters(["pad"]),
        ImageFit::Stretch => {}
    }
}

fn require_normalized_audio(requirements: &mut FfmpegRequirements) {
    requirements.require_filters(["aresample", "aformat", "atrim", "apad", "asetpts"]);
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use crate::model::FrameCount;

    use super::*;
    use crate::preflight::PreparedAsset;

    fn asset() -> PreparedAsset {
        PreparedAsset::new(PathBuf::from("asset"), "content".to_owned())
    }

    #[test]
    fn export_only_requirements_do_not_assume_native_artifact_encoders() {
        let requirements = FfmpegRequirements::for_export(RenderPolicy::CURRENT, false);
        assert!(requirements.requires_encoder("libx264"));
        assert!(!requirements.requires_encoder("ffv1"));
        assert!(!requirements.requires_encoder("flac"));
        assert!(!requirements.requires_encoder("aac"));
    }

    #[test]
    fn simple_image_requirements_exclude_unreachable_operations() {
        let mut requirements = FfmpegRequirements::for_export(RenderPolicy::CURRENT, false);
        add_video_requirements(
            RenderPolicy::CURRENT,
            &PreparedVideoKind::ImageVideo {
                asset: asset(),
                frames: FrameCount(1),
                fit: ImageFit::Stretch,
            },
            false,
            &mut requirements,
        );
        assert!(requirements.requires_encoder("libx264"));
        assert!(requirements.requires_filter("scale"));
        assert!(requirements.requires_filter("anullsrc"));
        assert!(!requirements.requires_filter("blend"));
        assert!(!requirements.requires_filter("fade"));
        assert!(!requirements.requires_filter("perspective"));
        assert!(!requirements.requires_encoder("aac"));
    }

    #[test]
    fn crossfade_and_audio_export_add_their_own_capabilities() {
        let mut requirements = FfmpegRequirements::for_export(RenderPolicy::CURRENT, true);
        add_video_requirements(
            RenderPolicy::CURRENT,
            &PreparedVideoKind::Crossfade {
                before: NodeId::new(0),
                after: NodeId::new(1),
                frames: FrameCount(1),
            },
            true,
            &mut requirements,
        );
        for filter in ["blend", "afade", "adelay", "amix", "split", "asplit"] {
            assert!(requirements.requires_filter(filter), "missing {filter}");
        }
        assert!(requirements.requires_encoder("aac"));
    }
}