BlueGit

timfa filemanager

Share video transcodes across concurrent viewers

timfa Tim Falken · pushed by timfa

Authored 2026-05-14 · 6 months ago

Hash
d35a8803aa1b9e09a1e2eb730043df834e5f09ce
Parent
c171b6b7
2 files changed +257 −46
server/video-stream.js +184 −45
@@ -13,6 +13,8 @@ const STREAM_IDLE_STOP_MS = 5 * 60 * 1000;
13 13 const ESTIMATED_SEGMENT_BYTES = 1024 * 1024;
14 14 const STREAM_SEGMENT_RETENTION_COUNT = parseSegmentRetentionCount(process.env.VIDEO_STREAM_SEGMENT_RETENTION_COUNT);
15 15 const sessions = new Map();
16 const leases = new Map();
17 const reusableSessionIdBySource = new Map();
16 18
17 19 function parseSegmentRetentionCount (value)
18 20 {
@@ -136,6 +138,13 @@ function ffprobePath ()
136 138 function pruneExpiredSessions ()
137 139 {
138 140 const now = Date.now();
141
142 for (const [leaseId, lease] of leases)
143 {
144 if (lease.expiresAt > now) continue;
145 releaseVideoStreamSession(leaseId);
146 }
147
139 148 for (const [sessionId, session] of sessions)
140 149 {
141 150 if (session.expiresAt > now) continue;
@@ -148,6 +157,11 @@ function refreshSession (session)
148 157 session.expiresAt = Date.now() + STREAM_SESSION_TTL_MS;
149 158 }
150 159
160 function refreshLease (lease)
161 {
162 lease.expiresAt = Date.now() + STREAM_SESSION_TTL_MS;
163 }
164
151 165 function destroySession (sessionId)
152 166 {
153 167 const session = sessions.get(sessionId);
@@ -155,6 +169,20 @@ function destroySession (sessionId)
155 169
156 170 sessions.delete(sessionId);
157 171
172 if (reusableSessionIdBySource.get(session.sourcePath) === session.id)
173 {
174 reusableSessionIdBySource.delete(session.sourcePath);
175 }
176
177 if (session.leaseIds)
178 {
179 for (const leaseId of session.leaseIds)
180 {
181 leases.delete(leaseId);
182 }
183 session.leaseIds.clear();
184 }
185
158 186 if (session.idleTimer)
159 187 {
160 188 clearTimeout(session.idleTimer);
@@ -173,10 +201,46 @@ function destroySession (sessionId)
173 201 return true;
174 202 }
175 203
176 function touchSessionActivity (session)
204 function getSessionForLease (leaseId)
205 {
206 const lease = leases.get(leaseId);
207 if (!lease) return null;
208
209 const session = sessions.get(lease.sessionId);
210 if (!session)
211 {
212 leases.delete(leaseId);
213 return null;
214 }
215
216 return { lease, session };
217 }
218
219 function createLeaseForSession (session)
220 {
221 const leaseId = crypto.randomBytes(18).toString('hex');
222 const lease = {
223 id: leaseId,
224 sessionId: session.id,
225 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
226 lastActivityAt: Date.now(),
227 lastSegmentIndex: null,
228 };
229 leases.set(leaseId, lease);
230 session.leaseIds.add(leaseId);
231 return lease;
232 }
233
234 function touchSessionActivity (session, lease)
177 235 {
178 236 refreshSession(session);
179 237 session.lastActivityAt = Date.now();
238
239 if (lease)
240 {
241 refreshLease(lease);
242 lease.lastActivityAt = Date.now();
243 }
180 244 }
181 245
182 246 function clearIdleStopTimer (session)
@@ -189,13 +253,13 @@ function clearIdleStopTimer (session)
189 253 function scheduleIdleStop (session)
190 254 {
191 255 clearIdleStopTimer(session);
192 if (session.activeRequests > 0) return;
256 if (session.activeRequests > 0 || (session.leaseIds && session.leaseIds.size > 0)) return;
193 257
194 258 session.idleTimer = setTimeout(() =>
195 259 {
196 260 const activeSession = sessions.get(session.id);
197 261 if (!activeSession) return;
198 if (activeSession.activeRequests > 0) return;
262 if (activeSession.activeRequests > 0 || (activeSession.leaseIds && activeSession.leaseIds.size > 0)) return;
199 263 if (Date.now() - activeSession.lastActivityAt < STREAM_IDLE_STOP_MS)
200 264 {
201 265 scheduleIdleStop(activeSession);
@@ -205,18 +269,18 @@ function scheduleIdleStop (session)
205 269 }, STREAM_IDLE_STOP_MS);
206 270 }
207 271
208 function startAssetRequest (session)
272 function startAssetRequest (session, lease)
209 273 {
210 274 session.activeRequests += 1;
211 touchSessionActivity(session);
275 touchSessionActivity(session, lease);
212 276 clearIdleStopTimer(session);
213 277 }
214 278
215 function finishAssetRequest (session)
279 function finishAssetRequest (session, lease)
216 280 {
217 281 if (session.activeRequests > 0) session.activeRequests -= 1;
218 touchSessionActivity(session);
219 if (session.activeRequests === 0) scheduleIdleStop(session);
282 touchSessionActivity(session, lease);
283 if (session.activeRequests === 0 && session.leaseIds.size === 0) scheduleIdleStop(session);
220 284 }
221 285
222 286 function parseSegmentIndexFromAssetPath (assetPath)
@@ -261,6 +325,10 @@ function runSegmentPrune (session)
261 325 .then(() =>
262 326 {
263 327 session.segmentPrunedUntil = Math.max(session.segmentPrunedUntil, cutoff);
328 if (session.segmentPrunedUntil >= 0 && reusableSessionIdBySource.get(session.sourcePath) === session.id)
329 {
330 reusableSessionIdBySource.delete(session.sourcePath);
331 }
264 332 })
265 333 .catch(() =>
266 334 {
@@ -276,11 +344,31 @@ function runSegmentPrune (session)
276 344 });
277 345 }
278 346
279 function scheduleSegmentPrune (session, segmentIndex)
347 function slowestLeaseSegmentIndex (session)
348 {
349 if (!session.leaseIds.size) return null;
350
351 let minIndex = null;
352 for (const leaseId of session.leaseIds)
353 {
354 const lease = leases.get(leaseId);
355 if (!lease) continue;
356 if (!Number.isInteger(lease.lastSegmentIndex)) return null;
357 if (minIndex === null || lease.lastSegmentIndex < minIndex) minIndex = lease.lastSegmentIndex;
358 }
359
360 return minIndex;
361 }
362
363 function scheduleSegmentPrune (session, lease, segmentIndex)
280 364 {
281 365 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return;
282 366
283 const pruneCutoff = segmentIndex - STREAM_SEGMENT_RETENTION_COUNT;
367 lease.lastSegmentIndex = segmentIndex;
368 const slowestIndex = slowestLeaseSegmentIndex(session);
369 if (!Number.isInteger(slowestIndex)) return;
370
371 const pruneCutoff = slowestIndex - STREAM_SEGMENT_RETENTION_COUNT;
284 372 if (pruneCutoff <= session.segmentPrunedUntil) return;
285 373
286 374 session.segmentPrunePendingCutoff = Math.max(session.segmentPrunePendingCutoff, pruneCutoff);
@@ -674,39 +762,72 @@ async function createVideoStreamSession (sourcePath)
674 762 pruneExpiredSessions();
675 763 ensureStreamRootDir();
676 764
677 const sessionId = crypto.randomBytes(18).toString('hex');
678 const outputDir = path.join(STREAM_ROOT_DIR, sessionId);
679 fs.mkdirSync(outputDir, { recursive: true });
765 const sourceKey = String(sourcePath || '');
766 let session = null;
680 767
681 const session = {
682 id: sessionId,
683 sourcePath,
684 outputDir,
685 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
686 process: null,
687 error: null,
688 subtitleTracks: [],
689 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
690 readyPromise: null,
691 activeRequests: 0,
692 lastActivityAt: Date.now(),
693 idleTimer: null,
694 segmentPruneRunning: false,
695 segmentPrunePendingCutoff: -1,
696 segmentPrunedUntil: -1,
697 };
768 const reusableSessionId = reusableSessionIdBySource.get(sourceKey);
769 if (reusableSessionId)
770 {
771 const reusable = sessions.get(reusableSessionId);
772 if (reusable && !reusable.error && reusable.segmentPrunedUntil < 0)
773 {
774 session = reusable;
775 } else
776 {
777 reusableSessionIdBySource.delete(sourceKey);
778 }
779 }
780
781 if (!session)
782 {
783 const sessionId = crypto.randomBytes(18).toString('hex');
784 const outputDir = path.join(STREAM_ROOT_DIR, sessionId);
785 fs.mkdirSync(outputDir, { recursive: true });
786
787 session = {
788 id: sessionId,
789 sourcePath: sourceKey,
790 outputDir,
791 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
792 process: null,
793 error: null,
794 subtitleTracks: [],
795 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
796 readyPromise: null,
797 activeRequests: 0,
798 lastActivityAt: Date.now(),
799 idleTimer: null,
800 segmentPruneRunning: false,
801 segmentPrunePendingCutoff: -1,
802 segmentPrunedUntil: -1,
803 leaseIds: new Set(),
804 };
805
806 session.readyPromise = initialiseSession(session).catch((err) =>
807 {
808 session.error = err;
809 throw err;
810 });
811
812 sessions.set(session.id, session);
813 reusableSessionIdBySource.set(sourceKey, session.id);
814 }
815
816 if (!session.leaseIds) session.leaseIds = new Set();
817 const lease = createLeaseForSession(session);
818 touchSessionActivity(session, lease);
698 819
699 session.readyPromise = initialiseSession(session).catch((err) =>
820 try
700 821 {
701 session.error = err;
822 await session.readyPromise;
823 } catch (err)
824 {
825 releaseVideoStreamSession(lease.id);
702 826 throw err;
703 });
704
705 sessions.set(sessionId, session);
706 await session.readyPromise;
827 }
707 828
708 829 return {
709 sessionId,
830 sessionId: lease.id,
710 831 durationSeconds: session.durationSeconds,
711 832 subtitleTracks: session.subtitleTracks.map((track) => ({ ...track })),
712 833 subtitleSummary: {
@@ -731,10 +852,12 @@ function contentTypeForAsset (assetPath)
731 852 async function sendVideoStreamAsset (sessionId, assetPath, req, res)
732 853 {
733 854 pruneExpiredSessions();
734 const session = sessions.get(sessionId);
735 if (!session) throw makeHttpError(404, 'Video stream session not found.');
855 const active = getSessionForLease(sessionId);
856 if (!active) throw makeHttpError(404, 'Video stream session not found.');
736 857
737 touchSessionActivity(session);
858 const { session, lease } = active;
859
860 touchSessionActivity(session, lease);
738 861 await session.readyPromise;
739 862
740 863 const relativeAssetPath = String(assetPath || 'master.m3u8').replace(/^[/\\]+/, '');
@@ -746,20 +869,20 @@ async function sendVideoStreamAsset (sessionId, assetPath, req, res)
746 869 }
747 870
748 871 const segmentIndex = parseSegmentIndexFromAssetPath(relativeAssetPath);
749 if (segmentIndex !== null) scheduleSegmentPrune(session, segmentIndex);
872 if (segmentIndex !== null) scheduleSegmentPrune(session, lease, segmentIndex);
750 873
751 874 await waitForFile(resolvedPath, session);
752 875 res.set('Cache-Control', 'private, no-store');
753 876 res.type(contentTypeForAsset(resolvedPath));
754 877
755 startAssetRequest(session);
878 startAssetRequest(session, lease);
756 879
757 880 let settled = false;
758 881 const finish = () =>
759 882 {
760 883 if (settled) return;
761 884 settled = true;
762 finishAssetRequest(session);
885 finishAssetRequest(session, lease);
763 886 };
764 887
765 888 req.on('aborted', finish);
@@ -791,8 +914,24 @@ async function sendVideoStreamAsset (sessionId, assetPath, req, res)
791 914
792 915 function releaseVideoStreamSession (sessionId)
793 916 {
794 pruneExpiredSessions();
795 return destroySession(String(sessionId || ''));
917 const leaseId = String(sessionId || '');
918 const active = getSessionForLease(leaseId);
919 if (!active)
920 {
921 leases.delete(leaseId);
922 return false;
923 }
924
925 const { session } = active;
926 leases.delete(leaseId);
927 session.leaseIds.delete(leaseId);
928
929 if (session.leaseIds.size === 0 && session.activeRequests === 0)
930 {
931 return destroySession(session.id);
932 }
933
934 return true;
796 935 }
797 936
798 937 module.exports = {
@@ -13,6 +13,8 @@ const STREAM_IDLE_STOP_MS = 5 * 60 * 1000;
13const ESTIMATED_SEGMENT_BYTES = 1024 * 1024;
13const ESTIMATED_SEGMENT_BYTES = 1024 * 1024;
14const STREAM_SEGMENT_RETENTION_COUNT = parseSegmentRetentionCount(process.env.VIDEO_STREAM_SEGMENT_RETENTION_COUNT);
14const STREAM_SEGMENT_RETENTION_COUNT = parseSegmentRetentionCount(process.env.VIDEO_STREAM_SEGMENT_RETENTION_COUNT);
15const sessions = new Map();
15const sessions = new Map();
16const leases = new Map();
17const reusableSessionIdBySource = new Map();
16
18
17function parseSegmentRetentionCount (value)
19function parseSegmentRetentionCount (value)
18{
20{
@@ -136,6 +138,13 @@ function ffprobePath ()
136function pruneExpiredSessions ()
138function pruneExpiredSessions ()
137{
139{
138 const now = Date.now();
140 const now = Date.now();
141
142 for (const [leaseId, lease] of leases)
143 {
144 if (lease.expiresAt > now) continue;
145 releaseVideoStreamSession(leaseId);
146 }
147
139 for (const [sessionId, session] of sessions)
148 for (const [sessionId, session] of sessions)
140 {
149 {
141 if (session.expiresAt > now) continue;
150 if (session.expiresAt > now) continue;
@@ -148,6 +157,11 @@ function refreshSession (session)
148 session.expiresAt = Date.now() + STREAM_SESSION_TTL_MS;
157 session.expiresAt = Date.now() + STREAM_SESSION_TTL_MS;
149}
158}
150
159
160function refreshLease (lease)
161{
162 lease.expiresAt = Date.now() + STREAM_SESSION_TTL_MS;
163}
164
151function destroySession (sessionId)
165function destroySession (sessionId)
152{
166{
153 const session = sessions.get(sessionId);
167 const session = sessions.get(sessionId);
@@ -155,6 +169,20 @@ function destroySession (sessionId)
155
169
156 sessions.delete(sessionId);
170 sessions.delete(sessionId);
157
171
172 if (reusableSessionIdBySource.get(session.sourcePath) === session.id)
173 {
174 reusableSessionIdBySource.delete(session.sourcePath);
175 }
176
177 if (session.leaseIds)
178 {
179 for (const leaseId of session.leaseIds)
180 {
181 leases.delete(leaseId);
182 }
183 session.leaseIds.clear();
184 }
185
158 if (session.idleTimer)
186 if (session.idleTimer)
159 {
187 {
160 clearTimeout(session.idleTimer);
188 clearTimeout(session.idleTimer);
@@ -173,10 +201,46 @@ function destroySession (sessionId)
173 return true;
201 return true;
174}
202}
175
203
176function touchSessionActivity (session)
204function getSessionForLease (leaseId)
205{
206 const lease = leases.get(leaseId);
207 if (!lease) return null;
208
209 const session = sessions.get(lease.sessionId);
210 if (!session)
211 {
212 leases.delete(leaseId);
213 return null;
214 }
215
216 return { lease, session };
217}
218
219function createLeaseForSession (session)
220{
221 const leaseId = crypto.randomBytes(18).toString('hex');
222 const lease = {
223 id: leaseId,
224 sessionId: session.id,
225 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
226 lastActivityAt: Date.now(),
227 lastSegmentIndex: null,
228 };
229 leases.set(leaseId, lease);
230 session.leaseIds.add(leaseId);
231 return lease;
232}
233
234function touchSessionActivity (session, lease)
177{
235{
178 refreshSession(session);
236 refreshSession(session);
179 session.lastActivityAt = Date.now();
237 session.lastActivityAt = Date.now();
238
239 if (lease)
240 {
241 refreshLease(lease);
242 lease.lastActivityAt = Date.now();
243 }
180}
244}
181
245
182function clearIdleStopTimer (session)
246function clearIdleStopTimer (session)
@@ -189,13 +253,13 @@ function clearIdleStopTimer (session)
189function scheduleIdleStop (session)
253function scheduleIdleStop (session)
190{
254{
191 clearIdleStopTimer(session);
255 clearIdleStopTimer(session);
192 if (session.activeRequests > 0) return;
256 if (session.activeRequests > 0 || (session.leaseIds && session.leaseIds.size > 0)) return;
193
257
194 session.idleTimer = setTimeout(() =>
258 session.idleTimer = setTimeout(() =>
195 {
259 {
196 const activeSession = sessions.get(session.id);
260 const activeSession = sessions.get(session.id);
197 if (!activeSession) return;
261 if (!activeSession) return;
198 if (activeSession.activeRequests > 0) return;
262 if (activeSession.activeRequests > 0 || (activeSession.leaseIds && activeSession.leaseIds.size > 0)) return;
199 if (Date.now() - activeSession.lastActivityAt < STREAM_IDLE_STOP_MS)
263 if (Date.now() - activeSession.lastActivityAt < STREAM_IDLE_STOP_MS)
200 {
264 {
201 scheduleIdleStop(activeSession);
265 scheduleIdleStop(activeSession);
@@ -205,18 +269,18 @@ function scheduleIdleStop (session)
205 }, STREAM_IDLE_STOP_MS);
269 }, STREAM_IDLE_STOP_MS);
206}
270}
207
271
208function startAssetRequest (session)
272function startAssetRequest (session, lease)
209{
273{
210 session.activeRequests += 1;
274 session.activeRequests += 1;
211 touchSessionActivity(session);
275 touchSessionActivity(session, lease);
212 clearIdleStopTimer(session);
276 clearIdleStopTimer(session);
213}
277}
214
278
215function finishAssetRequest (session)
279function finishAssetRequest (session, lease)
216{
280{
217 if (session.activeRequests > 0) session.activeRequests -= 1;
281 if (session.activeRequests > 0) session.activeRequests -= 1;
218 touchSessionActivity(session);
282 touchSessionActivity(session, lease);
219 if (session.activeRequests === 0) scheduleIdleStop(session);
283 if (session.activeRequests === 0 && session.leaseIds.size === 0) scheduleIdleStop(session);
220}
284}
221
285
222function parseSegmentIndexFromAssetPath (assetPath)
286function parseSegmentIndexFromAssetPath (assetPath)
@@ -261,6 +325,10 @@ function runSegmentPrune (session)
261 .then(() =>
325 .then(() =>
262 {
326 {
263 session.segmentPrunedUntil = Math.max(session.segmentPrunedUntil, cutoff);
327 session.segmentPrunedUntil = Math.max(session.segmentPrunedUntil, cutoff);
328 if (session.segmentPrunedUntil >= 0 && reusableSessionIdBySource.get(session.sourcePath) === session.id)
329 {
330 reusableSessionIdBySource.delete(session.sourcePath);
331 }
264 })
332 })
265 .catch(() =>
333 .catch(() =>
266 {
334 {
@@ -276,11 +344,31 @@ function runSegmentPrune (session)
276 });
344 });
277}
345}
278
346
279function scheduleSegmentPrune (session, segmentIndex)
347function slowestLeaseSegmentIndex (session)
348{
349 if (!session.leaseIds.size) return null;
350
351 let minIndex = null;
352 for (const leaseId of session.leaseIds)
353 {
354 const lease = leases.get(leaseId);
355 if (!lease) continue;
356 if (!Number.isInteger(lease.lastSegmentIndex)) return null;
357 if (minIndex === null || lease.lastSegmentIndex < minIndex) minIndex = lease.lastSegmentIndex;
358 }
359
360 return minIndex;
361}
362
363function scheduleSegmentPrune (session, lease, segmentIndex)
280{
364{
281 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return;
365 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return;
282
366
283 const pruneCutoff = segmentIndex - STREAM_SEGMENT_RETENTION_COUNT;
367 lease.lastSegmentIndex = segmentIndex;
368 const slowestIndex = slowestLeaseSegmentIndex(session);
369 if (!Number.isInteger(slowestIndex)) return;
370
371 const pruneCutoff = slowestIndex - STREAM_SEGMENT_RETENTION_COUNT;
284 if (pruneCutoff <= session.segmentPrunedUntil) return;
372 if (pruneCutoff <= session.segmentPrunedUntil) return;
285
373
286 session.segmentPrunePendingCutoff = Math.max(session.segmentPrunePendingCutoff, pruneCutoff);
374 session.segmentPrunePendingCutoff = Math.max(session.segmentPrunePendingCutoff, pruneCutoff);
@@ -674,39 +762,72 @@ async function createVideoStreamSession (sourcePath)
674 pruneExpiredSessions();
762 pruneExpiredSessions();
675 ensureStreamRootDir();
763 ensureStreamRootDir();
676
764
677 const sessionId = crypto.randomBytes(18).toString('hex');
765 const sourceKey = String(sourcePath || '');
678 const outputDir = path.join(STREAM_ROOT_DIR, sessionId);
766 let session = null;
679 fs.mkdirSync(outputDir, { recursive: true });
680
767
681 const session = {
768 const reusableSessionId = reusableSessionIdBySource.get(sourceKey);
682 id: sessionId,
769 if (reusableSessionId)
683 sourcePath,
770 {
684 outputDir,
771 const reusable = sessions.get(reusableSessionId);
685 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
772 if (reusable && !reusable.error && reusable.segmentPrunedUntil < 0)
686 process: null,
773 {
687 error: null,
774 session = reusable;
688 subtitleTracks: [],
775 } else
689 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
776 {
690 readyPromise: null,
777 reusableSessionIdBySource.delete(sourceKey);
691 activeRequests: 0,
778 }
692 lastActivityAt: Date.now(),
779 }
693 idleTimer: null,
780
694 segmentPruneRunning: false,
781 if (!session)
695 segmentPrunePendingCutoff: -1,
782 {
696 segmentPrunedUntil: -1,
783 const sessionId = crypto.randomBytes(18).toString('hex');
697 };
784 const outputDir = path.join(STREAM_ROOT_DIR, sessionId);
785 fs.mkdirSync(outputDir, { recursive: true });
786
787 session = {
788 id: sessionId,
789 sourcePath: sourceKey,
790 outputDir,
791 expiresAt: Date.now() + STREAM_SESSION_TTL_MS,
792 process: null,
793 error: null,
794 subtitleTracks: [],
795 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
796 readyPromise: null,
797 activeRequests: 0,
798 lastActivityAt: Date.now(),
799 idleTimer: null,
800 segmentPruneRunning: false,
801 segmentPrunePendingCutoff: -1,
802 segmentPrunedUntil: -1,
803 leaseIds: new Set(),
804 };
805
806 session.readyPromise = initialiseSession(session).catch((err) =>
807 {
808 session.error = err;
809 throw err;
810 });
811
812 sessions.set(session.id, session);
813 reusableSessionIdBySource.set(sourceKey, session.id);
814 }
815
816 if (!session.leaseIds) session.leaseIds = new Set();
817 const lease = createLeaseForSession(session);
818 touchSessionActivity(session, lease);
698
819
699 session.readyPromise = initialiseSession(session).catch((err) =>
820 try
700 {
821 {
701 session.error = err;
822 await session.readyPromise;
823 } catch (err)
824 {
825 releaseVideoStreamSession(lease.id);
702 throw err;
826 throw err;
703 });
827 }
704
705 sessions.set(sessionId, session);
706 await session.readyPromise;
707
828
708 return {
829 return {
709 sessionId,
830 sessionId: lease.id,
710 durationSeconds: session.durationSeconds,
831 durationSeconds: session.durationSeconds,
711 subtitleTracks: session.subtitleTracks.map((track) => ({ ...track })),
832 subtitleTracks: session.subtitleTracks.map((track) => ({ ...track })),
712 subtitleSummary: {
833 subtitleSummary: {
@@ -731,10 +852,12 @@ function contentTypeForAsset (assetPath)
731async function sendVideoStreamAsset (sessionId, assetPath, req, res)
852async function sendVideoStreamAsset (sessionId, assetPath, req, res)
732{
853{
733 pruneExpiredSessions();
854 pruneExpiredSessions();
734 const session = sessions.get(sessionId);
855 const active = getSessionForLease(sessionId);
735 if (!session) throw makeHttpError(404, 'Video stream session not found.');
856 if (!active) throw makeHttpError(404, 'Video stream session not found.');
736
857
737 touchSessionActivity(session);
858 const { session, lease } = active;
859
860 touchSessionActivity(session, lease);
738 await session.readyPromise;
861 await session.readyPromise;
739
862
740 const relativeAssetPath = String(assetPath || 'master.m3u8').replace(/^[/\\]+/, '');
863 const relativeAssetPath = String(assetPath || 'master.m3u8').replace(/^[/\\]+/, '');
@@ -746,20 +869,20 @@ async function sendVideoStreamAsset (sessionId, assetPath, req, res)
746 }
869 }
747
870
748 const segmentIndex = parseSegmentIndexFromAssetPath(relativeAssetPath);
871 const segmentIndex = parseSegmentIndexFromAssetPath(relativeAssetPath);
749 if (segmentIndex !== null) scheduleSegmentPrune(session, segmentIndex);
872 if (segmentIndex !== null) scheduleSegmentPrune(session, lease, segmentIndex);
750
873
751 await waitForFile(resolvedPath, session);
874 await waitForFile(resolvedPath, session);
752 res.set('Cache-Control', 'private, no-store');
875 res.set('Cache-Control', 'private, no-store');
753 res.type(contentTypeForAsset(resolvedPath));
876 res.type(contentTypeForAsset(resolvedPath));
754
877
755 startAssetRequest(session);
878 startAssetRequest(session, lease);
756
879
757 let settled = false;
880 let settled = false;
758 const finish = () =>
881 const finish = () =>
759 {
882 {
760 if (settled) return;
883 if (settled) return;
761 settled = true;
884 settled = true;
762 finishAssetRequest(session);
885 finishAssetRequest(session, lease);
763 };
886 };
764
887
765 req.on('aborted', finish);
888 req.on('aborted', finish);
@@ -791,8 +914,24 @@ async function sendVideoStreamAsset (sessionId, assetPath, req, res)
791
914
792function releaseVideoStreamSession (sessionId)
915function releaseVideoStreamSession (sessionId)
793{
916{
794 pruneExpiredSessions();
917 const leaseId = String(sessionId || '');
795 return destroySession(String(sessionId || ''));
918 const active = getSessionForLease(leaseId);
919 if (!active)
920 {
921 leases.delete(leaseId);
922 return false;
923 }
924
925 const { session } = active;
926 leases.delete(leaseId);
927 session.leaseIds.delete(leaseId);
928
929 if (session.leaseIds.size === 0 && session.activeRequests === 0)
930 {
931 return destroySession(session.id);
932 }
933
934 return true;
796}
935}
797
936
798module.exports = {
937module.exports = {
tests/video-stream.test.js +73 −1
@@ -380,8 +380,16 @@ describe('video stream bootstrap', () =>
380 380 });
381 381
382 382 const streamModule = require('../server/video-stream');
383 const beforeDirs = new Set(
384 fs.existsSync(streamModule.STREAM_ROOT_DIR)
385 ? fs.readdirSync(streamModule.STREAM_ROOT_DIR)
386 : []
387 );
383 388 const session = await streamModule.createVideoStreamSession(sourceFile);
384 const sessionDir = path.join(streamModule.STREAM_ROOT_DIR, session.sessionId);
389 const afterDirs = fs.readdirSync(streamModule.STREAM_ROOT_DIR);
390 const newDirName = afterDirs.find((dirName) => !beforeDirs.has(dirName));
391 expect(newDirName).toEqual(expect.any(String));
392 const sessionDir = path.join(streamModule.STREAM_ROOT_DIR, String(newDirName || ''));
385 393 expect(Number.isInteger(streamModule.STREAM_SEGMENT_RETENTION_COUNT)).toBe(true);
386 394 const targetSegmentIndex = streamModule.STREAM_SEGMENT_RETENTION_COUNT + 40;
387 395
@@ -406,4 +414,68 @@ describe('video stream bootstrap', () =>
406 414
407 415 streamModule.releaseVideoStreamSession(session.sessionId);
408 416 });
417
418 test('createVideoStreamSession reuses one transcode for concurrent viewers of the same file', async () =>
419 {
420 mockSpawn.mockImplementation((command, args) =>
421 {
422 const child = makeChildProcess();
423 const exeName = path.basename(String(command || '')).toLowerCase();
424
425 if (exeName.includes('ffprobe'))
426 {
427 process.nextTick(() =>
428 {
429 child.stdout.emit('data', Buffer.from(JSON.stringify({
430 streams: [
431 { codec_type: 'video', codec_name: 'h264', tags: {}, disposition: {} },
432 { codec_type: 'audio', codec_name: 'aac', tags: {}, disposition: { default: 1 } },
433 ],
434 })));
435 child.emit('close', 0);
436 });
437 return child;
438 }
439
440 const playlistPath = String(args[args.length - 1] || '');
441 const outputDir = path.dirname(playlistPath);
442 process.nextTick(() =>
443 {
444 fs.mkdirSync(outputDir, { recursive: true });
445 fs.writeFileSync(path.join(outputDir, 'master.m3u8'), '#EXTM3U\n');
446 });
447 return child;
448 });
449
450 const streamModule = require('../server/video-stream');
451 const firstViewer = await streamModule.createVideoStreamSession(sourceFile);
452 const secondViewer = await streamModule.createVideoStreamSession(sourceFile);
453
454 expect(firstViewer.sessionId).not.toBe(secondViewer.sessionId);
455
456 const ffmpegSpawns = mockSpawn.mock.calls.filter(([command]) =>
457 path.basename(String(command || '')).toLowerCase().includes('ffmpeg')
458 );
459 expect(ffmpegSpawns).toHaveLength(1);
460
461 const firstReqRes = makeReqRes();
462 await streamModule.sendVideoStreamAsset(firstViewer.sessionId, 'master.m3u8', firstReqRes.req, firstReqRes.res);
463
464 const secondReqRes = makeReqRes();
465 await streamModule.sendVideoStreamAsset(secondViewer.sessionId, 'master.m3u8', secondReqRes.req, secondReqRes.res);
466
467 streamModule.releaseVideoStreamSession(firstViewer.sessionId);
468
469 const stillActiveReqRes = makeReqRes();
470 await expect(
471 streamModule.sendVideoStreamAsset(secondViewer.sessionId, 'master.m3u8', stillActiveReqRes.req, stillActiveReqRes.res)
472 ).resolves.toBeUndefined();
473
474 const releasedReqRes = makeReqRes();
475 await expect(
476 streamModule.sendVideoStreamAsset(firstViewer.sessionId, 'master.m3u8', releasedReqRes.req, releasedReqRes.res)
477 ).rejects.toMatchObject({ status: 404 });
478
479 streamModule.releaseVideoStreamSession(secondViewer.sessionId);
480 });
409 481 });
@@ -380,8 +380,16 @@ describe('video stream bootstrap', () =>
380 });
380 });
381
381
382 const streamModule = require('../server/video-stream');
382 const streamModule = require('../server/video-stream');
383 const beforeDirs = new Set(
384 fs.existsSync(streamModule.STREAM_ROOT_DIR)
385 ? fs.readdirSync(streamModule.STREAM_ROOT_DIR)
386 : []
387 );
383 const session = await streamModule.createVideoStreamSession(sourceFile);
388 const session = await streamModule.createVideoStreamSession(sourceFile);
384 const sessionDir = path.join(streamModule.STREAM_ROOT_DIR, session.sessionId);
389 const afterDirs = fs.readdirSync(streamModule.STREAM_ROOT_DIR);
390 const newDirName = afterDirs.find((dirName) => !beforeDirs.has(dirName));
391 expect(newDirName).toEqual(expect.any(String));
392 const sessionDir = path.join(streamModule.STREAM_ROOT_DIR, String(newDirName || ''));
385 expect(Number.isInteger(streamModule.STREAM_SEGMENT_RETENTION_COUNT)).toBe(true);
393 expect(Number.isInteger(streamModule.STREAM_SEGMENT_RETENTION_COUNT)).toBe(true);
386 const targetSegmentIndex = streamModule.STREAM_SEGMENT_RETENTION_COUNT + 40;
394 const targetSegmentIndex = streamModule.STREAM_SEGMENT_RETENTION_COUNT + 40;
387
395
@@ -406,4 +414,68 @@ describe('video stream bootstrap', () =>
406
414
407 streamModule.releaseVideoStreamSession(session.sessionId);
415 streamModule.releaseVideoStreamSession(session.sessionId);
408 });
416 });
417
418 test('createVideoStreamSession reuses one transcode for concurrent viewers of the same file', async () =>
419 {
420 mockSpawn.mockImplementation((command, args) =>
421 {
422 const child = makeChildProcess();
423 const exeName = path.basename(String(command || '')).toLowerCase();
424
425 if (exeName.includes('ffprobe'))
426 {
427 process.nextTick(() =>
428 {
429 child.stdout.emit('data', Buffer.from(JSON.stringify({
430 streams: [
431 { codec_type: 'video', codec_name: 'h264', tags: {}, disposition: {} },
432 { codec_type: 'audio', codec_name: 'aac', tags: {}, disposition: { default: 1 } },
433 ],
434 })));
435 child.emit('close', 0);
436 });
437 return child;
438 }
439
440 const playlistPath = String(args[args.length - 1] || '');
441 const outputDir = path.dirname(playlistPath);
442 process.nextTick(() =>
443 {
444 fs.mkdirSync(outputDir, { recursive: true });
445 fs.writeFileSync(path.join(outputDir, 'master.m3u8'), '#EXTM3U\n');
446 });
447 return child;
448 });
449
450 const streamModule = require('../server/video-stream');
451 const firstViewer = await streamModule.createVideoStreamSession(sourceFile);
452 const secondViewer = await streamModule.createVideoStreamSession(sourceFile);
453
454 expect(firstViewer.sessionId).not.toBe(secondViewer.sessionId);
455
456 const ffmpegSpawns = mockSpawn.mock.calls.filter(([command]) =>
457 path.basename(String(command || '')).toLowerCase().includes('ffmpeg')
458 );
459 expect(ffmpegSpawns).toHaveLength(1);
460
461 const firstReqRes = makeReqRes();
462 await streamModule.sendVideoStreamAsset(firstViewer.sessionId, 'master.m3u8', firstReqRes.req, firstReqRes.res);
463
464 const secondReqRes = makeReqRes();
465 await streamModule.sendVideoStreamAsset(secondViewer.sessionId, 'master.m3u8', secondReqRes.req, secondReqRes.res);
466
467 streamModule.releaseVideoStreamSession(firstViewer.sessionId);
468
469 const stillActiveReqRes = makeReqRes();
470 await expect(
471 streamModule.sendVideoStreamAsset(secondViewer.sessionId, 'master.m3u8', stillActiveReqRes.req, stillActiveReqRes.res)
472 ).resolves.toBeUndefined();
473
474 const releasedReqRes = makeReqRes();
475 await expect(
476 streamModule.sendVideoStreamAsset(firstViewer.sessionId, 'master.m3u8', releasedReqRes.req, releasedReqRes.res)
477 ).rejects.toMatchObject({ status: 404 });
478
479 streamModule.releaseVideoStreamSession(secondViewer.sessionId);
480 });
409});
481});