Screen recording

.changeset/old-coins-heal.md

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

demo/hello_blocks/run.py

@@ -1,6 +1,5 @@
 import gradio as gr
 
-
 def greet(name):
     return "Hello " + name + "!"
 

gradio/routes.py

@@ -8,7 +8,6 @@
 import hashlib
 import importlib.resources
 import inspect
-import io
 import json
 import math
 import mimetypes
@@ -96,6 +95,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,
@@ -116,6 +116,8 @@
 if TYPE_CHECKING:
     from gradio.blocks import Block
 
+import shutil
+import tempfile
 
 mimetypes.init()
 
@@ -1539,23 +1541,9 @@ async def pwa_icon(size: int | None = None):
             blocks = app.get_blocks()
             favicon_path = blocks.favicon_path
             if favicon_path is None:
-                raise HTTPException(status_code=404)
-
-            if size is None:
-                return FileResponse(favicon_path)
-
-            import PIL.Image
-
-            img = PIL.Image.open(favicon_path)
-            img = img.resize((size, size))
-
-            img_byte_array = io.BytesIO()
-            img.save(img_byte_array, format="PNG")
-            img_byte_array.seek(0)
-
-            return StreamingResponse(
-                io.BytesIO(img_byte_array.read()), media_type="image/png"
-            )
+                return static_resource("img/logo.svg")
+            else:
+                return FileResponse(blocks.favicon_path)
 
         @app.get("/manifest.json")
         def manifest_json():
@@ -1646,8 +1634,85 @@ async def analytics_dashboard(key: str):
             else:
                 raise HTTPException(status_code=403, detail="Invalid key.")
 
-        app.include_router(router)
+        @app.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 = {
+                "remove_segment_start": form.get("remove_segment_start"),
+                "remove_segment_end": form.get("remove_segment_end"),
+            }
+
+            with tempfile.NamedTemporaryFile(
+                delete=False, suffix=".webm"
+            ) as input_file:
+                video_file.file.seek(0)
+                shutil.copyfileobj(video_file.file, input_file)
+                input_path = input_file.name
 
+            output_path = tempfile.mktemp(suffix="_processed.webm")
+
+            try:
+                processed_path, temp_files = await process_video_with_ffmpeg(
+                    input_path, output_path, params
+                )
+
+                return FileResponse(
+                    processed_path,
+                    media_type="video/webm",
+                    filename="gradio-screen-recording.webm",
+                    background=BackgroundTask(lambda: cleanup_files(temp_files)),
+                )
+            except Exception as e:
+                print(f"Error processing video: {str(e)}")
+                return FileResponse(
+                    input_path,
+                    media_type="video/webm",
+                    filename="gradio-screen-recording.webm",
+                    background=BackgroundTask(lambda: cleanup_files([input_path])),
+                )
+
+        async 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
 
 

gradio/screen_recording_utils.py

@@ -0,0 +1,164 @@
+import asyncio
+import os
+import shutil
+import tempfile
+import traceback
+
+
+async def process_video_with_ffmpeg(input_path, output_path, params):
+    """Process a video with ffmpeg based on the provided parameters."""
+    current_input = input_path
+    temp_files = [input_path]
+
+    try:
+        if params.get("remove_segment_start") and params.get("remove_segment_end"):
+            start = float(params["remove_segment_start"])
+            end = float(params["remove_segment_end"])
+
+            if start < end:
+                segment_output = tempfile.mktemp(suffix="_trimmed.mp4")
+                before_segment = tempfile.mktemp(suffix="_before.mp4")
+                after_segment = tempfile.mktemp(suffix="_after.mp4")
+
+                temp_files.extend([segment_output, before_segment, after_segment])
+
+                if start > 0:
+                    cmd_before = [
+                        "ffmpeg",
+                        "-y",
+                        "-i",
+                        current_input,
+                        "-t",
+                        str(start),
+                        "-c:v",
+                        "libx264",
+                        "-preset",
+                        "fast",
+                        "-crf",
+                        "22",
+                        "-c:a",
+                        "aac",
+                        before_segment,
+                    ]
+
+                    process = await asyncio.create_subprocess_exec(
+                        *cmd_before,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                    )
+                    stdout, stderr = await process.communicate()
+
+                    if process.returncode != 0:
+                        print(f"FFmpeg before segment error: {stderr.decode()}")
+
+                cmd_after = [
+                    "ffmpeg",
+                    "-y",
+                    "-i",
+                    current_input,
+                    "-ss",
+                    str(end),
+                    "-c:v",
+                    "libx264",
+                    "-preset",
+                    "fast",
+                    "-crf",
+                    "22",
+                    "-c:a",
+                    "aac",
+                    after_segment,
+                ]
+
+                process = await asyncio.create_subprocess_exec(
+                    *cmd_after,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, stderr = await process.communicate()
+
+                if process.returncode != 0:
+                    print(f"FFmpeg after segment error: {stderr.decode()}")
+
+                concat_file = tempfile.mktemp(suffix="_concat.txt")
+                temp_files.append(concat_file)
+
+                with open(concat_file, "w") as f:
+                    if (
+                        start > 0
+                        and os.path.exists(before_segment)
+                        and os.path.getsize(before_segment) > 0
+                    ):
+                        f.write(f"file '{before_segment}'\n")
+                    if (
+                        os.path.exists(after_segment)
+                        and os.path.getsize(after_segment) > 0
+                    ):
+                        f.write(f"file '{after_segment}'\n")
+
+                if os.path.exists(concat_file) and os.path.getsize(concat_file) > 0:
+                    cmd_concat = [
+                        "ffmpeg",
+                        "-y",
+                        "-f",
+                        "concat",
+                        "-safe",
+                        "0",
+                        "-i",
+                        concat_file,
+                        "-c",
+                        "copy",
+                        segment_output,
+                    ]
+
+                    process = await asyncio.create_subprocess_exec(
+                        *cmd_concat,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                    )
+                    stdout, stderr = await process.communicate()
+
+                    if process.returncode != 0:
+                        print(f"FFmpeg concat error: {stderr.decode()}")
+                    else:
+                        current_input = segment_output
+
+                for file in [before_segment, after_segment, concat_file]:
+                    try:
+                        if os.path.exists(file):
+                            os.unlink(file)
+                    except:
+                        pass
+        if not current_input.endswith(".webm"):
+            final_webm = output_path
+            cmd = [
+                "ffmpeg",
+                "-y",
+                "-i",
+                current_input,
+                "-c:v",
+                "libvpx-vp9",
+                "-crf",
+                "30",
+                "-b:v",
+                "0",
+                "-c:a",
+                "libopus",
+                final_webm,
+            ]
+
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await process.communicate()
+
+            if process.returncode != 0:
+                print(f"FFmpeg final conversion error: {stderr.decode()}")
+                shutil.copy(current_input, final_webm)
+
+            current_input = final_webm
+    except Exception as e:
+        print(f"Error in process_video_with_ffmpeg: {str(e)}")
+        traceback.print_exc()
+        return input_path, temp_files