Update app.py

app.py

@@ -23,6 +23,7 @@ def get_font_path():
     return None # Fallback: FFmpeg soll selbst suchen (klappt manchmal nicht)
 
 def save_temp_audio(audio_file):
+    # Diese Funktion wurde nicht verändert, nur zur Vollständigkeit belassen
     if isinstance(audio_file, str):
         ext = Path(audio_file).suffix
         if ext.lower() not in allowed_audios:
@@ -42,9 +43,25 @@ def save_temp_audio(audio_file):
         return temp_audio
     return None
 
+# HILFSFUNKTION für den Drawtext-Filter
+def create_timed_drawtext(word, start_time, duration, font_option, font_size, y_pos):
+    """Erstellt einen FFmpeg drawtext Filter, der ein Wort für eine bestimmte Zeit einblendet."""
+    # Definiere die Start- und Endzeit des Wortes
+    end_time = start_time + duration
+    
+    # Text-Filter mit enable='between(t,start_time,end_time)' für zeitgesteuerte Anzeige
+    # box=1 wird weggelassen, um den Filter nicht zu komplex zu machen, falls jedes Wort einen eigenen Hintergrund braucht.
+    # Hier verwenden wir einen festen Rahmen (borderw) für Lesbarkeit.
+    drawtext_filter = (
+        f"drawtext=text='{word.replace(':', '\\:')}'{font_option}:fontcolor=white:fontsize={font_size}:borderw=2:bordercolor=black:"
+        f"x=(w-text_w)/2:y=(h-text_h)*{y_pos}:"
+        f"enable='between(t,{start_time},{end_time})'"
+    )
+    return drawtext_filter
+
 def generate_slideshow_with_audio(images, input_text, duration_per_word, duration_per_image, fade_duration, font_size, y_pos, audio_file):
-    # Debug Print, um zu sehen, ob Werte korrekt ankommen
-    print(f"DEBUG: Font Size: {font_size}, Y-Pos: {y_pos}, Fade: {fade_duration}")
+    # Debug Print
+    print(f"DEBUG: Font Size: {font_size}, Y-Pos: {y_pos}, Duration/Word: {duration_per_word}, Fade: {fade_duration}")
 
     if not images:
         return None, "❌ Keine Bilder ausgewählt"
