.

app.py

@@ -32,53 +32,53 @@ def format_duration(seconds: int) -> str:
     return f"{minutes}:{secs:02d}"
 
 
-@spaces.GPU
-def process_video(
-    video_path: str,
-    progress = gr.Progress()
-) -> Tuple[str, str, str, str]:
-    try:
-        # duration = get_video_duration_seconds(video_path)
-        # if duration > 1200:  # 20 minutes
-        #     return None, None, None, "Video must be shorter than 20 minutes"
-
-        progress(0.1, desc="Loading model...")
-        model, processor = load_model()
-        detector = BatchedVideoHighlightDetector(model, processor, batch_size=16)
-
-        progress(0.2, desc="Analyzing video content...")
-        video_description = detector.analyze_video_content(video_path)
+# @spaces.GPU
+# def process_video(
+#     video_path: str,
+#     progress = gr.Progress()
+# ) -> Tuple[str, str, str, str]:
+#     try:
+#         # duration = get_video_duration_seconds(video_path)
+#         # if duration > 1200:  # 20 minutes
+#         #     return None, None, None, "Video must be shorter than 20 minutes"
+
+#         progress(0.1, desc="Loading model...")
+#         model, processor = load_model()
+#         detector = BatchedVideoHighlightDetector(model, processor, batch_size=8)
+
+#         progress(0.2, desc="Analyzing video content...")
+#         video_description = detector.analyze_video_content(video_path)
         
-        progress(0.3, desc="Determining highlight types...")
-        highlight_types = detector.determine_highlights(video_description)
+#         progress(0.3, desc="Determining highlight types...")
+#         highlight_types = detector.determine_highlights(video_description)
 
-        progress(0.4, desc="Detecting and extracting highlights...")
-        with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp_file:
-            output_path = tmp_file.name
+#         progress(0.4, desc="Detecting and extracting highlights...")
+#         with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp_file:
+#             output_path = tmp_file.name
         
-        detector.create_highlight_video(video_path, output_path)
+#         detector.create_highlight_video(video_path, output_path)
         
-        # progress(0.9, desc="Adding watermark...")
-        # output_path = temp_output.replace('.mp4', '_watermark.mp4')
-        # add_watermark(temp_output, output_path)
+#         # progress(0.9, desc="Adding watermark...")
+#         # output_path = temp_output.replace('.mp4', '_watermark.mp4')
+#         # add_watermark(temp_output, output_path)
         
-        os.unlink(output_path)
-        progress(1.0, desc="Complete!")
+#         os.unlink(output_path)
+#         progress(1.0, desc="Complete!")
 
-        video_description = video_description[:500] + "..." if len(video_description) > 500 else video_description
-        highlight_types = highlight_types[:500] + "..." if len(highlight_types) > 500 else highlight_types
+#         video_description = video_description[:500] + "..." if len(video_description) > 500 else video_description
+#         highlight_types = highlight_types[:500] + "..." if len(highlight_types) > 500 else highlight_types
         
-        return output_path, video_description, highlight_types, None
+#         return output_path, video_description, highlight_types, None
 
-    except Exception as e:
-        return None, None, None, f"Error processing video: {str(e)}"
+#     except Exception as e:
+#         return None, None, None, f"Error processing video: {str(e)}"
 
 def create_ui(examples_path: str):
     examples_data = load_examples(examples_path)
 
     with gr.Blocks() as app:
         gr.Markdown("# Video Highlight Generator")
-        gr.Markdown("Upload a video (max 20 minutes) and get an automated highlight reel!")
+        gr.Markdown("Upload a video and get an automated highlight reel!")
         
         with gr.Row():
             gr.Markdown("## Example Results")
@@ -111,68 +111,98 @@ def create_ui(examples_path: str):
             with gr.Column(scale=1):
                 input_video = gr.Video(
                     label="Upload your video (max 20 minutes)",
-                    interactive=True,
-                    max_length = 1200
+                    interactive=True
                 )
                 process_btn = gr.Button("Process Video", variant="primary")
-                status = gr.Markdown(visible=True)
             
-            # Right column: Progress, Results and Analysis
+            # Right column: Progress and Analysis
             with gr.Column(scale=1):
