Screen recording

.changeset/old-coins-heal.md

@@ -0,0 +1,6 @@
+---
+"@gradio/core": minor
+"gradio": minor
+---
+
+feat:Screen recording

gradio/routes.py

@@ -97,6 +97,7 @@
     create_lifespan_handler,
     move_uploaded_files_to_cache,
 )
+from gradio.screen_recording_utils import process_video_with_ffmpeg
 from gradio.server_messages import (
     CloseStreamMessage,
     EstimationMessage,
@@ -117,6 +118,8 @@
 if TYPE_CHECKING:
     from gradio.blocks import Block
 
+import shutil
+import tempfile
 
 mimetypes.init()
 
@@ -152,6 +155,10 @@
     "application/json",
 }
 
+DEFAULT_TEMP_DIR = os.environ.get("GRADIO_TEMP_DIR") or str(
+    Path(tempfile.gettempdir()) / "gradio"
+)
+
 
 class ORJSONResponse(JSONResponse):
     media_type = "application/json"
@@ -1769,8 +1776,105 @@ async def analytics_dashboard(key: str):
             else:
                 raise HTTPException(status_code=403, detail="Invalid key.")
 
-        app.include_router(router)
+        @router.post("/process_recording", dependencies=[Depends(login_check)])
+        async def process_recording(
+            request: fastapi.Request,
+        ):
+            try:
+                content_type_header = request.headers.get("Content-Type")
+                content_type: bytes
+                content_type, _ = parse_options_header(content_type_header or "")
+                if content_type != b"multipart/form-data":
+                    raise HTTPException(status_code=400, detail="Invalid content type.")
+
+                app = request.app
+                max_file_size = (
+                    app.get_blocks().max_file_size
+                    if hasattr(app, "get_blocks")
+                    else None
+                )
+                max_file_size = max_file_size if max_file_size is not None else math.inf
+
+                multipart_parser = GradioMultiPartParser(
+                    request.headers,
+                    request.stream(),
+                    max_files=1,
+                    max_fields=10,
+                    max_file_size=max_file_size,
+                )
+                form = await multipart_parser.parse()
+            except MultiPartException as exc:
+                code = 413 if "maximum allowed size" in exc.message else 400
+                return PlainTextResponse(exc.message, status_code=code)
 
+            video_files = form.getlist("video")
+            if not video_files or not isinstance(video_files[0], GradioUploadFile):
+                raise HTTPException(status_code=400, detail="No video file provided")
+
+            video_file = video_files[0]
+
+            params = {}
+            if (
+                form.get("remove_segment_start") is not None
+                and form.get("remove_segment_end") is not None
+            ):
+                params["remove_segment_start"] = form.get("remove_segment_start")
+                params["remove_segment_end"] = form.get("remove_segment_end")
+
+            zoom_effects_json = form.get("zoom_effects")
+            if zoom_effects_json:
+                try:
+                    params["zoom_effects"] = json.loads(str(zoom_effects_json))
+                except json.JSONDecodeError:
+                    params["zoom_effects"] = []
+
+            with tempfile.NamedTemporaryFile(
+                delete=False, suffix=".mp4", dir=DEFAULT_TEMP_DIR
+            ) as input_file:
+                video_file.file.seek(0)
+                shutil.copyfileobj(video_file.file, input_file)
+                input_path = input_file.name
+
+            if wasm_utils.IS_WASM or shutil.which("ffmpeg") is None:
+                return FileResponse(
+                    input_path,
+                    media_type="video/mp4",
+                    filename="gradio-screen-recording.mp4",
+                    background=BackgroundTask(lambda: cleanup_files([input_path])),
+                )
+
+            output_path = tempfile.mkstemp(
+                suffix="_processed.mp4", dir=DEFAULT_TEMP_DIR
+            )[1]
+
+            try:
+                processed_path, temp_files = await process_video_with_ffmpeg(
+                    input_path, output_path, params
+                )
+
+                return FileResponse(
+                    processed_path,
+                    media_type="video/mp4",
+                    filename="gradio-screen-recording.mp4",
+                    background=BackgroundTask(lambda: cleanup_files(temp_files)),
+                )
+            except Exception:
+                return FileResponse(
+                    input_path,
+                    media_type="video/mp4",
+                    filename="gradio-screen-recording.mp4",
+                    background=BackgroundTask(lambda: cleanup_files([input_path])),
+                )
+
+        def cleanup_files(files):
+            for file in files:
+                try:
+                    if file and os.path.exists(file):
+                        os.unlink(file)
+                except Exception as e:
+                    print(f"Error cleaning up file {file}: {str(e)}")
+
+        app.include_router(router)
         return app