Spaces:

1hitonline
/

flaskdockernew

Sleeping

App Files Files Community

MySafeCode commited on Jan 30

Commit

a29c634

verified ·

1 Parent(s): 5de2ee4

Update app.py

Browse files

Files changed (1) hide show

app.py +125 -158

app.py CHANGED Viewed

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
-# reliable_30fps_fixed.py - DEBUG VERSION
 import pygame
 import time
 import threading
 import base64
@@ -26,39 +27,58 @@ shared = {
     "capture_fps": 0,
     "streaming": True,
     "last_frame_time": time.time(),
-    "frames_this_second": 0,
-    "debug_info": ""
 }
 # ===== 2. CREATE FLASK APP =====
 app = Flask(__name__)
-# ===== 3. HTML TEMPLATE WITH DEBUG INFO =====
 HTML = '''
 <!DOCTYPE html>
 <html>
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>PyGame + Flask Streaming - DEBUG</title>
     <style>
         body { font-family: Arial; background: #0f172a; color: white; padding: 20px; margin: 0; }
         .container { max-width: 800px; margin: 0 auto; text-align: center; }
         h1 { color: #60a5fa; }
-        .debug { background: #1e293b; padding: 15px; margin: 20px 0; border-radius: 8px; text-align: left; }
-        .image-container { width: 400px; height: 300px; margin: 20px auto; border: 3px solid #60a5fa; background: #000; }
-        #streamImg { width: 100%; height: 100%; object-fit: contain; }
-        .stats { display: inline-block; background: #1e293b; padding: 20px; border-radius: 10px; margin: 10px; }
-        .stat-row { margin: 10px 0; display: flex; justify-content: space-between; }
         .stat-value { font-weight: bold; color: #60a5fa; }
     </style>
 </head>
 <body>
     <div class="container">
-        <h1>PyGame + Flask Streaming - DEBUG MODE</h1>
         <div class="image-container">
-            <img id="streamImg" src="/stream" alt="Live Stream" onerror="console.error('Image failed to load')">
         </div>
         <div class="stats">
@@ -68,16 +88,8 @@ HTML = '''
             <div class="stat-row"><span>Latency:</span><span class="stat-value" id="latency">-- ms</span></div>
         </div>
-        <div class="debug">
-            <h3>Debug Info:</h3>
-            <div id="debugInfo">Waiting for debug info...</div>
-            <div>Image URL: <span id="imageUrl"></span></div>
-            <div>Last frame time: <span id="lastFrameTime"></span></div>
-        </div>
-        <div style="margin-top: 20px;">
-            <button onclick="testImage()">Test Image Load</button>
-            <button onclick="reloadPage()">Reload Page</button>
         </div>
     </div>
@@ -89,13 +101,11 @@ HTML = '''
         function updateStream() {
             const now = Date.now();
             const img = document.getElementById('streamImg');
-            const timestamp = now;
-            // Update image with timestamp
-            img.src = '/stream?_=' + timestamp;
-            document.getElementById('imageUrl').textContent = img.src;
-            // Calculate FPS
             streamFrameCount++;
             if (now - lastStreamUpdate >= 1000) {
                 const streamFps = streamFrameCount / ((now - lastStreamUpdate) / 1000);
@@ -110,37 +120,18 @@ HTML = '''
                 .then(data => {
                     document.getElementById('captureFps').textContent = data.capture_fps.toFixed(1);
                     document.getElementById('totalFrames').textContent = data.frame_count;
-                    document.getElementById('debugInfo').textContent = data.debug_info || 'No debug info';
-                    document.getElementById('lastFrameTime').textContent = new Date(data.timestamp * 1000).toLocaleTimeString();
                     if (lastFrameTimestamp > 0) {
                         const latency = now - (data.timestamp * 1000);
                         document.getElementById('latency').textContent = Math.round(latency) + ' ms';
                     }
                     lastFrameTimestamp = data.timestamp * 1000;
-                })
-                .catch(err => {
-                    console.error('Stats fetch error:', err);
                 });
         }
-        function testImage() {
-            const img = document.getElementById('streamImg');
-            console.log('Testing image load...');
-            img.onload = () => console.log('✅ Image loaded successfully');
-            img.onerror = () => console.log('❌ Image failed to load');
-            img.src = '/stream?_=' + Date.now();
-        }
-        function reloadPage() {
-            location.reload();
-        }
-        // Start polling
         setInterval(updateStream, 33);
         updateStream();
