BlueGit

timfa filemanager

Files

filemanager / server / video-stream.js

video-stream.js

video-stream.js 29.9 KiB Download Raw
1'use strict';
2
3const { spawn } = require('child_process');
4const crypto = require('crypto');
5const fs = require('fs');
6const os = require('os');
7const path = require('path');
8const { clearCachesForFile, pruneOldImageSubtitleCaches, purgeSubtitleCacheDir } = require('./image-subtitles');
9
10const STREAM_ROOT_DIR = path.join(os.tmpdir(), 'filemanager-video-streams');
11const STREAM_SESSION_TTL_MS = 30 * 60 * 1000;
12const STREAM_READY_TIMEOUT_MS = 20 * 1000;
13const STREAM_IDLE_STOP_MS = 5 * 60 * 1000;
14const ESTIMATED_SEGMENT_BYTES = 1024 * 1024;
15const STREAM_SEGMENT_RETENTION_COUNT = parseSegmentRetentionCount(process.env.VIDEO_STREAM_SEGMENT_RETENTION_COUNT);
16const IMAGE_BASED_SUBTITLE_CODECS = new Set([
17 'hdmv_pgs_subtitle',
18 'pgssub',
19 'dvd_subtitle',
20 'dvdsub',
21 'dvb_subtitle',
22 'xsub',
23]);
24const sessions = new Map();
25const leases = new Map();
26const reusableSessionIdBySource = new Map();
27
28// Remove any .sup subtitle files left over from a previous server run.
29purgeSubtitleCacheDir();
30
31function parseSegmentRetentionCount (value)
32{
33 const parsed = Number.parseInt(String(value || ''), 10);
34 if (Number.isInteger(parsed) && parsed >= 30) return parsed;
35 return defaultSegmentRetentionCount();
36}
37
38function readRaspberryPiModel ()
39{
40 try
41 {
42 return fs.readFileSync('/proc/device-tree/model', 'utf8').replace(/\u0000/g, '').trim();
43 } catch
44 {
45 return '';
46 }
47}
48
49function clampNumber (value, min, max)
50{
51 return Math.min(max, Math.max(min, value));
52}
53
54function currentCpuPressureFactor (cpuCount)
55{
56 if (typeof os.loadavg !== 'function') return 1;
57 if (!Number.isFinite(cpuCount) || cpuCount <= 0) return 1;
58
59 const [load1] = os.loadavg();
60 if (!Number.isFinite(load1) || load1 < 0) return 1;
61
62 const saturation = load1 / cpuCount;
63 if (saturation >= 1.5) return 0.72;
64 if (saturation >= 1.2) return 0.8;
65 if (saturation >= 1.0) return 0.88;
66 if (saturation >= 0.8) return 0.94;
67 return 1;
68}
69
70function defaultSegmentRetentionCount ()
71{
72 const totalMemBytes = Number(os.totalmem()) || 0;
73 const freeMemBytes = Number(os.freemem()) || 0;
74 const cpuCount = Math.max(1, ((os.cpus() || []).length || 1));
75 const arch = String(os.arch() || '').toLowerCase();
76 const piModel = readRaspberryPiModel().toLowerCase();
77 const isPi5 = piModel.includes('raspberry pi 5');
78 const isArm = arch === 'arm' || arch === 'arm64' || arch.startsWith('armv');
79 const cpuPressure = currentCpuPressureFactor(cpuCount);
80
81 const freeMemRatio = totalMemBytes > 0 ? (freeMemBytes / totalMemBytes) : 1;
82 const memoryPressure = freeMemRatio < 0.12 ? 0.72 : freeMemRatio < 0.2 ? 0.84 : freeMemRatio < 0.3 ? 0.92 : 1;
83
84 if (isPi5)
85 {
86 const memoryBudgetBytes = Math.floor(totalMemBytes * 0.03);
87 const byMemory = Math.floor(memoryBudgetBytes / ESTIMATED_SEGMENT_BYTES);
88 const byCpu = 120 + ((cpuCount - 2) * 20);
89 const combined = Math.min(byMemory, byCpu);
90 return clampNumber(Math.floor(combined * cpuPressure * memoryPressure), 100, 220);
91 }
92
93 if (isArm)
94 {
95 const memoryBudgetBytes = Math.floor(totalMemBytes * 0.025);
96 const byMemory = Math.floor(memoryBudgetBytes / ESTIMATED_SEGMENT_BYTES);
97 const byCpu = 90 + ((cpuCount - 2) * 14);
98 const combined = Math.min(byMemory, byCpu);
99 return clampNumber(Math.floor(combined * cpuPressure * memoryPressure), 80, 180);
100 }
101
102 const memoryBudgetBytes = Math.floor(totalMemBytes * 0.05);
103 const byMemory = Math.floor(memoryBudgetBytes / ESTIMATED_SEGMENT_BYTES);
104 const byCpu = 140 + ((cpuCount - 4) * 16);
105 const combined = Math.min(byMemory, byCpu);
106 return clampNumber(Math.floor(combined * cpuPressure * memoryPressure), 120, 320);
107}
108
109function hasInitialHlsAssets (outputDir)
110{
111 try
112 {
113 const entries = fs.readdirSync(outputDir, { withFileTypes: true });
114 return entries.some((entry) =>
115 {
116 if (!entry.isFile()) return false;
117 if (entry.name === 'master.m3u8') return true;
118 if (/^stream_\d+\.m3u8(?:\.tmp)?$/i.test(entry.name)) return true;
119 if (/^stream_\d+_segment_\d+\.ts(?:\.tmp)?$/i.test(entry.name)) return true;
120 return false;
121 });
122 } catch
123 {
124 return false;
125 }
126}
127
128function makeHttpError (status, message)
129{
130 const err = new Error(message);
131 err.status = status;
132 return err;
133}
134
135function ensureStreamRootDir ()
136{
137 fs.mkdirSync(STREAM_ROOT_DIR, { recursive: true });
138}
139
140function ffmpegPath ()
141{
142 return String(process.env.FFMPEG_PATH || '').trim() || 'ffmpeg';
143}
144
145function ffprobePath ()
146{
147 return String(process.env.FFPROBE_PATH || '').trim() || 'ffprobe';
148}
149
150function pruneExpiredSessions ()
151{
152 const now = Date.now();
153
154 for (const [leaseId, lease] of leases)
155 {
156 if (lease.expiresAt > now) continue;
157 releaseVideoStreamSession(leaseId);
158 }
159
160 for (const [sessionId, session] of sessions)
161 {
162 if (session.expiresAt > now) continue;
163 destroySession(sessionId);
164 }
165}
166
167function refreshSession (session)
168{
169 session.expiresAt = Date.now() + STREAM_SESSION_TTL_MS;
170}
171
172function refreshLease (lease)
173{
174 lease.expiresAt = Date.now() + STREAM_SESSION_TTL_MS;
175}
176
177function destroySession (sessionId)
178{
179 const session = sessions.get(sessionId);
180 if (!session) return false;
181
182 sessions.delete(sessionId);
183
184 if (reusableSessionIdBySource.get(session.sourcePath) === session.id)
185 {
186 reusableSessionIdBySource.delete(session.sourcePath);
187 }
188
189 if (session.leaseIds)
190 {
191 for (const leaseId of session.leaseIds)
192 {
193 leases.delete(leaseId);
194 }
195 session.leaseIds.clear();
196 }
197
198 if (session.idleTimer)
199 {
200 clearTimeout(session.idleTimer);
201 session.idleTimer = null;
202 }
203
204 try
205 {
206 if (session.process) session.process.kill('SIGTERM');
207 } catch
208 {
209 // Ignore process cleanup failures.
210 }
211
212 fs.rmSync(session.outputDir, { recursive: true, force: true });
213
214 // Clear image subtitle caches associated with this file.
215 clearCachesForFile(session.sourcePath);
216
217 return true;
218}
219
220function pruneImageSubtitleCachesForSession (session)
221{
222 if (!session || !session.sourcePath) return;
223
224 const slowestIndex = slowestLeaseSegmentIndex(session);
225 if (!Number.isInteger(slowestIndex)) return;
226
227 const estimatedSegmentDurationSeconds = 6;
228 const slowestViewerTimeSeconds = slowestIndex * estimatedSegmentDurationSeconds;
229 pruneOldImageSubtitleCaches(session.sourcePath, slowestViewerTimeSeconds);
230}
231
232function getSessionForLease (leaseId)
233{
234 const lease = leases.get(leaseId);
235 if (!lease) return null;
236
237 const session = sessions.get(lease.sessionId);
238 if (!session)
239 {
240 leases.delete(leaseId);
241 return null;
242 }
243
244 return { lease, session };
245}
246
247function createLeaseForSession (session)
248{
249 const leaseId = crypto.randomBytes(18).toString('hex');
250 const lease = {
251 id: leaseId,
252 sessionId: session.id,
253 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
254 lastActivityAt: Date.now(),
255 lastSegmentIndex: null,
256 };
257 leases.set(leaseId, lease);
258 session.leaseIds.add(leaseId);
259 return lease;
260}
261
262function touchSessionActivity (session, lease)
263{
264 refreshSession(session);
265 session.lastActivityAt = Date.now();
266
267 if (lease)
268 {
269 refreshLease(lease);
270 lease.lastActivityAt = Date.now();
271 }
272}
273
274function clearIdleStopTimer (session)
275{
276 if (!session.idleTimer) return;
277 clearTimeout(session.idleTimer);
278 session.idleTimer = null;
279}
280
281function scheduleIdleStop (session)
282{
283 clearIdleStopTimer(session);
284 if (session.activeRequests > 0 || (session.leaseIds && session.leaseIds.size > 0)) return;
285
286 session.idleTimer = setTimeout(() =>
287 {
288 const activeSession = sessions.get(session.id);
289 if (!activeSession) return;
290 if (activeSession.activeRequests > 0 || (activeSession.leaseIds && activeSession.leaseIds.size > 0)) return;
291 if (Date.now() - activeSession.lastActivityAt < STREAM_IDLE_STOP_MS)
292 {
293 scheduleIdleStop(activeSession);
294 return;
295 }
296 destroySession(activeSession.id);
297 }, STREAM_IDLE_STOP_MS);
298}
299
300function startAssetRequest (session, lease)
301{
302 session.activeRequests += 1;
303 touchSessionActivity(session, lease);
304 clearIdleStopTimer(session);
305}
306
307function finishAssetRequest (session, lease)
308{
309 if (session.activeRequests > 0) session.activeRequests -= 1;
310 touchSessionActivity(session, lease);
311 if (session.activeRequests === 0 && session.leaseIds.size === 0) scheduleIdleStop(session);
312}
313
314function parseSegmentIndexFromAssetPath (assetPath)
315{
316 const baseName = path.basename(String(assetPath || ''));
317 const match = baseName.match(/^stream_\d+_segment_(\d+)\.ts$/i);
318 if (!match) return null;
319
320 const segmentIndex = Number.parseInt(match[1], 10);
321 return Number.isInteger(segmentIndex) ? segmentIndex : null;
322}
323
324function runSegmentPrune (session)
325{
326 if (session.segmentPruneRunning) return;
327 if (session.segmentPrunePendingCutoff <= session.segmentPrunedUntil) return;
328
329 const cutoff = session.segmentPrunePendingCutoff;
330 session.segmentPruneRunning = true;
331
332 fs.promises.readdir(session.outputDir)
333 .then((entries) =>
334 {
335 const removals = [];
336 for (const entryName of entries)
337 {
338 const match = String(entryName).match(/^stream_\d+_segment_(\d+)\.ts$/i);
339 if (!match) continue;
340 const segmentIndex = Number.parseInt(match[1], 10);
341 if (!Number.isInteger(segmentIndex)) continue;
342 if (segmentIndex > cutoff) continue;
343
344 removals.push(
345 fs.promises.unlink(path.join(session.outputDir, entryName)).catch(() =>
346 {
347 // Ignore races while ffmpeg rotates temp files and request handlers read segments.
348 })
349 );
350 }
351 return Promise.all(removals);
352 })
353 .then(() =>
354 {
355 session.segmentPrunedUntil = Math.max(session.segmentPrunedUntil, cutoff);
356 pruneImageSubtitleCachesForSession(session);
357 if (session.segmentPrunedUntil >= 0 && reusableSessionIdBySource.get(session.sourcePath) === session.id)
358 {
359 reusableSessionIdBySource.delete(session.sourcePath);
360 }
361 })
362 .catch(() =>
363 {
364 // Best effort cleanup; keep streaming even if pruning fails.
365 })
366 .finally(() =>
367 {
368 session.segmentPruneRunning = false;
369 if (session.segmentPrunePendingCutoff > session.segmentPrunedUntil)
370 {
371 runSegmentPrune(session);
372 }
373 });
374}
375
376function slowestLeaseSegmentIndex (session)
377{
378 if (!session.leaseIds.size) return null;
379
380 let minIndex = null;
381 for (const leaseId of session.leaseIds)
382 {
383 const lease = leases.get(leaseId);
384 if (!lease) continue;
385 if (!Number.isInteger(lease.lastSegmentIndex)) return null;
386 if (minIndex === null || lease.lastSegmentIndex < minIndex) minIndex = lease.lastSegmentIndex;
387 }
388
389 return minIndex;
390}
391
392function scheduleSegmentPrune (session, lease, segmentIndex)
393{
394 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return;
395
396 lease.lastSegmentIndex = segmentIndex;
397 const slowestIndex = slowestLeaseSegmentIndex(session);
398 if (!Number.isInteger(slowestIndex)) return;
399
400 const pruneCutoff = slowestIndex - STREAM_SEGMENT_RETENTION_COUNT;
401 if (pruneCutoff <= session.segmentPrunedUntil) return;
402
403 session.segmentPrunePendingCutoff = Math.max(session.segmentPrunePendingCutoff, pruneCutoff);
404 runSegmentPrune(session);
405}
406
407function runCommand (command, args)
408{
409 return new Promise((resolve, reject) =>
410 {
411 const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
412 let stdout = '';
413 let stderr = '';
414
415 child.stdout.on('data', (chunk) =>
416 {
417 stdout += chunk.toString();
418 });
419
420 child.stderr.on('data', (chunk) =>
421 {
422 stderr += chunk.toString();
423 });
424
425 child.on('error', (err) =>
426 {
427 if (err && err.code === 'ENOENT')
428 {
429 reject(makeHttpError(503, `${command} is not installed or not available in PATH.`));
430 return;
431 }
432 reject(err);
433 });
434
435 child.on('close', (code) =>
436 {
437 if (code === 0)
438 {
439 resolve({ stdout, stderr });
440 return;
441 }
442 reject(makeHttpError(500, stderr.trim() || `${command} exited with code ${code}.`));
443 });
444 });
445}
446
447async function probeInput (sourcePath)
448{
449 const { stdout } = await runCommand(ffprobePath(), [
450 '-v', 'error',
451 '-print_format', 'json',
452 '-show_streams',
453 '-show_format',
454 sourcePath,
455 ]);
456
457 let payload;
458 try
459 {
460 payload = JSON.parse(stdout || '{}');
461 } catch
462 {
463 throw makeHttpError(500, 'ffprobe returned invalid stream metadata.');
464 }
465
466 const typedIndexes = { video: 0, audio: 0, subtitle: 0 };
467 const streams = Array.isArray(payload.streams) ? payload.streams.map((stream) =>
468 {
469 const codecType = String(stream.codec_type || '').toLowerCase();
470 const relativeIndex = Object.prototype.hasOwnProperty.call(typedIndexes, codecType)
471 ? typedIndexes[codecType]++
472 : null;
473 return {
474 ...stream,
475 codecType,
476 relativeIndex,
477 tags: stream.tags || {},
478 disposition: stream.disposition || {},
479 };
480 }) : [];
481
482 return {
483 raw: payload,
484 durationSeconds: inputDurationSeconds(payload, streams),
485 video: streams.filter((stream) => stream.codecType === 'video'),
486 audio: streams.filter((stream) => stream.codecType === 'audio'),
487 subtitles: streams.filter((stream) => stream.codecType === 'subtitle'),
488 };
489}
490
491function parsePositiveNumber (value)
492{
493 const number = Number(value);
494 return Number.isFinite(number) && number > 0 ? number : null;
495}
496
497function parseDurationTagSeconds (value)
498{
499 const raw = String(value || '').trim();
500 if (!raw) return null;
501
502 const numeric = parsePositiveNumber(raw);
503 if (numeric) return numeric;
504
505 const match = raw.match(/^(\d+):([0-5]?\d):([0-5]?\d(?:\.\d+)?)$/);
506 if (!match) return null;
507
508 const hours = Number(match[1]);
509 const minutes = Number(match[2]);
510 const seconds = Number(match[3]);
511 if (!Number.isFinite(hours) || !Number.isFinite(minutes) || !Number.isFinite(seconds)) return null;
512 return hours * 3600 + minutes * 60 + seconds;
513}
514
515function inputDurationSeconds (payload, streams)
516{
517 const formatDuration = parsePositiveNumber(payload && payload.format && payload.format.duration);
518 if (formatDuration) return formatDuration;
519
520 for (const stream of streams)
521 {
522 const duration = parsePositiveNumber(stream.duration);
523 if (duration) return duration;
524 }
525
526 const formatTags = payload && payload.format && payload.format.tags;
527 const formatTagDuration = formatTags && parseDurationTagSeconds(formatTags.duration || formatTags.DURATION);
528 if (formatTagDuration) return formatTagDuration;
529
530 for (const stream of streams)
531 {
532 const tagDuration = parseDurationTagSeconds(stream.tags.duration || stream.tags.DURATION);
533 if (tagDuration) return tagDuration;
534 }
535
536 return null;
537}
538
539function sanitiseTrackValue (value, fallback)
540{
541 const cleaned = String(value || '').trim().replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
542 return cleaned || fallback;
543}
544
545function trackLanguage (stream)
546{
547 return sanitiseTrackValue(stream.tags.language || stream.tags.LANGUAGE || 'und', 'und').slice(0, 8);
548}
549
550function trackLabel (stream, fallback)
551{
552 const title = String(stream.tags.title || stream.tags.handler_name || '').trim();
553 if (title) return title;
554 const language = trackLanguage(stream);
555 if (language && language !== 'und') return `${fallback} (${language})`;
556 return fallback;
557}
558
559function findMatchingSidecarSrtPath (sourcePath)
560{
561 const absoluteSourcePath = path.resolve(String(sourcePath || ''));
562 const dirPath = path.dirname(absoluteSourcePath);
563 const baseName = path.parse(absoluteSourcePath).name;
564 const exactPath = path.join(dirPath, `${baseName}.srt`);
565
566 try
567 {
568 const exactStat = fs.statSync(exactPath);
569 if (exactStat.isFile()) return exactPath;
570 } catch
571 {
572 // Fall back to case-insensitive directory scan.
573 }
574
575 const wantedName = `${baseName}.srt`.toLowerCase();
576
577 try
578 {
579 const entries = fs.readdirSync(dirPath, { withFileTypes: true });
580 for (const entry of entries)
581 {
582 if (!entry.isFile()) continue;
583 if (entry.name.toLowerCase() !== wantedName) continue;
584 return path.join(dirPath, entry.name);
585 }
586 } catch
587 {
588 return null;
589 }
590
591 return null;
592}
593
594async function extractSubtitleTracks (sourcePath, outputDir, subtitleStreams)
595{
596 const extractedTracks = [];
597 const imageBasedTracks = [];
598 let skippedCount = 0;
599 let trackNumber = 0;
600
601 for (const stream of subtitleStreams)
602 {
603 const codecName = String(stream.codec_name || '').toLowerCase();
604
605 // Image-based subtitle formats will be shown as DOM overlays via frame extraction.
606 if (IMAGE_BASED_SUBTITLE_CODECS.has(codecName))
607 {
608 imageBasedTracks.push({
609 label: trackLabel(stream, `Subtitle ${stream.relativeIndex + 1}`),
610 language: trackLanguage(stream),
611 isDefault: !!stream.disposition.default,
612 streamIndex: stream.relativeIndex,
613 });
614 continue;
615 }
616
617 const fileName = `subtitle-${trackNumber}.vtt`;
618 const targetPath = path.join(outputDir, fileName);
619
620 try
621 {
622 await runCommand(ffmpegPath(), [
623 '-hide_banner',
624 '-loglevel', 'error',
625 '-nostdin',
626 '-y',
627 '-i', sourcePath,
628 '-map', `0:s:${stream.relativeIndex}`,
629 '-c:s', 'webvtt',
630 targetPath,
631 ]);
632 } catch
633 {
634 skippedCount += 1;
635 continue;
636 }
637
638 extractedTracks.push({
639 fileName,
640 label: trackLabel(stream, `Subtitle ${trackNumber + 1}`),
641 language: trackLanguage(stream),
642 isDefault: !!stream.disposition.default,
643 });
644 trackNumber += 1;
645 }
646
647 const sidecarSrtPath = findMatchingSidecarSrtPath(sourcePath);
648 const hasSidecarSrt = !!sidecarSrtPath;
649 if (sidecarSrtPath)
650 {
651 const fileName = `subtitle-${trackNumber}.vtt`;
652 const targetPath = path.join(outputDir, fileName);
653 try
654 {
655 await runCommand(ffmpegPath(), [
656 '-hide_banner',
657 '-loglevel', 'error',
658 '-nostdin',
659 '-y',
660 '-i', sidecarSrtPath,
661 '-c:s', 'webvtt',
662 targetPath,
663 ]);
664
665 extractedTracks.push({
666 fileName,
667 label: `Subtitle ${trackNumber + 1} (external)`,
668 language: 'und',
669 isDefault: extractedTracks.length === 0 && imageBasedTracks.length === 0,
670 });
671 trackNumber += 1;
672 } catch
673 {
674 skippedCount += 1;
675 }
676 }
677
678 return {
679 tracks: extractedTracks,
680 imageBasedTracks,
681 hasSidecarSrt,
682 skippedCount,
683 };
684}
685
686function buildHlsArgs (sourcePath, outputDir, streamInfo)
687{
688 const args = [
689 '-hide_banner',
690 '-loglevel', 'error',
691 '-nostdin',
692 '-y',
693 '-i', sourcePath,
694 '-map', '0:v:0',
695 ];
696
697 for (const audioStream of streamInfo.audio)
698 {
699 args.push('-map', `0:a:${audioStream.relativeIndex}`);
700 }
701
702 args.push(
703 '-c:v', 'libx264',
704 '-preset', 'veryfast',
705 '-crf', '23',
706 '-pix_fmt', 'yuv420p',
707 '-g', '48',
708 '-sc_threshold', '0',
709 );
710
711 if (streamInfo.audio.length)
712 {
713 args.push('-c:a', 'aac', '-b:a', '160k', '-ac', '2');
714 } else
715 {
716 args.push('-an');
717 }
718
719 const variantMap = [];
720 if (streamInfo.audio.length)
721 {
722 variantMap.push('v:0,agroup:audio,name:video');
723 streamInfo.audio.forEach((audioStream, index) =>
724 {
725 let entry = `a:${index},agroup:audio,name:${sanitiseTrackValue(trackLabel(audioStream, `Audio ${index + 1}`), `audio-${index + 1}`)},language:${trackLanguage(audioStream)}`;
726 if (audioStream.disposition.default) entry += ',default:yes';
727 variantMap.push(entry);
728 });
729 } else
730 {
731 variantMap.push('v:0,name:video');
732 }
733
734 args.push(
735 '-f', 'hls',
736 '-hls_time', '4',
737 '-hls_list_size', '0',
738 '-hls_flags', 'independent_segments+temp_file',
739 '-master_pl_name', 'master.m3u8',
740 '-hls_segment_filename', path.join(outputDir, 'stream_%v_segment_%06d.ts'),
741 '-var_stream_map', variantMap.join(' '),
742 path.join(outputDir, 'stream_%v.m3u8'),
743 );
744
745 return args;
746}
747
748function startHlsTranscode (session, streamInfo)
749{
750 const args = buildHlsArgs(session.sourcePath, session.outputDir, streamInfo);
751 const child = spawn(ffmpegPath(), args, { stdio: ['ignore', 'ignore', 'pipe'] });
752 let stderr = '';
753
754 child.stderr.on('data', (chunk) =>
755 {
756 stderr += chunk.toString();
757 if (stderr.length > 16000) stderr = stderr.slice(-16000);
758 });
759
760 child.on('error', (err) =>
761 {
762 if (err && err.code === 'ENOENT')
763 {
764 session.error = makeHttpError(503, 'ffmpeg is not installed or not available in PATH.');
765 return;
766 }
767 session.error = err;
768 });
769
770 child.on('close', (code) =>
771 {
772 session.process = null;
773 if (code === 0 || session.error) return;
774 session.error = makeHttpError(500, stderr.trim() || `ffmpeg exited with code ${code}.`);
775 });
776
777 session.process = child;
778}
779
780function waitForFile (targetPath, session, timeoutMs = STREAM_READY_TIMEOUT_MS)
781{
782 const startedAt = Date.now();
783
784 return new Promise((resolve, reject) =>
785 {
786 const check = () =>
787 {
788 if (fs.existsSync(targetPath))
789 {
790 resolve();
791 return;
792 }
793
794 if (session.error)
795 {
796 reject(session.error);
797 return;
798 }
799
800 if (Date.now() - startedAt >= timeoutMs)
801 {
802 reject(makeHttpError(504, 'Timed out while preparing the video stream.'));
803 return;
804 }
805
806 setTimeout(check, 120);
807 };
808
809 check();
810 });
811}
812
813function waitForStreamStart (session, timeoutMs = STREAM_READY_TIMEOUT_MS)
814{
815 const startedAt = Date.now();
816
817 return new Promise((resolve, reject) =>
818 {
819 const check = () =>
820 {
821 if (fs.existsSync(path.join(session.outputDir, 'master.m3u8')) || hasInitialHlsAssets(session.outputDir))
822 {
823 resolve();
824 return;
825 }
826
827 if (session.error)
828 {
829 reject(session.error);
830 return;
831 }
832
833 if (!session.process)
834 {
835 reject(makeHttpError(500, 'Video stream preparation stopped unexpectedly.'));
836 return;
837 }
838
839 if (Date.now() - startedAt >= timeoutMs)
840 {
841 reject(makeHttpError(504, 'Timed out while preparing the video stream.'));
842 return;
843 }
844
845 setTimeout(check, 120);
846 };
847
848 check();
849 });
850}
851
852async function initialiseSession (session)
853{
854 const streamInfo = await probeInput(session.sourcePath);
855 if (!streamInfo.video.length)
856 {
857 throw makeHttpError(400, 'File does not contain a video stream.');
858 }
859
860 const primaryVideoStream = streamInfo.video[0] || {};
861 session.videoWidth = parsePositiveNumber(primaryVideoStream.width);
862 session.videoHeight = parsePositiveNumber(primaryVideoStream.height);
863
864 const subtitleResult = await extractSubtitleTracks(session.sourcePath, session.outputDir, streamInfo.subtitles);
865 session.subtitleTracks = subtitleResult.tracks;
866 session.imageSubtitleTracks = subtitleResult.imageBasedTracks;
867 session.subtitleSummary = {
868 total: streamInfo.subtitles.length + (subtitleResult.hasSidecarSrt ? 1 : 0),
869 converted: subtitleResult.tracks.length,
870 imageBased: subtitleResult.imageBasedTracks.length,
871 skipped: subtitleResult.skippedCount,
872 };
873 startHlsTranscode(session, streamInfo);
874 session.durationSeconds = streamInfo.durationSeconds;
875 await waitForStreamStart(session);
876}
877
878async function createVideoStreamSession (sourcePath)
879{
880 pruneExpiredSessions();
881 ensureStreamRootDir();
882
883 const sourceKey = String(sourcePath || '');
884 let session = null;
885
886 const reusableSessionId = reusableSessionIdBySource.get(sourceKey);
887 if (reusableSessionId)
888 {
889 const reusable = sessions.get(reusableSessionId);
890 if (reusable && !reusable.error && reusable.segmentPrunedUntil < 0)
891 {
892 session = reusable;
893 } else
894 {
895 reusableSessionIdBySource.delete(sourceKey);
896 }
897 }
898
899 if (!session)
900 {
901 const sessionId = crypto.randomBytes(18).toString('hex');
902 const outputDir = path.join(STREAM_ROOT_DIR, sessionId);
903 fs.mkdirSync(outputDir, { recursive: true });
904
905 session = {
906 id: sessionId,
907 sourcePath: String(sourcePath || ''),
908 sourceKey: sourceKey,
909 outputDir,
910 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
911 process: null,
912 error: null,
913 subtitleTracks: [],
914 imageSubtitleTracks: [],
915 subtitleSummary: { total: 0, converted: 0, imageBased: 0, skipped: 0 },
916 readyPromise: null,
917 activeRequests: 0,
918 lastActivityAt: Date.now(),
919 idleTimer: null,
920 segmentPruneRunning: false,
921 segmentPrunePendingCutoff: -1,
922 segmentPrunedUntil: -1,
923 leaseIds: new Set(),
924 };
925
926 session.readyPromise = initialiseSession(session).catch((err) =>
927 {
928 session.error = err;
929 throw err;
930 });
931
932 sessions.set(session.id, session);
933 reusableSessionIdBySource.set(sourceKey, session.id);
934 }
935
936 if (!session.leaseIds) session.leaseIds = new Set();
937 const lease = createLeaseForSession(session);
938 touchSessionActivity(session, lease);
939
940 try
941 {
942 await session.readyPromise;
943 } catch (err)
944 {
945 releaseVideoStreamSession(lease.id);
946 throw err;
947 }
948
949 return {
950 sessionId: lease.id,
951 durationSeconds: session.durationSeconds,
952 videoWidth: session.videoWidth || null,
953 videoHeight: session.videoHeight || null,
954 subtitleTracks: session.subtitleTracks.map((track) => ({ ...track })),
955 imageSubtitleTracks: (session.imageSubtitleTracks || []).map((track) => ({ ...track })),
956 subtitleSummary: {
957 total: Number(session.subtitleSummary.total || 0),
958 converted: Number(session.subtitleSummary.converted || 0),
959 imageBased: Number(session.subtitleSummary.imageBased || 0),
960 skipped: Number(session.subtitleSummary.skipped || 0),
961 },
962 };
963}
964
965function contentTypeForAsset (assetPath)
966{
967 const ext = path.extname(assetPath).toLowerCase();
968 if (ext === '.m3u8') return 'application/vnd.apple.mpegurl';
969 if (ext === '.ts') return 'video/mp2t';
970 if (ext === '.vtt') return 'text/vtt; charset=utf-8';
971 if (ext === '.aac') return 'audio/aac';
972 if (ext === '.mp4' || ext === '.m4s') return 'video/mp4';
973 return 'application/octet-stream';
974}
975
976async function sendVideoStreamAsset (sessionId, assetPath, req, res)
977{
978 pruneExpiredSessions();
979 const active = getSessionForLease(sessionId);
980 if (!active) throw makeHttpError(404, 'Video stream session not found.');
981
982 const { session, lease } = active;
983
984 touchSessionActivity(session, lease);
985 await session.readyPromise;
986
987 const relativeAssetPath = String(assetPath || 'master.m3u8').replace(/^[/\\]+/, '');
988 const resolvedPath = path.resolve(session.outputDir, relativeAssetPath);
989 const resolvedRoot = path.resolve(session.outputDir);
990 if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(resolvedRoot + path.sep))
991 {
992 throw makeHttpError(404, 'Stream asset not found.');
993 }
994
995 const segmentIndex = parseSegmentIndexFromAssetPath(relativeAssetPath);
996 if (segmentIndex !== null) scheduleSegmentPrune(session, lease, segmentIndex);
997
998 await waitForFile(resolvedPath, session);
999 res.set('Cache-Control', 'private, no-store');
1000 res.type(contentTypeForAsset(resolvedPath));
1001
1002 startAssetRequest(session, lease);
1003
1004 let settled = false;
1005 const finish = () =>
1006 {
1007 if (settled) return;
1008 settled = true;
1009 finishAssetRequest(session, lease);
1010 };
1011
1012 req.on('aborted', finish);
1013 res.on('close', finish);
1014 res.on('finish', finish);
1015 res.on('error', finish);
1016
1017 await new Promise((resolve, reject) =>
1018 {
1019 res.sendFile(resolvedPath, (err) =>
1020 {
1021 finish();
1022 if (!err)
1023 {
1024 resolve();
1025 return;
1026 }
1027
1028 if (err.code === 'ECONNABORTED' || err.message === 'Request aborted')
1029 {
1030 resolve();
1031 return;
1032 }
1033
1034 reject(err);
1035 });
1036 });
1037}
1038
1039function releaseVideoStreamSession (sessionId)
1040{
1041 const leaseId = String(sessionId || '');
1042 const active = getSessionForLease(leaseId);
1043 if (!active)
1044 {
1045 leases.delete(leaseId);
1046 return false;
1047 }
1048
1049 const { session } = active;
1050 leases.delete(leaseId);
1051 session.leaseIds.delete(leaseId);
1052
1053 if (session.leaseIds.size === 0 && session.activeRequests === 0)
1054 {
1055 return destroySession(session.id);
1056 }
1057
1058 return true;
1059}
1060
1061function collectOutputDirStats (outputDir)
1062{
1063 const stats = {
1064 exists: false,
1065 totalBytes: 0,
1066 totalFiles: 0,
1067 segmentFiles: 0,
1068 segmentBytes: 0,
1069 playlistFiles: 0,
1070 subtitleFiles: 0,
1071 };
1072
1073 if (!outputDir || !fs.existsSync(outputDir)) return stats;
1074 stats.exists = true;
1075
1076 let entries = [];
1077 try
1078 {
1079 entries = fs.readdirSync(outputDir, { withFileTypes: true });
1080 } catch
1081 {
1082 return stats;
1083 }
1084
1085 for (const entry of entries)
1086 {
1087 if (!entry.isFile()) continue;
1088 const name = entry.name;
1089 const fullPath = path.join(outputDir, name);
1090 let size = 0;
1091 try
1092 {
1093 const fileStat = fs.statSync(fullPath);
1094 size = Number(fileStat.size) || 0;
1095 } catch
1096 {
1097 size = 0;
1098 }
1099
1100 stats.totalFiles += 1;
1101 stats.totalBytes += size;
1102
1103 if (/\.ts$/i.test(name))
1104 {
1105 stats.segmentFiles += 1;
1106 stats.segmentBytes += size;
1107 continue;
1108 }
1109
1110 if (/\.m3u8$/i.test(name))
1111 {
1112 stats.playlistFiles += 1;
1113 continue;
1114 }
1115
1116 if (/\.(sup|vtt)$/i.test(name))
1117 {
1118 stats.subtitleFiles += 1;
1119 }
1120 }
1121
1122 return stats;
1123}
1124
1125function getVideoStreamDebugSnapshot ()
1126{
1127 const activeStreams = [];
1128
1129 for (const [sessionId, session] of sessions.entries())
1130 {
1131 activeStreams.push({
1132 sessionId,
1133 sourcePath: session.sourcePath,
1134 outputDir: session.outputDir,
1135 viewers: session.leaseIds ? session.leaseIds.size : 0,
1136 activeRequests: Number(session.activeRequests || 0),
1137 expiresAt: Number(session.expiresAt || 0),
1138 output: collectOutputDirStats(session.outputDir),
1139 });
1140 }
1141
1142 const knownSessionDirs = new Set(activeStreams.map((stream) => path.resolve(stream.outputDir || '')));
1143 const orphanedOutputDirs = [];
1144 try
1145 {
1146 const entries = fs.readdirSync(STREAM_ROOT_DIR, { withFileTypes: true });
1147 for (const entry of entries)
1148 {
1149 if (!entry.isDirectory()) continue;
1150 const dirPath = path.resolve(path.join(STREAM_ROOT_DIR, entry.name));
1151 if (knownSessionDirs.has(dirPath)) continue;
1152 orphanedOutputDirs.push({
1153 outputDir: dirPath,
1154 output: collectOutputDirStats(dirPath),
1155 });
1156 }
1157 } catch
1158 {
1159 // Stream root may not exist yet.
1160 }
1161
1162 return {
1163 streamRootDir: STREAM_ROOT_DIR,
1164 activeSessionCount: sessions.size,
1165 activeLeaseCount: leases.size,
1166 activeStreams,
1167 orphanedOutputDirs,
1168 };
1169}
1170
1171module.exports = {
1172 STREAM_ROOT_DIR,
1173 STREAM_SESSION_TTL_MS,
1174 STREAM_IDLE_STOP_MS,
1175 STREAM_SEGMENT_RETENTION_COUNT,
1176 createVideoStreamSession,
1177 sendVideoStreamAsset,
1178 releaseVideoStreamSession,
1179 getVideoStreamDebugSnapshot,
1180};