BlueGit

timfa filemanager

Files

filemanager / server / video-stream.js

video-stream.js

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