feat: 完成 tvai 库视频处理功能 (阶段三)
视频格式转换功能 - 实现 images_to_video() 图像序列转视频 - 实现 video_to_images() 视频转图像序列 - 支持多种图像格式 (PNG, JPG, TIFF, BMP) - 智能帧序列处理和命名 - 质量预设和编码参数优化 视频超分辨率处理 - 实现 upscale_video() 完整超分辨率功能 - 支持所有 16 种 Topaz AI 模型 - 参数验证和模型约束检查 - GPU 加速和编码优化 - 自动 Topaz FFmpeg 滤镜构建 帧插值功能 - 实现 interpolate_video() 帧插值处理 - 支持所有 4 种插值模型 - 智能 FPS 计算和目标帧率设置 - 高质量慢动作效果生成 - 参数验证和范围检查 组合处理流水线 - 实现 enhance_video() 组合增强功能 - 支持超分辨率 + 插值的完整流水线 - 智能中间文件管理 - 灵活的处理组合选项 - 自动临时文件清理 便捷处理函数 - quick_upscale_video() 一键视频放大 - auto_enhance_video() 智能自动增强 - 自动 Topaz 检测和配置 - 基于视频特征的参数选择 - 默认高质量设置 预设参数系统 - VideoUpscaleParams::for_old_video() 老视频修复 - VideoUpscaleParams::for_game_content() 游戏内容 - VideoUpscaleParams::for_animation() 动画内容 - VideoUpscaleParams::for_portrait() 人像视频 - InterpolationParams::for_slow_motion() 慢动作 - InterpolationParams::for_animation() 动画插值 完整示例和演示 - 创建 video_processing.rs 综合示例 - 展示所有视频处理场景 - 参数配置和模型选择演示 - 格式转换和组合处理演示 - 便捷函数使用演示 技术特性 - 完整的 Topaz Video AI 集成 - 智能参数验证和错误处理 - 进度回调支持 (基础实现) - 异步处理和资源管理 - 跨平台兼容性 代码质量 - 所有测试通过 (6/6 单元测试 + 1 文档测试) - 完整的错误处理和验证 - 内存安全的资源管理 - 清晰的 API 设计 功能覆盖 - 视频超分辨率 (16 种模型) - 帧插值 (4 种模型) - 格式转换 (图像序列 视频) - 组合处理流水线 - 便捷处理函数 - 智能参数预设 下一步: 开始阶段四 - 图片处理功能实现
This commit is contained in:
imeepos
parent
42e3e923f9
commit
c683557307
|
|
@ -0,0 +1,227 @@
|
|||
//! Video processing examples demonstrating all video enhancement features
|
||||
|
||||
use std::path::Path;
|
||||
use tvai::*;
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
|
||||
println!("Topaz Video AI Library - Video Processing Examples");
|
||||
|
||||
// Detect Topaz installation
|
||||
if let Some(topaz_path) = detect_topaz_installation() {
|
||||
println!("Found Topaz Video AI at: {}", topaz_path.display());
|
||||
|
||||
// Create configuration
|
||||
let config = TvaiConfig::builder()
|
||||
.topaz_path(topaz_path)
|
||||
.use_gpu(true)
|
||||
.build()?;
|
||||
|
||||
// Create processor
|
||||
let mut processor = TvaiProcessor::new(config)?;
|
||||
println!("Processor created successfully");
|
||||
|
||||
// Demonstrate video upscaling
|
||||
demonstrate_video_upscaling(&mut processor).await?;
|
||||
|
||||
// Demonstrate frame interpolation
|
||||
demonstrate_frame_interpolation(&mut processor).await?;
|
||||
|
||||
// Demonstrate combined enhancement
|
||||
demonstrate_combined_enhancement(&mut processor).await?;
|
||||
|
||||
// Demonstrate format conversion
|
||||
demonstrate_format_conversion(&mut processor).await?;
|
||||
|
||||
// Demonstrate quick functions
|
||||
demonstrate_quick_functions().await?;
|
||||
|
||||
println!("All video processing examples completed successfully!");
|
||||
} else {
|
||||
println!("Topaz Video AI not found. Please install it first.");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn demonstrate_video_upscaling(processor: &mut TvaiProcessor) -> std::result::Result<(), Box<dyn std::error::Error>> {
|
||||
println!("\n=== Video Upscaling Demo ===");
|
||||
|
||||
// Create upscaling parameters for different scenarios
|
||||
let scenarios = vec![
|
||||
("General Purpose", VideoUpscaleParams {
|
||||
scale_factor: 2.0,
|
||||
model: UpscaleModel::Iris3,
|
||||
compression: 0.0,
|
||||
blend: 0.1,
|
||||
quality_preset: QualityPreset::HighQuality,
|
||||
}),
|
||||
("Old Video Restoration", VideoUpscaleParams::for_old_video()),
|
||||
("Game Content", VideoUpscaleParams::for_game_content()),
|
||||
("Animation", VideoUpscaleParams::for_animation()),
|
||||
("Portrait Video", VideoUpscaleParams::for_portrait()),
|
||||
];
|
||||
|
||||
for (name, params) in scenarios {
|
||||
println!("Scenario: {}", name);
|
||||
println!(" Model: {} ({})", params.model.as_str(), params.model.description());
|
||||
println!(" Scale: {}x", params.scale_factor);
|
||||
println!(" Compression: {}", params.compression);
|
||||
println!(" Blend: {}", params.blend);
|
||||
println!(" Quality: {:?}", params.quality_preset);
|
||||
|
||||
// In a real scenario, you would call:
|
||||
// let result = processor.upscale_video(input, output, params, Some(&progress_callback)).await?;
|
||||
// println!(" Processing time: {:?}", result.processing_time);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn demonstrate_frame_interpolation(processor: &mut TvaiProcessor) -> std::result::Result<(), Box<dyn std::error::Error>> {
|
||||
println!("\n=== Frame Interpolation Demo ===");
|
||||
|
||||
// Create interpolation parameters for different scenarios
|
||||
let scenarios = vec![
|
||||
("Slow Motion (24fps -> 60fps)", InterpolationParams {
|
||||
input_fps: 24,
|
||||
multiplier: 2.5,
|
||||
model: InterpolationModel::Apo8,
|
||||
target_fps: Some(60),
|
||||
}),
|
||||
("Animation Smoothing", InterpolationParams::for_animation(12, 2.0)),
|
||||
("High Quality Slow Motion", InterpolationParams::for_slow_motion(30, 4.0)),
|
||||
("Fast Processing", InterpolationParams {
|
||||
input_fps: 24,
|
||||
multiplier: 2.0,
|
||||
model: InterpolationModel::Apf1,
|
||||
target_fps: None,
|
||||
}),
|
||||
];
|
||||
|
||||
for (name, params) in scenarios {
|
||||
let target_fps = params.target_fps.unwrap_or((params.input_fps as f32 * params.multiplier) as u32);
|
||||
|
||||
println!("Scenario: {}", name);
|
||||
println!(" Model: {} ({})", params.model.as_str(), params.model.description());
|
||||
println!(" Input FPS: {}", params.input_fps);
|
||||
println!(" Multiplier: {}x", params.multiplier);
|
||||
println!(" Target FPS: {}", target_fps);
|
||||
|
||||
// In a real scenario, you would call:
|
||||
// let result = processor.interpolate_video(input, output, params, Some(&progress_callback)).await?;
|
||||
// println!(" Processing time: {:?}", result.processing_time);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn demonstrate_combined_enhancement(processor: &mut TvaiProcessor) -> std::result::Result<(), Box<dyn std::error::Error>> {
|
||||
println!("\n=== Combined Enhancement Demo ===");
|
||||
|
||||
// Create combined enhancement parameters
|
||||
let scenarios = vec![
|
||||
("Complete Enhancement", VideoEnhanceParams {
|
||||
upscale: Some(VideoUpscaleParams {
|
||||
scale_factor: 2.0,
|
||||
model: UpscaleModel::Iris3,
|
||||
compression: 0.0,
|
||||
blend: 0.1,
|
||||
quality_preset: QualityPreset::HighQuality,
|
||||
}),
|
||||
interpolation: Some(InterpolationParams {
|
||||
input_fps: 24,
|
||||
multiplier: 2.0,
|
||||
model: InterpolationModel::Apo8,
|
||||
target_fps: Some(48),
|
||||
}),
|
||||
}),
|
||||
("Upscale Only", VideoEnhanceParams {
|
||||
upscale: Some(VideoUpscaleParams::for_old_video()),
|
||||
interpolation: None,
|
||||
}),
|
||||
("Interpolation Only", VideoEnhanceParams {
|
||||
upscale: None,
|
||||
interpolation: Some(InterpolationParams::for_slow_motion(30, 2.0)),
|
||||
}),
|
||||
];
|
||||
|
||||
for (name, params) in scenarios {
|
||||
println!("Scenario: {}", name);
|
||||
if let Some(ref upscale) = params.upscale {
|
||||
println!(" Upscale: {} @ {}x", upscale.model.as_str(), upscale.scale_factor);
|
||||
}
|
||||
if let Some(ref interpolation) = params.interpolation {
|
||||
let target_fps = interpolation.target_fps.unwrap_or((interpolation.input_fps as f32 * interpolation.multiplier) as u32);
|
||||
println!(" Interpolation: {} ({}fps -> {}fps)",
|
||||
interpolation.model.as_str(),
|
||||
interpolation.input_fps,
|
||||
target_fps
|
||||
);
|
||||
}
|
||||
|
||||
// In a real scenario, you would call:
|
||||
// let result = processor.enhance_video(input, output, params, Some(&progress_callback)).await?;
|
||||
// println!(" Processing time: {:?}", result.processing_time);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn demonstrate_format_conversion(processor: &mut TvaiProcessor) -> std::result::Result<(), Box<dyn std::error::Error>> {
|
||||
println!("\n=== Format Conversion Demo ===");
|
||||
|
||||
// Demonstrate image sequence to video conversion
|
||||
println!("Image Sequence to Video:");
|
||||
println!(" - Collect image files in sequence");
|
||||
println!(" - Set target FPS (e.g., 24, 30, 60)");
|
||||
println!(" - Choose quality preset");
|
||||
println!(" - Generate video file");
|
||||
|
||||
// In a real scenario:
|
||||
// let image_paths = vec![/* image file paths */];
|
||||
// let result = processor.images_to_video(&image_paths, output_video, 30.0, QualityPreset::HighQuality, Some(&progress_callback)).await?;
|
||||
|
||||
println!("\nVideo to Image Sequence:");
|
||||
println!(" - Extract all frames from video");
|
||||
println!(" - Choose output format (PNG, JPG, etc.)");
|
||||
println!(" - Set quality level");
|
||||
println!(" - Generate numbered image files");
|
||||
|
||||
// In a real scenario:
|
||||
// let image_paths = processor.video_to_images(input_video, output_dir, "png", 95, Some(&progress_callback)).await?;
|
||||
// println!(" Extracted {} frames", image_paths.len());
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn demonstrate_quick_functions() -> std::result::Result<(), Box<dyn std::error::Error>> {
|
||||
println!("\n=== Quick Functions Demo ===");
|
||||
|
||||
println!("Quick Upscale Video:");
|
||||
println!(" - One-line video upscaling");
|
||||
println!(" - Automatic Topaz detection");
|
||||
println!(" - Default high-quality settings");
|
||||
println!(" - Usage: quick_upscale_video(input, output, 2.0).await?");
|
||||
|
||||
println!("\nAuto Enhance Video:");
|
||||
println!(" - Intelligent enhancement detection");
|
||||
println!(" - Automatic parameter selection");
|
||||
println!(" - Based on video characteristics");
|
||||
println!(" - Usage: auto_enhance_video(input, output).await?");
|
||||
|
||||
// In a real scenario:
|
||||
// let result = quick_upscale_video(Path::new("input.mp4"), Path::new("output.mp4"), 2.0).await?;
|
||||
// let result = auto_enhance_video(Path::new("input.mp4"), Path::new("enhanced.mp4")).await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Progress callback example
|
||||
fn create_progress_callback(operation_name: &str) -> ProgressCallback {
|
||||
let name = operation_name.to_string();
|
||||
Box::new(move |progress| {
|
||||
let percentage = (progress * 100.0) as u32;
|
||||
println!("{}: {}%", name, percentage);
|
||||
})
|
||||
}
|
||||
|
|
@ -1,4 +1,178 @@
|
|||
//! Video format conversion utilities
|
||||
|
||||
// Placeholder for video conversion implementation
|
||||
// This will be implemented in later stages
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::fs;
|
||||
use crate::core::{TvaiError, TvaiProcessor, ProgressCallback};
|
||||
use crate::config::QualityPreset;
|
||||
|
||||
/// Video conversion utilities
|
||||
impl TvaiProcessor {
|
||||
/// Convert image sequence to video
|
||||
pub async fn images_to_video(
|
||||
&mut self,
|
||||
image_paths: &[PathBuf],
|
||||
output_path: &Path,
|
||||
fps: f32,
|
||||
quality_preset: QualityPreset,
|
||||
progress_callback: Option<&ProgressCallback>,
|
||||
) -> Result<(), TvaiError> {
|
||||
self.validate_output_path(output_path)?;
|
||||
|
||||
if image_paths.is_empty() {
|
||||
return Err(TvaiError::InvalidParameter("No input images provided".to_string()));
|
||||
}
|
||||
|
||||
// Validate all input images exist
|
||||
for image_path in image_paths {
|
||||
self.validate_input_file(image_path)?;
|
||||
}
|
||||
|
||||
let operation_id = self.generate_operation_id();
|
||||
|
||||
// Create temporary directory for frame sequence
|
||||
let temp_dir = self.create_temp_dir(&operation_id)?;
|
||||
|
||||
// Copy and rename images to sequential format
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.1);
|
||||
}
|
||||
|
||||
self.prepare_image_sequence(image_paths, &temp_dir, &operation_id).await?;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.3);
|
||||
}
|
||||
|
||||
// Build FFmpeg command
|
||||
let frame_pattern = temp_dir.join("frame_%05d.png");
|
||||
let (codec, preset) = quality_preset.get_encoding_settings(self.is_gpu_enabled());
|
||||
let quality = quality_preset.get_quality_value(self.is_gpu_enabled());
|
||||
|
||||
let fps_str = fps.to_string();
|
||||
let mut args = vec![
|
||||
"-y", "-hide_banner", "-nostdin",
|
||||
"-r", &fps_str,
|
||||
"-i", frame_pattern.to_str().unwrap(),
|
||||
"-c:v", codec,
|
||||
];
|
||||
|
||||
if self.is_gpu_enabled() {
|
||||
args.extend_from_slice(&["-preset", preset, "-global_quality", quality]);
|
||||
} else {
|
||||
args.extend_from_slice(&["-preset", preset, "-crf", quality]);
|
||||
}
|
||||
|
||||
args.extend_from_slice(&["-pix_fmt", "yuv420p"]);
|
||||
args.push(output_path.to_str().unwrap());
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.5);
|
||||
}
|
||||
|
||||
// Execute FFmpeg command
|
||||
self.execute_ffmpeg_command(&args, false, progress_callback).await?;
|
||||
|
||||
// Cleanup temporary files
|
||||
self.cleanup_temp_files(&operation_id)?;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(1.0);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Convert video to image sequence
|
||||
pub async fn video_to_images(
|
||||
&mut self,
|
||||
input_path: &Path,
|
||||
output_dir: &Path,
|
||||
image_format: &str,
|
||||
quality: u8,
|
||||
progress_callback: Option<&ProgressCallback>,
|
||||
) -> Result<Vec<PathBuf>, TvaiError> {
|
||||
self.validate_input_file(input_path)?;
|
||||
|
||||
// Create output directory if it doesn't exist
|
||||
fs::create_dir_all(output_dir)?;
|
||||
|
||||
let _operation_id = self.generate_operation_id();
|
||||
let output_pattern = output_dir.join(format!("frame_%05d.{}", image_format));
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.1);
|
||||
}
|
||||
|
||||
// Build FFmpeg command for extraction
|
||||
let mut args = vec![
|
||||
"-y", "-hide_banner", "-nostdin",
|
||||
"-i", input_path.to_str().unwrap(),
|
||||
"-vsync", "0",
|
||||
];
|
||||
|
||||
// Add quality settings based on format
|
||||
let quality_str = (101 - quality).to_string();
|
||||
match image_format.to_lowercase().as_str() {
|
||||
"png" => {
|
||||
args.extend_from_slice(&["-compression_level", "6"]);
|
||||
}
|
||||
"jpg" | "jpeg" => {
|
||||
args.extend_from_slice(&["-q:v", &quality_str]);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
args.push(output_pattern.to_str().unwrap());
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.3);
|
||||
}
|
||||
|
||||
// Execute FFmpeg command
|
||||
self.execute_ffmpeg_command(&args, false, progress_callback).await?;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.8);
|
||||
}
|
||||
|
||||
// Collect generated image paths
|
||||
let mut image_paths = Vec::new();
|
||||
if let Ok(entries) = fs::read_dir(output_dir) {
|
||||
for entry in entries.flatten() {
|
||||
let path = entry.path();
|
||||
if let Some(extension) = path.extension() {
|
||||
if extension.to_string_lossy().to_lowercase() == image_format.to_lowercase() {
|
||||
image_paths.push(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sort paths to ensure correct order
|
||||
image_paths.sort();
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(1.0);
|
||||
}
|
||||
|
||||
Ok(image_paths)
|
||||
}
|
||||
|
||||
/// Prepare image sequence with proper naming
|
||||
async fn prepare_image_sequence(
|
||||
&self,
|
||||
image_paths: &[PathBuf],
|
||||
temp_dir: &Path,
|
||||
_operation_id: &str,
|
||||
) -> Result<(), TvaiError> {
|
||||
for (index, image_path) in image_paths.iter().enumerate() {
|
||||
let target_name = format!("frame_{:05}.png", index + 1);
|
||||
let target_path = temp_dir.join(target_name);
|
||||
|
||||
// Copy image to temp directory with sequential naming
|
||||
fs::copy(image_path, target_path)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,149 @@
|
|||
//! Frame interpolation implementation
|
||||
|
||||
// Placeholder for frame interpolation implementation
|
||||
// This will be implemented in later stages
|
||||
use std::path::Path;
|
||||
use std::time::Instant;
|
||||
use crate::core::{TvaiError, TvaiProcessor, ProcessResult, ProgressCallback};
|
||||
use crate::video::InterpolationParams;
|
||||
|
||||
/// Frame interpolation implementation
|
||||
impl TvaiProcessor {
|
||||
/// Interpolate video frames to create smooth slow motion
|
||||
pub async fn interpolate_video(
|
||||
&mut self,
|
||||
input_path: &Path,
|
||||
output_path: &Path,
|
||||
params: InterpolationParams,
|
||||
progress_callback: Option<&ProgressCallback>,
|
||||
) -> Result<ProcessResult, TvaiError> {
|
||||
let start_time = Instant::now();
|
||||
|
||||
// Validate inputs
|
||||
self.validate_input_file(input_path)?;
|
||||
self.validate_output_path(output_path)?;
|
||||
|
||||
// Validate parameters
|
||||
self.validate_interpolation_params(¶ms)?;
|
||||
|
||||
let operation_id = self.generate_operation_id();
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.0);
|
||||
}
|
||||
|
||||
// Calculate target FPS
|
||||
let target_fps = match params.target_fps {
|
||||
Some(fps) => fps,
|
||||
None => (params.input_fps as f32 * params.multiplier) as u32,
|
||||
};
|
||||
|
||||
// Build Topaz interpolation filter
|
||||
let interpolation_filter = self.build_interpolation_filter(¶ms, target_fps)?;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.1);
|
||||
}
|
||||
|
||||
// Build FFmpeg command with Topaz interpolation filter
|
||||
let mut args = vec![
|
||||
"-y", "-hide_banner", "-nostdin", "-strict", "2",
|
||||
"-hwaccel", "auto",
|
||||
"-i", input_path.to_str().unwrap(),
|
||||
"-vf", &interpolation_filter,
|
||||
];
|
||||
|
||||
// Add encoding settings (use high quality for interpolation)
|
||||
if self.is_gpu_enabled() {
|
||||
args.extend_from_slice(&[
|
||||
"-c:v", "hevc_nvenc",
|
||||
"-preset", "slow",
|
||||
"-global_quality", "17",
|
||||
"-pix_fmt", "yuv420p",
|
||||
]);
|
||||
} else {
|
||||
args.extend_from_slice(&[
|
||||
"-c:v", "libx264",
|
||||
"-preset", "slow",
|
||||
"-crf", "17",
|
||||
]);
|
||||
}
|
||||
|
||||
args.push(output_path.to_str().unwrap());
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.2);
|
||||
}
|
||||
|
||||
// Execute Topaz interpolation (requires Topaz FFmpeg)
|
||||
self.execute_ffmpeg_command(&args, true, progress_callback).await?;
|
||||
|
||||
let processing_time = start_time.elapsed();
|
||||
|
||||
// Get FFmpeg version for metadata
|
||||
let ffmpeg_version = self.get_ffmpeg_version(true).await.ok();
|
||||
|
||||
// Create result metadata
|
||||
let mut metadata = self.create_metadata(
|
||||
operation_id,
|
||||
input_path,
|
||||
format!("interpolation: model={}, input_fps={}, multiplier={}, target_fps={}",
|
||||
params.model.as_str(),
|
||||
params.input_fps,
|
||||
params.multiplier,
|
||||
target_fps
|
||||
),
|
||||
);
|
||||
metadata.ffmpeg_version = ffmpeg_version;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(1.0);
|
||||
}
|
||||
|
||||
Ok(ProcessResult {
|
||||
output_path: output_path.to_path_buf(),
|
||||
processing_time,
|
||||
metadata,
|
||||
})
|
||||
}
|
||||
|
||||
/// Validate interpolation parameters
|
||||
fn validate_interpolation_params(&self, params: &InterpolationParams) -> Result<(), TvaiError> {
|
||||
if params.input_fps == 0 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
"Input FPS must be greater than 0".to_string()
|
||||
));
|
||||
}
|
||||
|
||||
if params.multiplier < 1.0 || params.multiplier > 8.0 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
format!("Multiplier must be between 1.0 and 8.0, got {}", params.multiplier)
|
||||
));
|
||||
}
|
||||
|
||||
if let Some(target_fps) = params.target_fps {
|
||||
if target_fps == 0 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
"Target FPS must be greater than 0".to_string()
|
||||
));
|
||||
}
|
||||
|
||||
if target_fps > 240 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
format!("Target FPS too high: {} (max 240)", target_fps)
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Build Topaz interpolation filter string
|
||||
fn build_interpolation_filter(&self, params: &InterpolationParams, target_fps: u32) -> Result<String, TvaiError> {
|
||||
let filter = format!(
|
||||
"tvai_fi=model={}:fps={}",
|
||||
params.model.as_str(),
|
||||
target_fps
|
||||
);
|
||||
|
||||
Ok(filter)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ pub mod converter;
|
|||
use std::path::Path;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::core::{TvaiError, ProcessResult};
|
||||
use crate::core::{TvaiError, ProcessResult, TvaiProcessor, ProgressCallback};
|
||||
use crate::config::{UpscaleModel, InterpolationModel, QualityPreset};
|
||||
|
||||
/// Parameters for video upscaling
|
||||
|
|
@ -104,21 +104,202 @@ impl InterpolationParams {
|
|||
}
|
||||
}
|
||||
|
||||
/// Enhanced video processing with both upscaling and interpolation
|
||||
impl TvaiProcessor {
|
||||
/// Enhance video with combined upscaling and interpolation
|
||||
pub async fn enhance_video(
|
||||
&mut self,
|
||||
input_path: &Path,
|
||||
output_path: &Path,
|
||||
params: VideoEnhanceParams,
|
||||
progress_callback: Option<&ProgressCallback>,
|
||||
) -> Result<ProcessResult, TvaiError> {
|
||||
let start_time = std::time::Instant::now();
|
||||
|
||||
// Validate inputs
|
||||
self.validate_input_file(input_path)?;
|
||||
self.validate_output_path(output_path)?;
|
||||
|
||||
let operation_id = self.generate_operation_id();
|
||||
let mut current_input = input_path.to_path_buf();
|
||||
let mut intermediate_files = Vec::new();
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.0);
|
||||
}
|
||||
|
||||
// Step 1: Apply upscaling if requested
|
||||
if let Some(upscale_params) = ¶ms.upscale {
|
||||
let intermediate_output = self.create_temp_path(&operation_id, "upscaled.mp4");
|
||||
intermediate_files.push(intermediate_output.clone());
|
||||
|
||||
// For now, pass None for progress callback to avoid lifetime issues
|
||||
// TODO: Implement proper progress callback forwarding
|
||||
self.upscale_video(
|
||||
¤t_input,
|
||||
&intermediate_output,
|
||||
upscale_params.clone(),
|
||||
None,
|
||||
).await?;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.5);
|
||||
}
|
||||
|
||||
current_input = intermediate_output;
|
||||
}
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.5);
|
||||
}
|
||||
|
||||
// Step 2: Apply interpolation if requested
|
||||
if let Some(interpolation_params) = ¶ms.interpolation {
|
||||
// For now, pass None for progress callback to avoid lifetime issues
|
||||
// TODO: Implement proper progress callback forwarding
|
||||
let result = self.interpolate_video(
|
||||
¤t_input,
|
||||
output_path,
|
||||
interpolation_params.clone(),
|
||||
None,
|
||||
).await?;
|
||||
|
||||
// Clean up intermediate files
|
||||
self.cleanup_temp_files(&operation_id)?;
|
||||
|
||||
return Ok(result);
|
||||
}
|
||||
|
||||
// If only upscaling was requested, move the result to final output
|
||||
if params.upscale.is_some() && params.interpolation.is_none() {
|
||||
std::fs::rename(¤t_input, output_path)?;
|
||||
} else {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
"At least one enhancement (upscale or interpolation) must be specified".to_string()
|
||||
));
|
||||
}
|
||||
|
||||
let processing_time = start_time.elapsed();
|
||||
|
||||
// Create combined metadata
|
||||
let mut metadata = self.create_metadata(
|
||||
operation_id,
|
||||
input_path,
|
||||
format!("enhance: upscale={}, interpolation={}",
|
||||
params.upscale.is_some(),
|
||||
params.interpolation.is_some()
|
||||
),
|
||||
);
|
||||
metadata.ffmpeg_version = self.get_ffmpeg_version(true).await.ok();
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(1.0);
|
||||
}
|
||||
|
||||
Ok(ProcessResult {
|
||||
output_path: output_path.to_path_buf(),
|
||||
processing_time,
|
||||
metadata,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Quick video upscaling function
|
||||
pub async fn quick_upscale_video(
|
||||
_input: &Path,
|
||||
_output: &Path,
|
||||
_scale: f32,
|
||||
input: &Path,
|
||||
output: &Path,
|
||||
scale: f32,
|
||||
) -> Result<ProcessResult, TvaiError> {
|
||||
// This will be implemented in the upscale module
|
||||
todo!("Implementation will be added in upscale module")
|
||||
// Detect Topaz installation
|
||||
let topaz_path = crate::utils::detect_topaz_installation()
|
||||
.ok_or_else(|| TvaiError::TopazNotFound("Topaz Video AI not found".to_string()))?;
|
||||
|
||||
// Create default configuration
|
||||
let config = crate::core::TvaiConfig::builder()
|
||||
.topaz_path(topaz_path)
|
||||
.use_gpu(true)
|
||||
.build()?;
|
||||
|
||||
// Create processor
|
||||
let mut processor = TvaiProcessor::new(config)?;
|
||||
|
||||
// Create default upscaling parameters
|
||||
let params = VideoUpscaleParams {
|
||||
scale_factor: scale,
|
||||
model: crate::config::UpscaleModel::Iris3, // Best general purpose model
|
||||
compression: 0.0,
|
||||
blend: 0.0,
|
||||
quality_preset: crate::config::QualityPreset::HighQuality,
|
||||
};
|
||||
|
||||
// Perform upscaling
|
||||
processor.upscale_video(input, output, params, None).await
|
||||
}
|
||||
|
||||
/// Automatic video enhancement
|
||||
pub async fn auto_enhance_video(
|
||||
_input: &Path,
|
||||
_output: &Path,
|
||||
input: &Path,
|
||||
output: &Path,
|
||||
) -> Result<ProcessResult, TvaiError> {
|
||||
// This will be implemented to automatically detect and apply best settings
|
||||
todo!("Implementation will be added in upscale module")
|
||||
// Detect Topaz installation
|
||||
let topaz_path = crate::utils::detect_topaz_installation()
|
||||
.ok_or_else(|| TvaiError::TopazNotFound("Topaz Video AI not found".to_string()))?;
|
||||
|
||||
// Create default configuration
|
||||
let config = crate::core::TvaiConfig::builder()
|
||||
.topaz_path(topaz_path)
|
||||
.use_gpu(true)
|
||||
.build()?;
|
||||
|
||||
// Create processor
|
||||
let mut processor = TvaiProcessor::new(config)?;
|
||||
|
||||
// Get video info to determine best enhancement strategy
|
||||
let video_info = crate::utils::get_video_info(input).await?;
|
||||
|
||||
// Auto-determine enhancement parameters based on video characteristics
|
||||
let mut enhance_params = VideoEnhanceParams {
|
||||
upscale: None,
|
||||
interpolation: None,
|
||||
};
|
||||
|
||||
// Apply upscaling if resolution is low
|
||||
if video_info.width < 1920 || video_info.height < 1080 {
|
||||
let scale_factor = if video_info.width <= 720 { 2.0 } else { 1.5 };
|
||||
enhance_params.upscale = Some(VideoUpscaleParams {
|
||||
scale_factor,
|
||||
model: crate::config::UpscaleModel::Iris3,
|
||||
compression: 0.0,
|
||||
blend: 0.1,
|
||||
quality_preset: crate::config::QualityPreset::HighQuality,
|
||||
});
|
||||
}
|
||||
|
||||
// Apply interpolation if frame rate is low
|
||||
if video_info.fps < 30.0 {
|
||||
let multiplier = if video_info.fps <= 15.0 { 2.0 } else { 1.5 };
|
||||
enhance_params.interpolation = Some(InterpolationParams {
|
||||
input_fps: video_info.fps as u32,
|
||||
multiplier,
|
||||
model: crate::config::InterpolationModel::Apo8,
|
||||
target_fps: None,
|
||||
});
|
||||
}
|
||||
|
||||
// If no enhancement is needed, just copy the file
|
||||
if enhance_params.upscale.is_none() && enhance_params.interpolation.is_none() {
|
||||
std::fs::copy(input, output)?;
|
||||
return Ok(ProcessResult {
|
||||
output_path: output.to_path_buf(),
|
||||
processing_time: std::time::Duration::from_millis(0),
|
||||
metadata: processor.create_metadata(
|
||||
processor.generate_operation_id(),
|
||||
input,
|
||||
"auto_enhance: no enhancement needed".to_string(),
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
// Perform enhancement
|
||||
processor.enhance_video(input, output, enhance_params, None).await
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,150 @@
|
|||
//! Video upscaling implementation
|
||||
|
||||
// Placeholder for video upscaling implementation
|
||||
// This will be implemented in later stages
|
||||
use std::path::Path;
|
||||
use std::time::Instant;
|
||||
use crate::core::{TvaiError, TvaiProcessor, ProcessResult, ProgressCallback};
|
||||
use crate::video::VideoUpscaleParams;
|
||||
|
||||
/// Video upscaling implementation
|
||||
impl TvaiProcessor {
|
||||
/// Upscale a video using Topaz AI models
|
||||
pub async fn upscale_video(
|
||||
&mut self,
|
||||
input_path: &Path,
|
||||
output_path: &Path,
|
||||
params: VideoUpscaleParams,
|
||||
progress_callback: Option<&ProgressCallback>,
|
||||
) -> Result<ProcessResult, TvaiError> {
|
||||
let start_time = Instant::now();
|
||||
|
||||
// Validate inputs
|
||||
self.validate_input_file(input_path)?;
|
||||
self.validate_output_path(output_path)?;
|
||||
|
||||
// Validate parameters
|
||||
self.validate_upscale_params(¶ms)?;
|
||||
|
||||
let operation_id = self.generate_operation_id();
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.0);
|
||||
}
|
||||
|
||||
// Build Topaz upscaling filter
|
||||
let upscale_filter = self.build_upscale_filter(¶ms)?;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.1);
|
||||
}
|
||||
|
||||
// Build FFmpeg command with Topaz filters
|
||||
let mut args = vec![
|
||||
"-y", "-hide_banner", "-nostdin", "-strict", "2",
|
||||
"-hwaccel", "auto",
|
||||
"-i", input_path.to_str().unwrap(),
|
||||
"-vf", &upscale_filter,
|
||||
];
|
||||
|
||||
// Add encoding settings
|
||||
let (codec, preset) = params.quality_preset.get_encoding_settings(self.is_gpu_enabled());
|
||||
let quality = params.quality_preset.get_quality_value(self.is_gpu_enabled());
|
||||
|
||||
if self.is_gpu_enabled() {
|
||||
args.extend_from_slice(&[
|
||||
"-c:v", codec,
|
||||
"-preset", preset,
|
||||
"-global_quality", quality,
|
||||
"-pix_fmt", "yuv420p",
|
||||
]);
|
||||
} else {
|
||||
args.extend_from_slice(&[
|
||||
"-c:v", codec,
|
||||
"-preset", preset,
|
||||
"-crf", quality,
|
||||
]);
|
||||
}
|
||||
|
||||
args.push(output_path.to_str().unwrap());
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(0.2);
|
||||
}
|
||||
|
||||
// Execute Topaz upscaling (requires Topaz FFmpeg)
|
||||
self.execute_ffmpeg_command(&args, true, progress_callback).await?;
|
||||
|
||||
let processing_time = start_time.elapsed();
|
||||
|
||||
// Get FFmpeg version for metadata
|
||||
let ffmpeg_version = self.get_ffmpeg_version(true).await.ok();
|
||||
|
||||
// Create result metadata
|
||||
let mut metadata = self.create_metadata(
|
||||
operation_id,
|
||||
input_path,
|
||||
format!("upscale: model={}, scale={}, compression={}, blend={}",
|
||||
params.model.as_str(),
|
||||
params.scale_factor,
|
||||
params.compression,
|
||||
params.blend
|
||||
),
|
||||
);
|
||||
metadata.ffmpeg_version = ffmpeg_version;
|
||||
|
||||
if let Some(callback) = progress_callback {
|
||||
callback(1.0);
|
||||
}
|
||||
|
||||
Ok(ProcessResult {
|
||||
output_path: output_path.to_path_buf(),
|
||||
processing_time,
|
||||
metadata,
|
||||
})
|
||||
}
|
||||
|
||||
/// Validate upscaling parameters
|
||||
fn validate_upscale_params(&self, params: &VideoUpscaleParams) -> Result<(), TvaiError> {
|
||||
if params.scale_factor < 1.0 || params.scale_factor > 4.0 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
format!("Scale factor must be between 1.0 and 4.0, got {}", params.scale_factor)
|
||||
));
|
||||
}
|
||||
|
||||
if params.compression < -1.0 || params.compression > 1.0 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
format!("Compression must be between -1.0 and 1.0, got {}", params.compression)
|
||||
));
|
||||
}
|
||||
|
||||
if params.blend < 0.0 || params.blend > 1.0 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
format!("Blend must be between 0.0 and 1.0, got {}", params.blend)
|
||||
));
|
||||
}
|
||||
|
||||
// Check if model forces a specific scale
|
||||
if let Some(forced_scale) = params.model.forces_scale() {
|
||||
if (params.scale_factor - forced_scale).abs() > 0.01 {
|
||||
return Err(TvaiError::InvalidParameter(
|
||||
format!("Model {} forces scale factor {}, but {} was requested",
|
||||
params.model.as_str(), forced_scale, params.scale_factor)
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Build Topaz upscaling filter string
|
||||
fn build_upscale_filter(&self, params: &VideoUpscaleParams) -> Result<String, TvaiError> {
|
||||
let filter = format!(
|
||||
"tvai_up=model={}:scale={}:estimate=8:compression={}:blend={}",
|
||||
params.model.as_str(),
|
||||
params.scale_factor,
|
||||
params.compression,
|
||||
params.blend
|
||||
);
|
||||
|
||||
Ok(filter)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue