310 lines
10 KiB
TypeScript
310 lines
10 KiB
TypeScript
import { join } from 'node:path';
|
||
import { execFFmpeg, selectAudioBitrate } from '../utils';
|
||
import type { VideoProfile, VideoOptimizations, CodecQualitySettings, HardwareAccelerator } from '../types';
|
||
|
||
/**
|
||
* Get default CQ/CRF value based on resolution and codec
|
||
*/
|
||
function getDefaultQuality(height: number, codecType: 'h264' | 'av1', isGPU: boolean): number {
|
||
if (isGPU) {
|
||
// GPU encoders use CQ - ФИКСИРОВАННЫЕ ЗНАЧЕНИЯ ДЛЯ ТЕСТИРОВАНИЯ
|
||
if (codecType === 'h264') {
|
||
// H.264 NVENC CQ = 32 (для всех разрешений)
|
||
return 32;
|
||
} else {
|
||
// AV1 NVENC CQ = 42 (для всех разрешений)
|
||
return 42;
|
||
}
|
||
} else {
|
||
// CPU encoders use CRF
|
||
if (codecType === 'h264') {
|
||
// libx264 CRF (на ~3-5 ниже чем NVENC CQ)
|
||
if (height <= 360) return 25;
|
||
if (height <= 480) return 24;
|
||
if (height <= 720) return 23;
|
||
if (height <= 1080) return 22;
|
||
if (height <= 1440) return 21;
|
||
return 20; // 4K
|
||
} else {
|
||
// libsvtav1 CRF (шкала 0-63, на ~20% выше чем NVENC CQ)
|
||
if (height <= 360) return 40;
|
||
if (height <= 480) return 38;
|
||
if (height <= 720) return 35;
|
||
if (height <= 1080) return 32;
|
||
if (height <= 1440) return 30;
|
||
return 28; // 4K
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Encode single profile to MP4
|
||
* Stage 1: Heavy work - video encoding with optional optimizations
|
||
*/
|
||
export async function encodeProfileToMP4(
|
||
input: string,
|
||
tempDir: string,
|
||
profile: VideoProfile,
|
||
videoCodec: string,
|
||
preset: string,
|
||
duration: number,
|
||
segmentDuration: number,
|
||
sourceAudioBitrate: number | undefined,
|
||
codecType: 'h264' | 'av1',
|
||
qualitySettings?: CodecQualitySettings,
|
||
optimizations?: VideoOptimizations,
|
||
muted: boolean = false,
|
||
decoderAccel?: HardwareAccelerator,
|
||
onProgress?: (percent: number) => void
|
||
): Promise<string> {
|
||
const outputPath = join(tempDir, `video_${codecType}_${profile.name}.mp4`);
|
||
|
||
const args = ['-y'];
|
||
|
||
// Hardware decode (optional)
|
||
if (decoderAccel) {
|
||
if (decoderAccel === 'nvenc') {
|
||
args.push('-hwaccel', 'cuda', '-hwaccel_output_format', 'cuda');
|
||
} else if (decoderAccel === 'qsv') {
|
||
args.push('-hwaccel', 'qsv');
|
||
} else if (decoderAccel === 'vaapi') {
|
||
args.push('-hwaccel', 'vaapi');
|
||
} else if (decoderAccel === 'videotoolbox') {
|
||
args.push('-hwaccel', 'videotoolbox');
|
||
} else if (decoderAccel === 'v4l2') {
|
||
args.push('-hwaccel', 'v4l2');
|
||
}
|
||
}
|
||
|
||
args.push('-i', input, '-c:v', videoCodec);
|
||
|
||
// Determine if using GPU or CPU encoder
|
||
const isGPU = videoCodec.includes('nvenc') || videoCodec.includes('qsv') || videoCodec.includes('amf') || videoCodec.includes('vaapi') || videoCodec.includes('videotoolbox') || videoCodec.includes('v4l2');
|
||
|
||
// Determine quality value (CQ for GPU, CRF for CPU)
|
||
let qualityValue: number;
|
||
if (isGPU && qualitySettings?.cq !== undefined) {
|
||
qualityValue = qualitySettings.cq;
|
||
} else if (!isGPU && qualitySettings?.crf !== undefined) {
|
||
qualityValue = qualitySettings.crf;
|
||
} else {
|
||
// Use default quality based on resolution
|
||
qualityValue = getDefaultQuality(profile.height, codecType, isGPU);
|
||
}
|
||
|
||
// Add codec-specific options with CQ/CRF
|
||
if (videoCodec === 'h264_nvenc') {
|
||
// NVIDIA H.264 with CQ
|
||
args.push('-rc:v', 'vbr');
|
||
args.push('-cq', String(qualityValue));
|
||
args.push('-preset', preset);
|
||
args.push('-2pass', '0');
|
||
} else if (videoCodec === 'av1_nvenc') {
|
||
// NVIDIA AV1 with CQ
|
||
args.push('-rc:v', 'vbr');
|
||
args.push('-cq', String(qualityValue));
|
||
args.push('-preset', preset);
|
||
args.push('-2pass', '0');
|
||
} else if (videoCodec === 'av1_qsv') {
|
||
// Intel QSV AV1
|
||
args.push('-preset', preset);
|
||
args.push('-global_quality', String(qualityValue));
|
||
} else if (videoCodec === 'h264_qsv') {
|
||
// Intel QSV H.264
|
||
args.push('-preset', preset);
|
||
args.push('-global_quality', String(qualityValue));
|
||
} else if (videoCodec === 'av1_amf') {
|
||
// AMD AMF AV1
|
||
args.push('-quality', 'balanced');
|
||
args.push('-rc', 'cqp');
|
||
args.push('-qp_i', String(qualityValue));
|
||
args.push('-qp_p', String(qualityValue));
|
||
} else if (videoCodec === 'h264_amf') {
|
||
// AMD AMF H.264
|
||
args.push('-quality', 'balanced');
|
||
args.push('-rc', 'cqp');
|
||
args.push('-qp_i', String(qualityValue));
|
||
args.push('-qp_p', String(qualityValue));
|
||
} else if (videoCodec === 'libsvtav1') {
|
||
// CPU-based SVT-AV1 with CRF
|
||
args.push('-crf', String(qualityValue));
|
||
args.push('-preset', preset); // 0-13, 8 is medium speed
|
||
args.push('-svtav1-params', 'tune=0:enable-overlays=1');
|
||
} else if (videoCodec === 'libx264') {
|
||
// CPU-based x264 with CRF
|
||
args.push('-crf', String(qualityValue));
|
||
args.push('-preset', preset);
|
||
} else {
|
||
// Default fallback
|
||
args.push('-preset', preset);
|
||
}
|
||
|
||
// Add maxrate as safety limit (optional but recommended for streaming)
|
||
// This prevents extreme bitrate spikes on complex scenes
|
||
const bitrateMultiplier = codecType === 'av1' ? 0.6 : 1.0;
|
||
const maxBitrate = Math.round(parseInt(profile.videoBitrate) * bitrateMultiplier * 1.5); // +50% headroom
|
||
args.push('-maxrate', `${maxBitrate}k`);
|
||
args.push('-bufsize', `${maxBitrate * 2}k`);
|
||
|
||
// Set GOP size for DASH segments
|
||
// Keyframes must align with segment boundaries
|
||
const fps = profile.fps || 30;
|
||
const gopSize = Math.round(fps * segmentDuration);
|
||
args.push(
|
||
'-g', String(gopSize), // GOP size (e.g., 25 fps * 2 sec = 50 frames)
|
||
'-keyint_min', String(gopSize), // Minimum interval between keyframes
|
||
'-sc_threshold', '0' // Disable scene change detection (keeps GOP consistent)
|
||
);
|
||
|
||
// Build video filter chain
|
||
const filters: string[] = [];
|
||
const targetWidth = profile.width;
|
||
const targetHeight = profile.height;
|
||
|
||
const useCudaScale = decoderAccel === 'nvenc';
|
||
if (useCudaScale) {
|
||
// CUDA path: вписываем в профиль с сохранением исходного AR
|
||
filters.push(`scale_cuda=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease:force_divisible_by=2`);
|
||
} else {
|
||
filters.push(`scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease:force_divisible_by=2`);
|
||
}
|
||
|
||
// Apply optimizations (for future use)
|
||
if (optimizations) {
|
||
if (optimizations.deinterlace) {
|
||
filters.push('yadif');
|
||
}
|
||
if (optimizations.denoise) {
|
||
filters.push('hqdn3d');
|
||
}
|
||
if (optimizations.customFilters) {
|
||
filters.push(...optimizations.customFilters);
|
||
}
|
||
}
|
||
|
||
// Если использовали GPU-скейл, возвращаем кадры в системную память перед CPU-фильтрами
|
||
if (useCudaScale) {
|
||
filters.push('hwdownload', 'format=nv12');
|
||
}
|
||
|
||
// Центрируем кадр, чтобы браузеры (Firefox/videotoolbox) не игнорировали PAR
|
||
filters.push(`pad=${targetWidth}:${targetHeight}:(ow-iw)/2:(oh-ih)/2`, 'setsar=1');
|
||
|
||
args.push('-vf', filters.join(','));
|
||
|
||
if (!muted) {
|
||
// Audio encoding с нормализацией таймингов и автоподпаддингом тишиной
|
||
const targetAudioBitrate = parseInt(profile.audioBitrate) || 256;
|
||
const optimalAudioBitrate = selectAudioBitrate(sourceAudioBitrate, targetAudioBitrate);
|
||
args.push('-c:a', 'aac', '-b:a', optimalAudioBitrate);
|
||
|
||
const targetDur = duration.toFixed(3);
|
||
const audioFilters: string[] = [
|
||
'aresample=async=1:min_hard_comp=0.1:first_pts=0',
|
||
`apad=whole_dur=${targetDur}`,
|
||
`atrim=0:${targetDur}`
|
||
];
|
||
if (optimizations?.audioNormalize) {
|
||
audioFilters.push('loudnorm');
|
||
}
|
||
args.push('-af', audioFilters.join(','));
|
||
} else {
|
||
args.push('-an'); // без аудио дорожки
|
||
}
|
||
|
||
// Output
|
||
args.push('-f', 'mp4', outputPath);
|
||
|
||
await execFFmpeg(args, onProgress, duration);
|
||
|
||
return outputPath;
|
||
}
|
||
|
||
/**
|
||
* Encode all profiles to MP4 (parallel or sequential)
|
||
* Stage 1: Main encoding work
|
||
*/
|
||
export async function encodeProfilesToMP4(
|
||
input: string,
|
||
tempDir: string,
|
||
profiles: VideoProfile[],
|
||
videoCodec: string,
|
||
preset: string,
|
||
duration: number,
|
||
segmentDuration: number,
|
||
sourceAudioBitrate: number | undefined,
|
||
parallel: boolean,
|
||
maxConcurrent: number,
|
||
codecType: 'h264' | 'av1',
|
||
qualitySettings?: CodecQualitySettings,
|
||
optimizations?: VideoOptimizations,
|
||
muted: boolean = false,
|
||
decoderAccel?: HardwareAccelerator,
|
||
onProgress?: (profileName: string, percent: number) => void
|
||
): Promise<Map<string, string>> {
|
||
const mp4Files = new Map<string, string>();
|
||
|
||
if (parallel && profiles.length > 1) {
|
||
// Parallel encoding with batching
|
||
for (let i = 0; i < profiles.length; i += maxConcurrent) {
|
||
const batch = profiles.slice(i, i + maxConcurrent);
|
||
const batchPromises = batch.map((profile) =>
|
||
encodeProfileToMP4(
|
||
input,
|
||
tempDir,
|
||
profile,
|
||
videoCodec,
|
||
preset,
|
||
duration,
|
||
segmentDuration,
|
||
sourceAudioBitrate,
|
||
codecType,
|
||
qualitySettings,
|
||
optimizations,
|
||
muted,
|
||
decoderAccel,
|
||
(percent) => {
|
||
if (onProgress) {
|
||
onProgress(profile.name, percent);
|
||
}
|
||
}
|
||
)
|
||
);
|
||
|
||
const batchResults = await Promise.all(batchPromises);
|
||
batchResults.forEach((mp4Path, idx) => {
|
||
const profile = batch[idx];
|
||
mp4Files.set(profile.name, mp4Path);
|
||
});
|
||
}
|
||
} else {
|
||
// Sequential encoding
|
||
for (const profile of profiles) {
|
||
const mp4Path = await encodeProfileToMP4(
|
||
input,
|
||
tempDir,
|
||
profile,
|
||
videoCodec,
|
||
preset,
|
||
duration,
|
||
segmentDuration,
|
||
sourceAudioBitrate,
|
||
codecType,
|
||
qualitySettings,
|
||
optimizations,
|
||
muted,
|
||
decoderAccel,
|
||
(percent) => {
|
||
if (onProgress) {
|
||
onProgress(profile.name, percent);
|
||
}
|
||
}
|
||
);
|
||
|
||
mp4Files.set(profile.name, mp4Path);
|
||
}
|
||
}
|
||
|
||
return mp4Files;
|
||
}
|