import * as ffmpeg from 'fluent-ffmpeg'
+import { readFile, remove, writeFile } from 'fs-extra'
import { dirname, join } from 'path'
+import { VideoFileMetadata } from '@shared/models/videos/video-file-metadata'
import { getMaxBitrate, getTargetBitrate, VideoResolution } from '../../shared/models/videos'
+import { checkFFmpegEncoders } from '../initializers/checker-before-init'
+import { CONFIG } from '../initializers/config'
import { FFMPEG_NICE, VIDEO_TRANSCODING_FPS } from '../initializers/constants'
import { processImage } from './image-utils'
import { logger } from './logger'
-import { checkFFmpegEncoders } from '../initializers/checker-before-init'
-import { readFile, remove, writeFile } from 'fs-extra'
-import { CONFIG } from '../initializers/config'
/**
* A toolbox to play with audio
}
}
-function computeResolutionsToTranscode (videoFileHeight: number) {
+function computeResolutionsToTranscode (videoFileResolution: number, type: 'vod' | 'live') {
+ const configResolutions = type === 'vod'
+ ? CONFIG.TRANSCODING.RESOLUTIONS
+ : CONFIG.LIVE.TRANSCODING.RESOLUTIONS
+
const resolutionsEnabled: number[] = []
- const configResolutions = CONFIG.TRANSCODING.RESOLUTIONS
// Put in the order we want to proceed jobs
const resolutions = [
]
for (const resolution of resolutions) {
- if (configResolutions[resolution + 'p'] === true && videoFileHeight > resolution) {
+ if (configResolutions[resolution + 'p'] === true && videoFileResolution > resolution) {
resolutionsEnabled.push(resolution)
}
}
baseProfile = baseProfileMatrix['High'] // Fallback
}
- const level = videoStream.level.toString(16)
+ let level = videoStream.level.toString(16)
+ if (level.length === 1) level = `0${level}`
return `${videoCodec}.${baseProfile}${level}`
}
return 0
}
-async function getVideoFileBitrate (path: string) {
- return new Promise<number>((res, rej) => {
+async function getMetadataFromFile <T> (path: string, cb = metadata => metadata) {
+ return new Promise<T>((res, rej) => {
ffmpeg.ffprobe(path, (err, metadata) => {
if (err) return rej(err)
- return res(metadata.format.bit_rate)
+ return res(cb(new VideoFileMetadata(metadata)))
})
})
}
+async function getVideoFileBitrate (path: string) {
+ return getMetadataFromFile<number>(path, metadata => metadata.format.bit_rate)
+}
+
function getDurationFromVideoFile (path: string) {
- return new Promise<number>((res, rej) => {
- ffmpeg.ffprobe(path, (err, metadata) => {
- if (err) return rej(err)
+ return getMetadataFromFile<number>(path, metadata => Math.floor(metadata.format.duration))
+}
- return res(Math.floor(metadata.format.duration))
- })
- })
+function getVideoStreamFromFile (path: string) {
+ return getMetadataFromFile<any>(path, metadata => metadata.streams.find(s => s.codec_type === 'video') || null)
}
async function generateImageFromVideoFile (fromPath: string, folder: string, imageName: string, size: { width: number, height: number }) {
function transcode (options: TranscodeOptions) {
return new Promise<void>(async (res, rej) => {
try {
- let command = ffmpeg(options.inputPath, { niceness: FFMPEG_NICE.TRANSCODING })
+ let command = getFFmpeg(options.inputPath)
.output(options.outputPath)
if (options.type === 'quick-transcode') {
command = buildQuickTranscodeCommand(command)
} else if (options.type === 'hls') {
- command = await buildHLSCommand(command, options)
+ command = await buildHLSVODCommand(command, options)
} else if (options.type === 'merge-audio') {
command = await buildAudioMergeCommand(command, options)
} else if (options.type === 'only-audio') {
command = await buildx264Command(command, options)
}
- if (CONFIG.TRANSCODING.THREADS > 0) {
- // if we don't set any threads ffmpeg will chose automatically
- command = command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS)
- }
-
command
.on('error', (err, stdout, stderr) => {
logger.error('Error in transcoding job.', { stdout, stderr })
.sort((a, b) => fps % a - fps % b)[0]
}
+function convertWebPToJPG (path: string, destination: string): Promise<void> {
+ return new Promise<void>(async (res, rej) => {
+ try {
+ const command = ffmpeg(path).output(destination)
+
+ command.on('error', (err, stdout, stderr) => {
+ logger.error('Error in ffmpeg webp convert process.', { stdout, stderr })
+ return rej(err)
+ })
+ .on('end', () => res())
+ .run()
+ } catch (err) {
+ return rej(err)
+ }
+ })
+}
+
+function runLiveTranscoding (rtmpUrl: string, outPath: string, resolutions: number[]) {
+ const command = getFFmpeg(rtmpUrl)
+ command.inputOption('-fflags nobuffer')
+
+ const varStreamMap: string[] = []
+
+ command.complexFilter([
+ {
+ inputs: '[v:0]',
+ filter: 'split',
+ options: resolutions.length,
+ outputs: resolutions.map(r => `vtemp${r}`)
+ },
+
+ ...resolutions.map(r => ({
+ inputs: `vtemp${r}`,
+ filter: 'scale',
+ options: `w=-2:h=${r}`,
+ outputs: `vout${r}`
+ }))
+ ])
+
+ const liveFPS = VIDEO_TRANSCODING_FPS.AVERAGE
+
+ command.withFps(liveFPS)
+
+ command.outputOption('-b_strategy 1')
+ command.outputOption('-bf 16')
+ command.outputOption('-preset superfast')
+ command.outputOption('-level 3.1')
+ command.outputOption('-map_metadata -1')
+ command.outputOption('-pix_fmt yuv420p')
+
+ for (let i = 0; i < resolutions.length; i++) {
+ const resolution = resolutions[i]
+
+ command.outputOption(`-map [vout${resolution}]`)
+ command.outputOption(`-c:v:${i} libx264`)
+ command.outputOption(`-b:v:${i} ${getTargetBitrate(resolution, liveFPS, VIDEO_TRANSCODING_FPS)}`)
+
+ command.outputOption(`-map a:0`)
+ command.outputOption(`-c:a:${i} aac`)
+
+ varStreamMap.push(`v:${i},a:${i}`)
+ }
+
+ addDefaultLiveHLSParams(command, outPath)
+
+ command.outputOption('-var_stream_map', varStreamMap.join(' '))
+
+ command.run()
+
+ return command
+}
+
+function runLiveMuxing (rtmpUrl: string, outPath: string) {
+ const command = getFFmpeg(rtmpUrl)
+ command.inputOption('-fflags nobuffer')
+
+ command.outputOption('-c:v copy')
+ command.outputOption('-c:a copy')
+ command.outputOption('-map 0:a?')
+ command.outputOption('-map 0:v?')
+
+ addDefaultLiveHLSParams(command, outPath)
+
+ command.run()
+
+ return command
+}
+
// ---------------------------------------------------------------------------
export {
getVideoStreamCodec,
getAudioStreamCodec,
+ runLiveMuxing,
+ convertWebPToJPG,
getVideoStreamSize,
getVideoFileResolution,
+ getMetadataFromFile,
getDurationFromVideoFile,
+ runLiveTranscoding,
generateImageFromVideoFile,
TranscodeOptions,
TranscodeOptionsType,
// ---------------------------------------------------------------------------
+function addDefaultX264Params (command: ffmpeg.FfmpegCommand) {
+ command.outputOption('-level 3.1') // 3.1 is the minimal resource allocation for our highest supported resolution
+ .outputOption('-b_strategy 1') // NOTE: b-strategy 1 - heuristic algorithm, 16 is optimal B-frames for it
+ .outputOption('-bf 16') // NOTE: Why 16: https://github.com/Chocobozzz/PeerTube/pull/774. b-strategy 2 -> B-frames<16
+ .outputOption('-pix_fmt yuv420p') // allows import of source material with incompatible pixel formats (e.g. MJPEG video)
+ .outputOption('-map_metadata -1') // strip all metadata
+}
+
+function addDefaultLiveHLSParams (command: ffmpeg.FfmpegCommand, outPath: string) {
+ command.outputOption('-hls_time 4')
+ command.outputOption('-hls_list_size 15')
+ command.outputOption('-hls_flags delete_segments')
+ command.outputOption(`-hls_segment_filename ${join(outPath, '%v-%d.ts')}`)
+ command.outputOption('-master_pl_name master.m3u8')
+ command.outputOption(`-f hls`)
+
+ command.output(join(outPath, '%v.m3u8'))
+}
+
async function buildx264Command (command: ffmpeg.FfmpegCommand, options: TranscodeOptions) {
let fps = await getVideoFileFPS(options.inputPath)
if (
return command
}
-async function buildHLSCommand (command: ffmpeg.FfmpegCommand, options: HLSTranscodeOptions) {
+async function buildHLSVODCommand (command: ffmpeg.FfmpegCommand, options: HLSTranscodeOptions) {
const videoPath = getHLSVideoPath(options)
if (options.copyCodecs) command = presetCopy(command)
+ else if (options.resolution === VideoResolution.H_NOVIDEO) command = presetOnlyAudio(command)
else command = await buildx264Command(command, options)
command = command.outputOption('-hls_time 4')
await writeFile(options.outputPath, newContent)
}
-function getVideoStreamFromFile (path: string) {
- return new Promise<any>((res, rej) => {
- ffmpeg.ffprobe(path, (err, metadata) => {
- if (err) return rej(err)
-
- const videoStream = metadata.streams.find(s => s.codec_type === 'video')
- return res(videoStream || null)
- })
- })
-}
-
/**
* A slightly customised version of the 'veryfast' x264 preset
*
let localCommand = command
.format('mp4')
.videoCodec('libx264')
- .outputOption('-level 3.1') // 3.1 is the minimal resource allocation for our highest supported resolution
- .outputOption('-b_strategy 1') // NOTE: b-strategy 1 - heuristic algorithm, 16 is optimal B-frames for it
- .outputOption('-bf 16') // NOTE: Why 16: https://github.com/Chocobozzz/PeerTube/pull/774. b-strategy 2 -> B-frames<16
- .outputOption('-pix_fmt yuv420p') // allows import of source material with incompatible pixel formats (e.g. MJPEG video)
- .outputOption('-map_metadata -1') // strip all metadata
.outputOption('-movflags faststart')
+ addDefaultX264Params(localCommand)
+
const parsedAudio = await audio.get(input)
if (!parsedAudio.audioStream) {
.audioCodec('copy')
.noVideo()
}
+
+function getFFmpeg (input: string) {
+ // We set cwd explicitly because ffmpeg appears to create temporary files when trancoding which fails in read-only file systems
+ const command = ffmpeg(input, { niceness: FFMPEG_NICE.TRANSCODING, cwd: CONFIG.STORAGE.TMP_DIR })
+
+ if (CONFIG.TRANSCODING.THREADS > 0) {
+ // If we don't set any threads ffmpeg will chose automatically
+ command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS)
+ }
+
+ return command
+}
projects / github / Chocobozzz / PeerTube.git / blobdiff