Update app.py

app.py

@@ -62,7 +62,7 @@ filepath = hf_hub_download(
     repo_id=f"depth-anything/Video-Depth-Anything-{model_name}",
     filename=f"video_depth_anything_{encoder}.pth",
     repo_type="model",
-    cache_dir="/tmp/huggingface"  # Explizites Setzen des Cache-Verzeichnisses
+    cache_dir="/tmp/huggingface"  # Explicitly set the cache directory
 )
 video_depth_anything.load_state_dict(torch.load(filepath, map_location='cpu'))
 video_depth_anything = video_depth_anything.to(DEVICE).eval()
@@ -80,7 +80,7 @@ def infer_video_depth(
     grayscale: bool = True,
     convert_from_color: bool = True,
     blur: float = 0.3,
-    loop_factor: int = 1,  # Neuer Parameter
+    loop_factor: int = 1,  # New parameter for video looping
     output_dir: str = './outputs',
     input_size: int = 518,
 ):
@@ -162,197 +162,165 @@ def infer_video_depth(
         subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         os.replace(temp_audio_path, stitched_video_path)
     
-    # Nachdem die Videos erstellt wurden, wenden wir den Loop-Faktor an
-    if loop_factor > 1:
-        # Stellen sicher, dass das Ausgabeverzeichnis existiert
+    # Apply looping only to the RGBD video when requested
+    if loop_factor > 1 and stitch and stitched_video_path:
+        # Ensure the output directory exists
         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}")
+        # Save original path and absolute path
+        original_path = stitched_video_path
+        abs_original_path = os.path.abspath(original_path)
         
-        # Erstelle eine temporäre Textdatei mit der Liste der zu wiederholenden Dateien
-        concat_file_path = os.path.join(output_dir, 'concat_list.txt')
-        with open(concat_file_path, 'w') as f:
-            for _ in range(loop_factor):
-                # Absoluten Pfad verwenden
-                abs_path = os.path.abspath(depth_vis_path)
-                f.write(f"file '{abs_path}'\n")
+        print(f"Looping video {original_path} with factor {loop_factor}")
         
