Update app.py

app.py

@@ -20,7 +20,7 @@ PORT = 7860
 DISPLAY_NUM = ":99"
 WIDTH, HEIGHT = 1280, 720
 
-# Use public STUN/TURN if specific creds fail, but keeping your original config
+# TURN/STUN Config
 TURN_USER = "g08abe68c81a07f098bb5f0914549bb32440e5aad0b216c7fba2b61e76fd62c6"
 TURN_PASS = "aed1a10dd10eba9401ad9d99e5c66036d8a970eab5ba8e6dc9845ab57c771a7d"
 
@@ -33,7 +33,7 @@ class X11Engine:
         self.dirty_rects = []
         self.lock = threading.Lock()
         self.use_damage = False
-        self.last_full_refresh = 0
+        self.last_full_refresh = 0 
         self.alive = True
         
         try:
@@ -50,39 +50,36 @@ class X11Engine:
             self.d = None
 
     def close(self):
-        """Cleanup resources"""
         self.alive = False
         if self.d:
             try:
                 self.d.close()
-            except:
-                pass
+            except: pass
 
     def collect_damage(self):
         if not self.d or not self.use_damage: return
         try:
-            # Check pending events without blocking indefinitely
             while self.d.pending_events() > 0:
                 ev = self.d.next_event()
                 if ev.type == self.d.extension_event.DamageNotify:
                     with self.lock:
                         self.dirty_rects.append((ev.area.x, ev.area.y, ev.area.width, ev.area.height))
                     self.d.damage_subtract(self.damage_ext, 0, 0)
-        except Exception as e:
-            logger.debug(f"Event error: {e}")
+        except: pass
 
     def get_patches(self):
         if not self.alive: return []
         
         with self.lock:
             now = time.time()
-            # Force refresh every 3 seconds or if no damage system
-            if (now - self.last_full_refresh > 3.0) or (not self.use_damage and now - self.last_full_refresh > 0.1):
+            # Force full refresh if it's been >3s OR if it's the very first frame (0)
+            force = (self.last_full_refresh == 0) or (now - self.last_full_refresh > 3.0)
+            
+            if force:
                 rects = [(0, 0, WIDTH, HEIGHT)]
                 self.last_full_refresh = now
                 self.dirty_rects = []
             elif self.dirty_rects:
-                # Merge small updates or take last 10 to prevent overload
                 rects = list(self.dirty_rects[-10:])
                 self.dirty_rects = []
             else:
@@ -91,18 +88,18 @@ class X11Engine:
         patches = []
         for (x, y, w, h) in rects:
             try:
-                # Sanitize bounds for MSS (Critical to prevent crash)
                 x = max(0, min(x, WIDTH - 1))
                 y = max(0, min(y, HEIGHT - 1))
                 w = max(1, min(w, WIDTH - x))
                 h = max(1, min(h, HEIGHT - y))
                 
                 sct_img = self.sct.grab({"top": y, "left": x, "width": w, "height": h})
-                
-                # Convert to JPEG
                 img = Image.frombytes("RGB", sct_img.size, sct_img.bgra, "raw", "BGRX")
+                
                 buf = BytesIO()
-                img.save(buf, format="JPEG", quality=60, optimize=True)
+                # Lower quality to 30 ensures the first big frame doesn't exceed UDP/DataChannel limits
+                q = 30 if (w > 1000 and h > 500) else 60
+                img.save(buf, format="JPEG", quality=q, optimize=True)
                 
                 patches.append({
                     "x": x, "y": y, "w": w, "h": h,
@@ -118,7 +115,6 @@ class X11Engine:
         try:
             t = msg.get("type")
             if t == "mousemove":
-                # Ensure coordinates are within bounds
                 tx = int(max(0, min(msg["x"], 1.0)) * WIDTH)
                 ty = int(max(0, min(msg["y"], 1.0)) * HEIGHT)
                 xtest.fake_motion(self.d, tx, ty)
@@ -127,32 +123,32 @@ class X11Engine:
             elif t == "mouseup":
                 xtest.fake_button_event(self.d, msg.get("button", 0) + 1, False)
             self.d.sync()
-        except Exception:
-            pass
+        except: pass
 
 async def patch_stream_loop(channel, engine):
     logger.info("Stream started")
     try:
+        # Reset refresh timer to force an immediate full frame on connect
+        engine.last_full_refresh = 0
+        
         while channel.readyState == "open":
             start_time = time.perf_counter()
-            
-            # Run X11/MSS operations in a thread to avoid blocking AsyncIO
             await asyncio.to_thread(engine.collect_damage)
             patches = await asyncio.to_thread(engine.get_patches)
             
             if patches:
                 try:
-                    channel.send(json.dumps({"type": "patch", "p": patches}))
-                except Exception:
-                    break # Channel likely closed
+                    payload = json.dumps({"type": "patch", "p": patches})
+                    channel.send(payload)
+                    # logger.info(f"Sent {len(patches)} patches ({len(payload)} bytes)")
+                except Exception as e:
+                    logger.error(f"Send failed: {e}")
+                    break
             
-            # Maintain roughly 30 FPS cap
-            elapsed = time.perf_counter() - start_time
-            await asyncio.sleep(max(0.01, 0.033 - elapsed))
+            await asyncio.sleep(max(0.01, 0.033 - (time.perf_counter() - start_time)))
     except Exception as e:
         logger.error(f"Stream Loop Error: {e}")
     finally:
-        logger.info("Stream stopped, cleaning up engine")
         engine.close()
 
 async def offer(request):
@@ -164,29 +160,19 @@ async def offer(request):
             RTCIceServer(urls=["stun:stun.l.google.com:19302"])
         ]))
         
