在线教育视频如何使用HLS播放器：提升学习体验的技术指南

// HLS自适应码率配置示例
const hlsConfig = {
  startLevel: -1, // 自动选择起始质量
  capLevelToPlayerSize: true, // 限制最大分辨率
  maxBufferLength: 30, // 最大缓冲时长
  maxMaxBufferLength: 600, // 绝对最大缓冲
  lowLatencyMode: false, // 教育场景优先稳定性
  backBufferLength: 90 // 后向缓冲保持
};

#EXTM3U
#EXT-X-VERSION:6
#EXT-X-TARGETDURATION:10
#EXT-X-PLAYLIST-TYPE:VOD
 
# 课程章节标记
#EXT-X-PROGRAM-DATE-TIME:2026-01-22T10:00:00.000Z
#EXT-X-DISCONTINUITY-SEQUENCE:0
 
# 第一章节：课程介绍
#EXTINF:8.0,Chapter 1: Introduction
#EXT-X-BYTERANGE:1024000@0
chapter1_segment1.ts
 
#EXTINF:10.0,
#EXT-X-BYTERANGE:1280000@1024000
chapter1_segment2.ts
 
# 章节分界标记
#EXT-X-DISCONTINUITY
#EXT-X-PROGRAM-DATE-TIME:2026-01-22T10:05:00.000Z
 
# 第二章节：核心概念
#EXTINF:9.5,Chapter 2: Core Concepts
chapter2_segment1.ts
 
#EXT-X-ENDLIST

#EXTM3U
#EXT-X-VERSION:6
 
# 低码率版本 - 适合网络较差的学习环境
#EXT-X-STREAM-INF:BANDWIDTH=500000,RESOLUTION=640x360,CODECS="avc1.42e01e,mp4a.40.2"
low_quality_course.m3u8
 
# 标准码率版本 - 平衡质量与带宽
#EXT-X-STREAM-INF:BANDWIDTH=1500000,RESOLUTION=1280x720,CODECS="avc1.4d401f,mp4a.40.2"
standard_quality_course.m3u8
 
# 高码率版本 - 适合高质量学习需求
#EXT-X-STREAM-INF:BANDWIDTH=3000000,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2"
high_quality_course.m3u8
 
# 音频专用版本 - 支持纯音频学习模式
#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="Chinese",LANGUAGE="zh",URI="audio_only_course.m3u8"

interface EducationHLSPlayer {
  // 核心播放引擎
  engine: {
    hlsjs: HLS.js,           // Web端HLS解析
    mse: MediaSource,        // 媒体源扩展
    videoElement: HTMLVideoElement
  };
 
  // 教育功能模块
  education: {
    chapterManager: ChapterManager,     // 章节管理
    progressTracker: ProgressTracker,   // 学习进度
    noteSystem: NoteSystem,             // 笔记系统
    speedControl: SpeedController       // 倍速播放
  };
 
  // 性能监控
  analytics: {
    bufferMonitor: BufferMonitor,       // 缓冲监控
    qualityTracker: QualityTracker,     // 质量跟踪
    errorReporter: ErrorReporter        // 错误上报
  };
}

class EducationHLSPlayer {
  constructor(videoElement, config) {
    this.video = videoElement;
    this.hls = new Hls({
      // 教育场景优化配置
      debug: false,
      enableWorker: true,
      lowLatencyMode: false,
      backBufferLength: 90,
 
      // 自适应码率配置
      startLevel: -1,
      capLevelToPlayerSize: true,
      maxBufferLength: 30,
      maxMaxBufferLength: 600,
 
      // 错误恢复配置
      fragLoadingTimeOut: 20000,
      manifestLoadingTimeOut: 10000,
      levelLoadingTimeOut: 10000,
 
      // 教育内容特殊配置
      liveSyncDurationCount: 3,
      liveMaxLatencyDurationCount: Infinity,
      liveDurationInfinity: false
    });
 
    this.initializeEducationFeatures();
  }
 
  initializeEducationFeatures() {
    // 章节跳转功能
    this.setupChapterNavigation();
 
    // 学习进度跟踪
    this.setupProgressTracking();
 
    // 播放速度控制
    this.setupSpeedControl();
 
    // 错误处理与恢复
    this.setupErrorHandling();
  }
}

class EducationABRController {
  constructor(hls) {
    this.hls = hls;
    this.stabilityThreshold = 5000; // 5秒稳定期
    this.educationMode = true;
    this.lastSwitchTime = 0;
  }
 
  // 教育优化的码率选择策略
  selectOptimalLevel(levels, currentBandwidth, bufferLevel) {
    const now = Date.now();
 
    // 教育模式下增加切换间隔，保证学习连续性
    if (now - this.lastSwitchTime < this.stabilityThreshold) {
      return this.hls.currentLevel;
    }
 
    // 基于缓冲区状态的智能选择
    if (bufferLevel < 10) {
      // 缓冲不足时优先稳定性
      return this.selectConservativeLevel(levels, currentBandwidth);
    } else if (bufferLevel > 30) {
      // 缓冲充足时可以尝试更高质量
      return this.selectOptimisticLevel(levels, currentBandwidth);
    }
 
    return this.selectBalancedLevel(levels, currentBandwidth);
  }
 
  selectConservativeLevel(levels, bandwidth) {
    // 选择比当前带宽低20%的安全码率
    const safeBandwidth = bandwidth * 0.8;
    return levels.findIndex(level => level.bitrate <= safeBandwidth);
  }
}

class NetworkAdaptiveController {
  constructor() {
    this.networkType = this.detectNetworkType();
    this.connectionQuality = 'unknown';
    this.setupNetworkMonitoring();
  }
 
  detectNetworkType() {
    if ('connection' in navigator) {
      const connection = navigator.connection;
      return {
        effectiveType: connection.effectiveType,
        downlink: connection.downlink,
        rtt: connection.rtt,
        saveData: connection.saveData
      };
    }
    return null;
  }
 
  // 基于网络类型的预设配置
  getNetworkOptimizedConfig() {
    const configs = {
      'slow-2g': {
        maxBufferLength: 60,
        startLevel: 0, // 强制最低质量
        capLevelToPlayerSize: false
      },
      '2g': {
        maxBufferLength: 45,
        startLevel: 0,
        capLevelToPlayerSize: true
      },
      '3g': {
        maxBufferLength: 30,
        startLevel: 1,
        capLevelToPlayerSize: true
      },
      '4g': {
        maxBufferLength: 20,
        startLevel: -1, // 自动选择
        capLevelToPlayerSize: true
      }
    };
 
    return configs[this.networkType?.effectiveType] || configs['3g'];
  }
}

class IntelligentPreloader {
  constructor(player) {
    this.player = player;
    this.learningPattern = new Map(); // 学习行为模式
    this.preloadQueue = [];
  }
 
  // 基于学习行为的预测预加载
  predictAndPreload(currentChapter, userBehavior) {
    const prediction = this.analyzeLearningPattern(userBehavior);
 
    if (prediction.likelyToSkip) {
      // 预加载下一章节的开始部分
      this.preloadChapterStart(currentChapter + 1);
    } else if (prediction.likelyToRewatch) {
      // 预加载当前章节的重点片段
      this.preloadKeySegments(currentChapter);
    }
  }
 
  preloadChapterStart(chapterIndex) {
    const chapterStartTime = this.getChapterStartTime(chapterIndex);
    const preloadDuration = 30; // 预加载30秒
 
    this.player.hls.loadSource(
      this.generatePreloadM3U8(chapterStartTime, preloadDuration)
    );
  }
}

class SeamlessChapterNavigation {
  constructor(player) {
    this.player = player;
    this.chapterCache = new Map();
    this.transitionBuffer = 2; // 2秒过渡缓冲
  }
 
  async jumpToChapter(chapterIndex, timestamp = 0) {
    const currentTime = this.player.video.currentTime;
    const targetTime = this.getChapterStartTime(chapterIndex) + timestamp;
 
    // 检查目标时间是否已缓冲
    if (this.isTimeBuffered(targetTime)) {
      // 直接跳转
      this.player.video.currentTime = targetTime;
    } else {
      // 显示加载状态
      this.showLoadingIndicator();
 
      // 预加载目标章节
      await this.preloadChapter(chapterIndex);
 
      // 执行跳转
      this.player.video.currentTime = targetTime;
      this.hideLoadingIndicator();
    }
 
    // 更新学习进度
    this.updateLearningProgress(chapterIndex, timestamp);
  }
}

