BlueGit

timfa filemanager

Files

filemanager / server / video-stream.js

video-stream.js

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