265 lines
8.4 KiB
Rust
265 lines
8.4 KiB
Rust
use tvai_sdk::*;
|
|
use tempfile::TempDir;
|
|
use std::fs;
|
|
|
|
#[test]
|
|
fn test_template_loading_from_file() {
|
|
// Create a temporary template file
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let template_path = temp_dir.path().join("test_template.json");
|
|
|
|
let template_json = r#"{
|
|
"name": "Test Template",
|
|
"description": "A test template",
|
|
"author": "Test Author",
|
|
"date": "Mon Jan 01 12:00:00 2024 GMT+0000",
|
|
"veaiversion": "5.1.2",
|
|
"editable": true,
|
|
"enabled": true,
|
|
"saveOutputSettings": false,
|
|
"settings": {
|
|
"stabilize": {
|
|
"active": false,
|
|
"smooth": 50,
|
|
"method": 1,
|
|
"rsc": false,
|
|
"reduceMotion": false,
|
|
"reduceMotionIteration": 2
|
|
},
|
|
"motionblur": {
|
|
"active": false,
|
|
"model": "thm-2"
|
|
},
|
|
"slowmo": {
|
|
"active": false,
|
|
"model": "apo-8",
|
|
"factor": 1,
|
|
"duplicate": true,
|
|
"duplicateThreshold": 10
|
|
},
|
|
"enhance": {
|
|
"active": true,
|
|
"model": "prob-4",
|
|
"videoType": 1,
|
|
"auto": 0,
|
|
"fieldOrder": 0,
|
|
"compress": 0,
|
|
"detail": 0,
|
|
"sharpen": 0,
|
|
"denoise": 0,
|
|
"dehalo": 0,
|
|
"deblur": 0,
|
|
"addNoise": 0,
|
|
"recoverOriginalDetailValue": 20,
|
|
"isArtemis": false,
|
|
"isGaia": false,
|
|
"isTheia": false,
|
|
"isProteus": true,
|
|
"isIris": false
|
|
},
|
|
"grain": {
|
|
"active": false,
|
|
"grain": 5,
|
|
"grainSize": 2
|
|
},
|
|
"output": {
|
|
"active": true,
|
|
"outSizeMethod": 7,
|
|
"cropToFit": false,
|
|
"outputPAR": 0,
|
|
"outFPS": 0
|
|
}
|
|
}
|
|
}"#;
|
|
|
|
fs::write(&template_path, template_json).unwrap();
|
|
|
|
// Test loading template
|
|
let mut sdk = TvaiSdk::new();
|
|
let template = sdk.load_template_from_file(&template_path).unwrap();
|
|
|
|
assert_eq!(template.name, "Test Template");
|
|
assert_eq!(template.description, "A test template");
|
|
assert!(template.settings.enhance.active);
|
|
assert_eq!(template.settings.enhance.model, "prob-4");
|
|
}
|
|
|
|
#[test]
|
|
fn test_template_validation_and_completion() {
|
|
let mut template = Template {
|
|
name: "Test".to_string(),
|
|
description: "".to_string(),
|
|
author: "".to_string(),
|
|
date: "".to_string(),
|
|
veai_version: "".to_string(),
|
|
editable: true,
|
|
enabled: true,
|
|
save_output_settings: false,
|
|
path: None,
|
|
settings: TemplateSettings::default(),
|
|
};
|
|
|
|
// Should complete missing fields
|
|
template.validate_and_complete().unwrap();
|
|
|
|
assert_eq!(template.author, "Unknown");
|
|
assert!(!template.date.is_empty());
|
|
assert_eq!(template.veai_version, "5.1.2");
|
|
}
|
|
|
|
#[test]
|
|
fn test_ffmpeg_command_generation() {
|
|
let template = TemplatePresets::upscale_to_4k().unwrap();
|
|
let sdk = TvaiSdk::new();
|
|
|
|
let command = sdk.generate_ffmpeg_command(&template, "input.mp4", "output.mp4").unwrap();
|
|
|
|
assert!(command.contains("ffmpeg"));
|
|
assert!(command.contains("input.mp4"));
|
|
assert!(command.contains("output.mp4"));
|
|
assert!(command.contains("tvai_up"));
|
|
assert!(command.contains("model=ahq-12"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_template_builder() {
|
|
let template = TemplateBuilder::new("Custom Template")
|
|
.description("A custom template")
|
|
.author("Test User")
|
|
.enable_enhancement("prob-4")
|
|
.enhancement_params(30, 20, 10)
|
|
.enable_stabilization(60, 1)
|
|
.output_settings(6, 60.0)
|
|
.build()
|
|
.unwrap();
|
|
|
|
assert_eq!(template.name, "Custom Template");
|
|
assert_eq!(template.description, "A custom template");
|
|
assert_eq!(template.author, "Test User");
|
|
assert!(template.settings.enhance.active);
|
|
assert_eq!(template.settings.enhance.denoise, 30);
|
|
assert_eq!(template.settings.enhance.detail, 20);
|
|
assert_eq!(template.settings.enhance.sharpen, 10);
|
|
assert!(template.settings.stabilize.active);
|
|
assert_eq!(template.settings.stabilize.smooth, 60);
|
|
assert_eq!(template.settings.output.out_fps, 60.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_template_presets() {
|
|
// Test all presets can be created successfully
|
|
let upscale_4k = TemplatePresets::upscale_to_4k().unwrap();
|
|
assert_eq!(upscale_4k.name, "Upscale to 4K");
|
|
assert!(upscale_4k.settings.enhance.active);
|
|
|
|
let convert_60fps = TemplatePresets::convert_to_60fps().unwrap();
|
|
assert_eq!(convert_60fps.name, "Convert to 60 FPS");
|
|
assert!(convert_60fps.settings.slow_motion.active);
|
|
assert_eq!(convert_60fps.settings.output.out_fps, 60.0);
|
|
|
|
let remove_noise = TemplatePresets::remove_noise().unwrap();
|
|
assert_eq!(remove_noise.name, "Remove Noise");
|
|
assert!(remove_noise.settings.enhance.active);
|
|
assert_eq!(remove_noise.settings.enhance.model, "nyx-3");
|
|
|
|
let stabilize = TemplatePresets::stabilize_video().unwrap();
|
|
assert_eq!(stabilize.name, "Stabilize Video");
|
|
assert!(stabilize.settings.stabilize.active);
|
|
|
|
let slow_motion = TemplatePresets::slow_motion_4x().unwrap();
|
|
assert_eq!(slow_motion.name, "4x Slow Motion");
|
|
assert!(slow_motion.settings.slow_motion.active);
|
|
assert_eq!(slow_motion.settings.slow_motion.factor, 4.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_template_manager() {
|
|
let mut sdk = TvaiSdk::new();
|
|
|
|
// Add templates
|
|
let template1 = TemplatePresets::upscale_to_4k().unwrap();
|
|
let template2 = TemplatePresets::convert_to_60fps().unwrap();
|
|
|
|
sdk.add_template(template1).unwrap();
|
|
sdk.add_template(template2).unwrap();
|
|
|
|
assert_eq!(sdk.template_count(), 2);
|
|
assert!(sdk.has_template("Upscale to 4K"));
|
|
assert!(sdk.has_template("Convert to 60 FPS"));
|
|
|
|
// Test finding templates
|
|
let found = sdk.find_template("Upscale to 4K").unwrap();
|
|
assert_eq!(found.name, "Upscale to 4K");
|
|
|
|
// Test removing template
|
|
let removed = sdk.remove_template("Upscale to 4K").unwrap();
|
|
assert_eq!(removed.name, "Upscale to 4K");
|
|
assert_eq!(sdk.template_count(), 1);
|
|
assert!(!sdk.has_template("Upscale to 4K"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_batch_command_generation() {
|
|
let template = TemplatePresets::upscale_to_4k().unwrap();
|
|
let sdk = TvaiSdk::new();
|
|
|
|
let input_files = vec![
|
|
"video1.mp4".to_string(),
|
|
"video2.mp4".to_string(),
|
|
"video3.mp4".to_string(),
|
|
];
|
|
|
|
let commands = sdk.generate_batch_commands(&template, &input_files, "/output").unwrap();
|
|
|
|
assert_eq!(commands.len(), 3);
|
|
assert!(commands[0].contains("video1.mp4"));
|
|
assert!(commands[0].contains("/output/video1_processed.mp4"));
|
|
assert!(commands[1].contains("video2.mp4"));
|
|
assert!(commands[2].contains("video3.mp4"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_hardware_acceleration_command() {
|
|
let template = TemplatePresets::upscale_to_4k().unwrap();
|
|
let sdk = TvaiSdk::new();
|
|
|
|
let command = sdk.generate_ffmpeg_command_with_gpu(&template, "input.mp4", "output.mp4", "0").unwrap();
|
|
|
|
assert!(command.contains("device=0:"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_custom_codec_command() {
|
|
let template = TemplatePresets::upscale_to_4k().unwrap();
|
|
let sdk = TvaiSdk::new();
|
|
|
|
let command = sdk.generate_ffmpeg_command_with_codec(&template, "input.mp4", "output.mp4", "hevc_nvenc", Some(20)).unwrap();
|
|
|
|
assert!(command.contains("hevc_nvenc"));
|
|
assert!(command.contains("-cq 20"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_json_export_import() {
|
|
let mut sdk = TvaiSdk::new();
|
|
|
|
// Add some templates
|
|
sdk.add_template(TemplatePresets::upscale_to_4k().unwrap()).unwrap();
|
|
sdk.add_template(TemplatePresets::convert_to_60fps().unwrap()).unwrap();
|
|
|
|
// Export to JSON
|
|
let json = sdk.export_templates_to_json().unwrap();
|
|
assert!(json.contains("Upscale to 4K"));
|
|
assert!(json.contains("Convert to 60 FPS"));
|
|
|
|
// Clear and import
|
|
sdk.clear_templates();
|
|
assert_eq!(sdk.template_count(), 0);
|
|
|
|
let imported_count = sdk.import_templates_from_json(&json).unwrap();
|
|
assert_eq!(imported_count, 2);
|
|
assert_eq!(sdk.template_count(), 2);
|
|
assert!(sdk.has_template("Upscale to 4K"));
|
|
assert!(sdk.has_template("Convert to 60 FPS"));
|
|
}
|