class PrecisionSpeedController {
  constructor(player) {
    this.player = player;
    this.supportedSpeeds = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0];
    this.currentSpeed = 1.0;
  }
 
  setPlaybackRate(speed) {
    if (!this.supportedSpeeds.includes(speed)) {
      throw new Error(`Unsupported speed: ${speed}`);
    }
 
    // 平滑过渡到新速度
    this.smoothSpeedTransition(this.currentSpeed, speed);
    this.currentSpeed = speed;
 
    // 调整缓冲策略
    this.adjustBufferForSpeed(speed);
  }
 
  smoothSpeedTransition(fromSpeed, toSpeed) {
    const steps = 10;
    const stepSize = (toSpeed - fromSpeed) / steps;
    let currentStep = 0;
 
    const transition = setInterval(() => {
      currentStep++;
      const intermediateSpeed = fromSpeed + (stepSize * currentStep);
      this.player.video.playbackRate = intermediateSpeed;
 
      if (currentStep >= steps) {
        clearInterval(transition);
        this.player.video.playbackRate = toSpeed;
      }
    }, 50);
  }
}

class MemoryOptimizedHLS {
  constructor(config) {
    this.maxBufferSize = config.maxBufferSize || 100 * 1024 * 1024; // 100MB
    this.bufferCleanupThreshold = 0.8; // 80%使用率时清理
    this.segmentCache = new LRUCache(50); // 最多缓存50个片段
  }
 
  // 智能缓冲区管理
  manageBuffer() {
    const bufferUsage = this.calculateBufferUsage();
 
    if (bufferUsage > this.bufferCleanupThreshold) {
      this.performBufferCleanup();
    }
  }
 
  performBufferCleanup() {
    const currentTime = this.player.video.currentTime;
    const keepBehind = 30; // 保留30秒历史
    const keepAhead = 60;  // 保留60秒未来
 
    // 清理过远的历史缓冲
    if (currentTime > keepBehind) {
      this.player.hls.trigger(Hls.Events.BUFFER_FLUSHING, {
        startOffset: 0,
        endOffset: currentTime - keepBehind,
        type: 'video'
      });
    }
  }
}

class CDNOptimizer {
  constructor() {
    this.cdnEndpoints = [
      'https://cdn1.m3u8-player.net/',
      'https://cdn2.m3u8-player.net/',
      'https://cdn3.m3u8-player.net/'
    ];
    this.performanceMetrics = new Map();
  }
 
  // 动态CDN选择
  selectOptimalCDN(segmentUrl) {
    const metrics = this.performanceMetrics;
    let bestCDN = this.cdnEndpoints[0];
    let bestScore = Infinity;
 
    for (const cdn of this.cdnEndpoints) {
      const score = this.calculateCDNScore(cdn);
      if (score < bestScore) {
        bestScore = score;
        bestCDN = cdn;
      }
    }
 
    return bestCDN + segmentUrl;
  }
 
  calculateCDNScore(cdn) {
    const metrics = this.performanceMetrics.get(cdn) || {
      latency: 1000,
      errorRate: 0.1,
      bandwidth: 1000000
    };
 
    // 综合评分：延迟 + 错误率权重 - 带宽优势
    return metrics.latency + (metrics.errorRate * 10000) - (metrics.bandwidth / 1000);
  }
}

class EducationDRMManager {
  constructor(licenseServerUrl) {
    this.licenseServerUrl = licenseServerUrl;
    this.keyCache = new Map();
    this.userPermissions = null;
  }
 
  // AES-128加密的M3U8处理
  async handleEncryptedHLS(m3u8Url, userToken) {
    const response = await fetch(m3u8Url, {
      headers: {
        'Authorization': `Bearer ${userToken}`,
        'X-Education-Platform': 'm3u8-player.net'
      }
    });
 
    const m3u8Content = await response.text();
    return this.processEncryptedPlaylist(m3u8Content, userToken);
  }
 
