BlueGit

timfa filemanager

Files

filemanager / server / video-stream.js

video-stream.js

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