Editing Clips

# app.py:384-505
@app.post("/api/edit")
async def edit_clip(req: EditRequest, x_gemini_key: Optional[str]):
    # Supports edit chaining via input_filename parameter
    if req.input_filename:
        input_path = os.path.join(OUTPUT_DIR, req.job_id, req.input_filename)
    else:
        # Use original clip
        clip = job['result']['clips'][req.clip_index]
        filename = clip['video_url'].split('/')[-1]
        input_path = os.path.join(OUTPUT_DIR, req.job_id, filename)

# editor.py:40-112
def get_ffmpeg_filter(self, video_file_obj, duration, fps=30, width=None, height=None, transcript=None):
    prompt = f"""
    You are an expert FFmpeg video editor. Your task is to generate a complex 
    video filter string to make a short video viral, BUT ONLY apply effects 
    where they make sense contextually.
    
    Video Duration: {duration} seconds
    Video FPS: {fps}
    Video Resolution (MUST KEEP EXACT): {width}x{height}
    
    TRANSCRIPT (Context of what is being said):
    {transcript_text}
    
    Goal: Enhance the video with dynamic zooms, cuts, and visual effects to 
    increase retention, but DO NOT overdo it.
    
    Instructions:
    1. ANALYZE THE VIDEO AND TRANSCRIPT
    2. APPLY EFFECTS ONLY WHEN RELEVANT:
       - Use "punch-in" zooms (zoompan) to emphasize key points
       - slow zooms to face when speaker is speaking
       - Use visual effects (contrast, saturation) for mood changes
       - If nothing significant is happening, keep it simple
    3. Use filters like zoompan, eq, hue, unsharp
    4. Align effects with speech rhythm from transcript
    """

# editor.py:183-202
def _sanitize_filter_string(filter_string: str) -> str:
    # Converts comparison operators to FFmpeg functions
    # t<3 -> lt(t,3)
    # on>=75 -> gte(on,75)
    # t<=10 -> lte(t,10)
    
    patterns = [
        (r"([A-Za-z_]\w*)\s*>=\s*(-?\d+(?:\.\d+)?)", r"gte(\1,\2)"),
        (r"([A-Za-z_]\w*)\s*<=\s*(-?\d+(?:\.\d+)?)", r"lte(\1,\2)"),
        (r"([A-Za-z_]\w*)\s*>\s*(-?\d+(?:\.\d+)?)", r"gt(\1,\2)"),
        (r"([A-Za-z_]\w*)\s*<\s*(-?\d+(?:\.\d+)?)", r"lt(\1,\2)"),
    ]

# app.py:514-621
@app.post("/api/subtitle")
async def add_subtitles(req: SubtitleRequest):
    # Generates SRT from transcript
    # Burns subtitles into video with custom style

# subtitles.py:62-124
def generate_srt(transcript, clip_start, clip_end, output_path, max_chars=20, max_duration=2.0):
    # Extract words within time range
    for segment in transcript.get('segments', []):
        for word_info in segment.get('words', []):
            if word_info['end'] > clip_start and word_info['start'] < clip_end:
                words.append(word_info)
    
    # Group words into short blocks
    current_block = []
    for word in words:
        current_text_len = sum(len(w['word']) + 1 for w in current_block)
        duration = end - block_start
        
        # Close block if too long or too much time
        if current_text_len + len(word['word']) > max_chars or duration > max_duration:
            # Finalize current block
            text = " ".join([w['word'] for w in current_block]).strip()
            srt_content += format_srt_block(index, block_start, block_end, text)

# subtitles.py:44-59
def generate_srt_from_video(video_path, output_path, max_chars=20, max_duration=2.0):
    # Uses faster-whisper to transcribe dubbed audio
    transcript = transcribe_audio(video_path)
    
    # Get video duration
    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    duration = frame_count / fps if fps else 0
    cap.release()
    
    return generate_srt(transcript, 0, duration, output_path, max_chars, max_duration)

# subtitles.py:136-212
def burn_subtitles(video_path, srt_path, output_path, alignment=2, fontsize=16):
    # ASS alignment (numpad layout)
    # 2 = Bottom Center, 6 = Top Center, 10 = Middle Center
    
    # Font scaling: 0.5x input for balanced size
    final_fontsize = int(fontsize * 0.5)
    
    # Style with opaque background box
    style_string = f"""Alignment={ass_alignment},
        Fontname=Verdana,
        Fontsize={final_fontsize},
        PrimaryColour=&H00FFFFFF,      # White text
        OutlineColour=&H60000000,      # 40% opacity black box
        BackColour=&H00000000,
        BorderStyle=3,                  # Opaque box
        Outline=1,
        Shadow=0,
        MarginV=25,                     # 25px margin from edge
        Bold=1
    """

# app.py:631-704
@app.post("/api/hook")
async def add_hook(req: HookRequest):
    # Creates PNG overlay with custom text
    # Composites onto video with FFmpeg

# hooks.py:29-169
def create_hook_image(text, target_width, output_image_path, font_scale=1.0):
    # Configuration
    padding_x = 30
    padding_y = 25
    line_spacing = 20
    cornerradius = 20
    shadow_offset = (5, 5)
    shadow_blur = 10
    
    # Font size: 5% of video width (scaled by size parameter)
    base_font_size = int(target_width * 0.05)
    font_size = int(base_font_size * font_scale)
    
    # Uses Noto Serif Bold (downloaded automatically)
    font = ImageFont.truetype(FONT_PATH, font_size)

# app.py:670-671
size_map = {"S": 0.8, "M": 1.0, "L": 1.3}
font_scale = size_map.get(req.size, 1.0)

# hooks.py:54-91
max_text_width = target_width - (2 * padding_x)

for word in words:
    test_line = ' '.join(current_line + [word])
    bbox = draw.textbbox((0, 0), test_line, font=font)
    w = bbox[2] - bbox[0]
    
    if w <= max_text_width:
        current_line.append(word)
    else:
        lines.append(' '.join(current_line))
        current_line = [word]

# hooks.py:203-213
if position == "center":
    overlay_y = (video_height - box_h) // 2
elif position == "bottom":
    overlay_y = int(video_height * 0.70)  # 70% down
else:
    overlay_y = int(video_height * 0.20)  # 20% from top

# Always centered horizontally
overlay_x = (video_width - box_w) // 2

// Example from dashboard/src/components/VideoCard.jsx
const currentFilename = clip.video_url.split('/').pop();

await fetch('/api/subtitle', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    job_id: jobId,
    clip_index: clipIndex,
    input_filename: currentFilename,  // Uses latest version
    position: 'bottom',
    font_size: 24
  })
});