BodyBalanceEvaluation/backend/devices/screen_recorder.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
综合录制管理器
支持屏幕录制和足部视频录制
"""

import cv2
import numpy as np
import pyautogui
import threading
import time
from datetime import datetime
import os
import logging
import json
import base64
from pathlib import Path
from typing import Optional, Dict, Any, List
import sys
# 移除psutil导入，不再需要性能监控
import gc

try:
    from .camera_manager import CameraManager
    from .femtobolt_manager import FemtoBoltManager
    from .pressure_manager import PressureManager
    from .utils.config_manager import ConfigManager
except ImportError:
    from camera_manager import CameraManager
    from femtobolt_manager import FemtoBoltManager
    from pressure_manager import PressureManager
    from utils.config_manager import ConfigManager

class RecordingManager:
    def __init__(self, camera_manager: Optional[CameraManager] = None, db_manager=None, 
                 femtobolt_manager: Optional[FemtoBoltManager] = None, 
                 pressure_manager: Optional[PressureManager] = None,
                 config_manager: Optional[ConfigManager] = None):
        """
        初始化录制管理器
        
        Args:
            camera_manager: 相机管理器实例
            db_manager: 数据库管理器实例
            femtobolt_manager: FemtoBolt深度相机管理器实例
            pressure_manager: 压力传感器管理器实例
            config_manager: 配置管理器实例
        """
        self.camera_manager = camera_manager
        self.db_manager = db_manager
        self.femtobolt_manager = femtobolt_manager
        self.pressure_manager = pressure_manager
        
        # 配置管理
        self.config_manager = config_manager or ConfigManager()
        
        # 录制状态
        self.sync_recording = False
        self.is_recording = False
        self.recording_stop_event = threading.Event()
        
        # 会话信息
        self.current_session_id = None
        self.current_patient_id = None      
        self.recording_start_time = None
        
        # 视频写入器
        self.feet_video_writer = None
        self.screen_video_writer = None
        self.femtobolt_video_writer = None
        
        # 录制线程
        self.feet_recording_thread = None
        self.screen_recording_thread = None
        self.femtobolt_recording_thread = None

        # 独立的录制参数配置
        self.screen_fps = 25  # 屏幕录制帧率
        self.camera_fps = 20  # 相机录制帧率
        self.femtobolt_fps = 15  # FemtoBolt录制帧率
        
        # 录制区域
        self.screen_region = None
        self.camera_region = None
        self.femtobolt_region = None
        
        # 屏幕尺寸
        self.screen_size = pyautogui.size()
        
        # 输出目录
        self.screen_output_dir = None
        self.camera_output_dir = None
        self.femtobolt_output_dir = None
        
        # 视频参数
        self.MAX_FRAME_SIZE = (1280, 720)  # 最大帧尺寸
        
        # 独立的帧率控制参数
        self.screen_current_fps = self.screen_fps
        self.camera_current_fps = self.camera_fps
        self.femtobolt_current_fps = self.femtobolt_fps
        
        # 区域大小阈值配置 - 根据实际录制场景优化
        self.SMALL_REGION_THRESHOLD = 400 * 300  # 小区域阈值 (120,000像素)
        self.MEDIUM_REGION_THRESHOLD = 800 * 600  # 中等区域阈值 (480,000像素)
        self.LARGE_REGION_THRESHOLD = 1600 * 900  # 大区域阈值 (1,440,000像素)
        
        # 基于区域大小的帧率配置 - 大幅降低帧率以减小文件大小
        self.fps_config = {
            'small': {'screen': 12, 'camera': 25, 'femtobolt': 20},    # 小区域：低帧率
            'medium': {'screen': 10, 'camera': 22, 'femtobolt': 18},   # 中等区域：更低帧率
            'large': {'screen': 8, 'camera': 18, 'femtobolt': 15},     # 大区域：很低帧率
            'xlarge': {'screen': 6, 'camera': 15, 'femtobolt': 12}     # 超大区域：极低帧率
        }
        
        # 移除CPU监控和性能优化参数，使用固定帧率控制
        
        # 录制同步控制
        self.recording_sync_barrier = None  # 同步屏障
        self.recording_threads = {}  # 录制线程字典
        self.recording_start_sync = threading.Event()  # 录制开始同步事件
        self.global_recording_start_time = None  # 全局录制开始时间
        
        # 日志
        self.logger = logging.getLogger(__name__)
        
        self.logger.info("录制管理器初始化完成")
    
    # 移除系统性能检查方法
    
    def _calculate_region_size_category(self, region):
        """
        根据录制区域大小计算区域类别
        
        Args:
            region: 录制区域 (x, y, width, height)
            
        Returns:
            str: 区域大小类别 ('small', 'medium', 'large', 'xlarge')
        """
        if not region or len(region) != 4:
            return 'medium'  # 默认中等大小
        
        _, _, width, height = region
        area = width * height
        
        if area <= self.SMALL_REGION_THRESHOLD:
            return 'small'
        elif area <= self.MEDIUM_REGION_THRESHOLD:
            return 'medium'
        elif area <= self.LARGE_REGION_THRESHOLD:
            return 'large'
        else:
            return 'xlarge'
    
    def _set_adaptive_fps_by_region(self, recording_type, region):
        """
        根据录制区域大小设置自适应帧率
        
        Args:
            recording_type: 录制类型 ('screen', 'camera', 'femtobolt')
            region: 录制区域 (x, y, width, height)
        """
        size_category = self._calculate_region_size_category(region)
        target_fps = self.fps_config[size_category][recording_type]
        
        # 计算区域面积用于日志
        _, _, width, height = region
        area = width * height
        
        if recording_type == 'screen':
            self.screen_current_fps = target_fps
        elif recording_type == 'camera':
            self.camera_current_fps = target_fps
        elif recording_type == 'femtobolt':
            self.femtobolt_current_fps = target_fps
        
        self.logger.info(f"{recording_type}录制区域解包成功: x={region[0]}, y={region[1]}, w={width}, h={height}")
        self.logger.info(f"{recording_type}录制区域分析: 面积={area:,}像素, 类别={size_category}, 优化帧率={target_fps}fps")
        
        # 如果是大区域，提示将启用性能优化
        if size_category in ['large', 'xlarge']:
            self.logger.info(f"{recording_type}大区域检测: 将启用降采样和压缩优化以提升性能")
    
    # 移除动态性能调整方法，使用固定帧率控制
    
    def _optimize_frame_for_large_region(self, frame, region, recording_type):
        """
        为大区域录制优化帧数据
        
        Args:
            frame: 原始帧数据
            region: 录制区域
            recording_type: 录制类型
            
        Returns:
            优化后的帧数据
        """
        if frame is None:
            return None
        
        size_category = self._calculate_region_size_category(region)
        
        # 对所有区域进行优化处理以减小文件大小
        _, _, width, height = region
       
        # 根据区域大小进行不同程度的降采样
        if size_category == 'xlarge':  #screen录屏·超大区域
            # 超大区域：降采样到50%，极大减小文件大小            
            new_width = int(width * 1)
            new_height = int(height * 1)
            quality = 95  # 较高质量压缩
        elif size_category == 'large':
            # 大区域：降采样到60%，显著优化文件大小
            new_width = int(width * 1)
            new_height = int(height * 1)
            quality = 95  # 较高质量压缩
        elif size_category == 'medium': #足部视频录屏·中等区域
            # 中等区域：降采样到75%，适度优化            
            new_width = int(width * 1)
            new_height = int(height * 1)
            quality = 100  # 较高质量压缩
        else:  # small
            # 小区域：降采样到85%，轻度优化
            new_width = int(width * 1)
            new_height = int(height * 1)
            quality = 100  # 较高质量压缩
        
        # 应用降采样
        frame = cv2.resize(frame, (new_width, new_height), interpolation=cv2.INTER_AREA)
        self.logger.debug(f"{recording_type}区域降采样({size_category}): {width}x{height} -> {new_width}x{new_height}")
        
        # 应用激进的JPEG压缩以进一步减小文件大小
        encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
        _, encoded_frame = cv2.imencode('.jpg', frame, encode_param)
        frame = cv2.imdecode(encoded_frame, cv2.IMREAD_COLOR)
        
        # 重要：将帧尺寸调整回VideoWriter期望的原始尺寸
        # 这样可以保持压缩优化的同时确保与VideoWriter兼容
        frame = cv2.resize(frame, (width, height), interpolation=cv2.INTER_LINEAR)
        
        return frame
    
    def start_recording(self, session_id: str, patient_id: str, screen_location: List[int], camera_location: List[int], femtobolt_location: List[int], recording_types: List[str] = None) -> Dict[str, Any]:
        """
        启动同步录制
        
        Args:
            session_id: 检测会话ID
            patient_id: 患者ID
            screen_location: 屏幕录制区域 [x, y, w, h]
            camera_location: 相机录制区域 [x, y, w, h]
            femtobolt_location: FemtoBolt录制区域 [x, y, w, h]
            recording_types: 录制类型列表 ['screen', 'feet', 'femtobolt']，默认全部录制
            
        Returns:
            Dict: 录制启动状态和信息
        """
        result = {
            'success': False,
            'session_id': session_id,
            'patient_id': patient_id,
            'recording_start_time': None,
            'video_paths': {
                'feet_video': None,
                'screen_video': None,
                'femtobolt_video': None
            },
            'message': ''
        }
        
        try:
            # 检查是否已在录制
            if self.sync_recording:
                result['message'] = f'已在录制中，当前会话ID: {self.current_session_id}'
                return result
            
            # 设置默认录制类型
            recording_types = ['screen', 'feet']           
            
            # 验证录制区域参数（仅对启用的录制类型进行验证）
            if 'screen' in recording_types:
                if not screen_location or not isinstance(screen_location, list) or len(screen_location) != 4:
                    result['success'] = False
                    result['message'] = '屏幕录制区域参数无效或缺失，必须是包含4个元素的数组[x, y, w, h]'
                    return result
            
            if 'feet' in recording_types:
                if not camera_location or not isinstance(camera_location, list) or len(camera_location) != 4:
                    result['success'] = False
                    result['message'] = '相机录制区域参数无效或缺失，必须是包含4个元素的数组[x, y, w, h]'
                    return result
            
            if 'femtobolt' in recording_types:
                if not femtobolt_location or not isinstance(femtobolt_location, list) or len(femtobolt_location) != 4:
                    result['success'] = False
                    result['message'] = 'FemtoBolt录制区域参数无效或缺失，必须是包含4个元素的数组[x, y, w, h]'
                    return result
            
            # 设置录制参数
            self.current_session_id = session_id
            # self.logger.info(f'检测sessionID................: {self.current_session_id}')
            self.current_patient_id = patient_id
            self.screen_region = tuple(screen_location)  # [x, y, w, h] -> (x, y, w, h)
            self.camera_region = tuple(camera_location)  # [x, y, w, h] -> (x, y, w, h)
            self.femtobolt_region = tuple(femtobolt_location)  # [x, y, w, h] -> (x, y, w, h)
            
            # 根据录制区域大小设置自适应帧率
            if 'screen' in recording_types:
                self._set_adaptive_fps_by_region('screen', self.screen_region)
            if 'feet' in recording_types:
                self._set_adaptive_fps_by_region('camera', self.camera_region)
            if 'femtobolt' in recording_types:
                self._set_adaptive_fps_by_region('femtobolt', self.femtobolt_region)
            
            # 设置录制同步
            active_recording_count = len([t for t in recording_types if t in ['screen', 'feet', 'femtobolt']])
            self.recording_sync_barrier = threading.Barrier(active_recording_count)
            self.recording_start_sync.clear()
            self.global_recording_start_time = None
            
            self.recording_start_time = datetime.now()
            
            # 创建主存储目录
            timestamp = datetime.now().strftime('%H%M%S%f')[:-3]  # 精确到毫秒   
            file_dir = self.config_manager.get_config_value('FILEPATH', 'path')
            base_path = os.path.join(file_dir, patient_id, session_id,f'video_{timestamp}')   
            db_base_path = os.path.join(patient_id, session_id,f'video_{timestamp}')
            
            try:
                # 设置目录权限
                self._set_directory_permissions(base_path)
                os.makedirs(base_path, exist_ok=True)
                
            except Exception as dir_error:
                self.logger.error(f'创建录制目录失败: {base_path}, 错误: {dir_error}')
                result['success'] = False
                result['message'] = f'创建录制目录失败: {dir_error}'
                return result
            
             
            feet_video_path = os.path.join(base_path, 'feet.mp4')
            screen_video_path = os.path.join(base_path,  'screen.mp4')
            femtobolt_video_path = os.path.join(base_path,  'femtobolt.mp4')           
           

            # 准备数据库更新信息，返回给调用方统一处理
            result['database_updates'] = {
                'session_id': session_id,
                'status': 'recording',
                'video_paths': {
                    'normal_video_path': os.path.join(db_base_path, 'feet.mp4'),
                    'screen_video_path': os.path.join(db_base_path,  'screen.mp4'),
                    'femtobolt_video_path': os.path.join(db_base_path,  'femtobolt.mp4')
                }
            }
            self.logger.debug(f'数据库更新信息已准备 - 会话ID: {session_id}')
            
            # 视频编码参数 - 使用浏览器兼容的H.264编解码器
            # 优先使用H.264编码器以确保浏览器兼容性
            try:
                fourcc = cv2.VideoWriter_fourcc(*'avc1')  # H.264编码器，浏览器兼容性最好
            except:
                try:
                    fourcc = cv2.VideoWriter_fourcc(*'H264')  # 备选H.264编码器
                except:
                    try:
                        fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # 备选编解码器
                    except:
                        fourcc = cv2.VideoWriter_fourcc(*'MJPG')  # 最后备选
            
            # 根据录制类型选择性地初始化视频写入器，使用各自的自适应帧率
            self.screen_video_writer = None
            self.femtobolt_video_writer = None
            self.feet_video_writer = None
            
            if 'screen' in recording_types:
                self.screen_video_writer = cv2.VideoWriter(
                    screen_video_path, fourcc, self.screen_current_fps, (self.screen_region[2], self.screen_region[3])
                )
                self.logger.info(f'屏幕视频写入器使用帧率: {self.screen_current_fps}fps')
            
            if 'femtobolt' in recording_types:
                self.femtobolt_video_writer = cv2.VideoWriter(
                    femtobolt_video_path, fourcc, self.femtobolt_current_fps, (self.femtobolt_region[2], self.femtobolt_region[3])
                )
                self.logger.info(f'FemtoBolt视频写入器使用帧率: {self.femtobolt_current_fps}fps')
            
            if 'feet' in recording_types:
                self.feet_video_writer = cv2.VideoWriter(
                    feet_video_path, fourcc, self.camera_current_fps, (self.camera_region[2], self.camera_region[3])
                )
                self.logger.info(f'足部视频写入器使用帧率: {self.camera_current_fps}fps')        
            
            # 检查视频写入器状态（仅检查启用的录制类型）
            # 检查足部视频写入器
            if 'feet' in recording_types:
                if self.feet_video_writer and self.feet_video_writer.isOpened():
                    self.logger.info(f'足部视频写入器初始化成功: {feet_video_path}')
                else:
                    self.logger.error(f'足部视频写入器初始化失败: {feet_video_path}')
            else:
                self.logger.info('足部录制功能已禁用')
            
            # 检查屏幕视频写入器
            if 'screen' in recording_types:
                if self.screen_video_writer and self.screen_video_writer.isOpened():
                    self.logger.info(f'屏幕视频写入器初始化成功: {screen_video_path}')
                else:
                    self.logger.error(f'屏幕视频写入器初始化失败: {screen_video_path}')
            else:
                self.logger.info('屏幕录制功能已禁用')
            
            # 检查FemtoBolt视频写入器
            if 'femtobolt' in recording_types:
                if self.femtobolt_video_writer and self.femtobolt_video_writer.isOpened():
                    self.logger.info(f'FemtoBolt视频写入器初始化成功: {femtobolt_video_path}')
                else:
                    self.logger.error(f'FemtoBolt视频写入器初始化失败: {femtobolt_video_path}')
            else:
                self.logger.info('FemtoBolt录制功能已禁用')
            
            # 重置停止事件
            self.recording_stop_event.clear()
            self.sync_recording = True
            
            # 根据录制类型启动对应的录制线程
            if 'feet' in recording_types and self.feet_video_writer and self.feet_video_writer.isOpened():
                self.feet_recording_thread = threading.Thread(
                    target=self._generic_recording_thread,
                    args=('camera', self.camera_region, feet_video_path, self.feet_video_writer),
                    daemon=True,
                    name='FeetRecordingThread'
                )
                self.feet_recording_thread.start()
                # self.logger.info(f'足部录制线程已启动 - 区域: {self.camera_region}, 输出文件: {feet_video_path}')
            
            if 'screen' in recording_types and self.screen_video_writer and self.screen_video_writer.isOpened():
                self.screen_recording_thread = threading.Thread(
                    target=self._generic_recording_thread,
                    args=('screen', self.screen_region, screen_video_path, self.screen_video_writer),
                    daemon=True,
                    name='ScreenRecordingThread'
                )
                self.screen_recording_thread.start()
                # self.logger.info(f'屏幕录制线程已启动 - 区域: {self.screen_region}, 输出文件: {screen_video_path}')
            
            if 'femtobolt' in recording_types and self.femtobolt_video_writer and self.femtobolt_video_writer.isOpened():
                self.femtobolt_recording_thread = threading.Thread(
                    target=self._generic_recording_thread,
                    args=('femtobolt', self.femtobolt_region, femtobolt_video_path, self.femtobolt_video_writer),
                    daemon=True,
                    name='FemtoBoltRecordingThread'
                )
                self.femtobolt_recording_thread.start()
                # self.logger.info(f'FemtoBolt录制线程已启动 - 区域: {self.femtobolt_region}, 输出文件: {femtobolt_video_path}')
            
            result['success'] = True
            result['recording_start_time'] = self.recording_start_time.isoformat()
            result['message'] = '同步录制已启动'
            
            self.logger.info(f'同步录制已启动 - 会话ID: {session_id}, 患者ID: {patient_id}')
            
        except Exception as e:
            self.logger.error(f'启动同步录制失败: {e}')
            result['message'] = f'启动录制失败: {str(e)}'
            # 清理已创建的写入器
            self._cleanup_video_writers()
        
        return result
    
    def stop_recording(self, session_id: str = None) -> Dict[str, Any]:
        """
        停止录制
        
        Args:
            session_id: 会话ID，用于验证是否为当前录制会话
        
        Returns:
            Dict: 停止录制的结果
        """
        result = {
            'success': False,
            'session_id': self.current_session_id,
            'message': ''
        }
        
        try:
            # 验证会话ID
            if session_id and session_id != self.current_session_id:
                result['message'] = f'会话ID不匹配: 期望 {self.current_session_id}, 收到 {session_id}'
                return result
                
            if not self.sync_recording:
                result['message'] = '当前没有进行录制'
                return result
            
            # 记录停止时间，确保所有录制线程同时结束
            recording_stop_time = time.time()
            self.logger.info(f'开始停止录制，停止时间: {recording_stop_time}')
            
            # 设置停止标志
            self.sync_recording = False
            self.recording_stop_event.set()
            
            # 收集活跃的录制线程
            active_threads = []
            if hasattr(self, 'feet_recording_thread') and self.feet_recording_thread and self.feet_recording_thread.is_alive():
                active_threads.append(('feet', self.feet_recording_thread))
            if hasattr(self, 'screen_recording_thread') and self.screen_recording_thread and self.screen_recording_thread.is_alive():
                active_threads.append(('screen', self.screen_recording_thread))
            if hasattr(self, 'femtobolt_recording_thread') and self.femtobolt_recording_thread and self.femtobolt_recording_thread.is_alive():
                active_threads.append(('femtobolt', self.femtobolt_recording_thread))
            
            # 同时等待所有录制线程结束
            self.logger.info(f'等待 {len(active_threads)} 个录制线程结束')
            for thread_name, thread in active_threads:
                thread.join(timeout=5.0)
                if thread.is_alive():
                    self.logger.warning(f'{thread_name}录制线程未能在超时时间内结束')
                else:
                    self.logger.info(f'{thread_name}录制线程已结束')
            
            # 计算实际录制时长并记录详细信息
            if self.global_recording_start_time:
                actual_recording_duration = recording_stop_time - self.global_recording_start_time
                self.logger.info(f'录制时长统计:')
                self.logger.info(f'  全局开始时间: {self.global_recording_start_time}')
                self.logger.info(f'  全局结束时间: {recording_stop_time}')
                self.logger.info(f'  实际录制时长: {actual_recording_duration:.3f}秒')
                
                # 记录各录制类型的预期帧数
                for thread_name, thread in active_threads:
                    if thread_name == 'screen':
                        expected_frames = int(actual_recording_duration * self.screen_current_fps)
                        self.logger.info(f'  屏幕录制预期帧数: {expected_frames}帧 (帧率{self.screen_current_fps}fps)')
                    elif thread_name == 'feet':
                        expected_frames = int(actual_recording_duration * self.camera_current_fps)
                        self.logger.info(f'  足部录制预期帧数: {expected_frames}帧 (帧率{self.camera_current_fps}fps)')
                    elif thread_name == 'femtobolt':
                        expected_frames = int(actual_recording_duration * self.femtobolt_current_fps)
                        self.logger.info(f'  FemtoBolt录制预期帧数: {expected_frames}帧 (帧率{self.femtobolt_current_fps}fps)')
            
            # 清理视频写入器
            self._cleanup_video_writers()
            
            # 准备数据库更新信息，返回给调用方统一处理
            if self.current_session_id:
                result['database_updates'] = {
                    'session_id': self.current_session_id,
                    'status': 'recorded'
                }
                self.logger.info(f'数据库更新信息已准备 - 会话ID: {self.current_session_id}')
            
            result['success'] = True
            result['message'] = '录制已停止'
            
            self.logger.info(f'录制已停止 - 会话ID: {self.current_session_id}')
            
            # 重置会话信息
            self.current_session_id = None
            self.current_patient_id = None
            self.recording_start_time = None
            
        except Exception as e:
            self.logger.error(f'停止录制失败: {e}')
            result['message'] = f'停止录制失败: {str(e)}'
        
        return result
    
        
    def _generic_recording_thread(self, recording_type, region, output_file_name, video_writer):
        """
        通用录制线程，支持屏幕、相机和FemtoBolt录制
        
        Args:
            recording_type: 录制类型 ('screen', 'camera', 'femtobolt')
            region: 录制区域 (x, y, width, height)
            output_file_name: 输出文件名
            video_writer: 视频写入器对象
        """
        try:
            self.logger.info(f'{recording_type}录制线程启动 - 区域: {region}, 输出文件: {output_file_name}')
            frame_count = 0            
            
            # 根据录制类型获取对应的自适应帧率
            if recording_type == 'screen':
                target_fps = self.screen_current_fps
            elif recording_type == 'camera':
                target_fps = self.camera_current_fps
            elif recording_type == 'femtobolt':
                target_fps = self.femtobolt_current_fps
            else:
                target_fps = 25  # 默认帧率
            
            frame_interval = 1.0 / target_fps
            last_frame_time = time.time()
            
            self.logger.info(f'{recording_type}录制线程使用帧率: {target_fps}fps')
            
            # 等待所有录制线程准备就绪
            if self.recording_sync_barrier:
                self.recording_sync_barrier.wait()
            
            # 第一个到达的线程设置全局开始时间
            if self.global_recording_start_time is None:
                self.global_recording_start_time = time.time()
                self.recording_start_sync.set()
            else:
                self.recording_start_sync.wait()
            
            # 所有线程从相同时间点开始录制
            recording_start_time = self.global_recording_start_time
            
            if not video_writer or not video_writer.isOpened():
                self.logger.error(f'{recording_type}视频写入器初始化失败: {output_file_name}')
                return
            
            # 验证并解包region参数
            if not region or len(region) != 4:
                self.logger.error(f'{recording_type}录制区域参数无效: {region}')
                return
            
            x, y, w, h = region
            self.logger.info(f'{recording_type}录制区域解包成功: x={x}, y={y}, w={w}, h={h}')
            
            while self.sync_recording and not self.recording_stop_event.is_set():
                try:
                    current_time = time.time()
                    
                    # 严格的帧率控制 - 确保按照设定的fps精确录制
                    elapsed_time = current_time - last_frame_time
                    if elapsed_time < frame_interval:
                        sleep_time = frame_interval - elapsed_time
                        time.sleep(sleep_time)
                        current_time = time.time()  # 重新获取时间
                    
                    frame = None
                    
                    # 获取帧数据 - 从屏幕截图生成
                    screenshot = pyautogui.screenshot(region=(x, y, w, h))
                    frame = cv2.cvtColor(np.array(screenshot), cv2.COLOR_RGB2BGR)
                    frame = cv2.resize(frame, (w, h))
                    
                    # 对所有区域录制进行优化以减小文件大小
                    frame = self._optimize_frame_for_large_region(frame, region, recording_type)
                    
                    # 写入视频帧
                    if frame is not None:
                        video_writer.write(frame)
                        frame_count += 1                       
                    else:
                        self.logger.warning(f'{recording_type}获取帧失败，跳过此帧')
                    
                    last_frame_time = current_time
                    
                except Exception as e:
                    self.logger.error(f'{recording_type}录制线程错误: {e}')
                    time.sleep(0.1)
            
            # 计算录制统计信息
            if self.global_recording_start_time:
                total_recording_time = time.time() - self.global_recording_start_time               
                expected_frames = int(total_recording_time * target_fps)                
                if abs(frame_count - expected_frames) > target_fps * 0.1:  # 如果帧数差异超过0.1秒的帧数
                    self.logger.warning(f'{recording_type}帧数异常: 实际{frame_count}帧 vs 预期{expected_frames}帧，差异{frame_count - expected_frames}帧')
            else:
                self.logger.info(f'{recording_type}录制线程结束，总帧数: {frame_count}')
            
        except Exception as e:
            self.logger.error(f'{recording_type}录制线程异常: {e}')
        finally:
            # 清理资源
            if video_writer:
                try:
                    video_writer.release()
                    self.logger.info(f'{recording_type}视频写入器已释放')
                except Exception as e:
                    self.logger.error(f'释放{recording_type}视频写入器失败: {e}')
    
    def _cleanup_video_writers(self):
        """清理视频写入器"""
        try:
            if hasattr(self, 'feet_video_writer') and self.feet_video_writer:
                self.feet_video_writer.release()
                self.feet_video_writer = None
                self.logger.debug("足部视频写入器已清理")
            
            if hasattr(self, 'screen_video_writer') and self.screen_video_writer:
                self.screen_video_writer.release()
                self.screen_video_writer = None
                self.logger.debug("屏幕视频写入器已清理")
            
            if hasattr(self, 'femtobolt_video_writer') and self.femtobolt_video_writer:
                self.femtobolt_video_writer.release()
                self.femtobolt_video_writer = None
                self.logger.debug("FemtoBolt视频写入器已清理")
                
        except Exception as e:
            self.logger.error(f"清理视频写入器失败: {e}")
    
    def _set_directory_permissions(self, path):
        """设置目录权限"""
        try:
            import subprocess
            import platform
            
            if platform.system() == 'Windows':
                try:
                    # 为Users用户组授予完全控制权限
                    subprocess.run([
                        'icacls', path, '/grant', 'Users:(OI)(CI)F'
                    ], check=True, capture_output=True, text=True)
                    
                    # 为Everyone用户组授予完全控制权限
                    subprocess.run([
                        'icacls', path, '/grant', 'Everyone:(OI)(CI)F'
                    ], check=True, capture_output=True, text=True)
                    
                    self.logger.info(f"已设置Windows目录权限（Users和Everyone完全控制）: {path}")
                except subprocess.CalledProcessError as icacls_error:
                    self.logger.warning(f"Windows权限设置失败: {icacls_error}")
            else:
                self.logger.info(f"已设置目录权限为777: {path}")
                
        except Exception as perm_error:
            self.logger.warning(f"设置目录权限失败: {perm_error}，但目录创建成功")
    
    def set_screen_region(self, region):
        """设置屏幕录制区域"""
        if self.sync_recording:
            self.logger.warning("录制进行中，无法更改区域设置")
            return False
        
        self.screen_region = region
        
        if self.screen_region:
            x, y, width, height = self.screen_region
            # 确保区域在屏幕范围内
            x = max(0, min(x, self.screen_size[0] - 1))
            y = max(0, min(y, self.screen_size[1] - 1))
            width = min(width, self.screen_size[0] - x)
            height = min(height, self.screen_size[1] - y)
            self.screen_region = (x, y, width, height)
            self.logger.info(f"录制区域已设置: {self.screen_region}")
        else:
            self.logger.info("录制模式已设置: 全屏录制")
        
        return True
    
    def set_recording_regions(self, screen_region=None, camera_region=None, femtobolt_region=None):
        """
        设置三个录制区域
        
        Args:
            screen_region: 屏幕录制区域 (x, y, width, height)
            camera_region: 相机录制区域 (x, y, width, height)
            femtobolt_region: FemtoBolt录制区域 (x, y, width, height)
        """
        if self.sync_recording:
            self.logger.warning("录制进行中，无法更改区域设置")
            return False
        
        self.screen_region = screen_region
        self.camera_region = camera_region
        self.femtobolt_region = femtobolt_region
        
        self.logger.info(f'录制区域已设置:')
        self.logger.info(f'  屏幕区域: {screen_region}')
        self.logger.info(f'  相机区域: {camera_region}')
        self.logger.info(f'  FemtoBolt区域: {femtobolt_region}')
        
        return True
    
    def get_status(self):
        """获取录制状态"""
        return {
            'recording': self.sync_recording,
            'session_id': self.current_session_id,
            'patient_id': self.current_patient_id,
            'recording_start_time': self.recording_start_time.isoformat() if self.recording_start_time else None,
            'screen_size': self.screen_size,
            'screen_region': self.screen_region,
            'screen_fps': self.screen_fps,
            'feet_writer_active': self.feet_video_writer is not None and self.feet_video_writer.isOpened() if self.feet_video_writer else False,
            'screen_writer_active': self.screen_video_writer is not None and self.screen_video_writer.isOpened() if self.screen_video_writer else False
        }
    
    
    
    def collect_detection_data(self, session_id: str, patient_id: str, detection_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        保存前端传入的检测数据和图片
        
        Args:
            session_id: 检测会话ID
            patient_id: 患者ID
            detection_data: 前端传入的检测数据，包含base64格式的图片数据
            
        Returns:
            Dict: 包含所有采集数据的字典，符合detection_data表结构
        """
        # 生成采集时间戳
        timestamp = datetime.now().strftime('%H%M%S%f')[:-3]  # 精确到毫秒
        file_path = self.config_manager.get_config_value('FILEPATH', 'path')
        data_dir = Path(os.path.join(file_path,patient_id, session_id, f"image_{timestamp}"))
        # 创建数据存储目录
        data_dir.mkdir(parents=True, exist_ok=True)
        
        # 设置目录权限为777（完全权限）
        try:
            import stat
            os.chmod(str(data_dir), stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)  # 777权限
            self.logger.debug(f"已设置目录权限为777: {data_dir}")
        except Exception as perm_error:
            self.logger.warning(f"设置目录权限失败: {perm_error}，但目录创建成功")
        
        # 初始化数据字典
        data = {
            'session_id': session_id,
            'head_pose': detection_data.get('head_pose'),
            'body_pose': None,
            'body_image': None,
            'foot_data': detection_data.get('foot_data'),            
            'foot_data_image': None,
            'foot_image': None,
            'screen_image': None,            
            'timestamp': timestamp
        }
        
        try:
            # 保存图片数据
            image_fields = [
                ('body_image', 'body'),
                ('foot_image', 'foot'),
                ('foot_data_image', 'foot_data')               
            ]
            
            for field, prefix in image_fields:
                base64_data = detection_data.get(field)
                if base64_data:
                    try:
                        # 移除base64头部信息
                        if ';base64,' in base64_data:
                            base64_data = base64_data.split(';base64,')[1]
                        
                        # 解码base64数据
                        image_data = base64.b64decode(base64_data)
                        
                        # 生成图片文件名
                        filename = f'{prefix}_{timestamp}.jpg'
                        file_path = data_dir / filename
                        
                        # 保存图片
                        with open(file_path, 'wb') as f:
                            f.write(image_data)
                        
                        # 更新数据字典中的图片路径
                        
                        data[field] = str(os.path.join(patient_id, session_id, f"image_{timestamp}", filename))
                        self.logger.debug(f'{field}保存成功: {filename}')
                        
                    except Exception as e:
                        self.logger.error(f'保存{field}失败: {e}')
            # 屏幕截图
            screen_image = self._capture_screen_image(data_dir,timestamp)
            if screen_image:
                data['screen_image'] = str(os.path.join( patient_id, session_id, f"image_{timestamp}", screen_image))
            
            self.logger.debug(f'数据保存完成: {session_id}, 时间戳: {timestamp}')
            
        except Exception as e:
            self.logger.error(f'数据保存失败: {e}')
        
        return data
     
    
    
    def _capture_screen_image(self, data_dir,timestamp) -> Optional[str]:
        """
        采集屏幕截图，根据screen_region 进行截图
        
        Args:
            data_dir: 数据存储目录路径
          
        Returns:
            str: 截图文件的相对路径，失败返回None
        """
        try:
             # 截取屏幕
            if self.screen_region:
                # 使用指定区域截图
                x, y, width, height = self.screen_region
                screenshot = pyautogui.screenshot(region=(x, y, width, height))
            else:
                # 全屏截图
                screenshot = pyautogui.screenshot()
            
            # 保存截图
            from pathlib import Path
            screen_filename = f'screen_{timestamp}.jpg'
            image_path = Path(data_dir) / screen_filename
            screenshot.save(str(image_path), quality=95, optimize=True)           
            
            return screen_filename
            
        except Exception as e:
            self.logger.error(f'屏幕截图失败: {e}')
            return None
    
    


# 保持向后兼容的ScreenRecorder类
class ScreenRecorder:
    def __init__(self, output_dir="recordings", fps=20, quality=80, region=None):
        """向后兼容的屏幕录制器"""
        self.recording_manager = RecordingManager()
        self.recording_manager.screen_fps = fps
        self.recording_manager.set_screen_region(region)
        self.output_dir = output_dir
        
        # 创建输出目录
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)
    
    def start_recording(self, filename=None):
        """开始录制"""
        if filename is None:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"screen_record_{timestamp}"
        
        # 使用文件名作为会话ID
        session_id = filename
        patient_id = "default"
        
        return self.recording_manager.start_recording(session_id, patient_id)
    
    def stop_recording(self):
        """停止录制"""
        return self.recording_manager.stop_recording()
    
    def get_status(self):
        """获取状态"""
        return self.recording_manager.get_status()