# 文件名: py代码/ethernet_worker.py # (已修复：1. 添加了缺失的 send_video_frame 槽。 2. 移除了 send_audio_chunk 中的锁。) import socket import threading import os import time import struct import zlib import random from PyQt6.QtCore import QObject, pyqtSignal, pyqtSlot from PyQt6.QtGui import QImage CHUNK_SIZE = 1024 # 每个数据包的最大有效负载大小 (字节) PREFIX_TEXT = b'\x00' PREFIX_VIDEO = b'\x01' PREFIX_FILE_DATA = b'\x02' PREFIX_AUDIO_DATA = b'\x03' PREFIX_FILE_INFO = b'\x0F' PREFIX_AUDIO_STREAM = b'\x04' PREFIX_ACK = b'\xAA' HEADER_FORMAT = '!BI' HEADER_SIZE = struct.calcsize(HEADER_FORMAT) CRC_SIZE = struct.calcsize('!I') # --- [!! 停等协议 (Stop-and-Wait) 常量 !!] --- RETRY_COUNT = 128 ACK_TIMEOUT = 0.01 # --- [!! SR 滑动窗口 (Selective Repeat) 新增常量 !!] --- WINDOW_SIZE = 4 RELIABLE_TIMEOUT = 0.01 SR_MAX_RETRIES = 15 # --- [!! 發送速率 (Pacer) 新增常量 !!] --- MIN_SEND_INTERVAL = 0.00 # 每個數據包的最小發送間隔 (秒) # --- [!! 結束新增 !!] --- class EthernetWorker(QObject): """ (文档已更新) - 增加了对"隐形"P2P LAN模式的支持。 - 为文件/音频传输实现了 SR (Selective Repeat) 滑动窗口协议。 - 為 SR 增加了最大重傳次數限制。 - 為所有數據包添加了最小發送間隔 (Pacer)。 """ # (信号保持不变) started = pyqtSignal() stopped = pyqtSignal() log_received = pyqtSignal(str) video_frame_ready = pyqtSignal(QImage) error_occurred = pyqtSignal(str) finished = pyqtSignal() file_received = pyqtSignal(str, bytes) audio_chunk_received = pyqtSignal(bytes) file_send_progress = pyqtSignal(int, int, float) file_receive_progress = pyqtSignal(int, int, float) file_receive_started = pyqtSignal(str, int) file_transfer_finished = pyqtSignal(bool, str) def __init__(self): super().__init__() self.sock = None self._running = False self.fpga_addr = None self._recv_thread = None self._lock = threading.Lock() self.is_receiving_file = False self.current_file_info = {} self.file_buffer = bytearray() self.enable_file_reception = False self.is_lan_mode = False self.ack_event = threading.Event() self.last_received_ack_seq = -1 # --- [!! 新增：视频组包缓存 !!] --- # 结构: { frame_id: { 'chunks': {idx: data}, 'total': count, 'timestamp': time } } self.video_reassembly_buffer = {} # 用于发送端的帧计数器 self.tx_video_frame_id = 0 # ------------------------------- # --- 接收方状态 (SR 修改) --- self.recv_base = 0 # 接收窗口基址 self.recv_buffer = {} # {seq_num: payload} 存储乱序到达的包 self.recv_acked = set() # 已确认的序列号集合 # --- SR (Selective Repeat) 发送方状态 --- self.send_base = 0 self.next_seq_num = 0 self.send_buffer = {} # {seq_num: packet_bytes} self.send_timers = {} # {seq_num: Timer对象} self.send_retry_count = {} # {seq_num: 重传次数} self.sr_lock = threading.Lock() self.window_space_cv = threading.Condition(self.sr_lock) self.sr_transfer_active = False self.pacer_lock = threading.Lock() self.last_send_time = 0 @pyqtSlot(bool) def set_lan_mode(self, enabled): # (此方法保持不变) self.is_lan_mode = enabled # if enabled: # self.log_received.emit(f"--- [!] 局域网P2P模式已激活 (目标: {LAN_TARGET_IP}:{LAN_PORT}) ---") # else: # self.log_received.emit("--- [!] 局域网P2P模式已停用 (返回FPGA模式) ---") def start_listening(self, listen_ip, listen_port, fpga_ip, fpga_port): # (此方法保持不变) with self._lock: if self._recv_thread and self._recv_thread.is_alive(): self.log_received.emit("[警告] 监听已在运行,请先停止。") return local_listen_ip = listen_ip local_listen_port = listen_port self.fpga_addr = (fpga_ip, fpga_port) self.recv_base = 0 self.recv_buffer.clear() self.recv_acked.clear() self._running = True self._recv_thread = threading.Thread( target = self._recv_loop, args = (local_listen_ip, local_listen_port), daemon = True ) self._recv_thread.start() self.started.emit() # self.log_received.emit(f"UDP 正在监听 {local_listen_ip}:{local_listen_port}...") def _recv_loop(self, listen_ip, listen_port): """ SR 接收逻辑 """ try: self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.settimeout(0.5) try: self.sock.bind((listen_ip, listen_port)) except Exception as e: self.error_occurred.emit(f"UDP 绑定失败: {e} (地址: {listen_ip}:{listen_port})") return while self._running: try: data, addr = self.sock.recvfrom(65536) if not data or len(data) < (HEADER_SIZE + CRC_SIZE): continue # CRC 校验 received_crc = struct.unpack('!I', data[-CRC_SIZE:])[0] data_without_crc = data[:-CRC_SIZE] calculated_crc = zlib.crc32(data_without_crc) if received_crc != calculated_crc: self.log_received.emit(f"[UDP 错误] 收到 CRC 校验失败的包,已丢弃") continue # 解析包头 prefix_byte, seq_num = struct.unpack(HEADER_FORMAT, data_without_crc[:HEADER_SIZE]) prefix = bytes([prefix_byte]) payload = data_without_crc[HEADER_SIZE:] # ============================================ # [!! 文本命令完全独立处理 !!] # ============================================ if prefix == PREFIX_TEXT: try: text_message = payload.decode('utf-8').strip() if text_message: self.log_received.emit(f"[UDP 消息]: {text_message}") except Exception: self.log_received.emit(f"[UDP 警告] 收到无法解码的文本包") self._send_ack(seq_num, addr) continue # ============================================ # [!! 🔥 关键修复：提前检测并处理文件头 !!] # ============================================ if prefix == PREFIX_FILE_INFO: if not self.enable_file_reception: self._send_ack(seq_num, addr) continue try: info_str = payload.decode('utf-8') filename, filesize_str = info_str.split(':', 1) filesize = int(filesize_str) # === 立即重置接收窗口（在任何窗口检查之前） === self.recv_base = 0 self.recv_buffer.clear() self.recv_acked.clear() # 标记为已确认 self.recv_acked.add(0) # 假设文件头总是 seq_num=0 # 重置文件接收状态 self.current_file_info = { "name": filename, "size": filesize, "start_time": time.time() } self.file_buffer.clear() self.is_receiving_file = True # 发射接收开始信号 self.file_receive_started.emit(filename, filesize) self.file_receive_progress.emit(0, filesize, 0.0) self.log_received.emit( f"[UDP 文件] (SEQ={seq_num}) 开始接收: {filename} ({filesize} 字节)" ) # 滑动窗口到下一个位置 self.recv_base = 1 except Exception as e: self.log_received.emit(f"[UDP 错误] 收到损坏的文件头: {e}") self.is_receiving_file = False # 发送 ACK self._send_ack(seq_num, addr) continue # 跳过后续 SR 处理 # ============================================ # ACK 包处理 if prefix == PREFIX_ACK: self.last_received_ack_seq = seq_num self.ack_event.set() with self.sr_lock: if seq_num in self.send_buffer: self._sr_stop_timer(seq_num) self.send_buffer.pop(seq_num, None) self.send_retry_count.pop(seq_num, None) if seq_num == self.send_base: while self.send_base < self.next_seq_num and self.send_base not in self.send_buffer: self.send_base += 1 self.window_space_cv.notify_all() continue # 视频包处理 (分片重组) if prefix == PREFIX_VIDEO: try: vid_fid = data_without_crc[1] vid_idx = data_without_crc[2] vid_total = data_without_crc[3] vid_payload = data_without_crc[4:] if vid_fid not in self.video_reassembly_buffer: self.video_reassembly_buffer[vid_fid] = { 'chunks': {}, 'total': vid_total, 'ts': time.time() } self.video_reassembly_buffer[vid_fid]['chunks'][vid_idx] = vid_payload current_frame = self.video_reassembly_buffer[vid_fid] if len(current_frame['chunks']) == vid_total: full_jpeg = bytearray() for k in range(vid_total): if k in current_frame['chunks']: full_jpeg.extend(current_frame['chunks'][k]) image = QImage() if image.loadFromData(full_jpeg, "WEBP"): self.video_frame_ready.emit(image) del self.video_reassembly_buffer[vid_fid] # 清理过期帧 now = time.time() expired_ids = [k for k, v in self.video_reassembly_buffer.items() if now - v['ts'] > 1.0] for k in expired_ids: del self.video_reassembly_buffer[k] except Exception as e: pass continue # 音频流处理 (不可靠) if prefix == PREFIX_AUDIO_STREAM: self.audio_chunk_received.emit(payload) continue # ============================================ # SR 窗口逻辑 (仅用于文件数据传输) # ============================================ # 检查是否为旧包 if seq_num < self.recv_base: # 重发 ACK (可能是重传包) self._send_ack(seq_num, addr) continue # 检查是否超出窗口 if seq_num >= self.recv_base + WINDOW_SIZE: self.log_received.emit( f"[UDP SR] 收到超出窗口的包 {seq_num} " f"(窗口 [{self.recv_base}, {self.recv_base + WINDOW_SIZE - 1}]), 已丢弃" ) continue # 发送 ACK self._send_ack(seq_num, addr) # 检查是否已确认 if seq_num in self.recv_acked: continue # 缓存数据包 self.recv_buffer[seq_num] = (prefix, payload) self.recv_acked.add(seq_num) # 滑动窗口 - 处理所有连续的已确认包 while self.recv_base in self.recv_acked: recv_prefix, recv_payload = self.recv_buffer.pop(self.recv_base) self.recv_acked.remove(self.recv_base) # 处理数据包 self._process_received_packet(recv_prefix, self.recv_base, recv_payload, addr) # 窗口滑动 self.recv_base += 1 except socket.timeout: continue except Exception as e: if self._running: self.error_occurred.emit(f"UDP 接收错误: {e}") break finally: try: if self.sock: self.sock.close() except Exception: pass self.sock = None self._running = False self.stopped.emit() self.finished.emit() self.log_received.emit("UDP 监听已停止") def _process_received_packet(self, prefix, seq_num, payload, addr): """ 处理已确认接收的数据包 注意: PREFIX_TEXT 不会到达这里,已在 _recv_loop 中处理 """ if prefix == PREFIX_FILE_INFO: if not self.enable_file_reception: return try: info_str = payload.decode('utf-8') filename, filesize_str = info_str.split(':', 1) filesize = int(filesize_str) # === [!! 关键修复: 重置接收窗口 !!] === self.recv_base = 0 self.recv_buffer.clear() self.recv_acked.clear() # === [!! 修复结束 !!] === self.current_file_info = { "name": filename, "size": filesize, "start_time": time.time() } self.file_buffer.clear() self.is_receiving_file = True # 发射接收开始信号 self.file_receive_started.emit(filename, filesize) self.file_receive_progress.emit(0, filesize, 0.0) self.log_received.emit( f"[UDP 文件] (SEQ={seq_num}) 开始接收: {filename} ({filesize} 字节)" ) except Exception as e: self.log_received.emit(f"[UDP 错误] 收到损坏的文件头: {e}") self.is_receiving_file = False elif prefix == PREFIX_FILE_DATA: if self.is_receiving_file: self.file_buffer.extend(payload) # 发射接收进度信号 total_size = self.current_file_info.get("size", -1) received_bytes = len(self.file_buffer) # 计算实时速率 start_time = self.current_file_info.get("start_time", time.time()) elapsed = time.time() - start_time if elapsed > 0: speed_mbps = (received_bytes * 8) / (elapsed * 1024 * 1024) else: speed_mbps = 0.0 self.file_receive_progress.emit(received_bytes, total_size, speed_mbps) if received_bytes >= total_size: file_data_bytes = self.file_buffer[:total_size] filename = self.current_file_info.get("name", "unknown_file") self.log_received.emit(f"[UDP 文件] 接收完毕: {filename}") self.file_transfer_finished.emit(True, "接收完成") self.file_received.emit(filename, bytes(file_data_bytes)) self.is_receiving_file = False self.file_buffer.clear() self.current_file_info.clear() # === [!! 可选: 这里也可以重置,作为双重保险 !!] === self.recv_base = 0 self.recv_buffer.clear() self.recv_acked.clear() # === [!! 修复结束 !!] === elif prefix == PREFIX_AUDIO_DATA: self.log_received.emit(f"[UDP 消息] 收到一个音频包 (SEQ={seq_num}) (暂不处理)") elif prefix == PREFIX_TEXT: # 理论上不会到这里,因为已在 _recv_loop 中处理 try: text_message = payload.decode('utf-8').strip() if text_message: self.log_received.emit(f"[UDP 消息]: {text_message}") except Exception: pass else: self.log_received.emit(f"[UDP 警告] 收到未知前缀的包: 0x{prefix.hex()}") def stop_listening(self): # (保持不变) self._running = False self.log_received.emit("停止请求已发送 -> 正在等待接收线程退出...") def set_file_reception_enabled(self, enabled: bool): # (保持不变) self.enable_file_reception = enabled if enabled: self.log_received.emit("文件接收已启用") else: self.log_received.emit("文件接收已禁用") if self.is_receiving_file: self.is_receiving_file = False self.file_buffer.clear() self.current_file_info.clear() self.log_received.emit("[警告] 文件接收已中止") def _pack_data(self, prefix: bytes, seq_num: int, payload: bytes) -> bytes: # (保持不变) header = struct.pack(HEADER_FORMAT, prefix[0], seq_num) data_without_crc = header + payload crc = zlib.crc32(data_without_crc) return data_without_crc + struct.pack('!I', crc) def _send_udp_payload(self, raw_bytes: bytes) -> bool: """ [!! 重大修改: 添加 Pacer (速率控制器) !!] 這是所有數據包的底層發送函數。 ACK 包 (send_ack) 不會調用此函數。 """ addr = self.fpga_addr if not addr: self.error_occurred.emit("发送失败: 目标地址未设置") return False with self.pacer_lock: now = time.time() elapsed = now - self.last_send_time if elapsed < MIN_SEND_INTERVAL: time.sleep(MIN_SEND_INTERVAL - elapsed) self.last_send_time = time.time() try: if self.sock: self.sock.sendto(raw_bytes, addr) return True else: with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as tmp_sock: tmp_sock.sendto(raw_bytes, addr) return True except Exception as e: self.error_occurred.emit(f"UDP 发送失败: {e}") return False def _send_ack(self, seq_num_to_ack: int, target_addr: tuple): # (此方法保持不变) ack_packet = self._pack_data(PREFIX_ACK, seq_num_to_ack, b'') try: if self.sock: self.sock.sendto(ack_packet, target_addr) except Exception as e: self.log_received.emit(f"发送 ACK {seq_num_to_ack} 失败: {e}") # --- (SR 辅助函数: _sr_start_timer, _sr_stop_timer, _sr_handle_timeout, _send_sr_stream 保持不变) --- def _sr_start_timer(self, seq_num): self._sr_stop_timer(seq_num) timer = threading.Timer(RELIABLE_TIMEOUT, self._sr_handle_timeout, args = (seq_num,)) timer.daemon = True self.send_timers[seq_num] = timer timer.start() def _sr_stop_timer(self, seq_num): """停止特定序列号的计时器""" if seq_num in self.send_timers: self.send_timers[seq_num].cancel() self.send_timers.pop(seq_num, None) def _sr_handle_timeout(self, seq_num): """处理特定包的超时""" with self.sr_lock: if not self.sr_transfer_active: return if seq_num not in self.send_buffer: return retry_count = self.send_retry_count.get(seq_num, 0) + 1 self.send_retry_count[seq_num] = retry_count if retry_count >= SR_MAX_RETRIES: self.error_occurred.emit( f"[UDP SR 错误] 包 {seq_num} 达到最大重传次数 ({SR_MAX_RETRIES})。中止传输。") self.sr_transfer_active = False for sn in list(self.send_timers.keys()): self._sr_stop_timer(sn) self.window_space_cv.notify_all() return # self.log_received.emit( # f"[UDP SR 重传] 包 {seq_num} 超时! ({retry_count}/{SR_MAX_RETRIES}) 重传") packet = self.send_buffer.get(seq_num) if packet: self._send_udp_payload(packet) self._sr_start_timer(seq_num) def _send_sr_stream(self, prefix: bytes, start_seq: int, chunk_iterator) -> bool: with self.sr_lock: self.send_base = start_seq self.next_seq_num = start_seq self.send_buffer.clear() self.send_retry_count.clear() for seq_num in list(self.send_timers.keys()): self._sr_stop_timer(seq_num) self.sr_transfer_active = True try: chunk_cache = {} chunk_gen = iter(chunk_iterator) current_packet_index = 0 all_chunks_loaded = False while not all_chunks_loaded or self.send_base < self.next_seq_num: with self.sr_lock: if not self._running: self.error_occurred.emit("SR 发送中止 (1)") return False if not self.sr_transfer_active: self.error_occurred.emit("SR 发送中止 (因最大重传)") return False while (self.next_seq_num - self.send_base) < WINDOW_SIZE and not all_chunks_loaded: try: chunk = next(chunk_gen) except StopIteration: all_chunks_loaded = True break current_seq = start_seq + current_packet_index chunk_cache[current_seq] = chunk packet = self._pack_data(prefix, current_seq, chunk) self.send_buffer[current_seq] = packet self.send_retry_count[current_seq] = 0 self._send_udp_payload(packet) self._sr_start_timer(current_seq) self.next_seq_num += 1 current_packet_index += 1 with self.sr_lock: if not self._running: self.error_occurred.emit("SR 发送中止 (2)") return False if not self.sr_transfer_active: self.error_occurred.emit("SR 发送中止 (因最大重传)") return False if (self.next_seq_num - self.send_base) >= WINDOW_SIZE and not all_chunks_loaded: self.window_space_cv.wait(RELIABLE_TIMEOUT * 2) elif all_chunks_loaded and self.send_base < self.next_seq_num: self.window_space_cv.wait(RELIABLE_TIMEOUT * 2) acked_keys = [k for k in chunk_cache if k < self.send_base] for k in acked_keys: chunk_cache.pop(k, None) self.log_received.emit(f"-> [UDP SR 流] (Prefix 0x{prefix.hex()}) 发送完成。") return True except Exception as e: self.error_occurred.emit(f"SR 流发送失败: {e}") return False finally: with self.sr_lock: for seq_num in list(self.send_timers.keys()): self._sr_stop_timer(seq_num) self.send_buffer.clear() self.send_retry_count.clear() self.sr_transfer_active = False def _send_reliable_payload(self, prefix: bytes, seq_num: int, payload: bytes) -> bool: # (此方法保持不变) packet = self._pack_data(prefix, seq_num, payload) for i in range(RETRY_COUNT): self.ack_event.clear() self.last_received_ack_seq = -1 if not self._send_udp_payload(packet): self.error_occurred.emit("UDP 套接字发送失败,中止重试") return False if self.ack_event.wait(ACK_TIMEOUT): if self.last_received_ack_seq == seq_num: return True else: self.log_received.emit( f"[UDP 警告] 收到错误 ACK (Seq={self.last_received_ack_seq}, 期望={seq_num})") self.log_received.emit( f"[UDP 重试] 包 {seq_num} (Prefix 0x{prefix.hex()}) 未收到 ACK ({i + 1}/{RETRY_COUNT})") self.error_occurred.emit(f"包 {seq_num} (Prefix 0x{prefix.hex()}) 发送失败 {RETRY_COUNT} 次,已放弃") return False def _send_unreliable_payload(self, prefix: bytes, payload: bytes) -> bool: """ (此方法保持不变, Pacer 將在 _send_udp_payload 中自動應用) """ packet = self._pack_data(prefix, 0, payload) return self._send_udp_payload(packet) def send_command(self, cmd_str: str): # (保持不变 - 停等协议) with self._lock: seq_num = 0 payload = cmd_str.encode('utf-8') self.log_received.emit(f"-> [UDP发送 文本]: {cmd_str} (SEQ={seq_num})") success = self._send_reliable_payload(PREFIX_TEXT, seq_num, payload) if success: self.log_received.emit(f"-> [UDP发送 文本]: {cmd_str} 完成,序列号已重置") else: self.log_received.emit(f"-> [UDP发送 文本]: {cmd_str} 失败") def send_file_udp(self, file_path: str): """ [!! SR !!] 1. 使用 "停等" (_send_reliable_payload) 发送文件头 (SEQ=0) 2. 使用 "SR" (_send_sr_stream) 发送文件数据 (SEQ=1...N) 添加了进度信号发射 """ with self._lock: if not self.fpga_addr: self.error_occurred.emit("发送失败: 目标地址未设置") self.file_transfer_finished.emit(False, "目标地址未设置") return try: file_size = os.path.getsize(file_path) filename = os.path.basename(file_path) self.log_received.emit(f"-> [UDP发送 文件]: {filename} ({file_size} 字节)") start_time = time.time() # 发送前发射初始进度 self.file_send_progress.emit(0, file_size, 0.0) # --- 1. 发送文件头 (SEQ=0, 停等) --- seq_num = 0 info_str = f"{filename}:{file_size}" info_payload = info_str.encode('utf-8') self.log_received.emit(f"-> [UDP发送 文件头] (SEQ={seq_num})") if not self._send_reliable_payload(PREFIX_FILE_INFO, seq_num, info_payload): self.error_occurred.emit("文件头发送失败,未收到 ACK") self.file_transfer_finished.emit(False, "文件头发送失败") return self.log_received.emit(f"-> [UDP发送 文件头] 完成") # --- 2. 发送文件数据 (SEQ=1...N, SR) 带进度 --- sent_bytes = 0 def file_chunk_generator_with_progress(f): nonlocal sent_bytes while True: chunk = f.read(CHUNK_SIZE) if not chunk: break sent_bytes += len(chunk) # 计算实时速率 elapsed = time.time() - start_time if elapsed > 0: speed_mbps = (sent_bytes * 8) / (elapsed * 1024 * 1024) else: speed_mbps = 0.0 # 发射进度信号 self.file_send_progress.emit(sent_bytes, file_size, speed_mbps) yield chunk with open(file_path, 'rb') as f: start_seq_num = 1 self.log_received.emit(f"-> [UDP SR 发送] 文件数据 (从 SEQ={start_seq_num} 开始)...") if not self._send_sr_stream(PREFIX_FILE_DATA, start_seq_num, file_chunk_generator_with_progress(f)): self.error_occurred.emit(f"文件数据块发送失败 (SR)") self.file_transfer_finished.emit(False, "数据发送失败") return end_time = time.time() elapsed = end_time - start_time speed_mbps = (file_size * 8) / (elapsed * 1024 * 1024) if elapsed > 0 else 0 # 最终进度 self.file_send_progress.emit(file_size, file_size, speed_mbps) self.file_transfer_finished.emit(True, "发送完成") self.log_received.emit( f"-> [UDP发送 文件]: {filename} 完成, " f"耗时: {elapsed:.2f} 秒, " f"速度: {speed_mbps:.2f} Mbps ({file_size} 字节)" ) except FileNotFoundError: self.error_occurred.emit(f"文件未找到: {file_path}") self.file_transfer_finished.emit(False, "文件未找到") except Exception as e: self.error_occurred.emit(f"文件发送失败: {e}") self.file_transfer_finished.emit(False, str(e)) def send_audio_udp(self, audio_bytes: bytes): """ [!! SR !!] 1. 使用 "SR" (_send_sr_stream) 发送所有音频数据块 (SEQ=0...N) """ with self._lock: if not self.fpga_addr: self.error_occurred.emit("发送失败: 目标地址未设置") return data_size = len(audio_bytes) self.log_received.emit(f"-> [UDP SR 发送 音频]: {data_size} 字节至 {self.fpga_addr}") try: def audio_chunk_generator(data, size): idx = 0 while idx < len(data): yield data[idx: idx + size] idx += size start_seq_num = 0 start_time = time.time() success = self._send_sr_stream(PREFIX_AUDIO_DATA, start_seq_num, audio_chunk_generator(audio_bytes, CHUNK_SIZE)) end_time = time.time() if not success: self.error_occurred.emit("音频发送中断 (SR)") return elapsed = end_time - start_time speed_mbps = (data_size * 8) / (elapsed * 1024 * 1024) if elapsed > 0 else 0 self.log_received.emit( f"-> [UDP SR 发送 音频]: 完成, " f"耗时: {elapsed:.2f} 秒, " f"速度: {speed_mbps:.2f} Mbps ({data_size} 字节)" ) except Exception as e: self.error_occurred.emit(f"音频发送失败: {e}") @pyqtSlot(bytes) def send_audio_chunk(self, audio_data: bytes): """ (不可靠的实时流发送) """ with self._lock: if not self.fpga_addr: return if not self._send_unreliable_payload(PREFIX_AUDIO_STREAM, audio_data): pass # # --- [!! 修复结束 2 !!] --- # # --- [!! 关键修复 1 (Bug 214a27) !!] --- # @pyqtSlot(bytes) # def send_video_frame(self, jpeg_data: bytes): # """ # [公共槽] 发送一个实时视频帧 (不可靠) # (不使用 self._lock) # """ # if not self.fpga_addr: # return # # # # 使用 PREFIX_VIDEO (0x01)，这是为视频保留的 # # if not self._send_unreliable_payload(PREFIX_VIDEO, jpeg_data): # # pass # 丢包, 忽略 @pyqtSlot(bytes) def send_video_frame(self, jpeg_data: bytes): """ [修改版] 视频分包发送逻辑 协议头 (4 bytes): [0x01 (Prefix)] [Frame_ID] [Packet_Idx] [Total_Packets] """ if not self.fpga_addr: return # FPGA 限制 1400，我们设定 Payload 为 1024，留足余量 MAX_PAYLOAD = 1024 total_len = len(jpeg_data) # 计算总包数 (向上取整) total_packets = (total_len + MAX_PAYLOAD - 1) // MAX_PAYLOAD # 限制最大包数 (因为包头里 Total_Packets 只有 1 byte，最大 255) if total_packets > 255: print(f"[丢弃] 视频帧过大: {total_len} bytes (需要 {total_packets} 包 > 255)") return # 帧 ID 自增 (0-255 循环) self.tx_video_frame_id = (self.tx_video_frame_id + 1) % 256 fid = self.tx_video_frame_id # 循环发送每个分片 for i in range(total_packets): start = i * MAX_PAYLOAD end = min(start + MAX_PAYLOAD, total_len) chunk = jpeg_data[start:end] # 构建包头: Prefix(1) + FID(1) + Index(1) + Total(1) # 1. 构建包内容: Prefix(1) + FID(1) + Index(1) + Total(1) + Data(...) # 注意：这里 Prefix 是 0x01 (PREFIX_VIDEO) header = struct.pack('!BBBB', 0x01, fid, i, total_packets) data_without_crc = header + chunk # --- [!! 核心修复 !!] --- # 2. 计算 CRC32 crc = zlib.crc32(data_without_crc) # 3. 拼接完整的带 CRC 的包 final_packet = data_without_crc + struct.pack('!I', crc) # 这里的 send_udp_payload 会处理 socket 发送 # 视频允许丢包，所以我们不使用可靠重传 (Stop-and-Wait/SR) # 4. 发送 self._send_udp_payload(final_packet) # [重要] 微小延时，防止瞬间突发流量淹没 FPGA 的 2Mbps 带宽 # 1024 bytes * 8 bits = 8192 bits. # 2Mbps = 2,000,000 bits/s. # 理论最小间隔 ≈ 0.004s。设置为 0.002s 比较激进但流畅。 time.sleep(0.002)