686 lines
25 KiB
JavaScript
686 lines
25 KiB
JavaScript
const express = require('express')
|
|
const helperFuncs = require('./helperFuncs')
|
|
const FFMPEG = require('./ffmpeg')
|
|
const FFMPEG_TEXT = require('./ffmpegText')
|
|
const constants = require('./constants')
|
|
const fs = require('fs')
|
|
const ProgramPlayer = require('./program-player');
|
|
const channelCache = require('./channel-cache')
|
|
const wereThereTooManyAttempts = require('./throttler');
|
|
|
|
module.exports = { router: video, shutdown: shutdown }
|
|
|
|
let StreamCount = 0;
|
|
|
|
let stopPlayback = false;
|
|
|
|
async function shutdown() {
|
|
stopPlayback = true;
|
|
}
|
|
|
|
function video( channelService, fillerDB, db, programmingService, activeChannelService, programPlayTimeDB ) {
|
|
var router = express.Router()
|
|
|
|
router.get('/setup', (req, res) => {
|
|
let ffmpegSettings = db['ffmpeg-settings'].find()[0]
|
|
// Check if ffmpeg path is valid
|
|
if (!fs.existsSync(ffmpegSettings.ffmpegPath)) {
|
|
res.status(500).send("FFMPEG path is invalid. The file (executable) doesn't exist.")
|
|
console.error("The FFMPEG Path is invalid. Please check your configuration.")
|
|
return
|
|
}
|
|
|
|
console.log(`\r\nStream starting. Channel: 1 (dizqueTV)`)
|
|
|
|
let ffmpeg = new FFMPEG_TEXT(ffmpegSettings, 'dizqueTV (No Channels Configured)', 'Configure your channels using the dizqueTV Web UI')
|
|
|
|
ffmpeg.on('data', (data) => { res.write(data) })
|
|
|
|
ffmpeg.on('error', (err) => {
|
|
console.error("FFMPEG ERROR", err)
|
|
res.status(500).send("FFMPEG ERROR")
|
|
return
|
|
})
|
|
ffmpeg.on('close', () => {
|
|
res.end()
|
|
})
|
|
|
|
res.on('close', () => { // on HTTP close, kill ffmpeg
|
|
ffmpeg.kill()
|
|
console.log(`\r\nStream ended. Channel: 1 (dizqueTV)`)
|
|
})
|
|
})
|
|
// Continuously stream video to client. Leverage ffmpeg concat for piecing together videos
|
|
let concat = async (req, res, audioOnly, step) => {
|
|
if ( typeof(step) === 'undefined') {
|
|
step = 0;
|
|
}
|
|
if (stopPlayback) {
|
|
res.status(503).send("Server is shutting down.")
|
|
return;
|
|
}
|
|
|
|
// Check if channel queried is valid
|
|
if (typeof req.query.channel === 'undefined') {
|
|
res.status(500).send("No Channel Specified")
|
|
return
|
|
}
|
|
let number = parseInt(req.query.channel, 10);
|
|
let channel = await channelService.getChannel(number);
|
|
if (channel == null) {
|
|
res.status(500).send("Channel doesn't exist")
|
|
return
|
|
}
|
|
|
|
let ffmpegSettings = db['ffmpeg-settings'].find()[0]
|
|
|
|
// Check if ffmpeg path is valid
|
|
if (!fs.existsSync(ffmpegSettings.ffmpegPath)) {
|
|
res.status(500).send("FFMPEG path is invalid. The file (executable) doesn't exist.")
|
|
console.error("The FFMPEG Path is invalid. Please check your configuration.")
|
|
return
|
|
}
|
|
|
|
if (step == 0) {
|
|
res.writeHead(200, {
|
|
'Content-Type': 'video/mp2t'
|
|
})
|
|
}
|
|
|
|
console.log(`\r\nStream starting. Channel: ${channel.number} (${channel.name})`)
|
|
|
|
let ffmpeg = new FFMPEG(ffmpegSettings, channel); // Set the transcoder options
|
|
ffmpeg.setAudioOnly(audioOnly);
|
|
let stopped = false;
|
|
|
|
function stop() {
|
|
if (! stopped) {
|
|
stopped = true;
|
|
try {
|
|
res.end();
|
|
} catch (err) {}
|
|
ffmpeg.kill();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
ffmpeg.on('error', (err) => {
|
|
console.error("FFMPEG ERROR", err);
|
|
//status was already sent
|
|
stop();
|
|
return;
|
|
})
|
|
|
|
//ffmpeg.on('close', stop)
|
|
|
|
res.on('close', () => { // on HTTP close, kill ffmpeg
|
|
console.log(`\r\nStream ended. Channel: ${channel.number} (${channel.name})`);
|
|
stop();
|
|
})
|
|
|
|
ffmpeg.on('end', () => {
|
|
console.log("Queue exhausted so we are appending the channel stream again to the http output.")
|
|
concat(req, res, audioOnly, step+1);
|
|
})
|
|
|
|
let channelNum = parseInt(req.query.channel, 10)
|
|
let ff = await ffmpeg.spawnConcat(`http://localhost:${process.env.PORT}/playlist?channel=${channelNum}&audioOnly=${audioOnly}&stepNumber={step}`);
|
|
ff.pipe(res, { end: false} );
|
|
};
|
|
router.get('/video', async(req, res) => {
|
|
return await concat(req, res, false);
|
|
} );
|
|
router.get('/radio', async(req, res) => {
|
|
return await concat(req, res, true);
|
|
} );
|
|
|
|
// Stream individual video to ffmpeg concat above. This is used by the server, NOT the client
|
|
let streamFunction = async (req, res, t0, allowSkip) => {
|
|
if (stopPlayback) {
|
|
res.status(503).send("Server is shutting down.")
|
|
return;
|
|
}
|
|
|
|
// Check if channel queried is valid
|
|
res.on("error", (e) => {
|
|
console.error("There was an unexpected error in stream.", e);
|
|
} );
|
|
if (typeof req.query.channel === 'undefined') {
|
|
res.status(400).send("No Channel Specified")
|
|
return
|
|
}
|
|
|
|
let audioOnly = ("true" == req.query.audioOnly);
|
|
console.log(`/stream audioOnly=${audioOnly}`);
|
|
let session = parseInt(req.query.session);
|
|
let m3u8 = (req.query.m3u8 === '1');
|
|
let number = parseInt(req.query.channel);
|
|
let channel = await channelService.getChannel( number);
|
|
|
|
if (channel == null) {
|
|
res.status(404).send("Channel doesn't exist")
|
|
return
|
|
}
|
|
let isLoading = false;
|
|
if ( (typeof req.query.first !== 'undefined') && (req.query.first=='0') ) {
|
|
isLoading = true;
|
|
}
|
|
|
|
let isFirst = false;
|
|
if ( (typeof req.query.first !== 'undefined') && (req.query.first=='1') ) {
|
|
isFirst = true;
|
|
}
|
|
|
|
let isBetween = ( (typeof req.query.between !== 'undefined') && (req.query.between=='1') );
|
|
|
|
let ffmpegSettings = db['ffmpeg-settings'].find()[0]
|
|
|
|
// Check if ffmpeg path is valid
|
|
if (!fs.existsSync(ffmpegSettings.ffmpegPath)) {
|
|
res.status(500).send("FFMPEG path is invalid. The file (executable) doesn't exist.")
|
|
console.error("The FFMPEG Path is invalid. Please check your configuration.")
|
|
return
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get video lineup (array of video urls with calculated start times and durations.)
|
|
|
|
let prog = null;
|
|
let brandChannel = channel;
|
|
let redirectChannels = [];
|
|
let upperBounds = [];
|
|
|
|
const GAP_DURATION = constants.GAP_DURATION;
|
|
if (isLoading) {
|
|
lineupItem = {
|
|
type: 'loading',
|
|
title: "Loading Screen",
|
|
noRealTime: true,
|
|
streamDuration: GAP_DURATION,
|
|
duration: GAP_DURATION,
|
|
redirectChannels: [channel],
|
|
start: 0,
|
|
};
|
|
} else if (isBetween) {
|
|
lineupItem = {
|
|
type: 'interlude',
|
|
title: "Interlude Screen",
|
|
noRealTime: true,
|
|
streamDuration: GAP_DURATION,
|
|
duration: GAP_DURATION,
|
|
redirectChannels: [channel],
|
|
start: 0,
|
|
};
|
|
} else {
|
|
lineupItem = channelCache.getCurrentLineupItem( channel.number, t0);
|
|
}
|
|
if (lineupItem != null) {
|
|
redirectChannels = lineupItem.redirectChannels;
|
|
upperBounds = lineupItem.upperBounds;
|
|
brandChannel = redirectChannels[ redirectChannels.length -1];
|
|
} else {
|
|
prog = programmingService.getCurrentProgramAndTimeElapsed(t0, channel);
|
|
activeChannelService.peekChannel(t0, channel.number);
|
|
|
|
while (true) {
|
|
redirectChannels.push( helperFuncs.generateChannelContext(brandChannel) );
|
|
upperBounds.push( prog.program.duration - prog.timeElapsed );
|
|
|
|
if ( !(prog.program.isOffline) || (prog.program.type != 'redirect') ) {
|
|
break;
|
|
}
|
|
channelCache.recordPlayback(programPlayTimeDB,
|
|
brandChannel.number, t0, {
|
|
/*type: 'offline',*/
|
|
title: 'Error',
|
|
err: Error("Recursive channel redirect found"),
|
|
duration : 60000,
|
|
start: 0,
|
|
});
|
|
|
|
|
|
|
|
let newChannelNumber= prog.program.channel;
|
|
let newChannel = await channelService.getChannel(newChannelNumber);
|
|
|
|
if (newChannel == null) {
|
|
let err = Error("Invalid redirect to a channel that doesn't exist");
|
|
console.error("Invalid redirect to channel that doesn't exist.", err);
|
|
prog = {
|
|
program: {
|
|
isOffline: true,
|
|
err: err,
|
|
duration : 60000,
|
|
},
|
|
timeElapsed: 0,
|
|
}
|
|
continue;
|
|
}
|
|
brandChannel = newChannel;
|
|
lineupItem = channelCache.getCurrentLineupItem( newChannel.number, t0);
|
|
if (lineupItem != null) {
|
|
lineupItem = JSON.parse( JSON.stringify(lineupItem)) ;
|
|
break;
|
|
} else {
|
|
prog = programmingService.getCurrentProgramAndTimeElapsed(t0, newChannel);
|
|
activeChannelService.peekChannel(t0, newChannel.number);
|
|
}
|
|
}
|
|
}
|
|
if (lineupItem == null) {
|
|
if (prog == null) {
|
|
res.status(500).send("server error");
|
|
throw Error("Shouldn't prog be non-null?");
|
|
}
|
|
if (prog.program.isOffline && channel.programs.length == 1 && prog.programIndex != -1) {
|
|
//there's only one program and it's offline. So really, the channel is
|
|
//permanently offline, it doesn't matter what duration was set
|
|
//and it's best to give it a long duration to ensure there's always
|
|
//filler to play (if any)
|
|
let t = 365*24*60*60*1000;
|
|
prog.program = {
|
|
duration: t,
|
|
isOffline : true,
|
|
};
|
|
} else if ( allowSkip && (prog.program.isOffline && prog.program.duration - prog.timeElapsed <= constants.SLACK + 1) ) {
|
|
//it's pointless to show the offline screen for such a short time, might as well
|
|
//skip to the next program
|
|
let dt = prog.program.duration - prog.timeElapsed;
|
|
for (let i = 0; i < redirectChannels.length; i++) {
|
|
channelCache.clearPlayback(redirectChannels[i].number );
|
|
}
|
|
console.log("Too litlle time before the filler ends, skip to next slot");
|
|
return await streamFunction(req, res, t0 + dt + 1, false);
|
|
}
|
|
if ( (prog == null) || (typeof(prog) === 'undefined') || (prog.program == null) || (typeof(prog.program) == "undefined") ) {
|
|
throw "No video to play, this means there's a serious unexpected bug or the channel db is corrupted."
|
|
}
|
|
let fillers = await fillerDB.getFillersFromChannel(brandChannel);
|
|
try {
|
|
let lineup = helperFuncs.createLineup(programPlayTimeDB, prog, brandChannel, fillers, isFirst)
|
|
lineupItem = lineup.shift();
|
|
} catch (err) {
|
|
console.log("Error when attempting to pick video: " +err.stack);
|
|
lineupItem = {
|
|
isOffline: true,
|
|
err: err,
|
|
duration : 60000,
|
|
};
|
|
}
|
|
}
|
|
|
|
if ( !isBetween && !isLoading && (lineupItem != null) ) {
|
|
let upperBound = 1000000000;
|
|
let beginningOffset = 0;
|
|
if (typeof(lineupItem.beginningOffset) !== 'undefined') {
|
|
beginningOffset = lineupItem.beginningOffset;
|
|
}
|
|
//adjust upper bounds and record playbacks
|
|
for (let i = redirectChannels.length-1; i >= 0; i--) {
|
|
lineupItem = JSON.parse( JSON.stringify(lineupItem ));
|
|
lineupItem.redirectChannels = redirectChannels;
|
|
lineupItem.upperBounds = upperBounds;
|
|
let u = upperBounds[i] + beginningOffset;
|
|
if (typeof(u) !== 'undefined') {
|
|
let u2 = upperBound;
|
|
if ( typeof(lineupItem.streamDuration) !== 'undefined') {
|
|
u2 = Math.min(u2, lineupItem.streamDuration);
|
|
}
|
|
lineupItem.streamDuration = Math.min(u2, u);
|
|
upperBound = lineupItem.streamDuration;
|
|
}
|
|
channelCache.recordPlayback( programPlayTimeDB, redirectChannels[i].number, t0, lineupItem );
|
|
}
|
|
}
|
|
|
|
let t2 = (new Date()).getTime();
|
|
console.log( `Decision Latency: (${t2-t0})ms` );
|
|
|
|
|
|
console.log("=========================================================");
|
|
console.log("! Start playback");
|
|
console.log(`! Channel: ${channel.name} (${channel.number})`);
|
|
if (typeof(lineupItem.title) === 'undefined') {
|
|
lineupItem.title = 'Unknown';
|
|
}
|
|
console.log(`! Title: ${lineupItem.title}`);
|
|
if ( typeof(lineupItem.streamDuration) === 'undefined') {
|
|
console.log(`! From : ${lineupItem.start}`);
|
|
} else {
|
|
console.log(`! From : ${lineupItem.start} to: ${lineupItem.start + lineupItem.streamDuration}`);
|
|
}
|
|
console.log("=========================================================");
|
|
|
|
if (! isLoading && ! isBetween) {
|
|
channelCache.recordPlayback(programPlayTimeDB, channel.number, t0, lineupItem);
|
|
}
|
|
if (wereThereTooManyAttempts(session, lineupItem)) {
|
|
console.error("There are too many attempts to play the same item in a short period of time, playing the error stream instead.");
|
|
lineupItem = {
|
|
isOffline: true,
|
|
err: Error("Too many attempts, throttling.."),
|
|
duration : 60000,
|
|
};
|
|
}
|
|
|
|
let combinedChannel = helperFuncs.generateChannelContext(brandChannel);
|
|
combinedChannel.transcoding = channel.transcoding;
|
|
|
|
let playerContext = {
|
|
lineupItem : lineupItem,
|
|
ffmpegSettings : ffmpegSettings,
|
|
channel: combinedChannel,
|
|
db: db,
|
|
m3u8: m3u8,
|
|
audioOnly : audioOnly,
|
|
}
|
|
|
|
let player = new ProgramPlayer(playerContext);
|
|
let stopped = false;
|
|
let stop = () => {
|
|
if (!stopped) {
|
|
stopped = true;
|
|
player.cleanUp();
|
|
player = null;
|
|
res.end();
|
|
}
|
|
};
|
|
var playerObj = null;
|
|
res.writeHead(200, {
|
|
'Content-Type': 'video/mp2t'
|
|
});
|
|
|
|
shieldActiveChannels(redirectChannels, t0, constants.START_CHANNEL_GRACE_PERIOD);
|
|
|
|
let t1;
|
|
|
|
try {
|
|
playerObj = await player.play(res);
|
|
t1 = (new Date()).getTime();
|
|
console.log( `Player Latency: (${t1-t0})ms` );
|
|
} catch (err) {
|
|
console.log("Error when attempting to play video: " +err.stack);
|
|
try {
|
|
res.status(500).send("Unable to start playing video.").end();
|
|
} catch (err2) {
|
|
console.log(err2.stack);
|
|
}
|
|
stop();
|
|
return;
|
|
}
|
|
|
|
if (! isLoading) {
|
|
//setup end event to mark the channel as not playing anymore
|
|
let t0 = new Date().getTime();
|
|
let b = 0;
|
|
let stopDetected = false;
|
|
if (typeof(lineupItem.beginningOffset) !== 'undefined') {
|
|
b = lineupItem.beginningOffset;
|
|
t0 -= b;
|
|
}
|
|
|
|
// we have to do it for every single redirected channel...
|
|
|
|
for (let i = redirectChannels.length-1; i >= 0; i--) {
|
|
activeChannelService.registerChannelActive(t0, redirectChannels[i].number);
|
|
}
|
|
let listener = (data) => {
|
|
if (data.ignoreOnDemand) {
|
|
console.log("Ignore channel update because it is from on-demand service");
|
|
return;
|
|
}
|
|
let shouldStop = false;
|
|
try {
|
|
for (let i = 0; i < redirectChannels.length; i++) {
|
|
if (redirectChannels[i].number == data.channelNumber) {
|
|
shouldStop = true;
|
|
}
|
|
}
|
|
if (shouldStop) {
|
|
console.log("Playing channel has received an update.");
|
|
shieldActiveChannels( redirectChannels, t0, constants.CHANNEL_STOP_SHIELD )
|
|
setTimeout(stop, 100);
|
|
}
|
|
} catch (error) {
|
|
console.err("Unexpected error when processing channel change during playback", error);
|
|
}
|
|
|
|
};
|
|
channelService.on("channel-update", listener);
|
|
|
|
let oldStop = stop;
|
|
stop = () => {
|
|
channelService.removeListener("channel-update", listener);
|
|
if (!stopDetected) {
|
|
stopDetected = true;
|
|
let t1 = new Date().getTime();
|
|
t1 = Math.max( t0 + 1, t1 - constants.FORGETFULNESS_BUFFER - b );
|
|
for (let i = redirectChannels.length-1; i >= 0; i--) {
|
|
activeChannelService.registerChannelStopped(t1, redirectChannels[i].number);
|
|
}
|
|
}
|
|
oldStop();
|
|
};
|
|
}
|
|
let stream = playerObj;
|
|
|
|
|
|
|
|
//res.write(playerObj.data);
|
|
|
|
|
|
stream.on("end", () => {
|
|
let t2 = (new Date()).getTime();
|
|
console.log("Played video for: " + (t2 - t1) + " ms");
|
|
stop();
|
|
});
|
|
res.on("close", () => {
|
|
let t2 = (new Date()).getTime();
|
|
console.log("Played video for: " + (t2 - t1) + " ms");
|
|
console.log("Client Closed");
|
|
stop();
|
|
});
|
|
};
|
|
|
|
router.get('/stream', async (req, res) => {
|
|
let t0 = (new Date).getTime();
|
|
return await streamFunction(req, res, t0, true);
|
|
});
|
|
|
|
|
|
router.get('/m3u8', async (req, res) => {
|
|
if (stopPlayback) {
|
|
res.status(503).send("Server is shutting down.")
|
|
return;
|
|
}
|
|
|
|
|
|
let sessionId = StreamCount++;
|
|
|
|
//res.type('application/vnd.apple.mpegurl')
|
|
res.type("application/x-mpegURL");
|
|
|
|
// Check if channel queried is valid
|
|
if (typeof req.query.channel === 'undefined') {
|
|
res.status(500).send("No Channel Specified")
|
|
return
|
|
}
|
|
|
|
let channelNum = parseInt(req.query.channel, 10)
|
|
let channel = await channelService.getChannel(channelNum );
|
|
if (channel == null) {
|
|
res.status(500).send("Channel doesn't exist")
|
|
return
|
|
}
|
|
|
|
// Maximum number of streams to concatinate beyond channel starting
|
|
// If someone passes this number then they probably watch too much television
|
|
let maxStreamsToPlayInARow = 100;
|
|
|
|
var data = "#EXTM3U\n"
|
|
|
|
data += `#EXT-X-VERSION:3
|
|
#EXT-X-MEDIA-SEQUENCE:0
|
|
#EXT-X-ALLOW-CACHE:YES
|
|
#EXT-X-TARGETDURATION:60
|
|
#EXT-X-PLAYLIST-TYPE:VOD\n`;
|
|
|
|
let ffmpegSettings = db['ffmpeg-settings'].find()[0]
|
|
|
|
cur ="59.0";
|
|
|
|
if ( ffmpegSettings.enableFFMPEGTranscoding === true) {
|
|
//data += `#EXTINF:${cur},\n`;
|
|
data += `${req.protocol}://${req.get('host')}/stream?channel=${channelNum}&first=0&m3u8=1&session=${sessionId}\n`;
|
|
}
|
|
//data += `#EXTINF:${cur},\n`;
|
|
data += `${req.protocol}://${req.get('host')}/stream?channel=${channelNum}&first=1&m3u8=1&session=${sessionId}\n`
|
|
for (var i = 0; i < maxStreamsToPlayInARow - 1; i++) {
|
|
//data += `#EXTINF:${cur},\n`;
|
|
data += `${req.protocol}://${req.get('host')}/stream?channel=${channelNum}&m3u8=1&session=${sessionId}\n`
|
|
}
|
|
|
|
res.send(data)
|
|
})
|
|
router.get('/playlist', async (req, res) => {
|
|
if (stopPlayback) {
|
|
res.status(503).send("Server is shutting down.")
|
|
return;
|
|
}
|
|
|
|
|
|
res.type('text')
|
|
|
|
// Check if channel queried is valid
|
|
if (typeof req.query.channel === 'undefined') {
|
|
res.status(500).send("No Channel Specified")
|
|
return
|
|
}
|
|
|
|
let stepNumber = parseInt(req.query.stepNumber, 10)
|
|
if (isNaN(stepNumber)) {
|
|
stepNumber = 0;
|
|
}
|
|
let channelNum = parseInt(req.query.channel, 10)
|
|
let channel = await channelService.getChannel(channelNum );
|
|
if (channel == null) {
|
|
res.status(500).send("Channel doesn't exist")
|
|
return
|
|
}
|
|
|
|
// Maximum number of streams to concatinate beyond channel starting
|
|
// If someone passes this number then they probably watch too much television
|
|
let maxStreamsToPlayInARow = 100;
|
|
|
|
var data = "ffconcat version 1.0\n"
|
|
|
|
let ffmpegSettings = db['ffmpeg-settings'].find()[0]
|
|
|
|
let sessionId = StreamCount++;
|
|
let audioOnly = ("true" == req.query.audioOnly);
|
|
|
|
let transcodingEnabled = (ffmpegSettings.enableFFMPEGTranscoding === true)
|
|
&& (ffmpegSettings.normalizeVideoCodec === true)
|
|
&& (ffmpegSettings.normalizeAudioCodec === true)
|
|
&& (ffmpegSettings.normalizeResolution === true)
|
|
&& (ffmpegSettings.normalizeAudio === true);
|
|
|
|
if (
|
|
transcodingEnabled
|
|
&& (audioOnly !== true) /* loading screen is pointless in audio mode (also for some reason it makes it fail when codec is aac, and I can't figure out why) */
|
|
&& (stepNumber == 0)
|
|
) {
|
|
//loading screen
|
|
data += `file 'http://localhost:${process.env.PORT}/stream?channel=${channelNum}&first=0&session=${sessionId}&audioOnly=${audioOnly}'\n`;
|
|
}
|
|
let remaining = maxStreamsToPlayInARow;
|
|
if (stepNumber == 0) {
|
|
data += `file 'http://localhost:${process.env.PORT}/stream?channel=${channelNum}&first=1&session=${sessionId}&audioOnly=${audioOnly}'\n`
|
|
|
|
if (transcodingEnabled && (audioOnly !== true)) {
|
|
data += `file 'http://localhost:${process.env.PORT}/stream?channel=${channelNum}&between=1&session=${sessionId}&audioOnly=${audioOnly}'\n`;
|
|
}
|
|
remaining--;
|
|
}
|
|
|
|
for (var i = 0; i < remaining; i++) {
|
|
data += `file 'http://localhost:${process.env.PORT}/stream?channel=${channelNum}&session=${sessionId}&audioOnly=${audioOnly}'\n`
|
|
if (transcodingEnabled && (audioOnly !== true) ) {
|
|
data += `file 'http://localhost:${process.env.PORT}/stream?channel=${channelNum}&between=1&session=${sessionId}&audioOnly=${audioOnly}'\n`
|
|
}
|
|
}
|
|
|
|
res.send(data)
|
|
})
|
|
|
|
let shieldActiveChannels = (channelList, t0, timeout) => {
|
|
// because of channel redirects, it's possible that multiple channels
|
|
// are being played at once. Mark all of them as being played
|
|
// this is a grave period of 30
|
|
//mark all channels being played as active:
|
|
for (let i = channelList.length-1; i >= 0; i--) {
|
|
activeChannelService.registerChannelActive(t0, channelList[i].number);
|
|
}
|
|
setTimeout( () => {
|
|
for (let i = channelList.length-1; i >= 0; i--) {
|
|
activeChannelService.registerChannelStopped(t0, channelList[i].number);
|
|
}
|
|
}, timeout );
|
|
}
|
|
|
|
|
|
let mediaPlayer = async(channelNum, path, req, res) => {
|
|
let channel = await channelService.getChannel(channelNum );
|
|
if (channel === null) {
|
|
res.status(404).send("Channel not found.");
|
|
return;
|
|
}
|
|
res.type('video/x-mpegurl');
|
|
res.status(200).send(`#EXTM3U\n${req.protocol}://${req.get('host')}/${path}?channel=${channelNum}\n\n`);
|
|
}
|
|
|
|
router.get('/media-player/:number.m3u', async (req, res) => {
|
|
try {
|
|
let channelNum = parseInt(req.params.number, 10);
|
|
let path ="video";
|
|
if (req.query.fast==="1") {
|
|
path ="m3u8";
|
|
}
|
|
return await mediaPlayer(channelNum, path, req, res);
|
|
} catch(err) {
|
|
console.error(err);
|
|
res.status(500).send("There was an error.");
|
|
}
|
|
});
|
|
|
|
|
|
router.get('/media-player/fast/:number.m3u', async (req, res) => {
|
|
try {
|
|
let channelNum = parseInt(req.params.number, 10);
|
|
let path ="m3u8";
|
|
return await mediaPlayer(channelNum, path, req, res);
|
|
} catch(err) {
|
|
console.error(err);
|
|
res.status(500).send("There was an error.");
|
|
}
|
|
});
|
|
|
|
router.get('/media-player/radio/:number.m3u', async (req, res) => {
|
|
try {
|
|
let channelNum = parseInt(req.params.number, 10);
|
|
let path ="radio";
|
|
return await mediaPlayer(channelNum, path, req, res);
|
|
} catch(err) {
|
|
console.error(err);
|
|
res.status(500).send("There was an error.");
|
|
}
|
|
});
|
|
|
|
|
|
|
|
return router
|
|
}
|