1
# 多码率自适应流生成
2
ffmpeg -i input.mp4 \
3
  -map 0:v -map 0:a -map 0:v -map 0:a -map 0:v -map 0:a \
4
  -c:v libx264 -crf 22 -c:a aac -ar 48000 -ac 2 \
5
  -var_stream_map "v:0,a:0 v:1,a:1 v:2,a:2" \
6
  -b:v:0 800k -s:v:0 640x360 -profile:v:0 baseline \
7
  -b:v:1 1400k -s:v:1 842x480 -profile:v:1 main \
8
  -b:v:2 2800k -s:v:2 1280x720 -profile:v:2 high \
9
  -hls_time 6 -hls_list_size 0 \
10
  -hls_segment_filename "stream_%v/segment_%03d.ts" \
11
  -master_pl_name "master.m3u8" \
12
  -f hls -var_stream_map "v:0,a:0 v:1,a:1 v:2,a:2" "stream_%v/index.m3u8"
13
 
14
# 低延迟HLS配置
15
ffmpeg -i rtmp://live-server/stream \
16
  -c:v libx264 -preset ultrafast -tune zerolatency \
17
  -c:a aac -b:a 128k \
18
  -f hls \
19
  -hls_time 1 \
20
  -hls_list_size 3 \
21
  -hls_flags delete_segments+append_list \
22
  -hls_segment_type fmp4 \
23
  live_stream.m3u8

1
// Express + Node.js HLS服务器示例
2
const express = require('express');
3
const path = require('path');
4
const fs = require('fs');
5
 
6
class HLSServer {
7
  constructor() {
8
    this.app = express();
9
    this.setupRoutes();
10
    this.setupCORS();
11
  }
12
 
13
  setupRoutes() {
14
    // M3U8播放列表服务
15
    this.app.get('/*.m3u8', this.servePlaylist.bind(this));
16
 
17
    // TS片段服务
18
    this.app.get('/*.ts', this.serveSegment.bind(this));
19
 
20
    // 健康检查
21
    this.app.get('/health', (req, res) => {
22
      res.json({ status: 'healthy', timestamp: new Date().toISOString() });
23
    });
24
  }
25
 
26
  setupCORS() {
27
    this.app.use((req, res, next) => {
28
      res.header('Access-Control-Allow-Origin', '*');
29
      res.header('Access-Control-Allow-Headers', 'Range');
30
      res.header('Access-Control-Expose-Headers', 'Content-Length, Content-Range');
31
      next();
32
    });
33
  }
34
 
35
  servePlaylist(req, res) {
36
    const playlistPath = path.join(__dirname, 'streams', req.path);
37
 
38
    if (!fs.existsSync(playlistPath)) {
39
      return res.status(404).send('Playlist not found');
40
    }
41
 
42
    // 验证内容合规性
43
    if (!this.validateContentSource(playlistPath)) {
44
      return res.status(403).send('Unauthorized content');
45
    }
46
 
47
    res.setHeader('Content-Type', 'application/vnd.apple.mpegurl');
48
    res.setHeader('Cache-Control', 'no-cache');
49
    res.sendFile(playlistPath);
50
  }
51
 
52
  serveSegment(req, res) {
53
    const segmentPath = path.join(__dirname, 'streams', req.path);
54
 
55
    if (!fs.existsSync(segmentPath)) {
56
      return res.status(404).send('Segment not found');
57
    }
58
 
59
    res.setHeader('Content-Type', 'video/mp2t');
60
    res.setHeader('Cache-Control', 'public, max-age=31536000');
61
    res.sendFile(segmentPath);
62
  }
63
 
64
  validateContentSource(filePath) {
65
    // 内容来源验证逻辑
66
    // 仅允许合法授权的测试内容
67
    const allowedPaths = [
68
      '/test-content/',
69
      '/public-domain/',
70
      '/educational-samples/'
71
    ];
72
 
73
    return allowedPaths.some(allowed => filePath.includes(allowed));
74
  }
75
 
76
  start(port = 3000) {
77
    this.app.listen(port, () => {
78
      console.log(`HLS服务器运行在端口 ${port}`);
79
      console.log('⚠️  仅供技术研究和教育用途');
80
    });
81
  }
82
}
83
 
84
// 启动服务器（仅供研究用途）
85
const server = new HLSServer();
86
server.start();

