PeerTube/server/helpers/ffmpeg/ffprobe-utils.ts

255 lines
7.6 KiB
TypeScript
Raw Normal View History

import { FfprobeData } from 'fluent-ffmpeg'
2021-08-06 13:35:25 +02:00
import { getMaxBitrate } from '@shared/core-utils'
import {
buildFileMetadata,
ffprobePromise,
getAudioStream,
getMaxAudioBitrate,
2022-02-11 10:51:33 +01:00
getVideoStream,
getVideoStreamBitrate,
2022-02-11 10:51:33 +01:00
getVideoStreamDimensionsInfo,
getVideoStreamDuration,
getVideoStreamFPS,
2022-02-11 10:51:33 +01:00
hasAudioStream
} from '@shared/extra-utils/ffprobe'
2022-02-11 10:51:33 +01:00
import { VideoResolution, VideoTranscodingFPS } from '@shared/models'
import { CONFIG } from '../../initializers/config'
import { VIDEO_TRANSCODING_FPS } from '../../initializers/constants'
2022-11-07 10:43:22 +01:00
import { toEven } from '../core-utils'
2022-02-11 10:51:33 +01:00
import { logger } from '../logger'
2020-11-20 17:16:55 +01:00
2020-11-24 16:29:39 +01:00
/**
*
* Helpers to run ffprobe and extract data from the JSON output
*
*/
2022-02-11 10:51:33 +01:00
// ---------------------------------------------------------------------------
// Codecs
// ---------------------------------------------------------------------------
2020-11-20 17:16:55 +01:00
2022-02-11 10:51:33 +01:00
async function getVideoStreamCodec (path: string) {
const videoStream = await getVideoStream(path)
2020-11-20 17:16:55 +01:00
if (!videoStream) return ''
const videoCodec = videoStream.codec_tag_string
2021-01-29 13:57:17 +01:00
if (videoCodec === 'vp09') return 'vp09.00.50.08'
2021-04-21 09:08:14 +02:00
if (videoCodec === 'hev1') return 'hev1.1.6.L93.B0'
2021-01-29 13:57:17 +01:00
2020-11-20 17:16:55 +01:00
const baseProfileMatrix = {
2021-01-29 13:57:17 +01:00
avc1: {
High: '6400',
Main: '4D40',
Baseline: '42E0'
},
av01: {
High: '1',
Main: '0',
Professional: '2'
}
2020-11-20 17:16:55 +01:00
}
2021-01-29 13:57:17 +01:00
let baseProfile = baseProfileMatrix[videoCodec][videoStream.profile]
2020-11-20 17:16:55 +01:00
if (!baseProfile) {
logger.warn('Cannot get video profile codec of %s.', path, { videoStream })
2021-01-29 13:57:17 +01:00
baseProfile = baseProfileMatrix[videoCodec]['High'] // Fallback
}
2022-09-09 15:02:28 +02:00
if (videoCodec === 'av01') {
2022-09-12 10:15:42 +02:00
let level = videoStream.level.toString()
if (level.length === 1) level = `0${level}`
2021-01-29 13:57:17 +01:00
// Guess the tier indicator and bit depth
return `${videoCodec}.${baseProfile}.${level}M.08`
2020-11-20 17:16:55 +01:00
}
2022-09-12 10:15:42 +02:00
let level = videoStream.level.toString(16)
if (level.length === 1) level = `0${level}`
2021-01-29 13:57:17 +01:00
// Default, h264 codec
2020-11-20 17:16:55 +01:00
return `${videoCodec}.${baseProfile}${level}`
}
2021-08-27 14:32:44 +02:00
async function getAudioStreamCodec (path: string, existingProbe?: FfprobeData) {
2020-11-20 17:16:55 +01:00
const { audioStream } = await getAudioStream(path, existingProbe)
if (!audioStream) return ''
2021-01-29 13:57:17 +01:00
const audioCodecName = audioStream.codec_name
if (audioCodecName === 'opus') return 'opus'
if (audioCodecName === 'vorbis') return 'vorbis'
if (audioCodecName === 'aac') return 'mp4a.40.2'
if (audioCodecName === 'mp3') return 'mp4a.40.34'
2020-11-20 17:16:55 +01:00
logger.warn('Cannot get audio codec of %s.', path, { audioStream })
return 'mp4a.40.2' // Fallback
}
2022-02-11 10:51:33 +01:00
// ---------------------------------------------------------------------------
// Resolutions
// ---------------------------------------------------------------------------
function computeResolutionsToTranscode (options: {
input: number
type: 'vod' | 'live'
includeInput: boolean
strictLower: boolean
hasAudio: boolean
}) {
const { input, type, includeInput, strictLower, hasAudio } = options
2020-11-20 17:16:55 +01:00
const configResolutions = type === 'vod'
? CONFIG.TRANSCODING.RESOLUTIONS
: CONFIG.LIVE.TRANSCODING.RESOLUTIONS
const resolutionsEnabled = new Set<number>()
2020-11-20 17:16:55 +01:00
// Put in the order we want to proceed jobs
const availableResolutions: VideoResolution[] = [
2020-11-20 17:16:55 +01:00
VideoResolution.H_NOVIDEO,
VideoResolution.H_480P,
VideoResolution.H_360P,
VideoResolution.H_720P,
VideoResolution.H_240P,
VideoResolution.H_144P,
2020-11-20 17:16:55 +01:00
VideoResolution.H_1080P,
VideoResolution.H_1440P,
2020-11-20 17:16:55 +01:00
VideoResolution.H_4K
]
for (const resolution of availableResolutions) {
// Resolution not enabled
if (configResolutions[resolution + 'p'] !== true) continue
// Too big resolution for input file
if (input < resolution) continue
// We only want lower resolutions than input file
if (strictLower && input === resolution) continue
// Audio resolutio but no audio in the video
if (resolution === VideoResolution.H_NOVIDEO && !hasAudio) continue
resolutionsEnabled.add(resolution)
2020-11-20 17:16:55 +01:00
}
if (includeInput) {
2022-11-07 10:43:22 +01:00
// Always use an even resolution to avoid issues with ffmpeg
resolutionsEnabled.add(toEven(input))
}
return Array.from(resolutionsEnabled)
2020-11-20 17:16:55 +01:00
}
2022-02-11 10:51:33 +01:00
// ---------------------------------------------------------------------------
// Can quick transcode
// ---------------------------------------------------------------------------
2020-11-20 17:16:55 +01:00
async function canDoQuickTranscode (path: string): Promise<boolean> {
if (CONFIG.TRANSCODING.PROFILE !== 'default') return false
2020-11-20 17:16:55 +01:00
const probe = await ffprobePromise(path)
2020-11-24 14:08:23 +01:00
return await canDoQuickVideoTranscode(path, probe) &&
await canDoQuickAudioTranscode(path, probe)
}
2022-02-11 10:51:33 +01:00
async function canDoQuickAudioTranscode (path: string, probe?: FfprobeData): Promise<boolean> {
const parsedAudio = await getAudioStream(path, probe)
if (!parsedAudio.audioStream) return true
if (parsedAudio.audioStream['codec_name'] !== 'aac') return false
const audioBitrate = parsedAudio.bitrate
if (!audioBitrate) return false
const maxAudioBitrate = getMaxAudioBitrate('aac', audioBitrate)
if (maxAudioBitrate !== -1 && audioBitrate > maxAudioBitrate) return false
const channelLayout = parsedAudio.audioStream['channel_layout']
// Causes playback issues with Chrome
2022-08-10 16:05:38 +02:00
if (!channelLayout || channelLayout === 'unknown' || channelLayout === 'quad') return false
2022-02-11 10:51:33 +01:00
return true
}
2021-08-27 14:32:44 +02:00
async function canDoQuickVideoTranscode (path: string, probe?: FfprobeData): Promise<boolean> {
2022-02-11 10:51:33 +01:00
const videoStream = await getVideoStream(path, probe)
const fps = await getVideoStreamFPS(path, probe)
const bitRate = await getVideoStreamBitrate(path, probe)
const resolutionData = await getVideoStreamDimensionsInfo(path, probe)
2020-11-20 17:16:55 +01:00
2020-11-24 16:24:50 +01:00
// If ffprobe did not manage to guess the bitrate
if (!bitRate) return false
2020-11-20 17:16:55 +01:00
// check video params
2022-02-11 10:51:33 +01:00
if (!videoStream) return false
2020-11-20 17:16:55 +01:00
if (videoStream['codec_name'] !== 'h264') return false
if (videoStream['pix_fmt'] !== 'yuv420p') return false
if (fps < VIDEO_TRANSCODING_FPS.MIN || fps > VIDEO_TRANSCODING_FPS.MAX) return false
2021-08-06 13:35:25 +02:00
if (bitRate > getMaxBitrate({ ...resolutionData, fps })) return false
2020-11-20 17:16:55 +01:00
2020-11-24 14:08:23 +01:00
return true
}
2022-02-11 10:51:33 +01:00
// ---------------------------------------------------------------------------
// Framerate
// ---------------------------------------------------------------------------
2021-08-06 13:35:25 +02:00
function getClosestFramerateStandard <K extends keyof Pick<VideoTranscodingFPS, 'HD_STANDARD' | 'STANDARD'>> (fps: number, type: K) {
2020-11-20 17:16:55 +01:00
return VIDEO_TRANSCODING_FPS[type].slice(0)
.sort((a, b) => fps % a - fps % b)[0]
}
2020-11-26 11:29:50 +01:00
function computeFPS (fpsArg: number, resolution: VideoResolution) {
let fps = fpsArg
if (
// On small/medium resolutions, limit FPS
resolution !== undefined &&
resolution < VIDEO_TRANSCODING_FPS.KEEP_ORIGIN_FPS_RESOLUTION_MIN &&
fps > VIDEO_TRANSCODING_FPS.AVERAGE
) {
// Get closest standard framerate by modulo: downsampling has to be done to a divisor of the nominal fps value
fps = getClosestFramerateStandard(fps, 'STANDARD')
}
// Hard FPS limits
if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = getClosestFramerateStandard(fps, 'HD_STANDARD')
if (fps < VIDEO_TRANSCODING_FPS.MIN) {
throw new Error(`Cannot compute FPS because ${fps} is lower than our minimum value ${VIDEO_TRANSCODING_FPS.MIN}`)
}
2020-11-26 11:29:50 +01:00
return fps
}
2020-11-20 17:16:55 +01:00
// ---------------------------------------------------------------------------
export {
2022-02-11 10:51:33 +01:00
// Re export ffprobe utils
getVideoStreamDimensionsInfo,
buildFileMetadata,
2020-11-20 17:16:55 +01:00
getMaxAudioBitrate,
2022-02-11 10:51:33 +01:00
getVideoStream,
getVideoStreamDuration,
2020-11-20 17:16:55 +01:00
getAudioStream,
2022-02-11 10:51:33 +01:00
hasAudioStream,
getVideoStreamFPS,
2020-11-24 14:08:23 +01:00
ffprobePromise,
2022-02-11 10:51:33 +01:00
getVideoStreamBitrate,
getVideoStreamCodec,
getAudioStreamCodec,
computeFPS,
2020-11-20 17:16:55 +01:00
getClosestFramerateStandard,
2022-02-11 10:51:33 +01:00
computeResolutionsToTranscode,
2022-02-11 10:51:33 +01:00
2020-11-24 14:08:23 +01:00
canDoQuickTranscode,
canDoQuickVideoTranscode,
canDoQuickAudioTranscode
2020-11-20 17:16:55 +01:00
}