Yolov/ffmpegStreamer.py

import errno
import threading
import queue
import time
import os
import cv2
import numpy as np
import subprocess
import torch
from log import logger

# ffmpegStreamer.py 顶部添加
try:
    from platform_utils import is_windows, safe_readline
except ImportError:
    # 定义简单的兼容函数
    def is_windows():
        import os
        return os.name == 'nt'


    def safe_readline(fd, timeout=1.0):
        """简单的readline包装器"""
        try:
            line = fd.readline()
            if line:
                return line.decode('utf-8', errors='ignore').strip()
        except:
            pass
        return None

# 全局变量用于控制重启频率
_global_restart_count = 0
_global_last_restart_time = 0
_global_restart_lock = threading.Lock()


class FFmpegStreamer(threading.Thread):
    """独立推流线程 - 优化版本，减少频繁重启"""

    def __init__(self, config, fps, frame_width, frame_height):
        super().__init__()
        self.config = config['push']
        self.fps = fps
        self.original_width = frame_width
        self.original_height = frame_height

        # 使用原始分辨率
        self.scaled_width = frame_width
        self.scaled_height = frame_height

        self.queue = queue.Queue(maxsize=10)  # 合理大小的队列
        self.running = True
        self.process = None
        self.process_lock = threading.Lock()
        self.process_starting = threading.Event()
        self.daemon = True
        self.last_drop_warning = 0
        self.frame_buffer = None

        # 统计信息
        self.total_frames_sent = 0
        self.total_frames_dropped = 0
        self.frame_counter = 0
        self.start_time = time.time()
        self.avg_process_time = 0.033

        # 重连参数 - 调整为更保守
        self.max_restarts = 10  # 增加最大重启次数
        self.restart_count = 0
        self.min_restart_delay = 2.0  # 增加最小延迟
        self.max_restart_delay = 30.0  # 增加最大延迟
        self.last_restart_time = 0

        # 新增重启控制变量
        self.restart_lock = threading.Lock()
        self.restart_scheduled = False
        self.last_restart_attempt = 0
        self.pipe_broken = False  # 管道破裂标志
        self.last_successful_write = time.time()  # 记录上次成功写入时间

        # 新增：失败计数器，避免偶尔失败就重启
        self.consecutive_failures = 0
        self.max_consecutive_failures = 10  # 最大连续失败次数

        # 新增：健康检查相关
        self.health_check_interval = 5.0  # 健康检查间隔（秒）
        self.last_health_check = time.time()
        self.process_is_healthy = True  # 进程健康状态

        # 新增：输出监控相关
        self.last_output_time = time.time()
        self.silent_threshold = 60.0  # 60秒无输出才认为沉默（原来是30秒）
        self.silent_start_time = None
        self.output_count = 0
        self.last_process_check = time.time()

        # 新增：监控线程
        self.monitor_thread = None
        self.monitor_running = True

        self.stop_event = threading.Event()

        # 预计算帧处理参数
        self.buffer_size = self.scaled_width * self.scaled_height * 3
        logger.info(
            f"推流线程初始化 | 分辨率: {self.scaled_width}x{self.scaled_height} | 缓冲区: {self.buffer_size // 1024}KB")

    def run(self):
        """推流线程主循环 - 优化版本"""
        logger.info(f"启动推流线程 | 分辨率: {self.scaled_width}x{self.scaled_height} | FPS: {self.fps}")

        # 启动时确保FFmpeg已启动
        if not self.start_ffmpeg():
            logger.error("初始FFmpeg启动失败")
            self.running = False
            return

        # 新增：启动监控线程
        self.start_monitor_thread()

        # 新增：首次成功写入检查
        initial_wait_time = 3.0  # 启动后等待3秒再进行健康检查
        initial_start_time = time.time()

        while self.running and not self.stop_event.is_set():
            frame_start = time.perf_counter()
            # 检查是否应该停止
            if self.stop_event.is_set():
                logger.info("收到停止事件信号，退出循环")
                break

            # 健康检查（更保守的频率）
            current_time = time.time()
            if current_time - self.last_health_check >= self.health_check_interval:
                self.perform_health_check()
                self.last_health_check = current_time

            try:
                # 根据处理时间动态调整获取超时
                timeout = max(0.1, min(1.0, self.avg_process_time * 2))
                frame = self.queue.get(timeout=timeout)

                if frame is None:  # 停止信号
                    logger.info("接收到停止信号")
                    break

                # 检查进程状态（减少检查频率）
                if current_time - self.last_health_check >= self.health_check_interval:
                    if self.check_process_health():
                        # 进程不健康，尝试恢复
                        if not self.attempt_recovery():
                            logger.error("进程恢复失败，停止推流")
                            break
                    self.last_health_check = current_time

                # 处理帧
                processed_frame = self.process_frame(frame)

                # 安全写入FFmpeg
                write_success = self.write_frame(processed_frame)

                if write_success:
                    self.total_frames_sent += 1
                    self.consecutive_failures = 0  # 重置连续失败计数器
                    self.pipe_broken = False  # 重置管道破裂标志
                    self.last_successful_write = time.time()  # 更新成功写入时间
                    self.last_output_time = time.time()  # 更新最后活动时间

                    # 更新进程健康状态
                    self.process_is_healthy = True
                else:
                    self.total_frames_dropped += 1
                    self.consecutive_failures += 1

                    # 记录错误但不要立即重启
                    if self.consecutive_failures % 5 == 0:  # 每5次失败记录一次
                        logger.warning(f"连续写入失败 {self.consecutive_failures} 次")

                    # 只有在连续失败次数过多时才尝试重启
                    if self.consecutive_failures >= self.max_consecutive_failures:
                        logger.warning(f"连续失败 {self.consecutive_failures} 次，尝试恢复")
                        if not self.attempt_recovery():
                            logger.error("恢复失败，停止推流")
                            break

            except queue.Empty:
                # 队列空时进行轻度心跳检测
                self.light_heartbeat()
                continue
            except Exception as e:
                logger.error(f"处理帧时发生未知错误: {str(e)}", exc_info=True)
                self.total_frames_dropped += 1
                self.consecutive_failures += 1

            # 更新帧处理时间估计（EMA平滑）
            elapsed = time.perf_counter() - frame_start
            self.avg_process_time = self.avg_process_time * 0.9 + elapsed * 0.1

        # 清理资源
        self.stop_monitor_thread()
        self.stop_ffmpeg()
        self.log_statistics()
        logger.info("推流线程已停止")

    def start_monitor_thread(self):
        """启动FFmpeg输出监控线程"""
        if not self.config.get('enable_monitoring', True):
            return

        self.monitor_running = True
        self.monitor_thread = threading.Thread(
            target=self.monitor_ffmpeg_output,
            daemon=True,
            name=f"FFmpegMonitor_{id(self)}"
        )
        self.monitor_thread.start()
        logger.info("FFmpeg监控线程已启动")

    def stop_monitor_thread(self):
        """停止监控线程"""
        self.monitor_running = False
        if self.monitor_thread and self.monitor_thread.is_alive():
            self.monitor_thread.join(timeout=2.0)
            if self.monitor_thread.is_alive():
                logger.warning("监控线程未能及时停止")
            else:
                logger.info("监控线程已停止")

    def monitor_ffmpeg_output(self):
        """监控FFmpeg输出流（改进版本）"""
        logger.info("启动FFmpeg监控线程")

        try:
            stderr = self.process.stderr if self.process else None
            if not stderr:
                logger.warning("没有stderr管道，跳过监控")
                return

            buffer = []
            max_buffer_size = 100  # 限制缓冲区大小
            last_check_time = time.time()

            while self.monitor_running and self.process and self.check_process_status():
                try:
                    current_time = time.time()

                    # 定期检查进程状态（每5秒一次）
                    if current_time - last_check_time >= 5.0:
                        self._check_silent_state(current_time)
                        last_check_time = current_time

                    # 使用更简单的方法读取（非阻塞）
                    if is_windows():
                        # Windows: 使用select或直接尝试读取
                        try:
                            line = stderr.readline()
                            if line:
                                self._process_ffmpeg_line(line)
                                time.sleep(0.01)  # 短暂休眠避免CPU占用过高
                            else:
                                time.sleep(0.1)  # 没有数据时等待
                        except Exception as e:
                            time.sleep(0.5)
                    else:
                        # Unix: 使用select实现非阻塞读取
                        import select
                        rlist, _, _ = select.select([stderr], [], [], 0.1)
                        if rlist:
                            line = stderr.readline()
                            if line:
                                self._process_ffmpeg_line(line)

                except Exception as e:
                    # 读取错误，可能是管道关闭
                    if not self.monitor_running:
                        break
                    time.sleep(0.5)
                    continue

        except Exception as e:
            logger.debug(f"监控线程异常退出: {str(e)}")
        finally:
            logger.info("FFmpeg监控线程已退出")

    def _process_ffmpeg_line(self, line_bytes):
        """处理FFmpeg输出行"""
        try:
            line = line_bytes.decode('utf-8', errors='ignore').strip()
            if not line:
                return

            current_time = time.time()

            # 更新统计
            self.output_count += 1
            self.last_output_time = current_time
            self.silent_start_time = None  # 重置沉默计时

            # 只处理重要错误
            if 'error' in line.lower() or 'failed' in line.lower():
                logger.warning(f"FFmpeg错误: {line}")

                # 严重错误处理
                if any(keyword in line.lower() for keyword in [
                    'broken pipe', 'pipe broken', 'connection refused',
                    'cannot open connection', 'timeout'
                ]):
                    logger.error(f"FFmpeg关键错误: {line}")
                    self.pipe_broken = True

            # 性能信息
            elif 'frame=' in line and 'fps=' in line:
                if self.total_frames_sent % 100 == 0:  # 每100帧记录一次
                    logger.debug(f"FFmpeg状态: {line}")

        except Exception as e:
            logger.debug(f"处理FFmpeg行失败: {str(e)}")

    def _check_silent_state(self, current_time):
        """检查沉默状态（更宽容的策略）"""
        # 如果最近有成功写入，重置沉默计时
        if current_time - self.last_successful_write < 5.0:
            self.silent_start_time = None
            return

        # 如果最近有输出，重置沉默计时
        if current_time - self.last_output_time < 5.0:
            self.silent_start_time = None
            return

        # 开始沉默计时
        if self.silent_start_time is None:
            self.silent_start_time = current_time

        # 检查沉默时间是否超过阈值
        silent_duration = current_time - self.silent_start_time

        if silent_duration > self.silent_threshold:
            # 长时间沉默，但先不重启，而是进行深度检查
            logger.warning(f"FFmpeg长时间无输出 ({silent_duration:.1f}秒)")

            # 进行更严格的进程检查
            if not self._deep_process_check():
                logger.error(f"FFmpeg深度检查失败，准备重启")
                self.schedule_restart()
            else:
                logger.info(f"FFmpeg深度检查通过，继续监控")
                # 重置沉默计时，给更多时间
                self.silent_start_time = current_time - (self.silent_threshold / 2)

    def _deep_process_check(self):
        """深度进程检查"""
        if not self.process:
            return False

        try:
            # 方法1：检查进程是否存在
            return_code = self.process.poll()
            if return_code is not None:
                return False

            # 方法2：尝试发送信号检查（Unix）
            if not is_windows():
                import signal
                try:
                    os.kill(self.process.pid, 0)
                except OSError:
                    return False

            # 方法3：检查进程资源使用（如果可用）
            try:
                import psutil
                ps_process = psutil.Process(self.process.pid)

                # 检查进程状态
                status = ps_process.status()
                if status in (psutil.STATUS_ZOMBIE, psutil.STATUS_DEAD):
                    return False

                # 检查进程是否消耗CPU（可选）
                cpu_percent = ps_process.cpu_percent(interval=0.1)
                logger.debug(f"FFmpeg深度检查: CPU={cpu_percent}%, 状态={status}")

            except ImportError:
                # 没有psutil，跳过详细检查
                pass
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                return False

            return True

        except (OSError, ProcessLookupError):
            return False
        except Exception as e:
            logger.debug(f"深度检查异常: {str(e)}")
            return True  # 异常时假设进程正常

    def schedule_restart(self):
        """安排安全重启（避免重复调度）"""
        if self.restart_scheduled:
            return

        self.restart_scheduled = True

        def safe_restart():
            try:
                if self.running:
                    self.safe_restart_ffmpeg()
            except Exception as e:
                logger.error(f"安全重启失败: {str(e)}")
            finally:
                self.restart_scheduled = False

        threading.Thread(target=safe_restart, daemon=True).start()

    def perform_health_check(self):
        """执行健康检查（替代原来的网络检查）"""
        try:
            # 1. 检查进程是否存在
            if not self.process:
                logger.warning("进程不存在，标记为不健康")
                self.process_is_healthy = False
                return

            # 2. 检查进程是否在运行
            if self.process.poll() is not None:
                logger.warning("进程已退出，标记为不健康")
                self.process_is_healthy = False
                return

            # 3. 检查长时间没有成功写入（超过30秒）
            current_time = time.time()
            if current_time - self.last_successful_write > 30.0:
                logger.warning(f"长时间没有成功写入 ({current_time - self.last_successful_write:.1f}秒)")
                self.process_is_healthy = False
                return

            # 4. 检查管道状态
            if self.pipe_broken:
                logger.warning("管道破裂状态")
                self.process_is_healthy = False
                return

            # 检查通过
            self.process_is_healthy = True

        except Exception as e:
            logger.debug(f"健康检查异常: {str(e)}")
            self.process_is_healthy = False

    def check_process_health(self):
        """检查进程健康状况"""
        return not self.process_is_healthy

    def attempt_recovery(self):
        """尝试恢复（替代原来的立即重启）"""
        logger.info("尝试恢复推流进程...")

        # 检查是否应该停止
        if self.stop_event.is_set() or not self.running:
            logger.info("收到停止信号，跳过恢复")
            return False

        # 1. 先尝试轻微恢复（不清除进程）
        if not self.pipe_broken and self.consecutive_failures < 5:
            # 只是轻微问题，等待一下
            logger.info("轻微问题，等待2秒后重试")

            # 在等待期间检查停止信号
            wait_start = time.time()
            while time.time() - wait_start < 2.0:
                if self.stop_event.is_set() or not self.running:
                    logger.info("收到停止信号，取消等待")
                    return False
                time.sleep(0.1)

            # 尝试清理缓冲区
            try:
                while not self.queue.empty():
                    self.queue.get_nowait()
            except:
                pass

            self.consecutive_failures = 0
            return True

        # 2. 需要重启的情况
        logger.info("问题较严重，尝试重启FFmpeg")
        return self.safe_restart_ffmpeg()

    def safe_restart_ffmpeg(self):
        """安全重启FFmpeg（优化版本）"""
        with self.restart_lock:
            current_time = time.time()

            # 检查是否应该停止
            if self.stop_event.is_set() or not self.running:
                logger.info("收到停止信号，取消重启")
                return False

            # 防止频繁重启（增加最小间隔）
            min_interval = 10.0  # 至少间隔10秒才能再次重启
            if current_time - self.last_restart_attempt < min_interval:
                logger.debug(f"跳过重启：距离上次尝试时间过短 ({min_interval:.1f}秒)")
                return False

            self.last_restart_attempt = current_time

            # 检查全局重启频率
            with _global_restart_lock:
                global _global_restart_count, _global_last_restart_time

                # 全局限制：1分钟内最多重启3次
                if current_time - _global_last_restart_time < 60:
                    if _global_restart_count >= 3:
                        logger.error("全局重启频率过高，等待60秒")
                        return False
                else:
                    # 重置计数器
                    _global_restart_count = 0
                    _global_last_restart_time = current_time

                _global_restart_count += 1

            # 检查重启次数
            self.restart_count += 1
            max_restarts = 10
            if self.restart_count > max_restarts:
                logger.error(f"达到最大重启次数 {max_restarts}，停止推流")
                self.running = False
                return False

            # 指数退避延迟（更保守）
            delay = min(
                self.max_restart_delay,
                max(self.min_restart_delay, 2.0 * (2 ** (self.restart_count - 1)))
            )

            logger.info(f"准备重启FFmpeg ({self.restart_count}/{max_restarts}), {delay:.1f}秒后执行...")

            # 在延迟期间持续检查停止信号
            start_time = time.time()
            while time.time() - start_time < delay:
                if not self.running or self.stop_event.is_set():
                    logger.info("收到停止信号，取消重启")
                    return False
                time.sleep(0.5)

            try:
                # 清理旧的FFmpeg进程
                self.stop_ffmpeg()
                time.sleep(1.0)  # 等待资源释放

                # 检查是否应该停止
                if self.stop_event.is_set() or not self.running:
                    logger.info("收到停止信号，取消启动新进程")
                    return False

                # 启动新的FFmpeg进程
                success = self.start_ffmpeg()

                if success:
                    # 重置状态
                    self.pipe_broken = False
                    self.consecutive_failures = 0
                    self.process_is_healthy = True
                    self.last_successful_write = time.time()
                    self.last_output_time = time.time()
                    self.silent_start_time = None

                    logger.info(f"FFmpeg重启成功 (第{self.restart_count}次)")

                    # 成功重启后，适当减少重启计数
                    if self.restart_count > 1:
                        self.restart_count = max(0, self.restart_count - 1)

                return success
            except Exception as e:
                logger.error(f"重启失败: {str(e)}")
                return False

    def check_process_status(self):
        """检查进程状态（简化版本）"""
        if not self.process:
            return False

        try:
            # 简单检查进程是否在运行
            return self.process.poll() is None
        except:
            return False

    def light_heartbeat(self):
        """轻度心跳检测（减少开销）"""
        # 每10秒检查一次
        current_time = time.time()
        if hasattr(self, '_last_light_check'):
            if current_time - self._last_light_check < 10:
                return

        self._last_light_check = current_time

        # 检查停止信号
        if self.stop_event.is_set() or not self.running:
            logger.debug("心跳检测：收到停止信号")
            return

        # 简单检查进程是否存在
        if not self.check_process_status():
            logger.debug("心跳检测：进程不存在")
            if not self.attempt_recovery():
                logger.error("心跳检测恢复失败")

    def start_ffmpeg(self):
        """安全启动FFmpeg进程（优化版本）"""
        if self.process_starting.is_set():
            logger.debug("FFmpeg已在启动中，跳过重复启动")
            return False

        self.process_starting.set()
        success = False

        try:
            with self.process_lock:
                # 确保关闭现有进程
                if self.process:
                    self.stop_ffmpeg()
                    time.sleep(0.5)  # 等待清理完成

                logger.info(f"启动FFmpeg推流进程 | 目标地址: {self.config['url']}")

                # 构建FFmpeg命令
                command = self.build_ffmpeg_command()

                # 启动新进程（使用更简单的参数）
                creationflags = 0
                if is_windows():
                    # Windows上使用CREATE_NO_WINDOW避免弹出窗口
                    creationflags = subprocess.CREATE_NO_WINDOW

                self.process = subprocess.Popen(
                    command,
                    stdin=subprocess.PIPE,
                    stdout=subprocess.DEVNULL,
                    stderr=subprocess.PIPE,
                    bufsize=0,
                    creationflags=creationflags
                )

                # 重置状态
                self.restart_count = 0
                self.pipe_broken = False
                self.consecutive_failures = 0
                self.process_is_healthy = True
                self.last_successful_write = time.time()
                self.last_output_time = time.time()
                self.silent_start_time = None

                logger.info(f"FFmpeg启动成功 PID: {self.process.pid}")

                # 等待进程稳定（更长的等待时间）
                time.sleep(1.0)

                # 检查进程是否仍在运行
                if not self.check_process_status():
                    logger.error("FFmpeg启动后立即退出")
                    # 尝试读取错误输出
                    try:
                        err_output = self.process.stderr.read(1024)
                        if err_output:
                            logger.error(f"FFmpeg错误输出: {err_output.decode('utf-8', errors='ignore')}")
                    except:
                        pass
                    self.process = None
                    return False

                success = True

        except Exception as e:
            logger.error(f"启动FFmpeg失败: {str(e)}", exc_info=True)
            self.process = None
        finally:
            self.process_starting.clear()
            return success

    def build_ffmpeg_command(self):
        """构建优化的FFmpeg命令"""
        w, h = self.scaled_width, self.scaled_height

        # 基础命令
        command = [
            'ffmpeg',
            '-y', '-an',  # 覆盖输出文件，禁用音频
            '-loglevel', 'warning',  # 减少日志输出
            '-f', 'rawvideo',
            '-vcodec', 'rawvideo',
            '-pix_fmt', self.config.get('pixel_format', 'bgr24'),
            '-s', f'{w}x{h}',
            '-r', str(self.fps),
            '-i', '-',  # 从标准输入读取
            '-c:v', self.config['video_codec'],
            '-preset', self.config['preset'],
            '-g', str(int(self.fps * 2)),  # 关键帧间隔调整为2秒
            '-crf', str(self.config.get('crf', 23)),
            '-b:v', self.config.get('bitrate', '2000k'),
            '-maxrate', self.config.get('bitrate', '2000k'),  # 最大码率
            '-minrate', '500k',  # 最小码率
            '-bufsize', self.config.get('bufsize', '2000k'),  # 增加缓冲区
            '-threads', '2',  # 限制线程数，避免过多线程竞争
            '-f', self.config['format'],
            '-fflags', 'nobuffer',
            '-flags', 'low_delay',  # 低延迟标志
            '-strict', 'experimental',
            '-movflags', '+faststart',
            '-tune', 'zerolatency',  # 零延迟调优
            '-rtbufsize', '100M',  # 实时缓冲区大小
            # 添加网络相关参数
            '-timeout', '30000000',  # 网络超时30秒
            '-reconnect', '1',  # 启用自动重连
            '-reconnect_streamed', '1',
            '-reconnect_delay_max', '5',  # 最大重连延迟5秒
            '-rw_timeout', '5000000',  # 读写超时5秒
            self.config['url']
        ]

        # 启用硬件加速
        if self.config.get('gpu_acceleration', False) and torch.cuda.is_available():
            # 使用更稳定的硬件编码参数
            command[1:1] = [
                '-hwaccel', 'cuda',
                '-hwaccel_output_format', 'cuda',
                '-extra_hw_frames', '4'  # 减少硬件帧缓冲
            ]
            logger.info("启用CUDA硬件加速")

            # 如果是NVIDIA硬件编码，添加特定参数
            if 'nvenc' in self.config['video_codec']:
                # 移除原有的video_codec参数，重新添加
                idx = command.index('-c:v')
                command[idx + 1] = 'h264_nvenc'

                # 添加NVIDIA编码器特定参数
                nvenc_params = [
                    '-rc', 'vbr',  # 变码率
                    '-cq', '23',  # 恒定质量
                    '-b:v', '2M',
                    '-maxrate', '3M',
                    '-profile:v', 'main',
                    '-level', '4.1',
                    '-rc-lookahead', '0',  # 减少延迟
                    '-surfaces', '4',  # 减少表面数
                    '-g', str(int(self.fps * 2)),
                    '-bf', '0',  # 禁用B帧
                    '-refs', '1',  # 减少参考帧
                ]

                # 在-c:v参数后插入这些参数
                insert_idx = command.index('h264_nvenc') + 1
                for param in reversed(nvenc_params):
                    command.insert(insert_idx, param)

        logger.debug(f"FFmpeg命令: {' '.join(command[:20])}...")  # 只打印前20个参数
        return command

    def write_frame(self, frame_data):
        """安全写入帧数据（优化版本，减少误判）"""
        if not self.process:
            return False

        # 检查进程状态
        if not self.check_process_status():
            logger.debug("进程已退出，跳过写入")
            return False

        # 如果管道已经破裂，直接返回失败
        if self.pipe_broken:
            logger.debug("管道已破裂，跳过写入")
            return False

        try:
            with self.process_lock:
                if not self.process or not self.process.stdin:
                    return False

                # 尝试写入
                self.process.stdin.write(frame_data)

                # 注意：在Windows上，频繁flush可能导致性能问题
                # 可以改为每N帧flush一次，但这里保持简单
                try:
                    self.process.stdin.flush()
                except:
                    # flush失败不一定意味着写入失败
                    pass

                return True

        except BrokenPipeError:
            logger.warning("管道破裂")
            self.pipe_broken = True
            return False

        except OSError as e:
            # Windows特定错误
            import errno
            if is_windows():
                if hasattr(e, 'winerror'):
                    if e.winerror == 232 or e.winerror == 109:
                        logger.warning("管道已关闭")
                        self.pipe_broken = True
                        return False
            else:
                # Unix错误
                if hasattr(e, 'errno') and e.errno == errno.EPIPE:
                    logger.warning("管道破裂")
                    self.pipe_broken = True
                    return False

            logger.debug(f"写入错误: {str(e)}")
            return False

        except Exception as e:
            logger.debug(f"写入异常: {str(e)}")
            return False

    def stop_ffmpeg(self):
        """安全停止FFmpeg（改进清理逻辑）"""
        with self.process_lock:
            if not self.process:
                return

            pid = self.process.pid
            logger.info(f"停止FFmpeg进程 PID: {pid}...")

            # 第1层: 关闭输入流
            if self.process.stdin:
                try:
                    self.process.stdin.close()
                except:
                    pass

            # 第2层: 发送终止信号
            try:
                self.process.terminate()
            except:
                pass

            # 等待程序优雅退出
            try:
                self.process.wait(timeout=1.0)
            except subprocess.TimeoutExpired:
                # 第3层: 强制终止
                try:
                    logger.warning(f"强制终止FFmpeg进程 PID: {pid}")
                    self.process.kill()
                    self.process.wait(timeout=0.5)
                except:
                    pass
            except:
                pass

            # 确保进程已终止
            if self.process.poll() is None:
                logger.warning(f"FFmpeg进程 PID: {pid} 未能正常终止")

            self.process = None
            logger.info(f"FFmpeg进程 PID: {pid} 已停止")

    def process_frame(self, frame):
        """高效帧处理（减少内存分配）"""
        # 如果需要缩放
        if (self.scaled_width, self.scaled_height) != (self.original_width, self.original_height):
            # 使用更高效的缩放算法
            frame = cv2.resize(frame, (self.scaled_width, self.scaled_height),
                               interpolation=cv2.INTER_LANCZOS4)

        # 确保格式正确
        if frame.dtype != np.uint8:
            frame = frame.astype(np.uint8)

        if len(frame.shape) == 3 and frame.shape[2] == 4:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR)
        elif len(frame.shape) == 2:
            frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)

        return frame.tobytes()

    def add_frame(self, frame):
        """智能帧添加策略（优化版本）"""
        # 如果进程不健康，先尝试恢复
        if not self.process_is_healthy and self.consecutive_failures >= 3:
            logger.debug("进程不健康，跳过帧添加")
            self.total_frames_dropped += 1
            return False

        try:
            # 直接尝试添加，超时时间很短
            self.queue.put(frame, timeout=0.01)
            return True
        except queue.Full:
            # 队列满时，丢弃最旧的几帧
            for _ in range(min(3, self.queue.qsize() // 3)):
                try:
                    self.queue.get_nowait()
                except queue.Empty:
                    break

            # 再次尝试
            try:
                self.queue.put_nowait(frame)
                self.total_frames_dropped += 1  # 丢弃了旧帧，所以记录
                return True
            except queue.Full:
                self.total_frames_dropped += 1
                return False
        except Exception as e:
            logger.debug(f"帧处理错误: {str(e)}")
            self.total_frames_dropped += 1
            return False

    def log_statistics(self):
        """输出性能统计"""
        elapsed = time.time() - self.start_time
        sent = self.total_frames_sent
        dropped = self.total_frames_dropped
        total = sent + dropped

        if total > 0:
            fps = sent / elapsed
            drop_rate = (dropped / total) * 100

            logger.info(
                "推流统计结果:\n"
                f"  持续时间: {elapsed:.1f}秒\n"
                f"  总帧数: {total}\n"
                f"  成功发送: {sent}\n"
                f"  丢弃帧数: {dropped}\n"
                f"  丢帧率: {drop_rate:.1f}%\n"
                f"  平均FPS: {fps:.1f}\n"
                f"  重启次数: {self.restart_count}"
            )

    def stop(self):
        """优雅停止整个线程（改进停止逻辑）"""
        if not self.running:
            return

        logger.info("停止推流线程...")
        self.running = False

        # 设置停止事件
        self.stop_event.set()

        # 尝试多种方式停止

        # 1. 发送停止信号到队列
        try:
            self.queue.put(None, block=False, timeout=0.5)
            logger.debug("已发送None信号到队列")
        except:
            pass

        # 2. 如果队列满，清空队列并重新发送
        try:
            if self.queue.full():
                logger.debug("队列已满，清空队列...")
                while not self.queue.empty():
                    try:
                        self.queue.get_nowait()
                    except queue.Empty:
                        break
                # 重新发送停止信号
                self.queue.put(None, block=False)
        except:
            pass

        # 3. 停止监控线程
        self.stop_monitor_thread()

        # 4. 清理FFmpeg进程
        self.stop_ffmpeg()

        # 5. 强制唤醒线程（如果阻塞在queue.get）
        for _ in range(3):  # 多次尝试
            try:
                self.queue.put(None, block=False)
            except:
                break
            time.sleep(0.1)

        # 6. 等待线程结束
        if self.is_alive() and threading.current_thread() != self:
            wait_time = 5.0  # 增加等待时间
            start_wait = time.time()
            while self.is_alive() and (time.time() - start_wait) < wait_time:
                # 每0.5秒检查一次
                self.join(0.5)
                if not self.is_alive():
                    break

                # 如果线程还在运行，尝试强制中断
                logger.debug(f"线程仍在运行，等待时间: {time.time() - start_wait:.1f}s")

                # 尝试更多方法唤醒
                try:
                    self.queue.put(None, block=False)
                except:
                    pass

            if self.is_alive():
                logger.warning(f"推流线程在{wait_time}秒后仍未能完全停止")
                # 尝试最后的清理
                try:
                    self.stop_ffmpeg()  # 再次确保FFmpeg已停止
                    self.stop_monitor_thread()  # 再次停止监控线程
                except:
                    pass
            else:
                logger.info("推流线程已完全停止")

        logger.info("推流线程停止流程完成")