  processEncryptedPlaylist(content, userToken) {
    const lines = content.split('\n');
    const processedLines = [];
 
    for (let i = 0; i < lines.length; i++) {
      const line = lines[i];
 
      if (line.startsWith('#EXT-X-KEY:')) {
        // 处理加密密钥信息
        const keyInfo = this.parseKeyInfo(line);
        const proxyKeyUrl = this.createProxyKeyUrl(keyInfo.uri, userToken);
 
        processedLines.push(line.replace(keyInfo.uri, proxyKeyUrl));
      } else {
        processedLines.push(line);
      }
    }
 
    return processedLines.join('\n');
  }
}

class AccessControlManager {
  constructor() {
    this.coursePermissions = new Map();
    this.sessionTimeout = 3600000; // 1小时
  }
 
  // 验证课程访问权限
  async validateCourseAccess(courseId, userId, sessionToken) {
    const permission = await this.checkUserPermission(userId, courseId);
 
    if (!permission.hasAccess) {
      throw new Error('Access denied: Course not available for user');
    }
 
    if (permission.expiresAt < Date.now()) {
      throw new Error('Access denied: Course access expired');
    }
 
    // 验证会话有效性
    const sessionValid = await this.validateSession(sessionToken);
    if (!sessionValid) {
      throw new Error('Access denied: Invalid session');
    }
 
    return {
      granted: true,
      permissions: permission,
      sessionId: sessionToken
    };
  }
 
  // 生成带权限的播放URL
  generateSecurePlaylistUrl(courseId, userId, baseUrl) {
    const timestamp = Date.now();
    const nonce = this.generateNonce();
    const signature = this.generateSignature(courseId, userId, timestamp, nonce);
 
    return `${baseUrl}?course=${courseId}&user=${userId}&t=${timestamp}&nonce=${nonce}&sig=${signature}`;
  }
}

class MobileHLSOptimizer {
  constructor() {
    this.deviceCapabilities = this.detectDeviceCapabilities();
    this.networkType = this.detectNetworkType();
    this.batteryLevel = this.getBatteryLevel();
  }
 
  // 移动设备性能检测
  detectDeviceCapabilities() {
    const canvas = document.createElement('canvas');
    const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
 
    return {
      // 硬件解码支持
      hardwareDecoding: this.checkHardwareDecoding(),
 
      // GPU性能等级
      gpuTier: this.estimateGPUTier(gl),
 
      // 内存容量估算
      memorySize: navigator.deviceMemory || 2,
 
      // CPU核心数
      cpuCores: navigator.hardwareConcurrency || 2,
 
      // 屏幕信息
      screen: {
        width: screen.width,
        height: screen.height,
        pixelRatio: window.devicePixelRatio || 1
      }
    };
  }
 
  // 基于设备能力的配置优化
  getOptimizedConfig() {
    const config = {
      maxBufferLength: 20,
      maxMaxBufferLength: 120,
      startLevel: -1
    };
 
    // 低端设备优化
    if (this.deviceCapabilities.memorySize <= 2) {
      config.maxBufferLength = 10;
      config.maxMaxBufferLength = 60;
      config.startLevel = 0; // 强制最低质量
    }
 
    // 电池电量优化
    if (this.batteryLevel < 0.2) {
      config.lowLatencyMode = false;
      config.enableWorker = false; // 减少CPU使用
    }
 
    return config;
  }
}

class TouchOptimizedControls {
  constructor(playerElement) {
    this.player = playerElement;
    this.gestureThreshold = 50; // 手势识别阈值
    this.setupTouchHandlers();
  }
 
