BitGoblin/Zealot
1
0
Fork 0
Code Issues 7 Pull Requests Projects Releases 12 Wiki Activity

Added a simple program loop to repeatedly check for new video files

Browse Source
This commit is contained in:
Gregory Ballantine 2022-09-01 15:29:24 -04:00
parent e3eb54720c
commit e14795c493
3 changed files with 141 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/config.rs
View File

@ -3,32 +3,32 @@ use std::fs;
#[derive(Deserialize)] #[derive(Deserialize)]
pub struct Config { pub struct Config {
pub transcoder: Transcoder, pub transcoder: Transcoder,
} }
impl Config { impl Config {
pub fn new(config_path: &str) -> Config { pub fn new(config_path: &str) -> Config {
let resolved_path = shellexpand::tilde(config_path); let resolved_path = shellexpand::tilde(config_path);
let config_text = fs::read_to_string(&*resolved_path).unwrap(); let config_text = fs::read_to_string(&*resolved_path).unwrap();
let c: Config = toml::from_str(&config_text).unwrap(); let c: Config = toml::from_str(&config_text).unwrap();
return c; return c;
} }
pub fn get_repository(&self) -> String { pub fn get_repository(&self) -> String {
let resolved_path = shellexpand::tilde(&self.transcoder.repository); let resolved_path = shellexpand::tilde(&self.transcoder.repository);
return String::from(&*resolved_path); return String::from(&*resolved_path);
} }
} }
#[derive(Deserialize)] #[derive(Deserialize)]
pub struct Transcoder { pub struct Transcoder {
pub repository: String, pub repository: String,
pub interval: u16, pub interval: u16,
pub video_format: String, pub video_format: String,
pub video_codec: String, pub video_codec: String,
pub video_profile: String, pub video_profile: String,
pub video_resolution: String, pub video_resolution: String,
pub video_framerate: u8, pub video_framerate: u8,
pub video_color: String, pub video_color: String,
pub audio_codec: String, pub audio_codec: String,
} }

136
src/repository.rs
View File

@ -2,86 +2,86 @@ use std::fs;
use std::path::Path; use std::path::Path;
pub struct Repository { pub struct Repository {
pub base_dir: String, pub base_dir: String,
pub ingest_dir: String, pub ingest_dir: String,
pub archive_dir: String, pub archive_dir: String,
pub output_dir: String, pub output_dir: String,
} }
impl Repository { impl Repository {
pub fn new(base_path: &str) -> Repository { pub fn new(base_path: &str) -> Repository {
// create the base directory path // create the base directory path
create_directory(base_path); create_directory(base_path);
// create the needed sub-directories // create the needed sub-directories
let ingest_path = Path::new(base_path).join("ingest"); let ingest_path = Path::new(base_path).join("ingest");
create_directory(ingest_path.to_str().unwrap()); create_directory(ingest_path.to_str().unwrap());
let archive_path = Path::new(base_path).join("archive"); let archive_path = Path::new(base_path).join("archive");
create_directory(archive_path.to_str().unwrap()); create_directory(archive_path.to_str().unwrap());
let output_path = Path::new(base_path).join("output"); let output_path = Path::new(base_path).join("output");
create_directory(output_path.to_str().unwrap()); create_directory(output_path.to_str().unwrap());
return Repository { return Repository {
base_dir: String::from(base_path), base_dir: String::from(base_path),
ingest_dir: String::from(ingest_path.to_str().unwrap()), ingest_dir: String::from(ingest_path.to_str().unwrap()),
archive_dir: String::from(archive_path.to_str().unwrap()), archive_dir: String::from(archive_path.to_str().unwrap()),
output_dir: String::from(output_path.to_str().unwrap()), output_dir: String::from(output_path.to_str().unwrap()),
}; };
} }
pub fn search_ingest(&self) -> Vec<String> { pub fn search_ingest(&self) -> Vec<String> {
// read file entries from ingest // read file entries from ingest
let files = fs::read_dir(&self.ingest_dir).unwrap(); let files = fs::read_dir(&self.ingest_dir).unwrap();
// create vec object and loop through entries to find what we want // create vec object and loop through entries to find what we want
let mut ingest_files: Vec<String> = vec![]; let mut ingest_files: Vec<String> = vec![];
for f in files { for f in files {
let f = f.unwrap(); let f = f.unwrap();
let path = f.path(); let path = f.path();
if path.is_file() { if path.is_file() {
let file_path = path.file_name().unwrap().to_str(); let file_path = path.file_name().unwrap().to_str();
ingest_files.push(String::from(file_path.unwrap())); ingest_files.push(String::from(file_path.unwrap()));
} }
} }
return ingest_files; return ingest_files;
} }
pub fn archive_file(&self, file: &str) { pub fn archive_file(&self, file: &str) {
let ingest_file = Path::new(&self.ingest_dir).join(file); let ingest_file = Path::new(&self.ingest_dir).join(file);
let archive_file = Path::new(&self.archive_dir).join(file); let archive_file = Path::new(&self.archive_dir).join(file);
match fs::copy(&ingest_file, &archive_file) { match fs::copy(&ingest_file, &archive_file) {
Ok(_) => { Ok(_) => {
println!("Archiving video file {}.", ingest_file.to_str().unwrap()); println!("Archiving video file {}.", ingest_file.to_str().unwrap());
}, },
Err(e) => { Err(e) => {
eprintln!("Error archiving file {}: {}", ingest_file.to_str().unwrap(), e); eprintln!("Error archiving file {}: {}", ingest_file.to_str().unwrap(), e);
std::process::exit(1); std::process::exit(1);
} }
} }
} }
pub fn cleanup_file(&self, file: &str) { pub fn cleanup_file(&self, file: &str) {
let ingest_file = Path::new(&self.ingest_dir).join(file); let ingest_file = Path::new(&self.ingest_dir).join(file);
fs::remove_file(&ingest_file) fs::remove_file(&ingest_file)
.expect("File deletion failed."); .expect("File deletion failed.");
} }
} }
fn create_directory(path: &str) { fn create_directory(path: &str) {
let d = Path::new(path); let d = Path::new(path);
if d.is_dir() { if d.is_dir() {
println!("Directory {} already exists.", path); println!("Directory {} already exists.", path);
} else { } else {
match fs::create_dir(path) { match fs::create_dir(path) {
Ok(_) => { Ok(_) => {
println!("Creating directory {}.", path); println!("Creating directory {}.", path);
}, },
Err(e) => { Err(e) => {
eprintln!("Error creating {}: {}", path, e); eprintln!("Error creating {}: {}", path, e);
std::process::exit(1); std::process::exit(1);
} }
} }
} }
} }

