feat: specifying vaapi device path (#21)

allows specifying the vaapi device path for AMD/Intel GPUs via --vaapi-device CLI arg or VERTD_VAAPI_DEVICE_PATH env variable

fixes #21

Author: JovannMC

src/converter/gpu.rs

@@ -49,21 +49,31 @@ impl ConverterGPU {
         }
     }
 
-    pub fn hwaccel_args(&self) -> &[&str] {
+    #[allow(unused_variables)]
+    pub fn hwaccel_args(&self, vaapi_device_path: Option<&str>) -> Vec<String> {
         #[cfg(target_os = "linux")]
         match self {
-            ConverterGPU::NVIDIA => &["-hwaccel", "cuda"],
-            ConverterGPU::Apple => &["-hwaccel", "videotoolbox"],
-            ConverterGPU::AMD => &["-hwaccel", "vaapi", "-hwaccel_output_format", "vaapi"],
-            ConverterGPU::Intel => &["-hwaccel", "vaapi", "-hwaccel_output_format", "vaapi"],
+            ConverterGPU::NVIDIA => vec!["-hwaccel".to_string(), "cuda".to_string()],
+            ConverterGPU::Apple => vec!["-hwaccel".to_string(), "videotoolbox".to_string()],
+            ConverterGPU::AMD | ConverterGPU::Intel => {
+                let mut args = vec!["-hwaccel".to_string(), "vaapi".to_string()];
+
+                let device_path = vaapi_device_path.unwrap_or("/dev/dri/renderD128");
+
+                args.push("-vaapi_device".to_string());
+                args.push(device_path.to_string());
+                args.push("-hwaccel_output_format".to_string());
+                args.push("vaapi".to_string());
+                args
+            }
         }
 
         #[cfg(not(target_os = "linux"))]
         match self {
-            ConverterGPU::NVIDIA => &["-hwaccel", "cuda"],
-            ConverterGPU::Apple => &["-hwaccel", "videotoolbox"],
-            ConverterGPU::AMD => &["-hwaccel", "amf"],
-            ConverterGPU::Intel => &["-hwaccel", "qsv"],
+            ConverterGPU::NVIDIA => vec!["-hwaccel".to_string(), "cuda".to_string()],
+            ConverterGPU::Apple => vec!["-hwaccel".to_string(), "videotoolbox".to_string()],
+            ConverterGPU::AMD => vec!["-hwaccel".to_string(), "amf".to_string()],
+            ConverterGPU::Intel => vec!["-hwaccel".to_string(), "qsv".to_string()],
         }
     }
 }

src/converter/mod.rs