-        console.log('DEBUG: Streaming client started');
     </script>
 </body>
 </html>
@@ -157,34 +148,16 @@ def stats():
         'frame_count': shared['frame_count'],
         'capture_fps': shared['capture_fps'],
         'timestamp': time.time(),
-        'has_frame': shared['latest_frame'] is not None,
-        'debug_info': shared['debug_info'],
-        'frame_size': len(shared['latest_frame']) if shared['latest_frame'] else 0
     }
 @app.route('/stream')
 def stream():
-    """Stream endpoint - FIXED VERSION"""
     if shared['latest_frame']:
         try:
-            # Debug: Check frame size
-            frame_size = len(shared['latest_frame'])
-            print(f"DEBUG: Serving frame {shared['frame_count']}, size: {frame_size} bytes")
-            # Decode base64
             image_data = base64.b64decode(shared['latest_frame'])
-            # Check if it's valid image data
-            if len(image_data) < 100:  # Too small for a valid JPEG
-                print(f"WARNING: Image data too small: {len(image_data)} bytes")
-                # Return a test image
-                return Response(
-                    b'Test image',
-                    mimetype='text/plain',
-                    headers={'Cache-Control': 'no-cache'}
-                )
-            # Return the image
             return Response(
                 image_data,
                 mimetype='image/jpeg',
@@ -195,66 +168,47 @@ def stream():
                 }
             )
         except Exception as e:
-            print(f"ERROR in /stream: {e}")
-            shared['debug_info'] = f"Stream error: {str(e)}"
-    # Return a simple test image
-    print("WARNING: No frame available, sending test pattern")
-    import random
-    test_image = create_test_image()
-    return Response(
-        test_image,
-        mimetype='image/png',
-        headers={'Cache-Control': 'no-cache'}
-    )
-def create_test_image():
-    """Create a simple test image to verify streaming works."""
-    from PIL import Image, ImageDraw
-    import io as imageio
-    # Create a simple test image
-    img = Image.new('RGB', (400, 300), color='blue')
-    draw = ImageDraw.Draw(img)
-    draw.rectangle([50, 50, 350, 250], fill='red')
-    draw.text((150, 140), 'TEST', fill='white')
-    draw.text((120, 160), 'PyGame Stream', fill='white')
-    # Save to bytes
-    buffer = imageio.BytesIO()
-    img.save(buffer, format='PNG')
-    return buffer.getvalue()
-# ===== 5. FIXED CAPTURE LOOP =====
-def simple_capture_loop():
-    """CAPTURE LOOP WITH FIXED IMAGE SAVING"""
     try:
         pygame.init()
-        print("✅ PyGame initialized")
     except Exception as e:
         print(f"❌ PyGame init error: {e}")
-        shared['debug_info'] = f"PyGame init error: {e}"
         return
     # Create surfaces
     screen = pygame.Surface((WIDTH, HEIGHT))
-    # Animation
-    circle_x, circle_y = WIDTH//2, HEIGHT//2
     circle_r = 30
     speed_x, speed_y = 4, 3
     fps_update_time = time.time()
     frames_since_update = 0
-    frame_num = 0
     try:
         while shared["streaming"]:
             start_time = time.time()
-            frame_num += 1
-            # Update position
             circle_x += speed_x
             circle_y += speed_y
@@ -263,54 +217,58 @@ def simple_capture_loop():
             if circle_y - circle_r < 0 or circle_y + circle_r > HEIGHT:
                 speed_y *= -1
-            # Draw
-            screen.fill((25, 25, 45))
             pygame.draw.circle(screen, (255, 80, 80), (int(circle_x), int(circle_y)), circle_r)
             pygame.draw.circle(screen, (255, 255, 255), (int(circle_x), int(circle_y)), circle_r, 2)
-            # Add frame number text
             font = pygame.font.Font(None, 36)
-            text = font.render(f"Frame: {frame_num}", True, (100, 255, 100))
             screen.blit(text, (10, 10))
