Update rust_highlight/src/lib.rs

rust_highlight/src/lib.rs

@@ -124,6 +124,37 @@ fn generate_video_clip(id: usize, text: String, audio_path: String, duration: f6
     let mut frames_sent: usize = 0;
     let mut prev_visible_sub = String::new();
 
+    // Pre-render base frame with full text (optimization)
+    let base_frame = render_frame(
+        &full_text,
+        -1,
+        0,
+        0.0,
+        width as i32,
+        height as i32,
+        &line_styles,
+        &y_positions,
+        margin_x,
+        font,
+        default_font_scale,
+        header_font_scale,
+        default_thickness,
+        header_thickness,
+        default_text_color,
+        header_text_color,
+        bg_color,
+        pen_color,
+        pen_tip_radius,
+        pen_length,
+        pen_thickness,
+        pen_base_angle,
+        pen_movement_amplitude,
+    )?;
+
+    // Buffer for batch writing
+    let frame_size = (width * height * 3) as usize;
+    let mut buffer: Vec<u8> = Vec::with_capacity(frame_size * 100);
+
     // PHASE 1: Animation phase (first 1/4 of duration)
     for &idx_in_full in visible_indices.iter() {
         let visible_sub = &full_text[0..=idx_in_full];
@@ -168,49 +199,57 @@ fn generate_video_clip(id: usize, text: String, audio_path: String, duration: f6
                     pen_base_angle,
                     pen_movement_amplitude,
                 )?;
-                stdin.write_all(frame_img.data_bytes().unwrap())
-                    .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("Failed to write frame: {}", e)))?;
+                
+                buffer.extend_from_slice(frame_img.data_bytes().unwrap());
                 frames_sent += 1;
+                
+                // Flush buffer every 100 frames
+                if buffer.len() >= frame_size * 100 {
+                    stdin.write_all(&buffer)
+                        .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("Failed to write frames: {}", e)))?;
+                    buffer.clear();
+                }
             }
             prev_visible_sub = visible_sub.to_string();
         }
     }
 
+    // Flush remaining animation frames
+    if !buffer.is_empty() {
+        stdin.write_all(&buffer)
+            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("Failed to write frames: {}", e)))?;
+        buffer.clear();
+    }
+
     // PHASE 2: Static phase (remaining 3/4 of duration)
-    // Render the complete text without pen, statically
+    // Reuse the pre-rendered base frame
     println!("Animation complete. Rendering {} static frames...", static_frames);
     
-    let final_frame = render_frame(
-        &full_text,
-        -1,  // pen_x = -1 means no pen
-        0,
-        0.0,
-        width as i32,
-        height as i32,
-        &line_styles,
-        &y_positions,
-        margin_x,
-        font,
-        default_font_scale,
-        header_font_scale,
-        default_thickness,
-        header_thickness,
-        default_text_color,
-        header_text_color,
-        bg_color,
-        pen_color,
-        pen_tip_radius,
-        pen_length,
-        pen_thickness,
-        pen_base_angle,
-        pen_movement_amplitude,
-    )?;
+    let base_frame_bytes = base_frame.data_bytes().unwrap();
     
-    let final_frame_bytes = final_frame.data_bytes().unwrap();
-    for _ in 0..static_frames {
-        stdin.write_all(final_frame_bytes)
-            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("Failed to write static frame: {}", e)))?;
-        frames_sent += 1;
+    // Write static frames in batches
+    let batch_size = 300;
+    let full_batches = static_frames / batch_size;
+    let remainder = static_frames % batch_size;
+    
+    for _ in 0..full_batches {
+        for _ in 0..batch_size {
+            buffer.extend_from_slice(base_frame_bytes);
+        }
+        stdin.write_all(&buffer)
+            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("Failed to write static frames: {}", e)))?;
+        buffer.clear();
+        frames_sent += batch_size;
+    }
+    
+    // Write remaining frames
+    if remainder > 0 {
+        for _ in 0..remainder {
+            buffer.extend_from_slice(base_frame_bytes);
+        }
+        stdin.write_all(&buffer)
+            .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("Failed to write static frames: {}", e)))?;
+        frames_sent += remainder;
     }
 
     drop(stdin);