feat: migrate h256 to ffmpeg encoder

Author: LeadcodeDev

src/components/shape.rs

@@ -85,6 +85,7 @@ impl Widget for Shape {
                     };
                     if let Some(shader) = shader {
                         paint.set_shader(shader);
+                        paint.set_dither(true);
                     }
                     paint
                 }

src/encode/video.rs

@@ -936,6 +936,7 @@ pub fn encode_with_ffmpeg(
     let mut cmd = std::process::Command::new("ffmpeg");
     cmd.args([
         "-y",
+        "-loglevel", "error",
         "-f", "rawvideo",
         "-pixel_format", pix_fmt,
         "-video_size", &format!("{}x{}", width, height),
@@ -969,8 +970,8 @@ pub fn encode_with_ffmpeg(
             }
         }
         _ => {
-            // h264
-            cmd.args(["-c:v", "libx264", "-crf", &crf_val.to_string(), "-preset", "medium", "-pix_fmt", "yuv420p"]);
+            // h264 — use 10-bit for smoother dark gradients
+            cmd.args(["-c:v", "libx264", "-crf", &crf_val.to_string(), "-preset", "medium", "-profile:v", "high10", "-pix_fmt", "yuv420p10le"]);
         }
     }
 

src/engine/render_v2.rs

@@ -1168,10 +1168,16 @@ fn draw_bg_gradient_shift(
         return;
     }
 
-    let colors: Vec<skia_safe::Color4f> = bg.colors.iter().map(|c| color4f_from_hex(c)).collect();
+    let base_colors: Vec<skia_safe::Color4f> = bg.colors.iter().map(|c| color4f_from_hex(c)).collect();
     let angle = (bg.speed * time) % 360.0;
     let rad = angle.to_radians();
 
+    // Interpolate in linear color space to reduce banding on dark gradients
+    let linear_cs = skia_safe::ColorSpace::new_srgb_linear();
+
+    // Subdivide color stops (16 intermediate steps between each pair) for smoother gradients
+    let (colors, positions) = subdivide_gradient_stops(&base_colors, 16);
+
     let shader = match bg.gradient_type {
         GradientType::Linear => {
             let cx = width / 2.0;
@@ -1181,8 +1187,8 @@ fn draw_bg_gradient_shift(
             let end = Point::new(cx + rad.cos() * half_diag, cy + rad.sin() * half_diag);
             skia_safe::shader::Shader::linear_gradient(
                 (start, end),
-                GradientShaderColors::ColorsInSpace(&colors, Some(skia_safe::ColorSpace::new_srgb())),
-                None,
+                GradientShaderColors::ColorsInSpace(&colors, Some(linear_cs)),
+                Some(&positions[..]),
                 skia_safe::TileMode::Clamp,
                 None,
                 None,
@@ -1194,8 +1200,8 @@ fn draw_bg_gradient_shift(
             skia_safe::shader::Shader::radial_gradient(
                 center,
                 radius,
-                GradientShaderColors::ColorsInSpace(&colors, Some(skia_safe::ColorSpace::new_srgb())),
-                None,
+                GradientShaderColors::ColorsInSpace(&colors, Some(linear_cs)),
+                Some(&positions[..]),
                 skia_safe::TileMode::Clamp,
                 None,
                 None,
@@ -1206,10 +1212,49 @@ fn draw_bg_gradient_shift(
     if let Some(shader) = shader {
         let mut paint = Paint::default();
         paint.set_shader(shader);
+        paint.set_dither(true);
         canvas.draw_rect(skia_safe::Rect::from_wh(width, height), &paint);
     }
 }
 
+/// Subdivide gradient color stops by inserting intermediate interpolated colors.
+/// Returns (colors, positions) with `subdivisions` extra stops between each original pair.
+fn subdivide_gradient_stops(
+    colors: &[skia_safe::Color4f],
+    subdivisions: u32,
+) -> (Vec<skia_safe::Color4f>, Vec<f32>) {
+    let n = colors.len();
+    if n < 2 {
+        return (colors.to_vec(), vec![0.0]);
+    }
+    let total = (n - 1) * subdivisions as usize + n;
+    let mut out_colors = Vec::with_capacity(total);
+    let mut out_pos = Vec::with_capacity(total);
+    let seg = (n - 1) as f32;
+
+    for i in 0..n - 1 {
+        let c0 = &colors[i];
+        let c1 = &colors[i + 1];
+        let steps = subdivisions + 1;
+        for s in 0..steps {
+            let t = s as f32 / steps as f32;
+            let global_t = (i as f32 + t) / seg;
+            out_colors.push(skia_safe::Color4f {
+                r: c0.r + (c1.r - c0.r) * t,
+                g: c0.g + (c1.g - c0.g) * t,
+                b: c0.b + (c1.b - c0.b) * t,
+                a: c0.a + (c1.a - c0.a) * t,
+            });
+            out_pos.push(global_t);
+        }
+    }
+    // Last color
+    out_colors.push(colors[n - 1]);
+    out_pos.push(1.0);
+
+    (out_colors, out_pos)
+}
+
 /// Soft colored glow zones (halo preset).
 fn draw_bg_halo(
     canvas: &Canvas,

src/main.rs

@@ -260,12 +260,17 @@ fn cmd_render(
                 encode::encode_raw_stdout(&scenario, false)?;
             }
             _ => {
-                // Check if we need FFmpeg (for h265, vp9, prores, webm, mov)
-                let use_ffmpeg = codec.as_deref().map_or(false, |c| c != "h264")
-                    || matches!(fmt, "webm" | "mov")
-                    || transparent;
-
-                if use_ffmpeg {
+                // Try FFmpeg first (supports 10-bit H.264, all codecs)
+                // Fall back to built-in openh264 encoder if FFmpeg is not available
+                let ffmpeg_available = std::process::Command::new("ffmpeg")
+                    .arg("-version")
+                    .stdout(std::process::Stdio::null())
+                    .stderr(std::process::Stdio::null())
+                    .status()
+                    .map(|s| s.success())
+                    .unwrap_or(false);
+
+                if ffmpeg_available {
                     encode::encode_with_ffmpeg(
                         &scenario,
                         output.to_str().unwrap(),