Update video2.py

video2.py

@@ -396,228 +396,38 @@ def audio_func(id, lines, lang):
     return generate_tts_gtts(id, lines, lang)
 
 
-# Example usage
-if __name__ == "__main__":
-    # Example 1: Simple English text
-    lines = ["Hello, this is a test of the Google Text-to-Speech system."]
-    duration, path = audio_func(0, lines, "English")
-    print(f"Generated: {path} ({duration}s)")
-    
-    # Example 2: Bilingual text with custom format
-    bilingual_text = "Hello, welcome to our service. வணக்கம், எங்கள் சேவைக்கு வரவேற்கிறோம். &&&Tamil"
-    duration, path = audio_func(1, bilingual_text, bilingual_text)
-    print(f"Generated: {path} ({duration}s)")
-    
-    # Example 3: Tamil text
-    tamil_lines = ["வணக்கம், இது தமிழில் ஒரு சோதனை செய்தி."]
-    duration, path = audio_func(2, tamil_lines, "Tamil")
-    print(f"Generated: {path} ({duration}s)")
 #-----------------------------
 #---------------------------------
+import os
+import subprocess
+import shlex
+import time
+import math
+import numpy as np
+import cv2
+from moviepy.editor import VideoFileClip, AudioFileClip
+from moviepy.video.fx.speedx import speedx
+
+# video.py
 def video_func(id, lines, lang):
     duration, audio_path = audio_func(id, lines, lang)
     if not duration or not audio_path:
         print("Failed to generate audio.")
         return None
+    
     TEXT = lines[id]
     print("-----------------------------------------------------------------------------")
     print(TEXT)
-    SKIP_SPACES = False
-   
-    FPS = 30  # Keep for smoothness, but can reduce to 24 if needed for speed
-    ANIMATION_FRAMES_PER_CHAR = 2  # Reduced from 3 for faster rendering (less frames per char)
-    WIDTH, HEIGHT = 1280, 720
-    MARGIN_X, MARGIN_Y = 40, 60
-    LINE_SPACING = 8
-    FONT = cv2.FONT_HERSHEY_SIMPLEX
-    DEFAULT_FONT_SCALE = 1.5
-    HEADER_FONT_SCALE = 2.0  # Increased size for headers
-    DEFAULT_THICKNESS = 2
-    HEADER_THICKNESS = 3  # Bolder for headers
-    DEFAULT_TEXT_COLOR = (0, 0, 0)  # BGR Black
-    HEADER_TEXT_COLOR = (255, 0, 0)  # BGR Blue
-    BG_COLOR = (255, 255, 255)  # BGR White
-    silent_video_name = f"silent_video{id}.mp4"
-    silent_video_path = os.path.join(CLIPS_DIR, silent_video_name)
-    FFMPEG_PRESET = "ultrafast"
-    CRF = 28  # Increased CRF for faster encoding (lower quality, but quicker)
-    # Pen settings
-    PEN_COLOR = (0, 0, 255)  # Red pen (BGR)
-    PEN_TIP_RADIUS = 5
-    PEN_LENGTH = 20
-    PEN_THICKNESS = 2
-    PEN_BASE_ANGLE = 45
-    PEN_MOVEMENT_AMPLITUDE = 10
-    # ===================================
-   
-    # Helper: wrap text by pixel width using cv2.getTextSize, now with per-line styles
-    def wrap_text_cv(text, font, default_font_scale, default_thickness, max_width):
-        wrapped_lines = []
-        styles = []  # List of (is_header) for each wrapped line
-        for para in text.splitlines():
-            is_header = para.strip().startswith("###")
-            if is_header:
-                para = para.strip()[3:].strip()  # Remove "### " or "###"
-                font_scale = HEADER_FONT_SCALE
-                thickness = HEADER_THICKNESS
-            else:
-                font_scale = default_font_scale
-                thickness = default_thickness
-            if para == "":
-                wrapped_lines.append("")
-                styles.append(False)  # Not header
-                continue
-            words = para.split(" ")
-            cur = ""
-            for w in words:
-                candidate = w if cur == "" else cur + " " + w
-                (w_w, w_h), _ = cv2.getTextSize(candidate, font, font_scale, thickness)
-                if w_w <= max_width:
-                    cur = candidate
-                else:
-                    if cur != "":
-                        wrapped_lines.append(cur)
-                        styles.append(is_header)
-                    (single_w, _), _ = cv2.getTextSize(w, font, font_scale, thickness)
-                    if single_w > max_width:
-                        chunk = ""
-                        for ch in w:
-                            cand2 = chunk + ch
-                            (c_w, _), _ = cv2.getTextSize(cand2, font, font_scale, thickness)
-                            if c_w <= max_width:
-                                chunk = cand2
-                            else:
-                                wrapped_lines.append(chunk)
-                                styles.append(is_header)
-                                chunk = ch
-                        if chunk:
-                            cur = chunk
-                        else:
-                            cur = ""
-                    else:
-                        cur = w
-            if cur != "":
-                wrapped_lines.append(cur)
-                styles.append(is_header)
-        return wrapped_lines, styles
-   
-    # Pre-wrap text with styles
-    text_area_width = WIDTH - 2 * MARGIN_X
-    wrapped_lines, line_styles = wrap_text_cv(TEXT, FONT, DEFAULT_FONT_SCALE, DEFAULT_THICKNESS, text_area_width)
-    full_text = "\n".join(wrapped_lines)
-    if not full_text:
-        full_text = ""
-    # Visible indices
-    if SKIP_SPACES:
-        visible_indices = [i for i, ch in enumerate(full_text) if (ch != ' ' and ch != '\n' and ch != '\t')]
+    
+    # CREATE CLIPS DIRECTORY IF IT DOESN'T EXIST
+    os.makedirs(CLIPS_DIR, exist_ok=True)
+    
+    # Call Rust function
+    final_video_path = rust_highlight.generate_video_clip(id, TEXT, audio_path, duration, CLIPS_DIR)
+    
+    if final_video_path:
+        print(f"Final video saved at: {final_video_path}")
+        return final_video_path
     else:
-        visible_indices = list(range(len(full_text)))
-   
-    total_glyphs = len(visible_indices)
-    print(f"Wrapped lines: {len(wrapped_lines)} lines, total glyphs (counted): {total_glyphs}")
-    if total_glyphs == 0:
-        print("No text to animate.")
-        return None
-    # Minimal frames
-    min_frames = total_glyphs * ANIMATION_FRAMES_PER_CHAR
-    print(f"Rendering {min_frames} minimal frames for full text animation.")
-    # Pre-calc line heights and y_positions with per-line styles
-    line_heights = []
-    y_positions = []
-    y = MARGIN_Y
-    for i, line in enumerate(wrapped_lines):
-        is_header = line_styles[i]
-        font_scale = HEADER_FONT_SCALE if is_header else DEFAULT_FONT_SCALE
-        thickness = HEADER_THICKNESS if is_header else DEFAULT_THICKNESS
-        if line == "":
-            (w, h), baseline = cv2.getTextSize("Ay", FONT, font_scale, thickness)
-        else:
-            (w, h), baseline = cv2.getTextSize(line, FONT, font_scale, thickness)
-        lh = h + baseline + LINE_SPACING
-        line_heights.append(lh)
-        y_positions.append(y)
-        y += lh
-    # Prepare ffmpeg
-    ffmpeg_cmd = (
-        f'ffmpeg -y '
-        f'-f rawvideo -pix_fmt bgr24 -s {WIDTH}x{HEIGHT} -r {FPS} -i - '
-        f'-an '
-        f'-c:v libx264 -preset {FFMPEG_PRESET} -crf {CRF} -pix_fmt yuv420p '
-        f'{silent_video_path}'
-    )
-    print("FFMPEG CMD:", ffmpeg_cmd)
-   
-    proc = subprocess.Popen(shlex.split(ffmpeg_cmd), stdin=subprocess.PIPE, bufsize=10**8)
-    # Render function, now with per-line colors and styles
-    def render_frame(visible_text, pen_x, pen_y, anim_offset):
-        img = np.full((HEIGHT, WIDTH, 3), BG_COLOR, dtype=np.uint8)
-        lines = visible_text.split("\n")
-        for idx, line in enumerate(lines):
-            is_header = line_styles[idx]
-            font_scale = HEADER_FONT_SCALE if is_header else DEFAULT_FONT_SCALE
-            thickness = HEADER_THICKNESS if is_header else DEFAULT_THICKNESS
-            color = HEADER_TEXT_COLOR if is_header else DEFAULT_TEXT_COLOR
-            x = MARGIN_X
-            y = y_positions[idx]
-            (w, h), baseline = cv2.getTextSize(line, FONT, font_scale, thickness)
-            y_draw = y + h
-            if line != "":
-                cv2.putText(img, line, (x, y_draw), FONT, font_scale, color, thickness, lineType=cv2.LINE_AA)
-        if pen_x > 0:
-            offset_y = int(PEN_MOVEMENT_AMPLITUDE * math.sin(anim_offset * math.pi))
-            pen_tip_y = pen_y + offset_y
-            angle_rad = math.radians(PEN_BASE_ANGLE)
-            pen_end_x = pen_x + int(PEN_LENGTH * math.cos(angle_rad))
-            pen_end_y = pen_tip_y - int(PEN_LENGTH * math.sin(angle_rad))
-            cv2.line(img, (pen_x, pen_tip_y), (pen_end_x, pen_end_y), PEN_COLOR, PEN_THICKNESS)
-            cv2.circle(img, (pen_x, pen_tip_y), PEN_TIP_RADIUS, PEN_COLOR, -1)
-        return img
-   
-    t0 = time.time()
-    frames_sent = 0
-    prev_visible_sub = ""
-    last_pen_x = 0
-    last_pen_y = 0
-    for rank, idx_in_full in enumerate(visible_indices):
-        visible_sub = full_text[:idx_in_full + 1]
-        if visible_sub != prev_visible_sub:
-            lines = visible_sub.split("\n")
-            last_line = lines[-1]
-            line_idx = len(lines) - 1
-            is_header = line_styles[line_idx]
-            font_scale = HEADER_FONT_SCALE if is_header else DEFAULT_FONT_SCALE
-            thickness = HEADER_THICKNESS if is_header else DEFAULT_THICKNESS
-            (w, h), baseline = cv2.getTextSize(last_line, FONT, font_scale, thickness)
-            pen_x = MARGIN_X + w + 5
-            pen_y = y_positions[line_idx] + h // 2
-            last_pen_x = pen_x
-            last_pen_y = pen_y
-            for anim_step in range(ANIMATION_FRAMES_PER_CHAR):
-                frame_img = render_frame(visible_sub, pen_x, pen_y, anim_step / ANIMATION_FRAMES_PER_CHAR)
-                proc.stdin.write(frame_img.tobytes())
-                frames_sent += 1
-            prev_visible_sub = visible_sub
-    proc.stdin.close()
-    proc.wait()
-    elapsed = time.time() - t0
-    print(f"Frames sent: {frames_sent}, elapsed time: {elapsed:.3f} seconds")
-    if not os.path.exists(silent_video_path):
-        print("Silent video generation failed.")
-        return None
-    # Combine with audio using MoviePy
-    final_video_name = f"clip{id}.mp4"
-    final_video_path = os.path.join(CLIPS_DIR, final_video_name)
-    video_clip = VideoFileClip(silent_video_path)
-    rendered_duration = video_clip.duration
-    print(f"Rendered video duration: {rendered_duration:.3f}s, Audio duration: {duration:.3f}s")
-    if rendered_duration > 0 and duration > 0:
-        speed_factor = rendered_duration / duration
-        print(f"Adjusting video speed by factor: {speed_factor:.3f}")
-        video_clip = video_clip.fx(speedx, speed_factor)
-    final_clip = video_clip.set_audio(AudioFileClip(audio_path))
-    # Write final video with faster settings
-    final_clip.write_videofile(final_video_path, codec='libx264', audio_codec='aac', preset='ultrafast', verbose=False, logger=None, threads=4)  # Added threads for multi-threading
-    print(f"Final video saved at: {final_video_path}")
-    # Clean up
-    os.remove(silent_video_path)
-    return final_video_path
+        print("Video generation failed.")
+        return None