update compression

app.py

@@ -27,10 +27,10 @@ except Exception as e:
     raft_model = None
     gr.Warning("Falling back to OpenCV Farneback optical flow.")
 
-def compress_video(video_file, compression_factor, progress=gr.Progress(), progress_offset=0.0, progress_scale=0.2, output_file=None):
+def compress_video(video_file, target_width, target_height, progress=gr.Progress(), progress_offset=0.0, progress_scale=0.2, output_file=None):
     """
-    Compresses the video by resizing each frame to a lower resolution.
-    The new resolution is (original_width * compression_factor, original_height * compression_factor).
+    Compresses the video by resizing each frame to the specified target resolution.
+    The new resolution is exactly (target_width, target_height).
     Updates progress from progress_offset to progress_offset+progress_scale.
     """
     start_time = time.time()
@@ -38,12 +38,12 @@ def compress_video(video_file, compression_factor, progress=gr.Progress(), progr
     if not cap.isOpened():
         raise gr.Error("Could not open video file for compression.")
     
-    original_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    original_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    new_width = max(1, int(original_width * compression_factor))
-    new_height = max(1, int(original_height * compression_factor))
     fps = cap.get(cv2.CAP_PROP_FPS)
     
+    # Use the target resolution directly.
+    new_width = int(target_width)
+    new_height = int(target_height)
+    
     if output_file is None:
         temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
         output_file = temp_file.name
@@ -59,12 +59,12 @@ def compress_video(video_file, compression_factor, progress=gr.Progress(), progr
         ret, frame = cap.read()
         if not ret:
             break
-        # Resize frame to new resolution
+        # Resize frame to target resolution
         compressed_frame = cv2.resize(frame, (new_width, new_height))
         out.write(compressed_frame)
         if frame_idx % 10 == 0 or frame_idx == total_frames:
             print(f"[INFO] Compressed frame {frame_idx}/{total_frames}")
-        progress(progress_offset + (frame_idx/total_frames)*progress_scale, desc="Compressing Video")
+        progress(progress_offset + (frame_idx / total_frames) * progress_scale, desc="Compressing Video")
         frame_idx += 1
 
     cap.release()
@@ -250,10 +250,10 @@ def stabilize_video_using_csv(video_file, csv_file, zoom=1.0, vertical_only=Fals
     print(f"[INFO] Stabilized video saved to: {output_file} in {elapsed:.2f} seconds")
     return output_file
 
-def process_video_ai(video_file, zoom, vertical_only, compress_mode, compression_factor, progress=gr.Progress(track_tqdm=True)):
+def process_video_ai(video_file, zoom, vertical_only, compress_mode, target_width, target_height, progress=gr.Progress(track_tqdm=True)):
     """
     Gradio interface function:
-      - Optionally compresses the video if compress_mode is True.
+      - Optionally compresses the video if compress_mode is True, resizing it to the chosen resolution.
       - Generates motion data from the (possibly compressed) video.
       - Stabilizes the video based on the generated motion data.
       - If vertical_only is True, only vertical stabilization is applied.
@@ -273,7 +273,7 @@ def process_video_ai(video_file, zoom, vertical_only, compress_mode, compression
         if compress_mode:
             gr.Info("Compressing video before processing...")
             # Compression phase uses progress 0 to 0.2
-            video_file = compress_video(video_file, compression_factor, progress=progress, progress_offset=0.0, progress_scale=0.2)
+            video_file = compress_video(video_file, target_width, target_height, progress=progress, progress_offset=0.0, progress_scale=0.2)
             gr.Info("Video compression complete.")
             # Set new progress offsets for subsequent phases.
             motion_offset = 0.2
@@ -300,6 +300,7 @@ with gr.Blocks() as demo:
     gr.Markdown("# AI-Powered Video Stabilization")
     gr.Markdown(
         "Upload a video, select a zoom factor, choose whether to apply only vertical stabilization, and optionally compress the video before processing. "
+        "If compressing, specify the target resolution (width and height) for the compressed video. "
         "The system will generate motion data using an AI model (RAFT if available) and then stabilize the video with live progress updates and alerts."
     )
     
@@ -309,7 +310,8 @@ with gr.Blocks() as demo:
             zoom_slider = gr.Slider(minimum=1.0, maximum=2.0, step=0.1, value=1.0, label="Zoom Factor")
             vertical_checkbox = gr.Checkbox(label="Vertical Stabilization Only", value=False)
             compress_checkbox = gr.Checkbox(label="Compress Video Before Processing", value=False)
-            compression_slider = gr.Slider(minimum=0.1, maximum=1.0, step=0.1, value=0.5, label="Compression Factor (Scale)")
+            target_width = gr.Number(label="Target Width (px)", value=640)
+            target_height = gr.Number(label="Target Height (px)", value=360)
             process_button = gr.Button("Process Video")
         with gr.Column():
             original_video = gr.Video(label="Original Video")
@@ -318,7 +320,7 @@ with gr.Blocks() as demo:
     
     process_button.click(
         fn=process_video_ai,
-        inputs=[video_input, zoom_slider, vertical_checkbox, compress_checkbox, compression_slider],
+        inputs=[video_input, zoom_slider, vertical_checkbox, compress_checkbox, target_width, target_height],
         outputs=[original_video, stabilized_video, logs_output]
     )