  setupTouchHandlers() {
    let startX, startY, startTime;
 
    this.player.addEventListener('touchstart', (e) => {
      const touch = e.touches[0];
      startX = touch.clientX;
      startY = touch.clientY;
      startTime = Date.now();
    });
 
    this.player.addEventListener('touchend', (e) => {
      const touch = e.changedTouches[0];
      const endX = touch.clientX;
      const endY = touch.clientY;
      const endTime = Date.now();
 
      const deltaX = endX - startX;
      const deltaY = endY - startY;
      const deltaTime = endTime - startTime;
 
      // 水平滑动 - 快进/快退
      if (Math.abs(deltaX) > this.gestureThreshold && Math.abs(deltaY) < 50) {
        const seekDelta = (deltaX / this.player.offsetWidth) * 60; // 最大60秒
        this.seekRelative(seekDelta);
      }
 
      // 垂直滑动 - 音量/亮度控制
      if (Math.abs(deltaY) > this.gestureThreshold && Math.abs(deltaX) < 50) {
        if (startX < this.player.offsetWidth / 2) {
          // 左侧 - 亮度控制
          this.adjustBrightness(-deltaY / this.player.offsetHeight);
        } else {
          // 右侧 - 音量控制
          this.adjustVolume(-deltaY / this.player.offsetHeight);
        }
      }
 
      // 双击 - 播放/暂停
      if (deltaTime < 300 && Math.abs(deltaX) < 10 && Math.abs(deltaY) < 10) {
        this.handleDoubleTap();
      }
    });
  }
}

class EducationHLSPlayer {
  constructor(container, options = {}) {
    this.container = container;
    this.options = {
      autoplay: false,
      muted: false,
      controls: true,
      enableChapters: true,
      enableNotes: true,
      enableSpeedControl: true,
      ...options
    };
 
    this.initializePlayer();
  }
 
  initializePlayer() {
    // 创建视频元素
    this.video = document.createElement('video');
    this.video.controls = this.options.controls;
    this.video.muted = this.options.muted;
 
    // 初始化HLS
    if (Hls.isSupported()) {
      this.hls = new Hls(this.getHLSConfig());
      this.hls.attachMedia(this.video);
      this.setupHLSEvents();
    } else if (this.video.canPlayType('application/vnd.apple.mpegurl')) {
      // Safari原生支持
      this.nativeHLS = true;
    }
 
    // 构建UI
    this.buildPlayerUI();
 
    // 初始化教育功能
    this.initializeEducationFeatures();
  }
 
  getHLSConfig() {
    return {
      debug: false,
      enableWorker: true,
      lowLatencyMode: false,
 
      // 教育优化配置
      maxBufferLength: 30,
      maxMaxBufferLength: 600,
      startLevel: -1,
      capLevelToPlayerSize: true,
 
      // 错误恢复
      fragLoadingTimeOut: 20000,
      manifestLoadingTimeOut: 10000,
 
      // 自定义加载器
      loader: class extends Hls.DefaultConfig.loader {
        load(context, config, callbacks) {
          // 添加教育平台认证头
          if (!context.headers) context.headers = {};
          context.headers['X-Education-Platform'] = 'm3u8-player.net';
 
          super.load(context, config, callbacks);
        }
      }
    };
  }
 
  buildPlayerUI() {
    // 创建播放器容器
    this.playerContainer = document.createElement('div');
    this.playerContainer.className = 'education-hls-player';
 
    // 视频容器
    this.videoContainer = document.createElement('div');
    this.videoContainer.className = 'video-container';
    this.videoContainer.appendChild(this.video);
 
    // 控制栏
    this.controlBar = this.createControlBar();
 
    // 章节导航
    if (this.options.enableChapters) {
      this.chapterNav = this.createChapterNavigation();
    }
 
    // 笔记面板
    if (this.options.enableNotes) {
      this.notePanel = this.createNotePanel();
    }
 
    // 组装UI
    this.playerContainer.appendChild(this.videoContainer);
    this.playerContainer.appendChild(this.controlBar);
 
    if (this.chapterNav) {
      this.playerContainer.appendChild(this.chapterNav);
    }
 
    if (this.notePanel) {
      this.playerContainer.appendChild(this.notePanel);
    }
 
    this.container.appendChild(this.playerContainer);
  }
 