@@ -41,6 +41,7 @@ impl Converter {
         &self,
         job: &mut Job,
         gpu: &gpu::ConverterGPU,
+        vaapi_device_path: Option<&str>,
     ) -> anyhow::Result<(mpsc::Receiver<ProgressUpdate>, tokio::process::Child)> {
         let (tx, rx) = mpsc::channel(1);
         let input_filename = format!("input/{}.{}", job.id, self.conversion.from.to_string());
@@ -49,14 +50,15 @@ impl Converter {
         // let bitrate = job.bitrate().await?;
         // let fps = job.fps().await?;
         // the above but we run in parallel
-        let (gpu, (bitrate, fps)) = tokio::try_join!(gpu::get_gpu(), job.bitrate_and_fps())?;
+        let (bitrate, fps) = job.bitrate_and_fps().await?;
         let args = self
             .conversion
             .to_args(&self.speed, gpu, bitrate, fps)
             .await?;
         let args = args.iter().map(|s| s.as_str()).collect::<Vec<&str>>();
         let args = args.as_slice();
-        let gpu_args: &[&str] = gpu.hwaccel_args();
+        let gpu_args = gpu.hwaccel_args(vaapi_device_path);
+        let gpu_args_refs: Vec<&str> = gpu_args.iter().map(|s| s.as_str()).collect();
 
         let metadata_args: &[&str] = if self.keep_metadata {
             &["-map_metadata", "0", "-map_chapters", "0"]
@@ -65,8 +67,8 @@ impl Converter {
         };
 
         let command = &[
-            &["-hide_banner", "-loglevel", "error", "-progress", "pipe:1"],
-            gpu_args,
+            &["-hide_banner", "-loglevel", "error", "-progress", "pipe:1"][..],
+            &gpu_args_refs[..],
             &["-i", &input_filename],
             args,
             metadata_args,

src/http/services/download.rs

@@ -2,7 +2,6 @@
 
 use actix_web::{get, web, HttpResponse, Responder, ResponseError};
 use tokio::fs;
-use uuid::Uuid;
 
 use crate::{http::response::ApiResponse, state::APP_STATE};
 

src/http/services/keep.rs

@@ -2,7 +2,7 @@
 
 use actix_web::{
     post,
-    web::{self, Json},
+    web::Json,
     HttpResponse, Responder, ResponseError,
 };
 use discord_webhook2::{message, webhook::DiscordWebhook};

src/http/services/websocket.rs

@@ -143,11 +143,13 @@ pub async fn websocket(req: HttpRequest, stream: web::Payload) -> Result<HttpRes
 
                 let converter = Converter::new(from, to, speed, keep_metadata);
 
-                let gpu = {
+                let (gpu, vaapi_device_path) = {
                     let app_state = APP_STATE.lock().await;
-                    app_state.gpu.ok_or_else(|| {
-                        "GPU not initialized, please restart vertd.".to_string()
-                    })
+                    let gpu = app_state
+                        .gpu
+                        .ok_or_else(|| "GPU not initialized, please restart vertd.".to_string());
+                    let device_path = app_state.vaapi_device_path.clone();
+                    (gpu, device_path)
                 };
 
                 let gpu = match gpu {
@@ -159,7 +161,10 @@ pub async fn websocket(req: HttpRequest, stream: web::Payload) -> Result<HttpRes
                     }
                 };
 
-                let (mut rx, process) = match converter.convert(&mut job, &gpu).await {
+                let (mut rx, process) = match converter
+                    .convert(&mut job, &gpu, vaapi_device_path.as_deref())
+                    .await
+                {
                     Ok((rx, process)) => (rx, process),
                     Err(e) => {
                         let message: String = Message::Error {

src/main.rs

@@ -93,6 +93,36 @@ fn get_forced_gpu() -> Option<ConverterGPU> {
     None
 }
 
+fn get_vaapi_device_path() -> Option<String> {
+    // cli argument (-vaapi-device <value>)
+    let args: Vec<String> = env::args().collect();
+    if let Some(vaapi_arg_pos) = args
+        .iter()
+        .position(|arg| arg == "-vaapi-device" || arg == "--vaapi-device")
+    {
+        if let Some(device_value) = args.get(vaapi_arg_pos + 1) {
+            info!(
+                "using VA-API device path from command line argument: {}",
+                device_value
+            );
+            return Some(device_value.clone());
+        } else {
+            warn!("VA-API device path argument specified but no value provided");
+        }
+    }
+
+    // environment variable
+    if let Ok(device_path) = env::var("VERTD_VAAPI_DEVICE_PATH") {
+        info!(
+            "using VA-API device path from environment variable VERTD_VAAPI_DEVICE_PATH: {}",
+            device_path
+        );
+        return Some(device_path);
+    }
+
+    None
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenv().ok();
@@ -125,17 +155,31 @@ async fn main() -> anyhow::Result<()> {
         None => get_gpu().await,
     };
 
+    // get VA-API device path from CLI or env var
+    let vaapi_device_path = get_vaapi_device_path();
+
     match &gpu {
-        Ok(gpu) => info!(
-            "detected a{} {} GPU -- if this isn't your vendor, open an issue.",
-            match gpu {
-                converter::gpu::ConverterGPU::AMD => "n",
-                converter::gpu::ConverterGPU::Apple => "n",
-                converter::gpu::ConverterGPU::Intel => "n",
-                _ => "",
-            },
-            gpu
-        ),
+        Ok(gpu) => {
+            info!(
+                "detected a{} {} GPU -- if this isn't your vendor, open an issue.",
+                match gpu {
+                    ConverterGPU::AMD => "n",
+                    ConverterGPU::Apple => "n",
+                    ConverterGPU::Intel => "n",
+                    _ => "",
+                },
+                gpu
+            );
+
+            #[cfg(target_os = "linux")]
+            if matches!(gpu, ConverterGPU::AMD | ConverterGPU::Intel) {
+                let device_path = vaapi_device_path
+                    .as_ref()
+                    .map(|s| s.as_str())
+                    .unwrap_or("/dev/dri/renderD128");
+                info!("using VA-API device path: {}", device_path);
+            }
+        }
         Err(e) => {
             error!("failed to get GPU vendor: {}", e);
             error!("vertd will still work, but it's going to be incredibly slow. be warned!");
@@ -145,6 +189,7 @@ async fn main() -> anyhow::Result<()> {
     if let Ok(gpu) = gpu {
         let mut app_state = state::APP_STATE.lock().await;
         app_state.gpu = Some(gpu);
+        app_state.vaapi_device_path = vaapi_device_path;
     }
 
     // remove input/ and output/ recursively if they exist -- we don't care if this fails tho

src/state/mod.rs

@@ -10,6 +10,7 @@ pub struct AppState {
     pub jobs: HashMap<Uuid, Job>,
     pub active_processes: HashMap<Uuid, tokio::process::Child>,
     pub gpu: Option<ConverterGPU>,
+    pub vaapi_device_path: Option<String>,
 }
 
 impl AppState {
@@ -18,6 +19,7 @@ impl AppState {
             jobs: HashMap::new(),
             active_processes: HashMap::new(),
             gpu: None,
+            vaapi_device_path: None,
         }
     }
 }