video playback check

.gitignore

@@ -0,0 +1,8 @@
+*.ipynb
+ipynb_checkpoints/
+*.mp4
+*.avi
+flagged/
+frames/
+diff_frames/
+*.wmv

app.py

@@ -0,0 +1,196 @@
+import cv2
+import gradio as gr
+import numpy as np
+import os
+import shutil
+from pathlib import Path
+
+# def process_video(input_video):
+#     # Create a directory to store frames
+#     frames_dir = Path("frames")
+#     frames_dir.mkdir(exist_ok=True)
+    
+#     # Read the video
+#     cap = cv2.VideoCapture(input_video)
+#     count = 0
+#     frames = []
+    
+#     while True:
+#         ret, frame = cap.read()
+#         if not ret:
+#             break
+#         frame_path = str(frames_dir / f"frame_{count}.jpg")
+#         cv2.imwrite(frame_path, frame)
+#         frames.append(frame)
+#         count += 1
+    
+#     # Close video file
+#     cap.release()
+    
+#     # Process the first and the last frame (simple example: convert to grayscale)
+#     if frames:
+#         frames[0] = cv2.cvtColor(frames[0], cv2.COLOR_BGR2GRAY)
+#         frames[-1] = cv2.cvtColor(frames[-1], cv2.COLOR_BGR2GRAY)
+    
+#     # Create a processed video
+#     output_video_path = "processed_video.mp4"
+#     height, width = frames[0].shape[:2]
+#     fourcc = cv2.VideoWriter_fourcc(*'mp4v') # or use 'XVID' if mp4 does not work
+#     out = cv2.VideoWriter(output_video_path, fourcc, 60.0, (width, height), isColor=len(frames[0].shape) > 2)
+    
+#     for frame in frames:
+#         out.write(frame)
+    
+#     out.release()
+#     return output_video_path
+
+
+def process_video(input_video):
+    # Create a directory to store difference frames
+    diff_frames_dir = Path("diff_frames")
+    if os.path.exists(diff_frames_dir):
+        shutil.rmtree(diff_frames_dir)
+    diff_frames_dir.mkdir(exist_ok=True)
+    
+    frames_dir = Path("frames")
+    if os.path.exists(frames_dir):
+        shutil.rmtree(frames_dir)
+    frames_dir.mkdir(exist_ok=True)
+    
+    # Read the video
+    cap = cv2.VideoCapture(input_video)
+    count = 0
+    diff_frames = []
+    prev_frame = None
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        # Convert frame to grayscale
+        gray_frame = frame #cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        frame_path = str(frames_dir / f"frame_{count}.jpg")
+        cv2.imwrite(frame_path, frame)
+        
+        if prev_frame is not None:
+            # Calculate difference with the previous frame
+            diff = cv2.absdiff(prev_frame, gray_frame)
+            diff_frames.append(gray_frame)
+            
+            # Save difference frame
+            diff_frame_path = str(diff_frames_dir / f"diff_frame_{count}.jpg")
+            cv2.imwrite(diff_frame_path, diff)
+        else:
+            # For the first frame, there is no previous frame to compare
+            diff_frames.append(gray_frame)
+            
+        prev_frame = gray_frame
+        count += 1
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    print(fps)
+    size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
+    print(size)
+    # Close video file
+    cap.release()
+    
+    # Create a video from the difference frames
+    output_video_path = "diff_video.mp4"
+    if diff_frames:
+        print("Here")
+        height, width = diff_frames[0].shape[:2]
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")  # Use 'mp4v' for MP4 or 'XVID' for AVI
+        out = cv2.VideoWriter(output_video_path, fourcc, fps, size, isColor=True)
+         
+        for diff_frame in diff_frames:
+            # Need to convert single channel image to three channels to write with VideoWriter
+#             three_channel_frame = cv2.cvtColor(diff_frame, cv2.COLOR_GRAY2BGR)
+            out.write(diff_frame)
+        
+        out.release()
+    
+    return output_video_path
+
+def show_preds_video(input_video):
+    cap = cv2.VideoCapture(input_video)
+    while(cap.isOpened()):
+        ret, frame = cap.read()
+        if ret:
+            frame_copy = frame.copy()
+            
+            yield frame_copy
+
+
+# # Define Gradio Interface
+# iface = gr.Interface(
+#     fn=process_video,
+#     inputs=gr.Video(label="Upload a Video"),
+#     outputs=gr.Video(label="Processed Video"),
+#     title="Video Frame Processor",
+#     description="Upload a video to split it into frames, process the first and last frame, and return the video."
+# )
+
+# # Define Gradio Interface
+# iface = gr.Interface(
+#     fn=show_preds_video,
+#     inputs=gr.Video(label="Upload a Video"),
+#     outputs=[gr.components.Image(type="numpy", label="Output Image")],
+#     cache_examples=False,
+#     title="Video Frame Processor",
+#     description="Upload a video to split it into frames, process the first and last frame, and return the video."
+# )
+
+
+# if __name__ == "__main__":
+#     iface.launch(share=True)
+
+
+# # import spaces
+import gradio as gr
+import cv2
+import numpy as np
+import time
+import random
+from PIL import Image
+# from transparent_background import Remover
+
+# @spaces.GPU()
+def doo(video, mode, progress=gr.Progress()):
+    cap = cv2.VideoCapture(video)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))  # Get total frames
+    writer = None
+    tmpname = random.randint(111111111, 999999999)
+    processed_frames = 0
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+
+        if ret is False:
+            break
+            
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img = Image.fromarray(frame).convert('RGB')
+
+        if writer is None:
+            writer = cv2.VideoWriter(str(tmpname) + '.mp4', cv2.VideoWriter_fourcc(*'mp4v'), cap.get(cv2.CAP_PROP_FPS), img.size)
+
+        processed_frames += 1
+        print(f"Processing frame {processed_frames}")
+        progress(processed_frames / total_frames, desc=f"Processing frame {processed_frames}/{total_frames}")
+        out = img 
+        writer.write(cv2.cvtColor(np.array(out), cv2.COLOR_BGR2RGB))
+
+    cap.release()
+    writer.release()
+    return str(tmpname) + '.mp4'
+
+title = "🎞️ Video Tool 🎥"
+
+iface = gr.Interface(
+    fn=doo,
+    inputs="video",
+    outputs="video",
+    title=title
+)
+iface.launch()

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+torch
+torchvision
+opencv-python
+tqdm