-            # === CRITICAL FIX: Save image properly ===
-            try:
-                # Scale the image
-                scaled = pygame.transform.smoothscale(screen, (STREAM_WIDTH, STREAM_HEIGHT))
-                # Save to memory buffer
-                buffer = io.BytesIO()
-                # FIX 1: Use save_extended for better control
-                pygame.image.save_extended(scaled, buffer)
-                # Get the bytes
-                buffer.seek(0)
-                image_bytes = buffer.getvalue()
-                # FIX 2: Debug output
-                if frame_num % 30 == 0:  # Every second at 30 FPS
-                    print(f"Frame {frame_num}: Saved {len(image_bytes)} bytes")
-                # FIX 3: Encode to base64
-                encoded = base64.b64encode(image_bytes).decode('utf-8')
-                # FIX 4: Update shared state
-                shared["latest_frame"] = encoded
-                shared["debug_info"] = f"Frame {frame_num}: {len(encoded)} chars"
-            except Exception as e:
-                print(f"❌ Image save error on frame {frame_num}: {e}")
-                shared['debug_info'] = f"Save error: {e}"
-                # Create a simple fallback frame
-                fallback = pygame.Surface((STREAM_WIDTH, STREAM_HEIGHT))
-                fallback.fill((255, 0, 0) if frame_num % 2 == 0 else (0, 0, 255))
-                buffer = io.BytesIO()
-                pygame.image.save(fallback, buffer)
-                buffer.seek(0)
-                shared["latest_frame"] = base64.b64encode(buffer.getvalue()).decode('utf-8')
-            # Update counters
             shared["frame_count"] += 1
             frames_since_update += 1
             shared["frames_this_second"] += 1
@@ -324,7 +282,7 @@ def simple_capture_loop():
             shared["last_frame_time"] = current_time
-            # Control frame rate
             elapsed = time.time() - start_time
             target_time = 1.0 / TARGET_FPS
             if elapsed < target_time:
@@ -332,31 +290,37 @@ def simple_capture_loop():
     except Exception as e:
         print(f"❌ Capture loop error: {e}")
-        shared['debug_info'] = f"Capture error: {e}"
     pygame.quit()
-    print("🛑 Capture loop stopped")
 # ===== 6. MAIN FUNCTION =====
 def main():
     print("=" * 60)
-    print("🚀 PyGame + Flask Streaming - DEBUG VERSION")
     print("=" * 60)
     print(f"Port: {PORT}")
-    print(f"Resolution: {WIDTH}x{HEIGHT} → {STREAM_WIDTH}x{STREAM_HEIGHT}")
     print(f"Target FPS: {TARGET_FPS}")
     print("=" * 60)
     # Start capture thread
-    print("Starting capture thread...")
-    capture_thread = threading.Thread(target=simple_capture_loop, daemon=True)
     capture_thread.start()
-    # Wait a bit for initialization
-    time.sleep(1)
     print(f"Starting Flask server on port {PORT}...")
-    print(f"Open: https://YOUR_SPACE.hf.space")
     print("=" * 60)
     try:
@@ -367,11 +331,14 @@ def main():
             threaded=True,
             use_reloader=False
         )
     except Exception as e:
-        print(f"Server error: {e}")
     finally:
         shared['streaming'] = False
         capture_thread.join(timeout=2)
         print("✅ Shutdown complete")
 if __name__ == "__main__":

 #!/usr/bin/env python3
+# reliable_30fps_numpy.py - PyGame + Flask with NumPy surface arrays
 import pygame
+import numpy as np
 import time
 import threading
 import base64
     "capture_fps": 0,
     "streaming": True,
     "last_frame_time": time.time(),
+    "frames_this_second": 0
 }
 # ===== 2. CREATE FLASK APP =====
 app = Flask(__name__)