  createControlBar() {
    const controlBar = document.createElement('div');
    controlBar.className = 'control-bar';
 
    // 播放/暂停按钮
    const playButton = document.createElement('button');
    playButton.className = 'play-button';
    playButton.innerHTML = '▶️';
    playButton.addEventListener('click', () => this.togglePlay());
 
    // 进度条
    const progressContainer = document.createElement('div');
    progressContainer.className = 'progress-container';
 
    const progressBar = document.createElement('div');
    progressBar.className = 'progress-bar';
 
    const progressFilled = document.createElement('div');
    progressFilled.className = 'progress-filled';
 
    progressBar.appendChild(progressFilled);
    progressContainer.appendChild(progressBar);
 
    // 时间显示
    const timeDisplay = document.createElement('div');
    timeDisplay.className = 'time-display';
    timeDisplay.textContent = '00:00 / 00:00';
 
    // 倍速控制
    const speedControl = this.createSpeedControl();
 
    // 质量选择
    const qualityControl = this.createQualityControl();
 
    // 全屏按钮
    const fullscreenButton = document.createElement('button');
    fullscreenButton.className = 'fullscreen-button';
    fullscreenButton.innerHTML = '⛶';
    fullscreenButton.addEventListener('click', () => this.toggleFullscreen());
 
    // 组装控制栏
    controlBar.appendChild(playButton);
    controlBar.appendChild(progressContainer);
    controlBar.appendChild(timeDisplay);
    controlBar.appendChild(speedControl);
    controlBar.appendChild(qualityControl);
    controlBar.appendChild(fullscreenButton);
 
    return controlBar;
  }
 
  // 加载课程内容
  async loadCourse(courseUrl, courseMetadata = {}) {
    try {
      // 验证访问权限
      await this.validateAccess(courseUrl);
 
      // 加载课程元数据
      this.courseData = courseMetadata;
 
      // 加载HLS流
      if (this.hls) {
        this.hls.loadSource(courseUrl);
      } else if (this.nativeHLS) {
        this.video.src = courseUrl;
      }
 
      // 初始化章节信息
      if (this.courseData.chapters) {
        this.initializeChapters(this.courseData.chapters);
      }
 
      // 恢复学习进度
      await this.restoreLearningProgress();
 
    } catch (error) {
      this.handleError('Failed to load course', error);
    }
  }
}

<!DOCTYPE html>
<html>
<head>
    <title>教育HLS播放器示例</title>
    <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
</head>
<body>
    <div id="player-container"></div>
 
    <script>
        // 初始化播放器
        const player = new EducationHLSPlayer(
            document.getElementById('player-container'),
            {
                autoplay: false,
                enableChapters: true,
                enableNotes: true,
                enableSpeedControl: true
            }
        );
 
        // 加载课程
        const courseMetadata = {
            title: "HLS协议深度解析",
            duration: 3600,
            chapters: [
                { title: "HLS基础概念", startTime: 0, duration: 600 },
                { title: "M3U8文件格式", startTime: 600, duration: 900 },
                { title: "自适应码率原理", startTime: 1500, duration: 1200 },
                { title: "实际应用案例", startTime: 2700, duration: 900 }
            ]
        };
 
        player.loadCourse(
            'https://example.com/course/hls-tutorial/playlist.m3u8',
            courseMetadata
        );
    </script>
</body>
</html>

class HLSMonitoringSystem {
  constructor(player) {
    this.player = player;
    this.metrics = {
      bufferHealth: [],
      qualitySwitches: [],
      errors: [],
      loadTimes: [],
      rebufferEvents: []
    };
 
    this.setupMonitoring();
  }
 
  setupMonitoring() {
    // 缓冲区健康监控
    setInterval(() => {
      const bufferLength = this.getBufferLength();
      this.metrics.bufferHealth.push({
        timestamp: Date.now(),
        length: bufferLength,
        level: this.player.hls.currentLevel
      });
 
      // 缓冲区预警
      if (bufferLength < 5) {
        this.triggerAlert('LOW_BUFFER', { bufferLength });
      }
    }, 1000);
 
    // HLS事件监控
    this.player.hls.on(Hls.Events.ERROR, (event, data) => {
      this.recordError(data);
      this.handleError(data);
    });
 
    this.player.hls.on(Hls.Events.LEVEL_SWITCHED, (event, data) => {
      this.recordQualitySwitch(data);
    });
  }
 
