431 lines
No EOL
13 KiB
JavaScript
431 lines
No EOL
13 KiB
JavaScript
const fs = require("fs");
|
|
const path = require("path");
|
|
const { exec } = require("child_process");
|
|
const isWindows = process.platform === "win32";
|
|
const isArm = process.arch === "arm" || process.arch === "arm64";
|
|
const isAarch64 = process.arch === "arm64";
|
|
|
|
const ytDlpPath = path.join(
|
|
"deps",
|
|
isWindows ? "yt-dlp.exe" :
|
|
isArm ? (isAarch64 ? "yt-dlp_linux_aarch64" : "yt-dlp_linux_armv7l") :
|
|
"yt-dlp"
|
|
);
|
|
|
|
if (!isWindows) {
|
|
fs.chmodSync(ytDlpPath, 0o755);
|
|
}
|
|
|
|
process.env.PATH = `${path.join(process.cwd(), "deps")}${path.delimiter}${process.env.PATH}`;
|
|
|
|
|
|
const activeVideoProcesses = new Map();
|
|
const PROCESS_TIMEOUT = 30 * 60 * 1000;
|
|
|
|
function logWithVideoId(videoId, message, isError = false) {
|
|
const timestamp = new Date().toISOString();
|
|
const logFn = isError ? console.error : console.log;
|
|
logFn(`[${timestamp}][${videoId || "NO_VIDEO_ID"}] ${message}`);
|
|
}
|
|
|
|
async function processVideo(videoId) {
|
|
function updateProgress(percentage, state) {
|
|
if (activeVideoProcesses.has(videoId)) {
|
|
const processInfo = activeVideoProcesses.get(videoId);
|
|
processInfo.progress = percentage;
|
|
if (state) {
|
|
processInfo.state = state;
|
|
}
|
|
|
|
logWithVideoId(
|
|
videoId,
|
|
`Progress update: ${percentage.toFixed(2)}% (${
|
|
state || processInfo.state
|
|
})`
|
|
);
|
|
|
|
for (const client of processInfo.clients) {
|
|
if (client.ws.readyState === 1) {
|
|
client.ws.send(JSON.stringify({ preparing: percentage }));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
logWithVideoId(videoId, "Starting video download");
|
|
updateProgress(0, "downloading");
|
|
|
|
return new Promise((resolve, reject) => {
|
|
try {
|
|
const videoDirectory = `videohost/${videoId}`;
|
|
if (!fs.existsSync(videoDirectory)) {
|
|
fs.mkdirSync(videoDirectory, { recursive: true });
|
|
}
|
|
const process = exec(
|
|
`${ytDlpPath} --cookies cookies.txt --force-ipv4 --prefer-insecure -f "bestvideo[ext=mp4][height<=1440][vcodec^=avc]+bestaudio[ext=m4a]" --merge-output-format mp4 -o "videohost/${videoId}.mp4" "https://youtube.com/watch?v=${videoId}"`
|
|
);
|
|
|
|
console.log(
|
|
`${ytDlpPath} --cookies cookies.txt --force-ipv4 --prefer-insecure -f "bestvideo[ext=mp4][height<=1440][vcodec^=avc]+bestaudio[ext=m4a]" --merge-output-format mp4 -o "videohost/${videoId}.mp4" "https://youtube.com/watch?v=${videoId}"`
|
|
);
|
|
|
|
let isFirstDownload = true;
|
|
let currentDestination = "";
|
|
|
|
process.stdout.on("data", (data) => {
|
|
const output = data.toString();
|
|
|
|
if (output.includes("[download] Destination:")) {
|
|
isFirstDownload = !currentDestination;
|
|
currentDestination = output;
|
|
}
|
|
|
|
const match = output.match(/\[download\]\s+(\d+\.\d+)% of/);
|
|
if (match) {
|
|
let percentage = parseFloat(match[1]);
|
|
if (!isFirstDownload) {
|
|
percentage = 72 + percentage * 0.08;
|
|
} else {
|
|
percentage = percentage * 0.72;
|
|
}
|
|
updateProgress(percentage, "downloading");
|
|
}
|
|
});
|
|
|
|
process.stderr.on("data", (data) => {
|
|
logWithVideoId(videoId, `yt-dlp stderr: ${data}`, true);
|
|
});
|
|
|
|
process.on("close", async (code) => {
|
|
if (code === 0) {
|
|
logWithVideoId(
|
|
videoId,
|
|
"Download completed, starting conversion to HLS"
|
|
);
|
|
updateProgress(80, "preparing");
|
|
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
|
|
logWithVideoId(videoId, "Starting conversion to HLS");
|
|
updateProgress(80, "converting");
|
|
|
|
try {
|
|
await convertToHLS(videoId, updateProgress);
|
|
|
|
fs.unlink(`videohost/${videoId}.mp4`, (err) => {
|
|
if (err) {
|
|
logWithVideoId(
|
|
videoId,
|
|
`Error deleting original file: ${err.message}`,
|
|
true
|
|
);
|
|
} else {
|
|
logWithVideoId(
|
|
videoId,
|
|
"Original mp4 file deleted successfully"
|
|
);
|
|
}
|
|
});
|
|
|
|
resolve();
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
} else {
|
|
logWithVideoId(
|
|
videoId,
|
|
`Download process exited with code ${code}`,
|
|
true
|
|
);
|
|
reject(new Error("Unable to prepare video. Please try again later."));
|
|
}
|
|
});
|
|
} catch (error) {
|
|
reject(new Error(`Failed to start download process: ${error.message}`));
|
|
}
|
|
});
|
|
}
|
|
|
|
async function convertToHLS(videoId, updateProgress) {
|
|
logWithVideoId(videoId, "Starting HLS conversion");
|
|
|
|
return new Promise((resolve, reject) => {
|
|
try {
|
|
const videoDirectory = `videohost/${videoId}`;
|
|
|
|
const conversionProcess = exec(
|
|
`ffmpeg -i "videohost/${videoId}.mp4" -c:v copy -c:a copy -hls_time 6 -hls_list_size 0 -hls_segment_type mpegts -hls_playlist_type vod -hls_segment_filename "${videoDirectory}/%03d.ts" "${videoDirectory}/playlist.m3u8"`
|
|
);
|
|
|
|
let totalDuration = 0;
|
|
|
|
conversionProcess.stderr.on("data", (data) => {
|
|
const output = data.toString();
|
|
console.log("ffmpeg stderr:", output);
|
|
|
|
const durationMatch = output.match(
|
|
/Duration: (\d{2}):(\d{2}):(\d{2})\.(\d{2})/
|
|
);
|
|
if (durationMatch) {
|
|
const [_, hours, minutes, seconds, centiseconds] = durationMatch;
|
|
totalDuration =
|
|
parseFloat(hours) * 3600 +
|
|
parseFloat(minutes) * 60 +
|
|
parseFloat(seconds) +
|
|
parseFloat(centiseconds) / 100;
|
|
|
|
logWithVideoId(
|
|
videoId,
|
|
`Video duration: ${totalDuration.toFixed(2)} seconds`
|
|
);
|
|
}
|
|
|
|
const timeMatch = output.match(/time=(\d{2}):(\d{2}):(\d{2})\.(\d{2})/);
|
|
if (timeMatch && totalDuration > 0) {
|
|
const [_, hours, minutes, seconds, centiseconds] = timeMatch;
|
|
const currentTime =
|
|
parseFloat(hours) * 3600 +
|
|
parseFloat(minutes) * 60 +
|
|
parseFloat(seconds) +
|
|
parseFloat(centiseconds) / 100;
|
|
|
|
const percentage = 80 + (currentTime / totalDuration) * 20;
|
|
updateProgress(Math.min(percentage, 100), "converting");
|
|
}
|
|
});
|
|
|
|
conversionProcess.stdout.on("data", (data) => {
|
|
logWithVideoId(videoId, `ffmpeg stdout: ${data}`);
|
|
});
|
|
|
|
conversionProcess.on("close", (code) => {
|
|
if (code === 0) {
|
|
logWithVideoId(videoId, "Conversion completed successfully");
|
|
updateProgress(100, "completed");
|
|
resolve();
|
|
} else {
|
|
reject(new Error(`Conversion process exited with code ${code}`));
|
|
}
|
|
});
|
|
} catch (error) {
|
|
reject(new Error(`Failed to start conversion process: ${error.message}`));
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
function setupCleanupInterval() {
|
|
setInterval(() => {
|
|
const now = Date.now();
|
|
for (const [videoId, info] of activeVideoProcesses.entries()) {
|
|
if (now - info.startTime > PROCESS_TIMEOUT) {
|
|
logWithVideoId(
|
|
videoId,
|
|
"Cleaning up stalled process in periodic check",
|
|
true
|
|
);
|
|
|
|
for (const client of info.clients) {
|
|
if (client.ws.readyState === 1) {
|
|
client.ws.send(
|
|
JSON.stringify({
|
|
ok: false,
|
|
error: "Video processing timed out",
|
|
})
|
|
);
|
|
}
|
|
}
|
|
|
|
if (info.timeoutId) {
|
|
clearTimeout(info.timeoutId);
|
|
}
|
|
|
|
activeVideoProcesses.delete(videoId);
|
|
}
|
|
}
|
|
}, 5 * 60 * 1000);
|
|
}
|
|
|
|
|
|
function prepareRouteHandler(app) {
|
|
app.ws("/api/v1/prepare", (ws, req) => {
|
|
let videoId = null;
|
|
let clientId = Date.now() + Math.random().toString(36).substring(2, 15);
|
|
|
|
logWithVideoId(null, `New WebSocket connection established (${clientId})`);
|
|
|
|
ws.on("message", async (msg) => {
|
|
try {
|
|
const parsedMessage = JSON.parse(msg);
|
|
|
|
if (parsedMessage.videoId) {
|
|
videoId = parsedMessage.videoId;
|
|
ws.send(JSON.stringify({ ok: true }));
|
|
logWithVideoId(videoId, `Request for video (client: ${clientId})`);
|
|
|
|
const isValidYoutubeId = /^[a-zA-Z0-9_-]{11}$/.test(videoId);
|
|
if (!isValidYoutubeId) {
|
|
ws.send(
|
|
JSON.stringify({ ok: false, error: "Invalid YouTube video ID" })
|
|
);
|
|
logWithVideoId(videoId, "Invalid YouTube video ID", true);
|
|
return;
|
|
}
|
|
|
|
const videoPath = `videohost/${videoId}/playlist.m3u8`;
|
|
if (fs.existsSync(videoPath)) {
|
|
logWithVideoId(videoId, "Video already exists - sending stream URL");
|
|
ws.send(
|
|
JSON.stringify({
|
|
done: true,
|
|
streamUrl: "/videocd/" + videoId + "/playlist.m3u8",
|
|
})
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (activeVideoProcesses.has(videoId)) {
|
|
const processInfo = activeVideoProcesses.get(videoId);
|
|
logWithVideoId(
|
|
videoId,
|
|
`Video is already being processed (state: ${
|
|
processInfo.state
|
|
}, progress: ${processInfo.progress.toFixed(
|
|
2
|
|
)}%), attaching client ${clientId}`
|
|
);
|
|
|
|
processInfo.clients.push({ ws, clientId });
|
|
|
|
ws.send(JSON.stringify({ preparing: processInfo.progress }));
|
|
return;
|
|
}
|
|
|
|
const processInfo = {
|
|
clients: [{ ws, clientId }],
|
|
state: "initializing",
|
|
progress: 0,
|
|
startTime: Date.now(),
|
|
timeoutId: null,
|
|
};
|
|
|
|
processInfo.timeoutId = setTimeout(() => {
|
|
if (activeVideoProcesses.has(videoId)) {
|
|
logWithVideoId(videoId, "Process timed out after 30 minutes", true);
|
|
|
|
const info = activeVideoProcesses.get(videoId);
|
|
for (const client of info.clients) {
|
|
if (client.ws.readyState === 1) {
|
|
client.ws.send(
|
|
JSON.stringify({
|
|
ok: false,
|
|
error: "Video processing timed out",
|
|
})
|
|
);
|
|
}
|
|
}
|
|
|
|
activeVideoProcesses.delete(videoId);
|
|
}
|
|
}, PROCESS_TIMEOUT);
|
|
|
|
activeVideoProcesses.set(videoId, processInfo);
|
|
logWithVideoId(videoId, "Starting new video processing");
|
|
|
|
try {
|
|
await processVideo(videoId);
|
|
|
|
if (processInfo.timeoutId) {
|
|
clearTimeout(processInfo.timeoutId);
|
|
}
|
|
|
|
if (activeVideoProcesses.has(videoId)) {
|
|
const info = activeVideoProcesses.get(videoId);
|
|
logWithVideoId(
|
|
videoId,
|
|
`Processing completed. Notifying ${info.clients.length} clients`
|
|
);
|
|
|
|
for (const client of info.clients) {
|
|
if (client.ws.readyState === 1) {
|
|
client.ws.send(
|
|
JSON.stringify({
|
|
done: true,
|
|
streamUrl: "/videocd/" + videoId + "/playlist.m3u8",
|
|
})
|
|
);
|
|
}
|
|
}
|
|
|
|
activeVideoProcesses.delete(videoId);
|
|
}
|
|
|
|
logWithVideoId(videoId, "Video prepared successfully");
|
|
} catch (error) {
|
|
if (processInfo.timeoutId) {
|
|
clearTimeout(processInfo.timeoutId);
|
|
}
|
|
|
|
logWithVideoId(
|
|
videoId,
|
|
`Error processing video: ${error.message}`,
|
|
true
|
|
);
|
|
|
|
if (activeVideoProcesses.has(videoId)) {
|
|
const info = activeVideoProcesses.get(videoId);
|
|
for (const client of info.clients) {
|
|
if (client.ws.readyState === 1) {
|
|
client.ws.send(
|
|
JSON.stringify({
|
|
ok: false,
|
|
error:
|
|
"Unable to prepare video. Please try reloading the page.",
|
|
})
|
|
);
|
|
}
|
|
}
|
|
|
|
activeVideoProcesses.delete(videoId);
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logWithVideoId(videoId, `Unexpected error: ${error.message}`, true);
|
|
ws.send(JSON.stringify({ ok: false, error: "Server error occurred" }));
|
|
}
|
|
});
|
|
|
|
ws.on("close", () => {
|
|
logWithVideoId(videoId, `WebSocket closed for client ${clientId}`);
|
|
|
|
if (videoId && activeVideoProcesses.has(videoId)) {
|
|
const processInfo = activeVideoProcesses.get(videoId);
|
|
const clientIndex = processInfo.clients.findIndex(
|
|
(client) => client.clientId === clientId
|
|
);
|
|
|
|
if (clientIndex !== -1) {
|
|
processInfo.clients.splice(clientIndex, 1);
|
|
logWithVideoId(
|
|
videoId,
|
|
`Removed client ${clientId} from process. Remaining clients: ${processInfo.clients.length}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
|
|
ws.on("error", (error) => {
|
|
logWithVideoId(
|
|
videoId,
|
|
`WebSocket error for client ${clientId}: ${error.message}`,
|
|
true
|
|
);
|
|
});
|
|
});
|
|
|
|
|
|
setupCleanupInterval();
|
|
}
|
|
|
|
module.exports = prepareRouteHandler;
|