-        # Verwende ffmpeg, um das Video zu wiederholen ohne Neucodierung
-        cmd = [
+        # Check if the input video has an audio stream
+        has_audio = False
+        check_audio_cmd = [
             "ffmpeg",
-            "-y",
-            "-f", "concat",
-            "-safe", "0",
-            "-i", concat_file_path,
+            "-i", input_video,
             "-c", "copy",
-            depth_looped_path
+            "-f", "null",
+            "-"
         ]
-        subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        result = subprocess.run(check_audio_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stderr = result.stderr.decode('utf-8')
+        if "Audio" in stderr:
+            has_audio = True
+            print("Audio stream detected in input video")
         
-        # Ü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}")
+        # Temporary path in the output directory
+        temp_looped_path = os.path.join(output_dir, 'temp_rgbd_looped.mp4')
         
-        if stitch and stitched_video_path:
-            # Speichern wir den Originalnamen und absoluten Pfad
-            original_path = stitched_video_path
-            abs_original_path = os.path.abspath(original_path)
+        try:
+            # Create a temporary text file for the 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):
+                    # Use absolute path
+                    f.write(f"file '{abs_original_path}'\n")
             
-            print(f"Looping video {original_path} with factor {loop_factor}")
+            print(f"Creating temporary file at: {temp_looped_path}")
+            print(f"Using absolute path for original: {abs_original_path}")
             
-            # Überprüfen wir, ob das Input-Video einen Audio-Stream hat
-            has_audio = False
-            check_audio_cmd = [
+            # Use ffmpeg to loop the video
+            concat_cmd = [
                 "ffmpeg",
-                "-i", input_video,
+                "-y",
+                "-f", "concat",
+                "-safe", "0",
+                "-i", concat_stitched_file_path,
                 "-c", "copy",
-                "-f", "null",
-                "-"
+                temp_looped_path
             ]
-            result = subprocess.run(check_audio_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            stderr = result.stderr.decode('utf-8')
-            if "Audio" in stderr:
-                has_audio = True
-                print("Audio stream detected in input video")
+            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')}")
             
-            # Temporärer Pfad im Output-Verzeichnis
-            temp_looped_path = os.path.join(output_dir, 'temp_rgbd_looped.mp4')
+            # Check if the temporary file was created
+            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_dir)}")
+                # Fallback
+                return [depth_vis_path, stitched_video_path]
             
-            try:
-                # 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):
-                        # Absoluten Pfad verwenden
-                        f.write(f"file '{abs_original_path}'\n")
-                
-                print(f"Creating temporary file at: {temp_looped_path}")
-                print(f"Using absolute path for original: {abs_original_path}")
-                
-                # Verwende ffmpeg, um das Video zu loopen
-                concat_cmd = [
+            # If audio is present, we need to handle it separately
+            if has_audio:
+                # Extract the audio track from the original input video
+                audio_path = os.path.join(output_dir, 'extracted_audio.aac')
+                extract_audio_cmd = [
                     "ffmpeg",
                     "-y",
-                    "-f", "concat",
-                    "-safe", "0",
-                    "-i", concat_stitched_file_path,
-                    "-c", "copy",
-                    temp_looped_path
+                    "-i", input_video,  # Use original input video
+                    "-vn", "-acodec", "copy",
+                    audio_path
                 ]
-                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')}")
+                subprocess.run(extract_audio_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                 
-                # Ü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_dir)}")
-                    # 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_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)
-                    
-                    # 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_dir, 'concat_audio_list.txt')
-                        with open(concat_audio_file_path, 'w') as f:
-                            for _ in range(loop_factor):
-                                # Absoluten Pfad verwenden
-                                abs_audio_path = os.path.abspath(audio_path)
-                                f.write(f"file '{abs_audio_path}'\n")
-                        
-                        # Erstelle den geloopten Audio-Track
-                        looped_audio_path = os.path.join(output_dir, '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
-                
-                # 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)
+                # Check if audio was extracted
+                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:
-                    # Wenn kein Audio vorhanden ist, einfach das Video kopieren
-                    copy_cmd = [
+                    # Create a text file for audio looping
+                    concat_audio_file_path = os.path.join(output_dir, 'concat_audio_list.txt')
+                    with open(concat_audio_file_path, 'w') as f:
+                        for _ in range(loop_factor):
+                            # Use absolute path
+                            abs_audio_path = os.path.abspath(audio_path)
+                            f.write(f"file '{abs_audio_path}'\n")
+                    
+                    # Create the looped audio track
+                    looped_audio_path = os.path.join(output_dir, 'looped_audio.aac')
+                    audio_loop_cmd = [
                         "ffmpeg",
                         "-y",
-                        "-i", temp_looped_path,
+                        "-f", "concat",
+                        "-safe", "0",
+                        "-i", concat_audio_file_path,
                         "-c", "copy",
-                        original_path
+                        looped_audio_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)
+                    subprocess.run(audio_loop_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                     
-                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)}")
+                    # Check if audio was looped
+                    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
             
-            except Exception as e:
-                print(f"Error during looping process: {str(e)}")
-                import traceback
-                traceback.print_exc()
-                # Im Fehlerfall die ursprünglichen Dateien behalten
-                return [depth_vis_path, stitched_video_path]
+            # Final step: Combine video and audio if needed, otherwise just copy video
+            if has_audio:
+                # Combine the looped video with the looped 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  # Use the original path as destination
+                ]
+                subprocess.run(final_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            else:
+                # If no audio exists, just copy the video
+                copy_cmd = [
+                    "ffmpeg",
+                    "-y",
+                    "-i", temp_looped_path,
+                    "-c", "copy",
+                    original_path
+                ]
+                subprocess.run(copy_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            # Check if the replacement was successful
+            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")
+            
+            # Clean up temporary files
+            temp_files = [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)}")
+            import traceback
+            traceback.print_exc()
+            # In case of error, keep the original files
+            return [depth_vis_path, stitched_video_path]
 
     gc.collect()
     torch.cuda.empty_cache()
@@ -386,8 +354,8 @@ def construct_demo():
                     grayscale_option = gr.Checkbox(label="Output Depth as Grayscale", value=True)
                     convert_from_color_option = gr.Checkbox(label="Convert Grayscale from Color", value=True)
                     blur_slider = gr.Slider(minimum=0, maximum=1, step=0.01, label="Depth Blur (can reduce edge artifacts on display)", value=0.3)
-                    # Füge den Loop-Faktor Slider hinzu
-                    loop_factor = gr.Slider(label="Loop Factor (repeats the output video)", minimum=1, maximum=20, value=1, step=1)
+                    # Add the loop factor slider
+                    loop_factor = gr.Slider(label="Loop Factor (repeats the RGBD output video)", minimum=1, maximum=20, value=1, step=1)
                 generate_btn = gr.Button("Generate")
             with gr.Column(scale=2):
                 pass
@@ -396,7 +364,7 @@ def construct_demo():
         
         generate_btn.click(
             fn=infer_video_depth,
-            inputs=[input_video, max_len, target_fps, max_res, stitch_option, grayscale_option, convert_from_color_option, blur_slider, loop_factor],  # loop_factor hinzugefügt
+            inputs=[input_video, max_len, target_fps, max_res, stitch_option, grayscale_option, convert_from_color_option, blur_slider, loop_factor],  # Added loop_factor
             outputs=[depth_vis_video, stitched_video],
         )