iframe-proxy | Sunbelt Computer Software

392 lines (311 loc) · 12.4 KB
SuperDisplay Client
Receives and displays screen content from the server.
import socket
import threading
import struct
import logging
from typing import Optional
import time
from PyQt6.QtWidgets import (
    QApplication, QMessageBox, QDialog, QVBoxLayout, 
    QHBoxLayout, QLabel, QLineEdit, QPushButton, QSpinBox
from PyQt6.QtCore import QTimer, pyqtSignal, QObject, Qt
from client import VideoDecoder, DisplayWindow
from transport.base import InputEvent, unpack_frame_header, FRAME_HEADER_SIZE
# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
logger = logging.getLogger(__name__)
class ClientSignals(QObject):
    """Signals for thread-safe UI updates"""
    frame_received = pyqtSignal(object)  # numpy array
    status_update = pyqtSignal(str)
    connection_lost = pyqtSignal()
class ConnectionDialog(QDialog):
    """对话框，用于输入服务器连接信息"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("连接到 SuperDisplay 服务器")
        self.setModal(True)
        self.setMinimumWidth(400)
        # 存储用户输入
        self.server_ip = "127.0.0.1"  # 默认值
        self.server_port = 28017  # 默认值
        self._setup_ui()
    def _setup_ui(self):
        """设置UI界面"""
        layout = QVBoxLayout()
        layout.setSpacing(15)
        layout.setContentsMargins(20, 20, 20, 20)
        # 标题
        title_label = QLabel("请输入服务器连接信息")
        title_label.setStyleSheet("font-size: 14px; font-weight: bold;")
        layout.addWidget(title_label)
        # IP地址输入
        ip_layout = QHBoxLayout()
        ip_label = QLabel("服务器IP:")
        ip_label.setMinimumWidth(80)
        self._ip_input = QLineEdit()
        self._ip_input.setText(self.server_ip)
        self._ip_input.setPlaceholderText("例如: 192.168.1.100")
        ip_layout.addWidget(ip_label)
        ip_layout.addWidget(self._ip_input)
        layout.addLayout(ip_layout)
        # 端口输入
        port_layout = QHBoxLayout()
        port_label = QLabel("端口:")
        port_label.setMinimumWidth(80)
        self._port_input = QSpinBox()
        self._port_input.setRange(1, 65535)
        self._port_input.setValue(self.server_port)
        port_layout.addWidget(port_label)
        port_layout.addWidget(self._port_input)
        layout.addLayout(port_layout)
        # 提示信息
        hint_label = QLabel("提示: 请确保客户端和服务器在同一网络中")
        hint_label.setStyleSheet("color: gray; font-size: 11px;")
        layout.addWidget(hint_label)
        # 按钮
        button_layout = QHBoxLayout()
        button_layout.addStretch()
        self._cancel_btn = QPushButton("取消")
        self._cancel_btn.clicked.connect(self.reject)
        self._connect_btn = QPushButton("连接")
        self._connect_btn.setDefault(True)
        self._connect_btn.clicked.connect(self._on_connect)
        self._connect_btn.setStyleSheet("""
            QPushButton {
                background-color: #0078D4;
                color: white;
                padding: 6px 20px;
                border: none;
                border-radius: 4px;
            QPushButton:hover {
                background-color: #005A9E;
        """)
        button_layout.addWidget(self._cancel_btn)
        button_layout.addWidget(self._connect_btn)
        layout.addLayout(button_layout)
        self.setLayout(layout)
    def _on_connect(self):
        """处理连接按钮点击"""
        ip_text = self._ip_input.text().strip()
        # 验证IP地址
        if not ip_text:
            QMessageBox.warning(self, "输入错误", "请输入服务器IP地址")
            return
        # 简单验证IP格式
        parts = ip_text.split('.')
        if len(parts) != 4:
            QMessageBox.warning(self, "输入错误", "IP地址格式不正确")
            return
        try:
            for part in parts:
                num = int(part)
                if num < 0 or num > 255:
                    raise ValueError()
        except ValueError:
            QMessageBox.warning(self, "输入错误", "IP地址格式不正确")
            return
        # 保存输入
        self.server_ip = ip_text
        self.server_port = self._port_input.value()
        self.accept()
    def get_connection_info(self):
        """获取连接信息"""
        return self.server_ip, self.server_port
class SuperDisplayClient:
    """Client application for receiving screen content"""
    def __init__(self, server_ip: str, server_port: int = 28017):
        self._server_ip = server_ip
        self._server_port = server_port
        self._socket: Optional[socket.socket] = None
        self._decoder = VideoDecoder()
        self._display: Optional[DisplayWindow] = None
        self._running = False
        self._receive_thread: Optional[threading.Thread] = None
        # Signals for thread-safe communication
        self._signals = ClientSignals()
    def connect(self) -> bool:
        """Connect to the server"""
        try:
            logger.info(f"Connecting to {self._server_ip}:{self._server_port}...")
            # Create socket
            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
            self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2 * 1024 * 1024)  # 2MB buffer
            self._socket.settimeout(10.0)
            # Connect
            self._socket.connect((self._server_ip, self._server_port))
            logger.info("Connected to server")
            # Open decoder
            if not self._decoder.open():
                logger.error("Failed to open decoder")
                return False
            logger.info(f"Decoder opened: {self._decoder.codec_name}")
            self._running = True
            return True
        except Exception as e:
            logger.error(f"Connection failed: {e}")
            return False
    def start_receiving(self):
        """Start receiving frames"""
        self._receive_thread = threading.Thread(target=self._receive_loop, daemon=True)
        self._receive_thread.start()
    def _receive_loop(self):
        """Receive and decode frames"""
        logger.info("Receive loop started")
        frame_count = 0
        last_log_time = time.time()
        try:
            while self._running:
                # Receive frame header
                header_data = self._recv_exact(FRAME_HEADER_SIZE)
                if not header_data:
                    logger.warning("Connection closed by server")
                # Unpack header
                frame_size, is_keyframe = unpack_frame_header(header_data)
                # Receive frame data
                frame_data = self._recv_exact(frame_size)
                if not frame_data:
                    logger.warning("Incomplete frame received")
                # Decode frame
                frames = list(self._decoder.decode_packet(frame_data, is_keyframe))
                # Display frames
                for frame in frames:
                    self._signals.frame_received.emit(frame)
                    frame_count += 1
                # Log performance
                now = time.time()
                if now - last_log_time >= 5.0:
                    fps = frame_count / (now - last_log_time)
                    logger.info(f"Receiving at {fps:.1f} FPS (codec: {self._decoder.codec_name})")
                    frame_count = 0
                    last_log_time = now
        except Exception as e:
            logger.error(f"Receive error: {e}")
        finally:
            self._running = False
            self._signals.connection_lost.emit()
            logger.info("Receive loop stopped")
    def _recv_exact(self, n: int) -> Optional[bytes]:
        """Receive exactly n bytes"""
        if not self._socket:
            return None
        data = bytearray()
        while len(data) < n:
            try:
                chunk = self._socket.recv(n - len(data))
                if not chunk:
                    return None
                data.extend(chunk)
            except socket.timeout:
                logger.debug("Receive timeout")
                return None
            except Exception as e:
                logger.error(f"Receive error: {e}")
                return None
        return bytes(data)
    def send_input_event(self, event: InputEvent):
        """Send input event to server"""
        if not self._socket or not self._running:
            return
        try:
            data = event.to_bytes()
            self._socket.sendall(data)
        except Exception as e:
            logger.debug(f"Failed to send input event: {e}")
    def disconnect(self):
        """Disconnect from server"""
        self._running = False
        if self._receive_thread:
            self._receive_thread.join(timeout=2.0)
        if self._socket:
            try:
                self._socket.close()
            except:
            self._socket = None
        self._decoder.close()
        logger.info("Disconnected from server")
    def set_display(self, display: DisplayWindow):
        """Set the display window"""
        self._display = display
        # Connect display signals to input sending
        display.mouse_event.connect(self._on_mouse_event)
        display.key_event.connect(self._on_key_event)
        # Connect frame signal
        self._signals.frame_received.connect(display.display_frame)
        self._signals.status_update.connect(lambda msg: display.update_status(msg, 3000))
        self._signals.connection_lost.connect(self._on_connection_lost)
    def _on_mouse_event(self, action: int, button: int, x: float, y: float):
        """Handle mouse events from display"""
        event = InputEvent(
            event_type=2,  # mouse
            action=action,
            x=x,
            y=y,
            pressure=1.0 if action == 0 else 0.0,
            timestamp=int(time.time() * 1000)
        self.send_input_event(event)
    def _on_key_event(self, key: int, action: int):
        """Handle keyboard events from display"""
        # For now, we'll skip keyboard events
        # They would need proper key code mapping
        pass
    def _on_connection_lost(self):
        """Handle connection loss"""
        if self._display:
            self._display.update_status("Connection lost", 0)
def main():
    """Main entry point"""
    app = QApplication(sys.argv)
    # 显示连接对话框
    dialog = ConnectionDialog()
    if dialog.exec() != QDialog.DialogCode.Accepted:
        # 用户取消连接
        sys.exit(0)
    # 获取用户输入的服务器信息
    server_ip, server_port = dialog.get_connection_info()
    logger.info(f"用户输入: 服务器 {server_ip}:{server_port}")
    # Create display window
    display = DisplayWindow(width=1920, height=1080)
    display.show()
    # Create client
    client = SuperDisplayClient(server_ip, server_port)
    client.set_display(display)
    # Connect to server
    display.update_status(f"正在连接 {server_ip}:{server_port}...", 0)
    if not client.connect():
        QMessageBox.critical(
            display,
            "连接失败",
            f"无法连接到服务器 {server_ip}:{server_port}\n\n"
            f"请检查:\n"
            f"1. 服务器IP地址是否正确\n"
            f"2. 服务器是否已启动\n"
            f"3. 防火墙是否阻止了连接"
        sys.exit(1)
    display.update_status("连接成功！正在接收视频流...", 3000)
    QTimer.singleShot(3000, display.hide_status)
    # Start receiving
    client.start_receiving()
    # Cleanup on exit
    def cleanup():
        client.disconnect()
    app.aboutToQuit.connect(cleanup)
    sys.exit(app.exec())
if __name__ == "__main__":
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

client_app.py

Latest commit

History

client_app.py

File metadata and controls