94
src/transcoder.rs
View File

@ -1,61 +1,73 @@
use std::path::Path; use std::path::Path;
use std::process; use std::process;
use std::{thread, time};
use crate::config::Config; use crate::config::Config;
use crate::repository::Repository; use crate::repository::Repository;
pub struct Transcoder { pub struct Transcoder {
config: Config, config: Config,
repository: Repository, repository: Repository,
} }
impl Transcoder { impl Transcoder {
pub fn new(config: Config, repository: Repository) -> Transcoder { pub fn new(config: Config, repository: Repository) -> Transcoder {
return Transcoder{ return Transcoder{
config: config, config: config,
repository: repository, repository: repository,
} }
} }
pub fn start(self) { pub fn start(self) {
println!("Starting transcoder..."); println!("Starting transcoder...");
// search for files in ingest loop {
let ingest_files = self.repository.search_ingest(); // search for files in ingest
let ingest_files = self.repository.search_ingest();
for i in ingest_files { // check if we found any files to transcode
// copy the file to the archive if ingest_files.len() < 1 {
self.repository.archive_file(&i); println!("There were no files found in ingest to transcode; skipping run.");
} else {
for i in ingest_files {
// copy the file to the archive
self.repository.archive_file(&i);
// perform the video transcode // perform the video transcode
self.transcode(&i); self.transcode(&i);
// remove the source file // remove the source file
self.repository.cleanup_file(&i); self.repository.cleanup_file(&i);
} }
} }
fn transcode(&self, file: &str) { // put the loop to sleep for X minutes
let ingest_file = Path::new(&self.repository.ingest_dir).join(file); let sleep_minutes = time::Duration::from_secs((self.config.transcoder.interval * 60).into());
let output_file = Path::new(&self.repository.output_dir).join(file); thread::sleep(sleep_minutes);
}
}
let cmd_output = process::Command::new("/usr/bin/ffmpeg") fn transcode(&self, file: &str) {
.arg("-i") .arg(&*ingest_file.to_string_lossy()) let ingest_file = Path::new(&self.repository.ingest_dir).join(file);
.arg("-y") let output_file = Path::new(&self.repository.output_dir).join(file);
.arg("-f") .arg(&self.config.transcoder.video_format)
.arg("-c:v") .arg(&self.config.transcoder.video_codec)
.arg("-s") .arg(&self.config.transcoder.video_resolution)
.arg("-r") .arg(format!("{}", self.config.transcoder.video_framerate))
.arg("-vf") .arg(format!("format={}", &self.config.transcoder.video_color))
.arg("-profile:v").arg(&self.config.transcoder.video_profile)
.arg("-c:a") .arg(&self.config.transcoder.audio_codec)
.arg(&*output_file.to_string_lossy())
.output()
.expect("Failed to execute command");
assert!(cmd_output.status.success()); let cmd_output = process::Command::new("/usr/bin/ffmpeg")
.arg("-i") .arg(&*ingest_file.to_string_lossy())
.arg("-y")
.arg("-f") .arg(&self.config.transcoder.video_format)
.arg("-c:v") .arg(&self.config.transcoder.video_codec)
.arg("-s") .arg(&self.config.transcoder.video_resolution)
.arg("-r") .arg(format!("{}", self.config.transcoder.video_framerate))
.arg("-vf") .arg(format!("format={}", &self.config.transcoder.video_color))
.arg("-profile:v").arg(&self.config.transcoder.video_profile)
.arg("-c:a") .arg(&self.config.transcoder.audio_codec)
.arg(&*output_file.to_string_lossy())
.output()
.expect("Failed to execute command");
let results_raw = &String::from_utf8_lossy(&cmd_output.stderr); assert!(cmd_output.status.success());
println!("{}", results_raw);
} let results_raw = &String::from_utf8_lossy(&cmd_output.stderr);
println!("{}", results_raw);
}
} }