843 lines
15 KiB
JavaScript
843 lines
15 KiB
JavaScript
// helpers/hlsManager2.js
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const { spawn, execFileSync } = require('child_process');
|
|
const fetch = require('node-fetch'); // node-fetch@2
|
|
const config = require('../api_v1/config');
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Configuration
|
|
// -----------------------------------------------------------------------------
|
|
|
|
const FFMPEG_BIN = '/usr/local/bin/ffmpeg';
|
|
|
|
/*
|
|
* Temporary private MPP library.
|
|
*
|
|
* Once MPP 0986d01 is installed as the normal system library,
|
|
* remove this constant and the "env: FFMPEG_ENV" options below.
|
|
*/
|
|
const FFMPEG_ENV = {
|
|
...process.env,
|
|
|
|
LD_LIBRARY_PATH: [
|
|
'/usr/local/lib/mpp-0986d01',
|
|
process.env.LD_LIBRARY_PATH
|
|
]
|
|
.filter(Boolean)
|
|
.join(':')
|
|
};
|
|
|
|
const HLS_BASE = path.resolve(
|
|
process.env.HLS_BASE ||
|
|
path.join(process.cwd(), 'hls_output')
|
|
);
|
|
|
|
const jobs = new Map();
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// FFmpeg / RKMPP detection
|
|
// -----------------------------------------------------------------------------
|
|
|
|
function getFfmpegEncoders() {
|
|
try {
|
|
return execFileSync(
|
|
FFMPEG_BIN,
|
|
['-hide_banner', '-encoders'],
|
|
{
|
|
encoding: 'utf8',
|
|
env: FFMPEG_ENV,
|
|
stdio: ['ignore', 'pipe', 'pipe']
|
|
}
|
|
);
|
|
} catch (err) {
|
|
console.error(
|
|
`[hlsManager] Cannot execute ${FFMPEG_BIN}: ${err.message}`
|
|
);
|
|
|
|
return '';
|
|
}
|
|
}
|
|
|
|
function hasRkmpp() {
|
|
const out = getFfmpegEncoders();
|
|
|
|
const hasH264 = /\bh264_rkmpp\b/.test(out);
|
|
const hasHevc = /\bhevc_rkmpp\b/.test(out);
|
|
|
|
if (!hasH264 || !hasHevc) {
|
|
console.warn(
|
|
`[hlsManager] RKMPP not fully available: ` +
|
|
`h264_rkmpp=${hasH264}, hevc_rkmpp=${hasHevc}`
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
console.log(
|
|
`[hlsManager] RKMPP available: ` +
|
|
`h264_rkmpp=${hasH264}, hevc_rkmpp=${hasHevc}`
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// FFmpeg arguments
|
|
// -----------------------------------------------------------------------------
|
|
|
|
function buildFfmpegArgs(inputPath, jobDir, useRkmpp) {
|
|
const master = path.join(jobDir, 'master.m3u8');
|
|
const segPattern = path.join(jobDir, 'segment_%05d.ts');
|
|
|
|
// Filtro video: 720p, proporzioni originali, dimensioni compatibili
|
|
// con il codec e formato yuv420p.
|
|
const videoFilter =
|
|
'scale=1280:1080:force_original_aspect_ratio=decrease:force_divisible_by=16,' +
|
|
'pad=1280:1080:(ow-iw)/2:(oh-ih)/2,setsar=1,format=yuv420p';
|
|
|
|
if (useRkmpp) {
|
|
return [
|
|
'-hide_banner',
|
|
'-loglevel',
|
|
'warning',
|
|
'-y',
|
|
|
|
'-probesize',
|
|
'5000000',
|
|
|
|
'-analyzeduration',
|
|
'10000000',
|
|
|
|
// Decodifica hardware RKMPP.
|
|
'-hwaccel',
|
|
'rkmpp',
|
|
|
|
'-i',
|
|
inputPath,
|
|
|
|
'-map',
|
|
'0:v:0',
|
|
|
|
'-map',
|
|
'0:a:0?',
|
|
|
|
// Ridimensionamento a 720p e codifica H.264 hardware.
|
|
'-vf',
|
|
videoFilter,
|
|
|
|
'-c:v',
|
|
'h264_rkmpp',
|
|
|
|
'-rc_mode',
|
|
'CBR',
|
|
|
|
'-b:v',
|
|
'2500k',
|
|
|
|
'-maxrate',
|
|
'3000k',
|
|
|
|
'-bufsize',
|
|
'6000k',
|
|
|
|
'-r',
|
|
'30',
|
|
|
|
'-g',
|
|
'90',
|
|
|
|
'-keyint_min',
|
|
'90',
|
|
|
|
// Audio AAC stereo.
|
|
'-c:a',
|
|
'aac',
|
|
|
|
'-b:a',
|
|
'160k',
|
|
|
|
'-ac',
|
|
'2',
|
|
|
|
'-ar',
|
|
'48000',
|
|
|
|
// HLS event: la playlist può crescere durante il transcoding.
|
|
'-f',
|
|
'hls',
|
|
|
|
'-hls_time',
|
|
'3',
|
|
|
|
'-hls_list_size',
|
|
'0',
|
|
|
|
'-hls_playlist_type',
|
|
'event',
|
|
|
|
'-hls_segment_type',
|
|
'mpegts',
|
|
|
|
'-hls_flags',
|
|
'independent_segments',
|
|
|
|
'-hls_segment_filename',
|
|
segPattern,
|
|
|
|
master
|
|
];
|
|
}
|
|
|
|
// Fallback CPU: mantiene il comportamento precedente.
|
|
return [
|
|
'-hide_banner',
|
|
'-y',
|
|
|
|
'-probesize',
|
|
'5000000',
|
|
|
|
'-analyzeduration',
|
|
'10000000',
|
|
|
|
'-noautorotate',
|
|
|
|
'-i',
|
|
inputPath,
|
|
|
|
'-map',
|
|
'0:v:0',
|
|
|
|
'-map',
|
|
'0:a:0?',
|
|
|
|
'-vf',
|
|
videoFilter,
|
|
|
|
'-c:v',
|
|
'libx264',
|
|
|
|
'-profile:v',
|
|
'high',
|
|
|
|
'-level',
|
|
'4.1',
|
|
|
|
'-preset',
|
|
'veryfast',
|
|
|
|
'-tune',
|
|
'zerolatency',
|
|
|
|
'-b:v',
|
|
'2500k',
|
|
|
|
'-maxrate',
|
|
'3000k',
|
|
|
|
'-bufsize',
|
|
'6000k',
|
|
|
|
'-r',
|
|
'30',
|
|
|
|
'-g',
|
|
'90',
|
|
|
|
'-keyint_min',
|
|
'90',
|
|
|
|
'-sc_threshold',
|
|
'0',
|
|
|
|
'-pix_fmt',
|
|
'yuv420p',
|
|
|
|
'-c:a',
|
|
'aac',
|
|
|
|
'-b:a',
|
|
'160k',
|
|
|
|
'-ac',
|
|
'2',
|
|
|
|
'-ar',
|
|
'48000',
|
|
|
|
'-f',
|
|
'hls',
|
|
|
|
'-hls_time',
|
|
'3',
|
|
|
|
'-hls_list_size',
|
|
'0',
|
|
|
|
'-hls_playlist_type',
|
|
'event',
|
|
|
|
'-hls_segment_type',
|
|
'mpegts',
|
|
|
|
'-hls_flags',
|
|
'independent_segments',
|
|
|
|
'-hls_segment_filename',
|
|
segPattern,
|
|
|
|
master
|
|
];
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Callback
|
|
// -----------------------------------------------------------------------------
|
|
|
|
async function sendCallback(job, payload) {
|
|
if (!job.callbackUrl) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const resp = await fetch(job.callbackUrl, {
|
|
method: 'POST',
|
|
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
},
|
|
|
|
body: JSON.stringify(payload),
|
|
|
|
timeout: 10000
|
|
});
|
|
|
|
console.log(
|
|
`[job ${job.jobId}] callback ${resp.status}`
|
|
);
|
|
} catch (err) {
|
|
console.error(
|
|
`[job ${job.jobId}] callback failed: ${err.message}`
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Helpers
|
|
// -----------------------------------------------------------------------------
|
|
|
|
function countSegments(jobDir) {
|
|
if (!fs.existsSync(jobDir)) {
|
|
return 0;
|
|
}
|
|
|
|
try {
|
|
return fs.readdirSync(jobDir)
|
|
.filter(name => /^segment_\d+\.ts$/.test(name))
|
|
.length;
|
|
} catch (err) {
|
|
console.error(
|
|
`[hlsManager] Cannot read ${jobDir}: ${err.message}`
|
|
);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
function buildPublicUrl(job, masterPath) {
|
|
const base =
|
|
job.publicBaseUrl ||
|
|
config.BASE_URL ||
|
|
null;
|
|
|
|
const publicRoot = path.resolve(
|
|
process.cwd(),
|
|
'public'
|
|
);
|
|
|
|
let publicPath;
|
|
|
|
if (
|
|
masterPath === publicRoot ||
|
|
masterPath.startsWith(
|
|
`${publicRoot}${path.sep}`
|
|
)
|
|
) {
|
|
const rel = path
|
|
.relative(publicRoot, masterPath)
|
|
.split(path.sep)
|
|
.join('/');
|
|
|
|
publicPath = `/${rel}`;
|
|
} else {
|
|
/*
|
|
* Compatibilita con eventuali job legacy
|
|
* ancora salvati sotto HLS_BASE.
|
|
*/
|
|
const rel = path
|
|
.relative(HLS_BASE, masterPath)
|
|
.split(path.sep)
|
|
.join('/');
|
|
|
|
publicPath = `/hls/${rel}`;
|
|
}
|
|
|
|
if (base) {
|
|
return (
|
|
`${base.replace(/\/$/, '')}` +
|
|
publicPath
|
|
);
|
|
}
|
|
|
|
return publicPath;
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Start job
|
|
// -----------------------------------------------------------------------------
|
|
|
|
function startJob({
|
|
inputPath,
|
|
outDir,
|
|
segmentsNeeded = 3,
|
|
callbackUrl,
|
|
publicBaseUrl = null
|
|
}) {
|
|
if (!inputPath) {
|
|
throw new Error('inputPath is required');
|
|
}
|
|
|
|
if (!outDir) {
|
|
throw new Error('outDir is required');
|
|
}
|
|
|
|
/*
|
|
* outDir identifica la directory fisica del video Cast.
|
|
*/
|
|
const jobDir = path.resolve(outDir);
|
|
|
|
/*
|
|
* Evita conversioni concorrenti sullo stesso video.
|
|
* Se esiste già un job attivo o un output pronto,
|
|
* riutilizza il jobId invece di cancellare i segmenti.
|
|
*/
|
|
for (const existingJob of jobs.values()) {
|
|
if (
|
|
path.resolve(existingJob.outDir) !== jobDir ||
|
|
existingJob.inputPath !== inputPath
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
const masterExists = fs.existsSync(
|
|
existingJob.masterPath
|
|
);
|
|
|
|
const tsCount = countSegments(jobDir);
|
|
|
|
const processRunning =
|
|
existingJob.exitCode === null &&
|
|
existingJob.status !== 'timeout';
|
|
|
|
const outputPlayable =
|
|
existingJob.exitCode === 0 &&
|
|
existingJob.ready &&
|
|
masterExists &&
|
|
tsCount >= 1;
|
|
|
|
if (processRunning || outputPlayable) {
|
|
console.log(
|
|
`[job ${existingJob.jobId}] Reuse existing job ` +
|
|
`for ${jobDir}`
|
|
);
|
|
|
|
return existingJob.jobId;
|
|
}
|
|
}
|
|
|
|
const jobId = Date.now().toString();
|
|
|
|
/*
|
|
* Pulisce i vecchi file soltanto quando non c'è
|
|
* un job attivo o un output pronto da riutilizzare.
|
|
*/
|
|
fs.rmSync(jobDir, {
|
|
recursive: true,
|
|
force: true
|
|
});
|
|
|
|
fs.mkdirSync(jobDir, {
|
|
recursive: true
|
|
});
|
|
|
|
const useRkmpp = true;
|
|
|
|
const ffArgs = buildFfmpegArgs(
|
|
inputPath,
|
|
jobDir,
|
|
useRkmpp
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] Starting FFmpeg`
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] binary: ${FFMPEG_BIN}`
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] RKMPP: ${useRkmpp}`
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] input: ${inputPath}`
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] output: ${jobDir}`
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] args: ${ffArgs.join(' ')}`
|
|
);
|
|
|
|
const proc = spawn(
|
|
FFMPEG_BIN,
|
|
ffArgs,
|
|
{
|
|
env: FFMPEG_ENV,
|
|
|
|
stdio: [
|
|
'ignore',
|
|
'pipe',
|
|
'pipe'
|
|
]
|
|
}
|
|
);
|
|
|
|
const job = {
|
|
jobId,
|
|
|
|
inputPath,
|
|
|
|
outDir: jobDir,
|
|
|
|
callbackUrl,
|
|
|
|
segmentsNeeded:
|
|
Math.max(1, Number(segmentsNeeded)),
|
|
|
|
proc,
|
|
|
|
notified: false,
|
|
ready: false,
|
|
status: 'processing',
|
|
|
|
startTime: Date.now(),
|
|
|
|
useRkmpp,
|
|
|
|
publicBaseUrl,
|
|
|
|
masterPath: path.join(
|
|
jobDir,
|
|
'master.m3u8'
|
|
),
|
|
|
|
exitCode: null,
|
|
|
|
error: null,
|
|
|
|
poller: null
|
|
};
|
|
|
|
jobs.set(
|
|
jobId,
|
|
job
|
|
);
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FFmpeg stdout
|
|
// ---------------------------------------------------------------------------
|
|
|
|
if (proc.stdout) {
|
|
proc.stdout.setEncoding('utf8');
|
|
|
|
proc.stdout.on(
|
|
'data',
|
|
data => {
|
|
const text = data.toString().trim();
|
|
|
|
if (text) {
|
|
console.log(
|
|
`[ffmpeg ${jobId}] ${text}`
|
|
);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FFmpeg stderr
|
|
// ---------------------------------------------------------------------------
|
|
|
|
if (proc.stderr) {
|
|
proc.stderr.setEncoding('utf8');
|
|
|
|
proc.stderr.on(
|
|
'data',
|
|
data => {
|
|
const text = data.toString().trim();
|
|
|
|
if (text) {
|
|
console.log(
|
|
`[ffmpeg ${jobId}] ${text}`
|
|
);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Spawn error
|
|
// ---------------------------------------------------------------------------
|
|
|
|
proc.on(
|
|
'error',
|
|
err => {
|
|
job.error = err;
|
|
|
|
console.error(
|
|
`[job ${jobId}] FFmpeg process error: ${err.message}`
|
|
);
|
|
}
|
|
);
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Poll HLS output
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const pollInterval = 500;
|
|
|
|
const timeoutMs =
|
|
5 * 60 * 1000;
|
|
|
|
const poller = setInterval(
|
|
async () => {
|
|
try {
|
|
if (
|
|
!job.notified &&
|
|
fs.existsSync(job.masterPath)
|
|
) {
|
|
const tsCount =
|
|
countSegments(job.outDir);
|
|
|
|
console.log(
|
|
`[job ${jobId}] HLS progress: segments=${tsCount}, required=${job.segmentsNeeded}`
|
|
);
|
|
|
|
if (tsCount >= job.segmentsNeeded) {
|
|
job.ready = true;
|
|
job.status = 'ready';
|
|
job.notified = true;
|
|
|
|
const publicUrl =
|
|
buildPublicUrl(
|
|
job,
|
|
job.masterPath
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] HLS ready: ` +
|
|
`${tsCount} segments`
|
|
);
|
|
|
|
await sendCallback(
|
|
job,
|
|
{
|
|
jobId: job.jobId,
|
|
|
|
master_m3u8:
|
|
publicUrl,
|
|
|
|
ready_segments:
|
|
tsCount,
|
|
|
|
status:
|
|
'ready'
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Timeout
|
|
// ---------------------------------------------------------------------
|
|
|
|
if (
|
|
!job.notified &&
|
|
Date.now() - job.startTime >
|
|
timeoutMs
|
|
) {
|
|
job.notified = true;
|
|
job.status = 'timeout';
|
|
|
|
console.error(
|
|
`[job ${jobId}] HLS timeout`
|
|
);
|
|
|
|
await sendCallback(
|
|
job,
|
|
{
|
|
jobId: job.jobId,
|
|
|
|
out_dir:
|
|
job.outDir,
|
|
|
|
status:
|
|
'timeout'
|
|
}
|
|
);
|
|
|
|
// Do not kill FFmpeg here automatically.
|
|
// The process may still be finishing a large input.
|
|
}
|
|
} catch (err) {
|
|
console.error(
|
|
`[job ${jobId}] poller error: ${err.message}`
|
|
);
|
|
}
|
|
},
|
|
pollInterval
|
|
);
|
|
|
|
job.poller = poller;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// FFmpeg exit
|
|
// ---------------------------------------------------------------------------
|
|
|
|
proc.on(
|
|
'exit',
|
|
async code => {
|
|
clearInterval(
|
|
poller
|
|
);
|
|
|
|
job.exitCode = code;
|
|
|
|
try {
|
|
const masterExists =
|
|
fs.existsSync(
|
|
job.masterPath
|
|
);
|
|
|
|
const tsCount =
|
|
countSegments(
|
|
job.outDir
|
|
);
|
|
|
|
console.log(
|
|
`[job ${jobId}] FFmpeg exited ` +
|
|
`with code ${code}, ` +
|
|
`segments=${tsCount}`
|
|
);
|
|
|
|
if (!job.notified) {
|
|
const publicUrl =
|
|
masterExists
|
|
? buildPublicUrl(
|
|
job,
|
|
job.masterPath
|
|
)
|
|
: null;
|
|
|
|
|
|
const hasPlayableOutput =
|
|
code === 0 &&
|
|
masterExists &&
|
|
tsCount >= 1;
|
|
|
|
if (hasPlayableOutput) {
|
|
job.ready = true;
|
|
}
|
|
|
|
|
|
job.status = job.ready
|
|
? (
|
|
tsCount >= job.segmentsNeeded
|
|
? 'ready'
|
|
: 'finished_short_video'
|
|
)
|
|
: (
|
|
code === 0 && masterExists
|
|
? 'finished_insufficient_segments'
|
|
: 'error'
|
|
);
|
|
|
|
|
|
status = job.status;
|
|
job.notified = true;
|
|
|
|
await sendCallback(
|
|
job,
|
|
{
|
|
jobId:
|
|
job.jobId,
|
|
|
|
master_m3u8:
|
|
publicUrl,
|
|
|
|
ready_segments:
|
|
tsCount,
|
|
|
|
status,
|
|
|
|
returncode:
|
|
code
|
|
}
|
|
);
|
|
}
|
|
} catch (err) {
|
|
console.error(
|
|
`[job ${jobId}] on-exit callback error: ${err.message}`
|
|
);
|
|
} finally {
|
|
job.finishedAt = Date.now();
|
|
setTimeout(() => {
|
|
jobs.delete(jobId);
|
|
}, 2 * 60 * 1000).unref();
|
|
}
|
|
}
|
|
);
|
|
|
|
return jobId;
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Get job
|
|
// -----------------------------------------------------------------------------
|
|
|
|
function getJob(jobId) {
|
|
return jobs.get(
|
|
jobId
|
|
) || null;
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Exports
|
|
// -----------------------------------------------------------------------------
|
|
|
|
module.exports = {
|
|
startJob,
|
|
getJob
|
|
};
|