fix: work around many conversion failures

thanks to the community for submitting their files, this should make conversions more reliable now!

Author: JovannMC

src/converter/format.rs

@@ -78,6 +78,7 @@ impl Conversion {
         gpu: &ConverterGPU,
         bitrate: u64,
         fps: u32,
+        job: &super::job::Job,
     ) -> anyhow::Result<Vec<String>> {
         let conversion_opts: Vec<String> = match self.to {
             ConverterFormat::MP4
@@ -95,14 +96,40 @@ impl Conversion {
                 let encoder = self
                     .accelerated_or_default_codec(gpu, &["h264"], "libx264")
                     .await;
-                vec![
-                    "-c:v".to_string(),
-                    encoder,
+
+                let mut args = vec!["-c:v".to_string(), encoder.clone()];
+
+                let (width, height) = job.resolution().await?;
+                let is_4k = width >= 3840 || height >= 2160;
+                let pix_fmt = job.pix_fmt().await?;
+
+                // convert to 8bit if 10bit (h264_nvenc does not support 10bit)
+                // could probably use h265 instead?
+                let is_10bit = pix_fmt.contains("10le") || pix_fmt.contains("10be");
+                if is_10bit {
+                    args.extend(["-pix_fmt".to_string(), "yuv420p".to_string()]);
+                }
+
+                if is_4k {
+                    args.extend(["-level:v".to_string(), "5.2".to_string()]);
+                    if fps > 120 {
+                        args.extend(["-r".to_string(), "120".to_string()]);
+                    }
+                }
+
+                // scale to 160:-1 if width is less than 160
+                if width < 160 {
+                    args.extend(["-vf".to_string(), "scale=160:-1".to_string()]);
+                }
+
+                args.extend([
                     "-c:a".to_string(),
                     "aac".to_string(),
                     "-strict".to_string(),
                     "experimental".to_string(),
-                ]
+                ]);
+
+                args
             }
 
             ConverterFormat::GIF => {
@@ -225,6 +252,8 @@ impl Conversion {
                 "25".to_string(),
                 "-block_size".to_string(),
                 "882".to_string(),
+                "-strict".to_string(),
+                "-1".to_string(),
             ],
         };
 

src/converter/job.rs

@@ -167,6 +167,115 @@ impl Job {
         let (bitrate, fps) = (self.bitrate().await?, self.fps().await?);
         Ok((bitrate, fps))
     }
+
+    pub async fn resolution(&self) -> anyhow::Result<(u32, u32)> {
+        let path = format!("input/{}.{}", self.id, self.from);
+
+        let output = Command::new("ffprobe")
+            .args([
+                "-v",
+                "error",
+                "-select_streams",
+                "v:0",
+                "-show_entries",
+                "stream=width,height",
+                "-of",
+                "csv=s=x:p=0",
+                &path,
+            ])
+            .output()
+            .await?;
+
+        let res_str = String::from_utf8(output.stdout)?;
+        let mut parts = res_str.trim().split('x');
+        let width = parts
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("failed to get width"))?
+            .parse::<u32>()?;
+        let height = parts
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("failed to get height"))?
+            .parse::<u32>()?;
+
+        Ok((width, height))
+    }
+
+    pub async fn pix_fmt(&self) -> anyhow::Result<String> {
+        let path = format!("input/{}.{}", self.id, self.from);
+
+        let output = Command::new("ffprobe")
+            .args([
+                "-v",
+                "error",
+                "-select_streams",
+                "v:0",
+                "-show_entries",
+                "stream=pix_fmt",
+                "-of",
+                "default=nokey=1:noprint_wrappers=1",
+                &path,
+            ])
+            .output()
+            .await?;
+
+        let pix_fmt = String::from_utf8(output.stdout)?
+            .lines()
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("failed to get pixel format"))?
+            .to_string();
+
+        Ok(pix_fmt)
+    }
+
+    pub async fn codecs(&self) -> anyhow::Result<(String, String)> {
+        let path = format!("input/{}.{}", self.id, self.from);
+
+        // Video codec
+        let output = Command::new("ffprobe")
+            .args([
+                "-v",
+                "error",
+                "-select_streams",
+                "v:0",
+                "-show_entries",
+                "stream=codec_name",
+                "-of",
+                "default=nokey=1:noprint_wrappers=1",
+                &path,
+            ])
+            .output()
+            .await?;
+
+        let video_codec = String::from_utf8(output.stdout)?
+            .lines()
+            .next()
+            .unwrap_or("none")
+            .to_string();
+
+        // Audio codec
+        let output = Command::new("ffprobe")
+            .args([
+                "-v",
+                "error",
+                "-select_streams",
+                "a:0",
+                "-show_entries",
+                "stream=codec_name",
+                "-of",
+                "default=nokey=1:noprint_wrappers=1",
+                &path,
+            ])
+            .output()
+            .await?;
+
+        let audio_codec = String::from_utf8(output.stdout)?
+            .lines()
+            .next()
+            .unwrap_or("none")
+            .to_string();
+
+        Ok((video_codec, audio_codec))
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize)]

src/converter/mod.rs

@@ -53,7 +53,7 @@ impl Converter {
         let (bitrate, fps) = job.bitrate_and_fps().await?;
         let args = self
             .conversion
-            .to_args(&self.speed, gpu, bitrate, fps)
+            .to_args(&self.speed, gpu, bitrate, fps, job)
             .await?;
         let args = args.iter().map(|s| s.as_str()).collect::<Vec<&str>>();
         let args = args.as_slice();