-                gr.Progress()
-                
+
                 # Output video (initially hidden)
                 output_video = gr.Video(
                     label="Highlight Video",
                     visible=False,
                     interactive=False,
+                    downloadable=True
                 )
-                
-                # Analysis accordion
+
+                status = gr.Markdown()
+        
                 with gr.Accordion("Model chain of thought details", open=True, visible=False) as analysis_accordion:
-                    video_description = gr.Markdown(visible=True)
-                    highlight_types = gr.Markdown(visible=True)
+                    video_description = gr.Markdown("", elem_id="video_desc")
+                    highlight_types = gr.Markdown("", elem_id="highlight_types")
+                
 
+        @spaces.GPU
         def on_process(video, progress=gr.Progress()):
             if not video:
                 return {
                     status: "Please upload a video",
-                    output_video: gr.update(visible=False),
-                    analysis_accordion: gr.update(visible=False),
+                    video_description: "",
+                    highlight_types: "",
+                    output_video: gr.update(visible=False)
                 }
             
-            status.value = "Processing video..."
-            output_path, desc, highlights, err = process_video(video, progress=progress)
-            
-            if err:
+            try:
+                duration = get_video_duration_seconds(video)
+                if duration > 1200:  # 20 minutes
+                    return {
+                        status: "Video must be shorter than 20 minutes",
+                        video_description: "",
+                        highlight_types: "",
+                        output_video: gr.update(visible=False)
+                    }
+
+                progress(0.1, desc="Loading model...")
+                status.value = "Loading model..."
+                model, processor = load_model()
+                detector = BatchedVideoHighlightDetector(model, processor, batch_size=8)
+
+                progress(0.2, desc="Analyzing video content...")
+                status.value = "Analyzing video content..."
+                video_desc = detector.analyze_video_content(video)
+                # Update description in real-time
+                video_description.value = f"#Summary: {video_desc[:500] + '...' if len(video_desc) > 500 else video_desc}"
+                
+                progress(0.3, desc="Determining highlight types...")
+                status.value = "Determining highlight types..."
+                highlights = detector.determine_highlights(video_desc)
+                # Update highlights in real-time
+                highlight_types.value = f"#Highlights to search for: {highlights[:500] + '...' if len(highlights) > 500 else highlights}"
+
+                progress(0.4, desc="Detecting and extracting highlights...")
+                status.value = "Detecting and extracting highlights..."
+                with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp_file:
+                    temp_output = tmp_file.name
+                detector.create_highlight_video(video, temp_output)
+                
+                # progress(0.9, desc="Adding watermark...")
+                # status.value = "Adding watermark..."
+                # output_path = temp_output.replace('.mp4', '_watermark.mp4')
+                # add_watermark(temp_output, output_path)
+                
+                # os.unlink(temp_output)
+                progress(1.0, desc="Complete!")
+                
                 return {
-                    status: f"Error: {err}",
-                    output_video: gr.update(visible=False),
-                    analysis_accordion: gr.update(visible=False),
+                    status: "Processing complete!",
+                    video_description: video_description.value,
+                    highlight_types: highlight_types.value,
+                    output_video: gr.update(value=temp_output, visible=True)
+                }
+
+            except Exception as e:
+                return {
+                    status: f"Error processing video: {str(e)}",
+                    video_description: "",
+                    highlight_types: "",
+                    output_video: gr.update(visible=False)
                 }
-            
-            # Format the analysis text
-            desc = f"#Summary: {desc[:500] + '...' if len(desc) > 500 else desc}"
-            highlights = f"#Highlights to search for: {highlights[:500] + '...' if len(highlights) > 500 else highlights}"
-            
-            return {
-                status: "Processing complete!",
-                output_video: gr.update(value=output_path, visible=True),
-                analysis_accordion: gr.update(visible=True),
-                video_description: desc,
-                highlight_types: highlights,
-            }
 
         process_btn.click(
             on_process,
             inputs=[input_video],
-            outputs=[
-                status,
-                output_video,
-                analysis_accordion,
-                video_description,
-                highlight_types,
-            ]
+            outputs=[status, video_description, highlight_types, output_video]
         )
 
     return app