@@ -54,58 +71,135 @@ def generate_slideshow_with_audio(images, input_text, duration_per_word, duratio
 
     # Text in Wörter aufteilen
     words = input_text.split() if input_text else []
-    word_index = 0
+    
+    # Berechne die Gesamt-Textdauer
+    total_text_duration = len(words) * duration_per_word
+    
+    # Schriftart finden
+    font_path = get_font_path()
+    font_option = f":fontfile='{font_path}'" if font_path else ""
 
-    # Audio verarbeiten
+    # Audio verarbeiten (Muss vor dem ersten FFmpeg-Aufruf sein, um die Datei zu speichern)
     temp_audio_file = None
     if audio_file:
         temp_audio_file = save_temp_audio(audio_file)
 
-    # Schriftart finden
-    font_path = get_font_path()
-    font_option = f":fontfile='{font_path}'" if font_path else ""
-
-    for i, img_path in enumerate(images):
-        img_path = Path(img_path.name)
-        clip_path_with_text = Path(temp_dir) / f"clip_with_text_{i}.mp4"
+    # 1. ERSTES BILD: Hier wird die sequenzielle Textanzeige angewendet
+    
+    # Stelle sicher, dass die Dauer des ersten Clips lang genug für den gesamten Text ist
+    # Wir nehmen die maximale Dauer zwischen der gewünschten Bilddauer und der Textdauer
+    duration_clip_1 = max(duration_per_image, total_text_duration)
+    
+    # Generiere die sequentiellen Drawtext-Filter
+    drawtext_filters = []
+    current_time = 0.0
+    for word in words:
+        # Erstelle den Filter für das aktuelle Wort
+        # Wir verwenden duration_per_word als die Anzeigezeit für jedes Wort
+        filter_str = create_timed_drawtext(word, current_time, duration_per_word, font_option, font_size, y_pos)
+        drawtext_filters.append(filter_str)
+        # Nächste Startzeit erhöhen
+        current_time += duration_per_word
+    
+    # FÜGE FADE HINZU: Wir wenden den Fade-Filter nur auf den Video-Stream an.
+    # Der Text-Stream wird nur über die 'enable' Bedingung gesteuert.
+    fade_filter = f"[v]fade=t=in:st=0:d={fade_duration},fade=t=out:st={duration_clip_1}-{fade_duration}:d={fade_duration}[v_out]"
+    
+    # FÜGE ALLE FILTER ZUSAMMEN: scale, pad, fps, format, [Text-Filter], fade
+    # Jeder Text-Filter muss über das Overlay-Filter auf den Stream angewendet werden.
+    # Dies ist sehr komplex und einfacher, indem man alle drawtext-Filter in einem einzigen
+    # drawtext-Aufruf bündelt, ODER den Text nur für das erste Bild nutzt.
+    
+    # Vereinfachte Methode: Nur der primäre Filterstring für das 1. Bild
+    if drawtext_filters:
+        # Fügen Sie alle drawtext-Filter (mit Komma getrennt) zum Haupt-VF-Filter hinzu
+        # Die Kette sieht dann so aus: scale -> pad -> fps -> format -> drawtext_1 -> drawtext_2 -> ... -> fade
+        # Da drawtext direkt auf den Stream angewendet wird, müssen wir mit dem overlay-Filter arbeiten,
+        # was bei mehreren Wörtern sehr komplex wird.
+        # Wir machen es uns einfacher und nutzen eine Kette von 'drawtext' Filtern.
+        # **ACHTUNG: Dies ist technisch nicht korrekt für *zeitgesteuertes* Einblenden, wenn man nur ein 'drawtext' nutzt.
+        # Stattdessen nutzen wir die 'enable' Bedingung in einem einzigen 'drawtext'-Aufruf,
+        # was einfacher ist, aber jedes Wort einzeln als drawtext-Aufruf benötigt.**
+        
+        # Um es einfach zu halten, verwenden wir die `create_timed_drawtext` Funktion,
+        # die den `enable` Parameter nutzt. Wir fügen die einzelnen Filter-Anweisungen
+        # in einer Kette zusammen.
+        
+        # **Korrektur:** Statt einer Kette muss man für jedes Wort einen eigenen `drawtext` Filter
+        # in der FFmpeg-Kommandozeile verwenden, verbunden durch Kommas.
         
-        # Aktuelles Wort holen
-        if word_index < len(words):
-            text = words[word_index]
-            word_index += 1
-        else:
-            text = ""
-
-        # WICHTIG: Text in temporäre Datei schreiben, um Escaping-Probleme zu vermeiden
-        text_file_path = Path(temp_dir) / f"text_{i}.txt"
-        with open(text_file_path, "w", encoding="utf-8") as f:
-            f.write(text)
-
-        # Drawtext Filter mit textfile statt text='...'
-        # box=1 macht einen leichten Hintergrund hinter den Text für Lesbarkeit
-        vf_filters = (
+        # 1. Basisanpassungen
+        base_filters = (
             "scale=w=1280:h=720:force_original_aspect_ratio=decrease,"
             "pad=1280:720:(ow-iw)/2:(oh-ih)/2:color=black,"
-            "fps=25,format=yuv420p,"
-            f"drawtext=textfile='{text_file_path}'{font_option}:fontcolor=white:fontsize={font_size}:borderw=2:bordercolor=black:"
-            f"x=(w-text_w)/2:y=(h-text_h)*{y_pos}:"
-            f"alpha='if(lt(t,{fade_duration}), t/{fade_duration}, if(lt(t,{duration_per_image}-{fade_duration}), 1, ({duration_per_image}-t)/{fade_duration}))'"
+            "fps=25,format=yuv420p"
+        )
+        
+        # 2. Sequentielle Textfilter
+        # Der erste Filter (base_filters) wird direkt angewendet, dann kommen die drawtext-Filter
+        # und ganz zum Schluss der Fade-Filter.
+        
+        # Fügen Sie die Drawtext-Filter hinzu
+        all_drawtext_filters = ",".join(drawtext_filters)
+        
+        # 3. Fade-Filter: Muss der letzte in der Kette sein, um das Ein- und Ausblenden des Bildes zu steuern.
+        # Hier ist es einfacher, das Bild (anstatt des gesamten Videos) einzublenden.
+        fade_img_filter = f"fade=t=in:st=0:d={fade_duration},fade=t=out:st={duration_clip_1}-{fade_duration}:d={fade_duration}"
+        
+        vf_filters_clip1 = f"{base_filters},{all_drawtext_filters},{fade_img_filter}"
+    else:
+        # Kein Text, nur Bild-Filter mit Fade
+        fade_img_filter = f"fade=t=in:st=0:d={fade_duration},fade=t=out:st={duration_clip_1}-{fade_duration}:d={fade_duration}"
+        vf_filters_clip1 = (
+            "scale=w=1280:h=720:force_original_aspect_ratio=decrease,"
+            "pad=1280:720:(ow-iw)/2:(oh-ih)/2:color=black,"
+            f"fps=25,format=yuv420p,{fade_img_filter}"
         )
 
+    # Erstelle Clip 1 (mit Text)
+    img_path_1 = Path(images[0].name)
+    clip_path_1 = Path(temp_dir) / "clip_with_text_0.mp4"
+    
+    cmd_1 = [
+        "ffmpeg", "-y", "-loop", "1", "-i", str(img_path_1),
+        "-t", str(duration_clip_1),
+        "-vf", vf_filters_clip1,
+        str(clip_path_1)
+    ]
+    
+    try:
+        subprocess.run(cmd_1, check=True, capture_output=True, text=True)
+        clips_with_text.append(clip_path_1)
+    except subprocess.CalledProcessError as e:
+        return None, f"❌ FFmpeg Fehler bei Bild 1 (mit Text):\n{e.stderr}"
+
+    # 2. FOLGE-BILDER: Nur Bild mit Fade
+    for i in range(1, len(images)):
+        img_path = Path(images[i].name)
+        clip_path = Path(temp_dir) / f"clip_{i}.mp4"
+        
+        # Nur Bild-Filter mit Fade
+        fade_img_filter = f"fade=t=in:st=0:d={fade_duration},fade=t=out:st={duration_per_image}-{fade_duration}:d={fade_duration}"
+        vf_filters_clip = (
+            "scale=w=1280:h=720:force_original_aspect_ratio=decrease,"
+            "pad=1280:720:(ow-iw)/2:(oh-ih)/2:color=black,"
+            f"fps=25,format=yuv420p,{fade_img_filter}"
+        )
+        
         cmd = [
             "ffmpeg", "-y", "-loop", "1", "-i", str(img_path),
             "-t", str(duration_per_image),
-            "-vf", vf_filters,
-            str(clip_path_with_text)
+            "-vf", vf_filters_clip,
+            str(clip_path)
         ]
         
         try:
             subprocess.run(cmd, check=True, capture_output=True, text=True)
-            clips_with_text.append(clip_path_with_text)
+            clips_with_text.append(clip_path)
         except subprocess.CalledProcessError as e:
-            return None, f"❌ FFmpeg Fehler bei Bild {i+1}:\n{e.stderr}"
+            return None, f"❌ FFmpeg Fehler bei Bild {i+1} (ohne Text):\n{e.stderr}"
 
-    # Zusammenfügen
+    # Zusammenfügen (Der Rest der Funktion bleibt gleich)
     filelist_path = Path(temp_dir) / "filelist.txt"
     with open(filelist_path, "w") as f:
         for clip in clips_with_text:
@@ -120,7 +214,10 @@ def generate_slideshow_with_audio(images, input_text, duration_per_word, duratio
         str(output_video)
     ]
     
-    subprocess.run(cmd_concat, check=True)
+    try:
+        subprocess.run(cmd_concat, check=True)
+    except subprocess.CalledProcessError as e:
+        return None, f"❌ FFmpeg Fehler beim Zusammenfügen:\n{e.stderr}"
 
     # Audio hinzufügen falls vorhanden
     if temp_audio_file:
@@ -130,7 +227,10 @@ def generate_slideshow_with_audio(images, input_text, duration_per_word, duratio
             "-c:v", "copy", "-c:a", "aac", "-shortest",
             str(final_output)
         ]
-        subprocess.run(cmd_audio, check=True)
+        try:
+            subprocess.run(cmd_audio, check=True)
+        except subprocess.CalledProcessError as e:
+            return None, f"❌ FFmpeg Fehler beim Hinzufügen von Audio:\n{e.stderr}"
         return str(final_output), "✅ Video mit Audio erstellt!"
 
     return str(output_video), "✅ Video erstellt (ohne Audio)"
@@ -141,16 +241,14 @@ with gr.Blocks() as demo:
 
     with gr.Row():
         img_input = gr.Files(label="Bilder", file_types=allowed_medias)
-        text_input = gr.Textbox(label="Text", lines=5, placeholder="Wörter werden auf Bilder verteilt")
+        text_input = gr.Textbox(label="Text (Wörter erscheinen nacheinander auf dem ersten Bild)", lines=5, placeholder="Jedes Wort wird für 'Dauer pro Wort' angezeigt.")
     
     with gr.Row():
-        duration_image_input = gr.Number(value=3, label="Dauer pro Bild (s)")
+        duration_image_input = gr.Number(value=3, label="Dauer pro BILD (s) [für Bild 2+ und Min-Dauer für Bild 1]")
+        duration_word_input = gr.Number(value=1.0, label="Dauer pro WORT (s) [bestimmt Geschwindigkeit der Text-Anzeige]")
         fade_input = gr.Number(value=0.5, label="Fade Dauer (s)")
         font_size_input = gr.Number(value=80, label="Schriftgröße (px)")
-        ypos_input = gr.Slider(0.0, 1.0, value=0.5, label="Y-Position (0=Oben, 1=Unten)")
-    
-    # Dummy Input für duration_per_word (wird im Script aktuell nicht genutzt, aber die Funk erwartet ihn)
-    duration_word_input = gr.Number(value=0.5, visible=False) 
+        ypos_input = gr.Slider(0.0, 1.0, value=0.9, label="Y-Position (0=Oben, 1=Unten)")
     
     audio_input = gr.File(label="Audio (optional)", file_types=allowed_audios)
     btn = gr.Button("Erstellen", variant="primary")
@@ -165,11 +263,11 @@ with gr.Blocks() as demo:
         inputs=[
             img_input, 
             text_input, 
-            duration_word_input, 
+            duration_word_input, # Jetzt aktiv
             duration_image_input, 
-            fade_input,       # War vorher vertauscht
-            font_size_input,  # War vorher vertauscht
-            ypos_input,       # War vorher vertauscht
+            fade_input, 
+            font_size_input, 
+            ypos_input, 
             audio_input
         ],
         outputs=[out_video, status]