Update app.py

app.py

@@ -10,23 +10,13 @@ import threading
 import numpy as np
 import psutil
 import ctypes
-import traceback
 from ctypes import c_int, c_void_p, c_char_p, POINTER, c_ubyte, c_bool
 from aiohttp import web
-
-# CORRECT IMPORTS FOR AIORTC
-from aiortc import (
-    RTCPeerConnection, 
-    RTCSessionDescription, 
-    VideoStreamTrack, 
-    RTCIceServer, 
-    RTCConfiguration
-)
-from aiortc.rtcconfiguration import RTCIceTransportPolicy, RTCBundlePolicy
+from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack, RTCIceServer, RTCConfiguration
 from av import VideoFrame
 
 # ==========================================
-# C++ X11 CAPTURE + FAULT TOLERANCE
+# C++ X11 CAPTURE + FAULT TOLERANCE + DUAL CHANNEL
 # ==========================================
 CPP_SOURCE = r"""
 #include <X11/Xlib.h>
@@ -135,6 +125,8 @@ int init_grabber(int w, int h, const char* display_name) {
     XShmAttach(cap.display, &cap.shminfo);
     XSync(cap.display, False);
 
+    // SWS_FAST_BILINEAR is good, SWS_POINT is faster but blocky. 
+    // Using BILINEAR for balance.
     cap.sws_ctx = sws_getContext(w, h, AV_PIX_FMT_BGRA,
                                  w, h, AV_PIX_FMT_YUV420P,
                                  SWS_FAST_BILINEAR, NULL, NULL, NULL);
@@ -151,12 +143,14 @@ int init_grabber(int w, int h, const char* display_name) {
 int capture_frame() {
     if (cap.is_init && cap.display && cap.image) {
         last_x_error_code = 0;
+        // This blocks only the video thread
         XShmGetImage(cap.display, cap.root, cap.image, 0, 0, AllPlanes);
         return (last_x_error_code == 0);
     }
     return 0;
 }
 
+// Optimized pointer math happens inside sws_scale
 void convert_to_yuv(void* y, int y_stride, void* u, int u_stride, void* v, int v_stride) {
     if (!cap.is_init || !cap.sws_ctx || !cap.image) return;
     
@@ -168,10 +162,11 @@ void convert_to_yuv(void* y, int y_stride, void* u, int u_stride, void* v, int v
     sws_scale(cap.sws_ctx, srcSlice, srcStride, 0, cap.height, dst, dstStride);
 }
 
+// INPUT FUNCTIONS USE SEPARATE DISPLAY CONNECTION
 void move_mouse(int x, int y) {
     if (!cap.is_init || !cap.input_display) return;
     XTestFakeMotionEvent(cap.input_display, -1, x, y, CurrentTime);
-    XFlush(cap.input_display); 
+    XFlush(cap.input_display); // Flush only input stream
 }
 
 void mouse_button(int button, int is_down) {
@@ -205,6 +200,7 @@ def compile_cpp():
     with open("xcapture.cpp", "w") as f:
         f.write(CPP_SOURCE)
     
+    # ADDED: -march=native -ffast-math -flto for CPU optimization
     cmd = [
         "g++", "-O3", "-march=native", "-ffast-math", "-flto", "-shared", "-fPIC", 
         "-o", LIB_PATH, "xcapture.cpp", 
@@ -221,6 +217,7 @@ compile_cpp()
 # Load C++ Library
 try:
     xlib = ctypes.CDLL(LIB_PATH)
+    
     xlib.init_grabber.argtypes = [c_int, c_int, c_char_p]
     xlib.init_grabber.restype = c_int
     xlib.capture_frame.argtypes = []
@@ -235,6 +232,7 @@ try:
     xlib.mouse_button.restype = None
     xlib.key_send.argtypes = [c_char_p, c_int]
     xlib.key_send.restype = None
+
     USE_CSHM = True
 except Exception as e:
     print(f"Library load failed: {e}")
@@ -249,8 +247,14 @@ DEFAULT_WIDTH = 1280
 DEFAULT_HEIGHT = 720
 
 logging.basicConfig(level=logging.WARNING)
+
+# Dedicated thread for video capture
 video_executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+
+# LOCKS
+# video_lock: Protects XShm, resizing, and video display connection
 video_lock = threading.Lock()
+# Input does NOT use a lock anymore because it uses a separate X11 connection in C++
 
 config = {
     "width": DEFAULT_WIDTH,
@@ -261,6 +265,7 @@ class InputManager:
     def __init__(self):
         self.scroll_accum = 0
 
+    # No locking needed here, C++ handles separate connection
     def mouse_move(self, x, y):
         if USE_CSHM: xlib.move_mouse(x, y)
 
@@ -300,7 +305,7 @@ def start_system():
         "-ac", "-noreset", "-nolisten", "tcp"
     ], stderr=subprocess.DEVNULL)
     
-    time.sleep(1)
+    time.sleep(1) # Reduced sleep
     set_resolution(DEFAULT_WIDTH, DEFAULT_HEIGHT)
     
     if shutil.which("matchbox-window-manager"):
@@ -311,6 +316,7 @@ def start_system():
 def maintain_antigravity():
     while True:
         try:
+            # Check optimization: Avoid list parsing overhead
             running = False
             for p in psutil.process_iter(['name']):
                 if p.info['name'] == "antigravity":
@@ -319,12 +325,13 @@ def maintain_antigravity():
             if not running:
                 subprocess.Popen(["antigravity"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         except: pass
-        time.sleep(5)
+        time.sleep(5) # Increased sleep to save CPU
 
 def set_resolution(w, h):
     with video_lock:
         if w == config["width"] and h == config["height"]:
             return
+        
         try:
             if w % 2 != 0: w += 1
             if h % 2 != 0: h += 1
@@ -332,10 +339,14 @@ def set_resolution(w, h):
             if h > MAX_HEIGHT: h = MAX_HEIGHT
 
             mode_name = f"M_{w}_{h}"
+            
+            # Combine xrandr calls to reduce process fork overhead? 
+            # Xrandr is CLI, safer to keep separate but fast.
             subprocess.call(["xrandr", "--newmode", mode_name, f"{60*w*h/1000000:.2f}", 
                             str(w), str(w+40), str(w+80), str(w+160), 
                             str(h), str(h+3), str(h+10), str(h+16), 
                             "-hsync", "+vsync"], stderr=subprocess.DEVNULL)
+            
             subprocess.call(["xrandr", "--addmode", "screen", mode_name], stderr=subprocess.DEVNULL)
             subprocess.call(["xrandr", "--output", "screen", "--mode", mode_name], stderr=subprocess.DEVNULL)
             
@@ -355,6 +366,8 @@ class VirtualScreenTrack(VideoStreamTrack):
 
     def _produce_frame(self, w, h):
         if not USE_CSHM: return None
+        
+        # Only lock the video part. Input continues in parallel.
         with video_lock:
             try:
                 if w != self.last_w or h != self.last_h:
@@ -363,25 +376,39 @@ class VirtualScreenTrack(VideoStreamTrack):
                     self.last_w = w
                     self.last_h = h
 
-                if xlib.capture_frame() == 0: return None
+                # 1. Capture (Copy X11 -> Shared Memory)
+                if xlib.capture_frame() == 0:
+                    return None
                 
+                # 2. Allocate Frame (Python overhead, but required for aiortc)
                 frame = VideoFrame(width=w, height=h, format="yuv420p")
+                
+                # 3. Convert (Shared Memory -> Frame Buffer)
+                # Using direct address integer for speed
                 xlib.convert_to_yuv(
                     c_void_p(int(frame.planes[0].buffer_ptr)), frame.planes[0].line_size,
                     c_void_p(int(frame.planes[1].buffer_ptr)), frame.planes[1].line_size,
                     c_void_p(int(frame.planes[2].buffer_ptr)), frame.planes[2].line_size
                 )
                 return frame
-            except: return None
+            except:
+                return None
 
     async def recv(self):
         pts, time_base = await self.next_timestamp()
+        
         w, h = config["width"], config["height"]
         
         frame = None
         if USE_CSHM:
+            # Offload heavy C++ work to thread.
+            # While this runs, the Main Thread can process "process_input" (Mouse/Keys)
+            # because we are not holding the Global Interpreter Lock (ctypes releases it)
+            # and we are not holding a global "input lock".
             try:
-                frame = await asyncio.get_event_loop().run_in_executor(video_executor, self._produce_frame, w, h)
+                frame = await asyncio.get_event_loop().run_in_executor(
+                    video_executor, self._produce_frame, w, h
+                )
             except: pass
         
         if frame is None:
@@ -395,63 +422,49 @@ class VirtualScreenTrack(VideoStreamTrack):
 
 async def offer(request):
     try:
-        try:
-            params = await request.json()
-            offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])
-        except Exception as e:
-            return web.Response(status=400, text="Invalid JSON")
-
-        ice_servers = [RTCIceServer(
-            urls=["turns:turn.cloudflare.com:443?transport=tcp"], 
-            username="g08abe68c81a07f098bb5f0914549bb32440e5aad0b216c7fba2b61e76fd62c6",
-            credential="aed1a10dd10eba9401ad9d99e5c66036d8a970eab5ba8e6dc9845ab57c771a7d"
-        )]
-        
-        # Using correct Enums imported from rtcconfiguration
-        pc = RTCPeerConnection(RTCConfiguration(
-            iceServers=ice_servers,
-            iceTransportPolicy=RTCIceTransportPolicy.relay,
-            bundlePolicy=RTCBundlePolicy.maxBundle
-        ))
-        
-        pcs.add(pc)
-
-        @pc.on("connectionstatechange")
-        async def on_state():
-            if pc.connectionState in ["failed", "closed"]:
-                await pc.close()
-                pcs.discard(pc)
-
-        @pc.on("datachannel")
-        def on_dc(channel):
-            @channel.on("message")
-            async def on_message(message):
-                await process_input(message)
-
-        pc.addTrack(VirtualScreenTrack())
-
-        await pc.setRemoteDescription(offer)
-        answer = await pc.createAnswer()
-
-        sdp_lines = answer.sdp.splitlines()
-        new_sdp = []
-        for line in sdp_lines:
-            new_sdp.append(line)
-            if line.startswith("m=video"):
-                new_sdp.append("b=AS:4000")
-                new_sdp.append("b=TIAS:4000000")
-        answer.sdp = "\r\n".join(new_sdp)
-
-        await pc.setLocalDescription(answer)
-
-        return web.Response(content_type="application/json", text=json.dumps({
-            "sdp": pc.localDescription.sdp,
-            "type": pc.localDescription.type
-        }), headers={"Access-Control-Allow-Origin": "*"})
-
-    except Exception as e:
-        traceback.print_exc()
-        return web.Response(status=500, text=f"Server Error: {str(e)}")
+        params = await request.json()
+        offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])
+    except: return web.Response(status=400)
+
+    ice_servers = [RTCIceServer(urls=["stun:stun.l.google.com:19302"])]
+    pc = RTCPeerConnection(RTCConfiguration(iceServers=ice_servers))
+    pcs.add(pc)
+
+    @pc.on("connectionstatechange")
+    async def on_state():
+        if pc.connectionState in ["failed", "closed"]:
+            await pc.close()
+            pcs.discard(pc)
+
+    @pc.on("datachannel")
+    def on_dc(channel):
+        @channel.on("message")
+        async def on_message(message):
+            # Direct call to input processing
+            await process_input(message)
+
+    pc.addTrack(VirtualScreenTrack())
+
+    await pc.setRemoteDescription(offer)
+    answer = await pc.createAnswer()
+
+    # FORCE HIGHER BITRATE (4Mbps)
+    # Injecting bandwidth info into SDP before setting local description
+    sdp_lines = answer.sdp.splitlines()
+    new_sdp = []
+    for line in sdp_lines:
+        new_sdp.append(line)
+        if line.startswith("m=video"):
+            new_sdp.append("b=AS:4000")
+            new_sdp.append("b=TIAS:4000000")
+    answer.sdp = "\r\n".join(new_sdp)
+
+    await pc.setLocalDescription(answer)
+
+    return web.Response(content_type="application/json", text=json.dumps({
+        "sdp": pc.localDescription.sdp,
+        "type": pc.localDescription.type
+    }), headers={"Access-Control-Allow-Origin": "*"})
 
 def map_key(key):
     if not key: return None
@@ -465,6 +478,7 @@ async def handle_debounced_resize(w, h):
     if resize_timer: resize_timer.cancel()
     
     async def task():
+        # REDUCED DELAY FROM 0.5 to 0.1 FOR FASTER RESIZING
         await asyncio.sleep(0.1) 
         await asyncio.get_event_loop().run_in_executor(video_executor, set_resolution, w, h)
     
@@ -472,8 +486,11 @@ async def handle_debounced_resize(w, h):
 
 async def process_input(data):
     try:
+        # Optimized parsing
         msg = json.loads(data)
         t = msg.get("type")
+        
+        # Immediate dispatch
         if t == "mousemove":
             w, h = config["width"], config["height"]
             input_manager.mouse_move(int(msg["x"] * w), int(msg["y"] * h))