266 lines
10 KiB
JavaScript
266 lines
10 KiB
JavaScript
const express = require('express');
|
|
const multer = require('multer');
|
|
const path = require('path');
|
|
const fs = require('fs');
|
|
const { spawn } = require('child_process');
|
|
const rateLimit = require('express-rate-limit');
|
|
const log = require('../lib/logger');
|
|
const { UPLOADS_DIR, RESULTS_DIR } = require('../lib/storage');
|
|
const queue = require('../lib/queue');
|
|
const ws = require('../lib/ws');
|
|
|
|
const router = express.Router();
|
|
|
|
const MAX_FILE_SIZE = 200 * 1024 * 1024;
|
|
const MAX_FILE_SIZE_ADMIN = 1024 * 1024 * 1024;
|
|
|
|
function videoFileFilter(req, file, cb) {
|
|
const valid = ['video/mp4', 'video/webm', 'video/quicktime', 'video/x-msvideo', 'video/x-matroska', 'video/mpeg', 'video/3gpp', 'video/ogg'];
|
|
if (valid.includes(file.mimetype) || file.originalname.match(/\.(mp4|webm|mov|avi|mkv|mpeg|mpg|3gp|ogg|flv|wmv)$/i)) {
|
|
cb(null, true);
|
|
} else {
|
|
cb(new Error('Неподдерживаемый формат видео'));
|
|
}
|
|
}
|
|
|
|
const uploadUser = multer({ dest: UPLOADS_DIR, limits: { fileSize: MAX_FILE_SIZE }, fileFilter: videoFileFilter });
|
|
const uploadAdmin = multer({ dest: UPLOADS_DIR, limits: { fileSize: MAX_FILE_SIZE_ADMIN }, fileFilter: videoFileFilter });
|
|
|
|
function uploadMiddleware(req, res, next) {
|
|
const isAdmin = req.session && req.session.user && req.session.user.role === 'admin';
|
|
const handler = isAdmin ? uploadAdmin.single('video') : uploadUser.single('video');
|
|
handler(req, res, next);
|
|
}
|
|
|
|
const limiter = rateLimit({
|
|
keyGenerator: (req) => (req.session && req.session.user && req.session.user.id) ? "user_" + req.session.user.id : req.ip,
|
|
windowMs: 60000, max: 10, message: { error: 'Слишком много запросов' },
|
|
});
|
|
|
|
// In-memory progress tracking for active FFmpeg processes
|
|
const liveProgress = new Map();
|
|
|
|
function runFFmpeg(args, jobId, duration) {
|
|
return new Promise((resolve, reject) => {
|
|
const proc = spawn('ffmpeg', args, { timeout: 600000 });
|
|
let stderrBuf = '';
|
|
|
|
proc.stderr.on('data', (d) => {
|
|
const chunk = d.toString();
|
|
stderrBuf += chunk;
|
|
const timeMatch = chunk.match(/(?:out_time|time)=\s*(\d{2}):(\d{2}):(\d{2})[\.\d]*/);
|
|
if (timeMatch && duration > 0) {
|
|
const secs = parseInt(timeMatch[1]) * 3600 + parseInt(timeMatch[2]) * 60 + parseInt(timeMatch[3]);
|
|
const pct = Math.min(99, Math.round((secs / duration) * 100));
|
|
const live = liveProgress.get(jobId);
|
|
if (live && pct > live.progress) {
|
|
live.progress = pct;
|
|
queue.updateProgress(jobId, pct);
|
|
ws.notify(jobId, { type: "progress", progress: pct });
|
|
}
|
|
}
|
|
});
|
|
|
|
proc.on('close', (code) => {
|
|
if (code === 0) resolve();
|
|
else reject(new Error(`ffmpeg exited with code ${code}: ${stderrBuf.slice(-500)}`));
|
|
});
|
|
|
|
proc.on('error', reject);
|
|
});
|
|
}
|
|
|
|
function getVideoDuration(filePath) {
|
|
return new Promise((resolve) => {
|
|
const proc = spawn('ffprobe', ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', filePath]);
|
|
let out = '';
|
|
proc.stdout.on('data', (d) => { out += d.toString(); });
|
|
proc.on('close', () => {
|
|
try {
|
|
const info = JSON.parse(out);
|
|
const duration = parseFloat(info.format?.duration || '0');
|
|
const streams = info.streams || [];
|
|
const video = streams.find(s => s.codec_type === 'video');
|
|
const audio = streams.find(s => s.codec_type === 'audio');
|
|
resolve({
|
|
duration,
|
|
width: video ? parseInt(video.width) : 0,
|
|
height: video ? parseInt(video.height) : 0,
|
|
codec: video ? video.codec_name : '',
|
|
audioCodec: audio ? audio.codec_name : '',
|
|
bitrate: info.format?.bit_rate ? Math.round(parseInt(info.format.bit_rate) / 1024) : 0,
|
|
});
|
|
} catch {
|
|
resolve({ duration: 0, width: 0, height: 0, codec: '', audioCodec: '', bitrate: 0 });
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// Page
|
|
router.get('/', (req, res) => {
|
|
res.sendFile(path.join(__dirname, '..', 'public', 'video.html'));
|
|
});
|
|
|
|
// Upload and get info
|
|
router.post('/upload', limiter, uploadMiddleware, async (req, res) => {
|
|
if (!req.file) return res.status(400).json({ error: 'Файл не загружен' });
|
|
|
|
try {
|
|
const info = await getVideoDuration(req.file.path);
|
|
|
|
// Create job in SQLite queue
|
|
const jobId = queue.addJob('video', {
|
|
inputPath: req.file.path,
|
|
originalName: req.file.originalname,
|
|
size: req.file.size,
|
|
duration: info.duration,
|
|
info,
|
|
}, req.session.user && req.session.user.id);
|
|
|
|
// Schedule cleanup of input file after 30 min
|
|
setTimeout(() => {
|
|
try { fs.existsSync(req.file.path) && fs.unlinkSync(req.file.path); } catch {}
|
|
}, 30 * 60 * 1000);
|
|
|
|
log.info(`Video upload: ${req.file.originalname} (${(req.file.size / 1024 / 1024).toFixed(1)}MB, ${info.duration.toFixed(1)}s)`);
|
|
|
|
res.json({ jobId, info, originalName: req.file.originalname, size: req.file.size });
|
|
} catch (err) {
|
|
try { fs.unlinkSync(req.file.path); } catch {}
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// Convert
|
|
router.post('/convert', limiter, express.json(), async (req, res) => {
|
|
const { jobId, mode, format, quality, startTime, endTime } = req.body;
|
|
const job = queue.getJob(jobId);
|
|
// 404 (not 403) on ownership mismatch — do not leak existence of others' jobs
|
|
if (!job || String(job.user_id) !== String(req.session.user && req.session.user.id)) return res.status(404).json({ error: 'Задача не найдена' });
|
|
if (job.status === 'processing') return res.status(409).json({ error: 'Уже обрабатывается' });
|
|
|
|
queue.startJob(jobId);
|
|
|
|
const payload = job.payload;
|
|
const ext = { mp4: '.mp4', webm: '.webm', avi: '.avi', mkv: '.mkv', mp3: '.mp3', aac: '.aac', gif: '.gif' };
|
|
const outExt = ext[format] || '.mp4';
|
|
const outFile = path.join(RESULTS_DIR, `${jobId}${outExt}`);
|
|
|
|
// Track live progress in memory
|
|
liveProgress.set(jobId, { progress: 0 });
|
|
|
|
try {
|
|
let args = ['-y', '-progress', 'pipe:2', '-i', payload.inputPath];
|
|
|
|
if (startTime !== undefined && startTime > 0) args.push('-ss', String(startTime));
|
|
if (endTime !== undefined && endTime > 0) args.push('-to', String(endTime));
|
|
|
|
switch (mode) {
|
|
case 'convert': {
|
|
if (format === 'mp4') args.push('-c:v', 'libx264', '-preset', 'fast', '-crf', '23', '-c:a', 'aac', '-movflags', '+faststart');
|
|
else if (format === 'webm') args.push('-c:v', 'libvpx', '-b:v', '1M', '-c:a', 'libvorbis');
|
|
else if (format === 'avi') args.push('-c:v', 'libx264', '-preset', 'fast', '-crf', '23', '-c:a', 'aac');
|
|
else if (format === 'mkv') args.push('-c:v', 'libx264', '-preset', 'fast', '-crf', '23', '-c:a', 'aac');
|
|
break;
|
|
}
|
|
case 'compress': {
|
|
const crf = quality === 'high' ? '18' : quality === 'low' ? '28' : '23';
|
|
args.push('-c:v', 'libx264', '-preset', 'fast', '-crf', crf, '-c:a', 'aac', '-b:a', '128k');
|
|
if (format === 'mp4' || !format) args.push('-movflags', '+faststart');
|
|
break;
|
|
}
|
|
case 'audio': {
|
|
args.push('-vn');
|
|
if (format === 'mp3') args.push('-c:a', 'libmp3lame', '-b:a', '192k');
|
|
else args.push('-c:a', 'aac', '-b:a', '192k');
|
|
break;
|
|
}
|
|
case 'gif': {
|
|
const w = Math.min(payload.info.width || 480, 480);
|
|
args.push('-vf', `scale=${w}:-1:flags=lanczos,fps=12`, '-loop', '0');
|
|
break;
|
|
}
|
|
default:
|
|
queue.failJob(jobId, 'Неизвестный режим');
|
|
return res.status(400).json({ error: 'Неизвестный режим' });
|
|
}
|
|
|
|
args.push(outFile);
|
|
|
|
// Respond immediately, process in background
|
|
res.json({ status: 'processing' });
|
|
|
|
runFFmpeg(args, jobId, payload.duration).then(() => {
|
|
const outStat = fs.statSync(outFile);
|
|
const outputSize = outStat.size;
|
|
const savings = payload.size > 0 ? Math.round((1 - outputSize / payload.size) * 100) : 0;
|
|
const downloadUrl = `/video/download/${jobId}${outExt}`;
|
|
|
|
queue.finishJob(jobId, { downloadUrl, outputSize, savings });
|
|
ws.notify(jobId, { type: "done", downloadUrl, outputSize, savings });
|
|
liveProgress.delete(jobId);
|
|
|
|
// Cleanup output after 30 min
|
|
setTimeout(() => { try { fs.existsSync(outFile) && fs.unlinkSync(outFile); } catch {} }, 30 * 60 * 1000);
|
|
|
|
log.info(`Video ${mode}: ${payload.originalName} → ${format} (${(outputSize / 1024 / 1024).toFixed(1)}MB, ${savings}% saved)`);
|
|
}).catch(err => {
|
|
queue.failJob(jobId, err.message.slice(0, 200));
|
|
ws.notify(jobId, { type: 'error', error: err.message.slice(0, 200) });
|
|
liveProgress.delete(jobId);
|
|
log.error('Video convert error', { error: err.message });
|
|
});
|
|
} catch (err) {
|
|
queue.failJob(jobId, err.message);
|
|
liveProgress.delete(jobId);
|
|
log.error('Video convert error', { error: err.message });
|
|
res.status(500).json({ error: 'Ошибка конвертации: ' + err.message.slice(0, 200) });
|
|
}
|
|
});
|
|
|
|
// Progress
|
|
router.get('/progress/:jobId', (req, res) => {
|
|
const job = queue.getJob(req.params.jobId);
|
|
if (!job || String(job.user_id) !== String(req.session.user && req.session.user.id)) return res.status(404).json({ error: 'Not found' });
|
|
|
|
// Use live progress if available (more up-to-date)
|
|
const live = liveProgress.get(req.params.jobId);
|
|
const progress = live ? live.progress : job.progress;
|
|
|
|
const result = { status: job.status, progress };
|
|
if (job.status === 'done' && job.result) {
|
|
result.downloadUrl = job.result.downloadUrl;
|
|
result.outputSize = job.result.outputSize;
|
|
result.savings = job.result.savings;
|
|
}
|
|
if (job.status === 'error') {
|
|
result.error = job.error || 'Ошибка обработки';
|
|
}
|
|
res.json(result);
|
|
});
|
|
|
|
// Download result
|
|
router.get('/download/:filename', (req, res) => {
|
|
const filename = path.basename(req.params.filename);
|
|
const filePath = path.join(RESULTS_DIR, filename);
|
|
if (!fs.existsSync(filePath)) return res.status(404).json({ error: 'Файл не найден' });
|
|
res.download(filePath);
|
|
});
|
|
|
|
// Multer error handler
|
|
router.use((err, req, res, next) => {
|
|
if (err instanceof multer.MulterError) {
|
|
if (err.code === 'LIMIT_FILE_SIZE') {
|
|
const isAdmin = req.session && req.session.user && req.session.user.role === 'admin';
|
|
const limit = isAdmin ? '1 GB' : '200 MB';
|
|
return res.status(413).json({ error: 'Файл слишком большой. Максимум ' + limit + '.' });
|
|
}
|
|
return res.status(400).json({ error: err.message });
|
|
}
|
|
if (err) return res.status(400).json({ error: err.message });
|
|
next();
|
|
});
|
|
|
|
module.exports = router;
|