Update app.py

app.py

@@ -164,7 +164,12 @@ def infer_video_depth(
     
     # Nachdem die Videos erstellt wurden, wenden wir den Loop-Faktor an
     if loop_factor > 1:
+        # Stellen sicher, dass das Ausgabeverzeichnis existiert
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Für die Tiefenkarte
         depth_looped_path = os.path.join(output_dir, os.path.splitext(os.path.basename(depth_vis_path))[0] + f'_loop{loop_factor}.mp4')
+        print(f"Creating looped depth video with factor {loop_factor}")
         
         # Erstelle eine temporäre Textdatei mit der Liste der zu wiederholenden Dateien
         concat_file_path = os.path.join(output_dir, 'concat_list.txt')
@@ -184,13 +189,22 @@ def infer_video_depth(
         ]
         subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         
-        # Ersetze den ursprünglichen Pfad durch den neuen geloopten Pfad
-        depth_vis_path = depth_looped_path
+        # Überprüfe, ob die Datei erstellt wurde
+        if os.path.exists(depth_looped_path):
+            # Ersetze den ursprünglichen Pfad durch den neuen geloopten Pfad
+            depth_vis_path = depth_looped_path
+        else:
+            print(f"WARNING: Failed to create looped depth video at {depth_looped_path}")
         
         if stitch and stitched_video_path:
-            # Speichern wir den Originalnamen
+            # Speichern wir den Originalnamen und absoluten Pfad
             original_path = stitched_video_path
             
+            print(f"Looping video {original_path} with factor {loop_factor}")
+            
+            # Pfad für das Ausgangsverzeichnis sicherstellen
+            output_folder = os.path.dirname(original_path)
+            
             # Überprüfen wir, ob das Input-Video einen Audio-Stream hat
             has_audio = False
             check_audio_cmd = [
@@ -204,92 +218,135 @@ def infer_video_depth(
             stderr = result.stderr.decode('utf-8')
             if "Audio" in stderr:
                 has_audio = True
-            
-            # Erstelle eine temporäre Textdatei für die stitched Videos
-            concat_stitched_file_path = os.path.join(output_dir, 'concat_stitched_list.txt')
-            with open(concat_stitched_file_path, 'w') as f:
-                for _ in range(loop_factor):
-                    f.write(f"file '{original_path}'\n")
+                print("Audio stream detected in input video")
             
             # Temporärer Pfad für das geloopte Video ohne Audio
-            temp_looped_path = os.path.join(output_dir, 'temp_looped_rgbd.mp4')
+            temp_looped_path = os.path.join(output_folder, 'temp_looped_rgbd.mp4')
             
-            # Verwende ffmpeg, um das Video zu loopen
-            concat_cmd = [
-                "ffmpeg",
-                "-y",
-                "-f", "concat",
-                "-safe", "0",
-                "-i", concat_stitched_file_path,
-                "-c", "copy",
-                temp_looped_path
-            ]
-            subprocess.run(concat_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            
-            # Wenn Audio vorhanden ist, müssen wir es separat behandeln
-            if has_audio:
-                # Extrahiere den Audio-Track aus dem originalen Input-Video
-                # Dies ist die sauberste Quelle
-                audio_path = os.path.join(output_dir, 'extracted_audio.aac')
-                extract_audio_cmd = [
-                    "ffmpeg",
-                    "-y",
-                    "-i", input_video,  # Original Input-Video verwenden
-                    "-vn", "-acodec", "copy",
-                    audio_path
-                ]
-                subprocess.run(extract_audio_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                
-                # Erstelle eine Textdatei für das Audio-Looping
-                concat_audio_file_path = os.path.join(output_dir, 'concat_audio_list.txt')
-                with open(concat_audio_file_path, 'w') as f:
+            try:
+                # Erstelle eine temporäre Textdatei für die stitched Videos
+                concat_stitched_file_path = os.path.join(output_folder, 'concat_stitched_list.txt')
+                with open(concat_stitched_file_path, 'w') as f:
                     for _ in range(loop_factor):
-                        f.write(f"file '{audio_path}'\n")
+                        f.write(f"file '{original_path}'\n")
+                
+                print(f"Creating temporary file at: {temp_looped_path}")
                 
-                # Erstelle den geloopten Audio-Track
-                looped_audio_path = os.path.join(output_dir, 'looped_audio.aac')
-                audio_loop_cmd = [
+                # Verwende ffmpeg, um das Video zu loopen
+                concat_cmd = [
                     "ffmpeg",
                     "-y",
                     "-f", "concat",
                     "-safe", "0",
-                    "-i", concat_audio_file_path,
+                    "-i", concat_stitched_file_path,
                     "-c", "copy",
-                    looped_audio_path
+                    temp_looped_path
                 ]
-                subprocess.run(audio_loop_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                process = subprocess.run(concat_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                print(f"FFmpeg concat command exit code: {process.returncode}")
+                if process.returncode != 0:
+                    print(f"FFmpeg error: {process.stderr.decode('utf-8')}")
                 
-                # Kombiniere das geloopte Video mit dem geloopten Audio
-                final_cmd = [
-                    "ffmpeg",
-                    "-y",
-                    "-i", temp_looped_path,
-                    "-i", looped_audio_path,
-                    "-c:v", "copy",
-                    "-c:a", "aac",
-                    "-map", "0:v:0",
-                    "-map", "1:a:0",
-                    "-shortest",
-                    original_path  # Verwenden des originalen Pfads als Ziel
-                ]
-                subprocess.run(final_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            else:
-                # Wenn kein Audio vorhanden ist, einfach das Video umbenennen
-                os.replace(temp_looped_path, original_path)
-            
-            # Bereinige temporäre Dateien
-            temp_files = [concat_file_path, concat_stitched_file_path]
-            if has_audio:
-                temp_files.extend([concat_audio_file_path, audio_path, looped_audio_path])
-            if os.path.exists(temp_looped_path):
-                temp_files.append(temp_looped_path)
+                # Überprüfe, ob die temporäre Datei erzeugt wurde
+                if not os.path.exists(temp_looped_path):
+                    print(f"ERROR: Failed to create temporary file {temp_looped_path}")
+                    print(f"Current directory contents: {os.listdir(output_folder)}")
+                    # Fallback
+                    return [depth_vis_path, stitched_video_path]
+                
+                # Wenn Audio vorhanden ist, müssen wir es separat behandeln
+                if has_audio:
+                    # Extrahiere den Audio-Track aus dem originalen Input-Video
+                    audio_path = os.path.join(output_folder, 'extracted_audio.aac')
+                    extract_audio_cmd = [
+                        "ffmpeg",
+                        "-y",
+                        "-i", input_video,  # Original Input-Video verwenden
+                        "-vn", "-acodec", "copy",
+                        audio_path
+                    ]
+                    subprocess.run(extract_audio_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                    
+                    # Prüfen, ob Audio extrahiert wurde
+                    if not os.path.exists(audio_path) or os.path.getsize(audio_path) == 0:
+                        print(f"WARNING: Failed to extract audio or no audio track in {input_video}")
+                        has_audio = False
+                    else:
+                        # Erstelle eine Textdatei für das Audio-Looping
+                        concat_audio_file_path = os.path.join(output_folder, 'concat_audio_list.txt')
+                        with open(concat_audio_file_path, 'w') as f:
+                            for _ in range(loop_factor):
+                                f.write(f"file '{audio_path}'\n")
+                        
+                        # Erstelle den geloopten Audio-Track
+                        looped_audio_path = os.path.join(output_folder, 'looped_audio.aac')
+                        audio_loop_cmd = [
+                            "ffmpeg",
+                            "-y",
+                            "-f", "concat",
+                            "-safe", "0",
+                            "-i", concat_audio_file_path,
+                            "-c", "copy",
+                            looped_audio_path
+                        ]
+                        subprocess.run(audio_loop_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                        
+                        # Prüfe, ob Audio geloopt wurde
+                        if not os.path.exists(looped_audio_path) or os.path.getsize(looped_audio_path) == 0:
+                            print(f"WARNING: Failed to create looped audio")
+                            has_audio = False
                 
-            for file_path in temp_files:
-                if os.path.exists(file_path):
-                    try:
-                        os.remove(file_path)
-                    except:
-                        pass
+                # Finaler Schritt: Kombiniere Video und Audio wenn nötig, sonst nur Video kopieren
+                if has_audio:
+                    # Kombiniere das geloopte Video mit dem geloopten Audio
+                    final_cmd = [
+                        "ffmpeg",
+                        "-y",
+                        "-i", temp_looped_path,
+                        "-i", looped_audio_path,
+                        "-c:v", "copy",
+                        "-c:a", "aac",
+                        "-map", "0:v:0",
+                        "-map", "1:a:0",
+                        "-shortest",
+                        original_path  # Verwenden des originalen Pfads als Ziel
+                    ]
+                    subprocess.run(final_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                else:
+                    # Wenn kein Audio vorhanden ist, einfach das Video kopieren
+                    copy_cmd = [
+                        "ffmpeg",
+                        "-y",
+                        "-i", temp_looped_path,
+                        "-c", "copy",
+                        original_path
+                    ]
+                    subprocess.run(copy_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                
+                # Überprüfen, ob die Ersetzung erfolgreich war
+                if not os.path.exists(original_path):
+                    print(f"ERROR: Failed to replace {original_path} with looped version")
+                else:
+                    print(f"Successfully replaced {original_path} with looped version")
+                
+                # Bereinige temporäre Dateien
+                temp_files = [concat_file_path, concat_stitched_file_path]
+                if has_audio:
+                    temp_files.extend([concat_audio_file_path, audio_path, looped_audio_path])
+                if os.path.exists(temp_looped_path):
+                    temp_files.append(temp_looped_path)
+                    
+                for file_path in temp_files:
+                    if os.path.exists(file_path):
+                        try:
+                            os.remove(file_path)
+                        except Exception as e:
+                            print(f"Warning: Could not remove temporary file {file_path}: {str(e)}")
+            
+            except Exception as e:
+                print(f"Error during looping process: {str(e)}")
+                # Im Fehlerfall die ursprünglichen Dateien behalten
+                return [depth_vis_path, stitched_video_path]
 
     gc.collect()
     torch.cuda.empty_cache()