+# ===== 3. HTML TEMPLATE =====
 HTML = '''
 <!DOCTYPE html>
 <html>
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>PyGame + NumPy Streaming</title>
     <style>
         body { font-family: Arial; background: #0f172a; color: white; padding: 20px; margin: 0; }
         .container { max-width: 800px; margin: 0 auto; text-align: center; }
         h1 { color: #60a5fa; }
+        .image-container {
+            width: 400px;
+            height: 300px;
+            margin: 20px auto;
+            border: 3px solid #60a5fa;
+            background: #000;
+            overflow: hidden;
+        }
+        #streamImg {
+            width: 100%;
+            height: 100%;
+            object-fit: contain;
+            image-rendering: pixelated;
+        }
+        .stats {
+            display: inline-block;
+            background: #1e293b;
+            padding: 20px;
+            border-radius: 10px;
+            margin: 10px;
+            text-align: left;
+        }
+        .stat-row { margin: 10px 0; display: flex; justify-content: space-between; min-width: 200px; }
         .stat-value { font-weight: bold; color: #60a5fa; }
+        .info { color: #94a3b8; margin-top: 20px; font-size: 0.9em; }
     </style>
 </head>
 <body>
     <div class="container">
+        <h1>PyGame + NumPy Surface Array Streaming</h1>
+        <p class="info">Using NumPy arrays for pixel manipulation</p>
         <div class="image-container">
+            <img id="streamImg" src="/stream" alt="Live Stream">
         </div>
         <div class="stats">
             <div class="stat-row"><span>Latency:</span><span class="stat-value" id="latency">-- ms</span></div>
         </div>
+        <div class="info">
+            Rendering with NumPy arrays • Port: ''' + str(PORT) + ''' • Target: 30 FPS
         </div>
     </div>
         function updateStream() {
             const now = Date.now();
             const img = document.getElementById('streamImg');
+            // Update image with anti-cache timestamp
+            img.src = '/stream?_=' + now;
+            // Calculate stream FPS
             streamFrameCount++;
             if (now - lastStreamUpdate >= 1000) {
                 const streamFps = streamFrameCount / ((now - lastStreamUpdate) / 1000);
                 .then(data => {
                     document.getElementById('captureFps').textContent = data.capture_fps.toFixed(1);
                     document.getElementById('totalFrames').textContent = data.frame_count;
                     if (lastFrameTimestamp > 0) {
                         const latency = now - (data.timestamp * 1000);
                         document.getElementById('latency').textContent = Math.round(latency) + ' ms';
                     }
                     lastFrameTimestamp = data.timestamp * 1000;
                 });
         }
+        // Start polling at 30 FPS
         setInterval(updateStream, 33);
         updateStream();
     </script>
 </body>
 </html>
         'frame_count': shared['frame_count'],
         'capture_fps': shared['capture_fps'],
         'timestamp': time.time(),
+        'has_frame': shared['latest_frame'] is not None
     }
 @app.route('/stream')
 def stream():
+    """Stream endpoint - returns the latest NumPy/surface frame."""
     if shared['latest_frame']:
         try:
+            # Decode base64 and serve
             image_data = base64.b64decode(shared['latest_frame'])
             return Response(
                 image_data,
                 mimetype='image/jpeg',
                 }
             )
         except Exception as e:
+            print(f"Stream error: {e}")
+    # Return empty response if no frame
+    return Response(b'', mimetype='image/jpeg')
+# ===== 5. NUMPY SURFACE CAPTURE LOOP =====
+def numpy_capture_loop():
+    """Capture loop using NumPy arrays for pixel manipulation."""
     try:
         pygame.init()
+        print("✅ PyGame initialized for NumPy rendering")
     except Exception as e:
         print(f"❌ PyGame init error: {e}")
         return
     # Create surfaces
     screen = pygame.Surface((WIDTH, HEIGHT))
+    # Create NumPy array for direct pixel access (optional, for advanced effects)
+    # This creates a 3D array: [height, width, 3] for RGB
+    pixel_array = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
+    # Animation variables
+    circle_x, circle_y = WIDTH // 2, HEIGHT // 2
     circle_r = 30
     speed_x, speed_y = 4, 3
+    # For gradient effect using NumPy
+    x_coords = np.arange(WIDTH)
+    y_coords = np.arange(HEIGHT)
+    X, Y = np.meshgrid(x_coords, y_coords)
     fps_update_time = time.time()
     frames_since_update = 0
     try:
         while shared["streaming"]:
             start_time = time.time()
+            # === UPDATE POSITION ===
             circle_x += speed_x
             circle_y += speed_y
             if circle_y - circle_r < 0 or circle_y + circle_r > HEIGHT:
                 speed_y *= -1
+            # === METHOD 1: Traditional PyGame drawing (simpler) ===
+            screen.fill((25, 25, 45))  # Dark blue background
+            # Draw bouncing circle
             pygame.draw.circle(screen, (255, 80, 80), (int(circle_x), int(circle_y)), circle_r)
             pygame.draw.circle(screen, (255, 255, 255), (int(circle_x), int(circle_y)), circle_r, 2)
+            # Draw frame counter
             font = pygame.font.Font(None, 36)
+            text = font.render(f"Frame: {shared['frame_count']}", True, (100, 255, 100))
             screen.blit(text, (10, 10))
+            # Draw FPS
+            fps_text = font.render(f"FPS: {shared['capture_fps']:.1f}", True, (100, 255, 100))
+            screen.blit(fps_text, (10, 50))
+            # === OPTIONAL: METHOD 2: NumPy pixel manipulation ===
+            # Uncomment this for advanced NumPy effects
+            """
+            # Clear with gradient using NumPy
+            gradient = 25 + (X * 0.03 + Y * 0.02).astype(np.uint8)
+            pixel_array[:, :, 0] = gradient  # Red channel
+            pixel_array[:, :, 1] = gradient // 2  # Green channel
+            pixel_array[:, :, 2] = 45  # Blue channel
+            # Draw circle using NumPy (distance formula)
+            distance = np.sqrt((X - circle_x)**2 + (Y - circle_y)**2)
+            circle_mask = distance < circle_r
+            # Set circle pixels to red
+            pixel_array[circle_mask, 0] = 255  # Red
+            pixel_array[circle_mask, 1] = 80   # Green
+            pixel_array[circle_mask, 2] = 80   # Blue
+            # Convert NumPy array to PyGame surface
+            pygame.surfarray.blit_array(screen, pixel_array)
+            """
+            # === SCALE AND SAVE FRAME ===
+            # Scale down for streaming
+            scaled = pygame.transform.smoothscale(screen, (STREAM_WIDTH, STREAM_HEIGHT))
+            # Save to memory buffer
+            buffer = io.BytesIO()
+            pygame.image.save(scaled, buffer, 'JPEG')
+            buffer.seek(0)
+            # Encode to base64 for sharing
+            image_bytes = buffer.getvalue()
+            shared["latest_frame"] = base64.b64encode(image_bytes).decode('utf-8')
+            # === UPDATE COUNTERS ===
             shared["frame_count"] += 1
             frames_since_update += 1
             shared["frames_this_second"] += 1
             shared["last_frame_time"] = current_time
+            # === FRAME RATE CONTROL ===
             elapsed = time.time() - start_time
             target_time = 1.0 / TARGET_FPS
             if elapsed < target_time:
     except Exception as e:
         print(f"❌ Capture loop error: {e}")
+        import traceback
+        traceback.print_exc()
     pygame.quit()
+    print("🛑 NumPy capture loop stopped")
 # ===== 6. MAIN FUNCTION =====
 def main():
     print("=" * 60)
+    print("🚀 PyGame + NumPy Surface Array Streaming")
     print("=" * 60)
     print(f"Port: {PORT}")
+    print(f"Render: {WIDTH}x{HEIGHT} → Stream: {STREAM_WIDTH}x{STREAM_HEIGHT}")
     print(f"Target FPS: {TARGET_FPS}")
+    print("Using NumPy for pixel manipulation")
     print("=" * 60)
     # Start capture thread
+    print("Starting NumPy capture thread...")
+    capture_thread = threading.Thread(target=numpy_capture_loop, daemon=True)
     capture_thread.start()
+    # Wait for first frame
+    print("Waiting for first frame...")
+    for i in range(30):
+        if shared['latest_frame']:
+            print(f"✅ First frame ready after {i*0.1:.1f}s")
+            break
+        time.sleep(0.1)
     print(f"Starting Flask server on port {PORT}...")
     print("=" * 60)
     try:
             threaded=True,
             use_reloader=False
         )
+    except KeyboardInterrupt:
+        print("\n👋 Interrupted")
     except Exception as e:
+        print(f"❌ Server error: {e}")
     finally:
         shared['streaming'] = False
         capture_thread.join(timeout=2)
+        print(f"\n📊 Final: {shared['frame_count']} frames @ {shared['capture_fps']:.1f} FPS")
         print("✅ Shutdown complete")
 if __name__ == "__main__":