1
// 现代HLS播放器实现
2
class AdvancedHLSPlayer {
3
  constructor(videoElement) {
4
    this.video = videoElement;
5
    this.hls = null;
6
    this.analytics = new PlaybackAnalytics();
7
    this.qualityLevels = [];
8
    this.initialize();
9
  }
10
 
11
  initialize() {
12
    if (!Hls.isSupported()) {
13
      console.warn('HLS.js not supported, trying native HLS');
14
      return this.initializeNativeHLS();
15
    }
16
 
17
    this.hls = new Hls({
18
      debug: process.env.NODE_ENV === 'development',
19
      enableWorker: true,
20
      lowLatencyMode: true,
21
      backBufferLength: 90,
22
 
23
      // ABR配置
24
      abrEwmaFastLive: 3.0,
25
      abrEwmaSlowLive: 9.0,
26
      abrMaxWithRealBitrate: false,
27
 
28
      // 网络配置
29
      manifestLoadingTimeOut: 10000,
30
      manifestLoadingMaxRetry: 4,
31
      levelLoadingTimeOut: 10000,
32
 
33
      // 片段配置
34
      fragLoadingTimeOut: 20000,
35
      fragLoadingMaxRetry: 6
36
    });
37
 
38
    this.setupEventListeners();
39
  }
40
 
41
  setupEventListeners() {
42
    // 播放列表解析完成
43
    this.hls.on(Hls.Events.MANIFEST_PARSED, (event, data) => {
44
      console.log('解析到 ' + data.levels.length + ' 个质量级别');
45
      this.qualityLevels = data.levels;
46
      this.analytics.recordEvent('manifest_parsed', { levels: data.levels.length });
47
    });
48
 
49
    // 质量级别切换
50
    this.hls.on(Hls.Events.LEVEL_SWITCHED, (event, data) => {
51
      const level = this.hls.levels[data.level];
52
      console.log(`切换到质量级别: ${level.height}p @ ${Math.round(level.bitrate/1000)}kbps`);
53
      this.analytics.recordQualityChange(data.level, level);
54
    });
55
 
56
    // 错误处理
57
    this.hls.on(Hls.Events.ERROR, (event, data) => {
58
      console.error('HLS错误:', data);
59
      this.handleError(data);
60
    });
61
 
62
    // 片段加载统计
63
    this.hls.on(Hls.Events.FRAG_LOADED, (event, data) => {
64
      this.analytics.recordFragmentLoad(data.frag, data.stats);
65
    });
66
  }
67
 
68
  loadSource(url) {
69
    // 验证内容源合法性
70
    if (!this.validateSourceURL(url)) {
71
      throw new Error('不支持的内容源');
72
    }
73
 
74
    this.hls.loadSource(url);
75
    this.hls.attachMedia(this.video);
76
  }
77
 
78
  validateSourceURL(url) {
79
    const allowedDomains = [
80
      'commondatastorage.googleapis.com',
81
      'demo.unified-streaming.com',
82
      'bitdash-a.akamaihd.net'
83
    ];
84
 
85
    try {
86
      const domain = new URL(url).hostname;
87
      return allowedDomains.includes(domain);
88
    } catch {
89
      return false;
90
    }
91
  }
92
 
93
  setQualityLevel(index) {
94
    if (index === -1) {
95
      this.hls.currentLevel = -1; // 自动质量选择
96
    } else if (index < this.qualityLevels.length) {
97
      this.hls.currentLevel = index;
98
    }
99
  }
100
 
101
  handleError(data) {
102
    if (data.fatal) {
103
      switch(data.type) {
104
        case Hls.ErrorTypes.NETWORK_ERROR:
105
          console.log('网络错误，尝试恢复...');
106
          this.hls.startLoad();
107
          break;
108
        case Hls.ErrorTypes.MEDIA_ERROR:
109
          console.log('媒体错误，尝试恢复...');
110
          this.hls.recoverMediaError();
111
          break;
112
        default:
113
          console.log('无法恢复的错误');
114
          this.destroy();
115
          break;
116
      }
117
    }
118
 
119
    this.analytics.recordError(data);
120
  }
121
 
122
  destroy() {
123
    if (this.hls) {
124
      this.hls.destroy();
125
      this.hls = null;
126
    }
127
  }
128
}
129
 
130
// 播放分析类
131
class PlaybackAnalytics {
132
  constructor() {
133
    this.events = [];
134
    this.startTime = Date.now();
135
  }
136
 
137
  recordEvent(type, data) {
138
    this.events.push({
139
      type,
140
      timestamp: Date.now() - this.startTime,
141
      data
142
    });
143
  }
144
 
145
  recordQualityChange(level, levelData) {
146
    this.recordEvent('quality_change', {
147
      level,
148
      resolution: `${levelData.width}x${levelData.height}`,
149
      bitrate: levelData.bitrate
150
    });
151
  }
152
 
153
  recordFragmentLoad(fragment, stats) {
154
    this.recordEvent('fragment_loaded', {
155
      url: fragment.url,
156
      duration: fragment.duration,
157
      loadTime: stats.loading.end - stats.loading.start,
158
      size: stats.total
159
    });
160
  }
161
 
162
  recordError(errorData) {
163
    this.recordEvent('error', {
164
      type: errorData.type,
165
      details: errorData.details,
166
      fatal: errorData.fatal
167
    });
168
  }
169
 
170
  generateReport() {
171
    return {
172
      totalEvents: this.events.length,
173
      sessionDuration: Date.now() - this.startTime,
174
      qualityChanges: this.events.filter(e => e.type === 'quality_change').length,
175
      errors: this.events.filter(e => e.type === 'error').length,
176
      averageLoadTime: this.calculateAverageLoadTime()
177
    };
178
  }
179
 
180
  calculateAverageLoadTime() {
181
    const loadEvents = this.events.filter(e => e.type === 'fragment_loaded');
182
    if (loadEvents.length === 0) return 0;
183
 
184
    const totalTime = loadEvents.reduce((sum, event) => sum + event.data.loadTime, 0);
185
    return totalTime / loadEvents.length;
186
  }
187
}