  recordError(errorData) {
    const errorRecord = {
      timestamp: Date.now(),
      type: errorData.type,
      details: errorData.details,
      fatal: errorData.fatal,
      url: errorData.url,
      response: errorData.response
    };
 
    this.metrics.errors.push(errorRecord);
 
    // 发送到监控服务
    this.sendToMonitoring('hls_error', errorRecord);
  }
 
  generateHealthReport() {
    const now = Date.now();
    const last5Minutes = now - 5 * 60 * 1000;
 
    return {
      bufferHealth: {
        average: this.calculateAverageBuffer(last5Minutes),
        minimum: this.getMinimumBuffer(last5Minutes),
        rebufferCount: this.countRebuffers(last5Minutes)
      },
      qualityMetrics: {
        switchCount: this.countQualitySwitches(last5Minutes),
        averageLevel: this.calculateAverageQuality(last5Minutes),
        stabilityScore: this.calculateStabilityScore(last5Minutes)
      },
      errorMetrics: {
        errorCount: this.countErrors(last5Minutes),
        fatalErrors: this.countFatalErrors(last5Minutes),
        recoveryRate: this.calculateRecoveryRate(last5Minutes)
      }
    };
  }
}

class AutoRecoveryManager {
  constructor(player) {
    this.player = player;
    this.recoveryStrategies = [
      this.retryCurrentSegment.bind(this),
      this.switchToLowerQuality.bind(this),
      this.reloadManifest.bind(this),
      this.restartPlayer.bind(this)
    ];
    this.currentStrategy = 0;
    this.maxRetries = 3;
  }
 
  async handleError(errorData) {
    console.log(`HLS Error: ${errorData.type} - ${errorData.details}`);
 
    if (errorData.fatal) {
      await this.attemptRecovery(errorData);
    } else {
      // 非致命错误，记录但继续播放
      this.logNonFatalError(errorData);
    }
  }
 
  async attemptRecovery(errorData) {
    if (this.currentStrategy >= this.recoveryStrategies.length) {
      this.reportUnrecoverableError(errorData);
      return;
    }
 
    const strategy = this.recoveryStrategies[this.currentStrategy];
 
    try {
      console.log(`Attempting recovery strategy ${this.currentStrategy + 1}`);
      await strategy(errorData);
 
      // 恢复成功，重置策略索引
      this.currentStrategy = 0;
 
    } catch (recoveryError) {
      console.log(`Recovery strategy ${this.currentStrategy + 1} failed`);
      this.currentStrategy++;
 
      // 尝试下一个策略
      setTimeout(() => this.attemptRecovery(errorData), 1000);
    }
  }
 
  async retryCurrentSegment(errorData) {
    if (errorData.frag) {
      // 重新加载失败的片段
      this.player.hls.trigger(Hls.Events.ERROR, {
        type: Hls.ErrorTypes.NETWORK_ERROR,
        details: Hls.ErrorDetails.FRAG_LOAD_ERROR,
        fatal: false,
        frag: errorData.frag
      });
    }
  }
 
  async switchToLowerQuality(errorData) {
    const currentLevel = this.player.hls.currentLevel;
    if (currentLevel > 0) {
      this.player.hls.currentLevel = currentLevel - 1;
      console.log(`Switched to lower quality: level ${currentLevel - 1}`);
    } else {
      throw new Error('Already at lowest quality');
    }
  }
 
  async reloadManifest(errorData) {
    const currentSrc = this.player.hls.url;
    this.player.hls.destroy();
 
    // 重新初始化HLS
    this.player.hls = new Hls(this.player.getHLSConfig());
    this.player.hls.attachMedia(this.player.video);
    this.player.hls.loadSource(currentSrc);
  }
}

// 低延迟HLS配置示例
const llHLSConfig = {
  lowLatencyMode: true,
  liveBackBufferLength: 4,
  liveSyncDurationCount: 1,
  liveMaxLatencyDurationCount: 3,
  enableWorker: true,
 
  // 部分片段支持
  enableSoftwareAES: true,
  startFragPrefetch: true
};