-        # Create a new engine for this connection
         engine = X11Engine()
-        
         @pc.on("datachannel")
         def on_dc(channel):
             @channel.on("open")
-            def on_open(): 
-                asyncio.create_task(patch_stream_loop(channel, engine))
-            
+            def on_open(): asyncio.create_task(patch_stream_loop(channel, engine))
             @channel.on("message")
-            def on_message(msg): 
-                engine.inject_input(json.loads(msg))
+            def on_message(msg): engine.inject_input(json.loads(msg))
 
         await pc.setRemoteDescription(RTCSessionDescription(sdp=params["sdp"], type=params["type"]))
         answer = await pc.createAnswer()
         await pc.setLocalDescription(answer)
-        
-        return web.json_response(
-            {"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}, 
-            headers={"Access-Control-Allow-Origin": "*"}
-        )
+        return web.json_response({"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}, headers={"Access-Control-Allow-Origin": "*"})
     except Exception as e:
-        logger.error(f"Offer failed: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
 async def index(request):
@@ -194,26 +180,26 @@ async def index(request):
     return web.Response(content_type="text/html", text=content)
 
 if __name__ == "__main__":
-    # 1. Start Virtual Screen
     os.environ["DISPLAY"] = DISPLAY_NUM
+    
+    # 1. Start Xvfb
     logger.info("Starting Xvfb...")
-    xvfb = subprocess.Popen(["Xvfb", DISPLAY_NUM, "-screen", "0", f"{WIDTH}x{HEIGHT}x24", "+extension", "DAMAGE", "-ac", "-noreset"])
-    time.sleep(3) # Wait for X server
+    subprocess.Popen(["Xvfb", DISPLAY_NUM, "-screen", "0", f"{WIDTH}x{HEIGHT}x24", "+extension", "DAMAGE", "-ac", "-noreset"])
+    time.sleep(2)
     
-    # 2. Start Opera with Docker-safe flags
+    # 2. Start Fluxbox (Window Manager) - Fixes black screen issues
+    logger.info("Starting Fluxbox...")
+    subprocess.Popen(["fluxbox"], env=os.environ)
+    time.sleep(1)
+
+    # 3. Start Opera
     logger.info("Starting Browser...")
-    # --disable-dev-shm-usage is CRITICAL in Docker
-    browser_cmd = (
-        "opera --no-sandbox --disable-gpu --disable-dev-shm-usage "
-        "--start-maximized --window-size=1280,720 --window-position=0,0 "
-        "--remote-debugging-port=9222"
-    )
-    subprocess.Popen(browser_cmd, shell=True)
+    cmd = "opera --no-sandbox --disable-gpu --disable-dev-shm-usage --start-maximized --window-size=1280,720 --window-position=0,0"
+    subprocess.Popen(cmd, shell=True, env=os.environ)
     
-    # 3. Start Web Server
+    # 4. Start Server
     app = web.Application()
     app.router.add_get("/", index)
     app.router.add_post("/offer", offer)
-    
-    logger.info(f"Server running on {HOST}:{PORT}")
+    logger.info(f"Server running on port {PORT}")
     web.run_app(app, host=HOST, port=PORT)