Update video2.py

video2.py

@@ -317,37 +317,210 @@ def audio_func(id, lines, lang):
 
 #-----------------------------
 #---------------------------------
-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)
-    
-    # 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
+    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')]
     else:
-        print("Video generation failed.")
+        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