X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fhelpers%2Fffprobe-utils.ts;h=e58444b07296dd16453abfbc7ad27cd12bec488a;hb=f645af439669b084dc7ea360751a0e4c1980c81b;hp=1cf397767e807a2ce06947ecdca5b793524afeb3;hpb=884d2c39ae23b44d0d037aaff0f66ad9ae0807ba;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/helpers/ffprobe-utils.ts b/server/helpers/ffprobe-utils.ts
index 1cf397767..e58444b07 100644
--- a/server/helpers/ffprobe-utils.ts
+++ b/server/helpers/ffprobe-utils.ts
@@ -1,6 +1,6 @@
 import * as ffmpeg from 'fluent-ffmpeg'
-import { VideoFileMetadata } from '@shared/models/videos/video-file-metadata'
-import { getMaxBitrate, VideoResolution } from '../../shared/models/videos'
+import { getMaxBitrate } from '@shared/core-utils'
+import { VideoFileMetadata, VideoResolution, VideoTranscodingFPS } from '../../shared/models/videos'
 import { CONFIG } from '../initializers/config'
 import { VIDEO_TRANSCODING_FPS } from '../initializers/constants'
 import { logger } from './logger'
@@ -76,7 +76,7 @@ function getMaxAudioBitrate (type: 'aac' | 'mp3' | string, bitrate: number) {
   }
 }
 
-async function getVideoStreamSize (path: string, existingProbe?: ffmpeg.FfprobeData) {
+async function getVideoStreamSize (path: string, existingProbe?: ffmpeg.FfprobeData): Promise<{ width: number, height: number }> {
   const videoStream = await getVideoStreamFromFile(path, existingProbe)
 
   return videoStream === null
@@ -91,18 +91,36 @@ async function getVideoStreamCodec (path: string) {
 
   const videoCodec = videoStream.codec_tag_string
 
+  if (videoCodec === 'vp09') return 'vp09.00.50.08'
+  if (videoCodec === 'hev1') return 'hev1.1.6.L93.B0'
+
   const baseProfileMatrix = {
-    High: '6400',
-    Main: '4D40',
-    Baseline: '42E0'
+    avc1: {
+      High: '6400',
+      Main: '4D40',
+      Baseline: '42E0'
+    },
+    av01: {
+      High: '1',
+      Main: '0',
+      Professional: '2'
+    }
   }
 
-  let baseProfile = baseProfileMatrix[videoStream.profile]
+  let baseProfile = baseProfileMatrix[videoCodec][videoStream.profile]
   if (!baseProfile) {
     logger.warn('Cannot get video profile codec of %s.', path, { videoStream })
-    baseProfile = baseProfileMatrix['High'] // Fallback
+    baseProfile = baseProfileMatrix[videoCodec]['High'] // Fallback
+  }
+
+  if (videoCodec === 'av01') {
+    const level = videoStream.level
+
+    // Guess the tier indicator and bit depth
+    return `${videoCodec}.${baseProfile}.${level}M.08`
   }
 
+  // Default, h264 codec
   let level = videoStream.level.toString(16)
   if (level.length === 1) level = `0${level}`
 
@@ -114,8 +132,11 @@ async function getAudioStreamCodec (path: string, existingProbe?: ffmpeg.Ffprobe
 
   if (!audioStream) return ''
 
-  const audioCodec = audioStream.codec_name
-  if (audioCodec === 'aac') return 'mp4a.40.2'
+  const audioCodecName = audioStream.codec_name
+
+  if (audioCodecName === 'opus') return 'opus'
+  if (audioCodecName === 'vorbis') return 'vorbis'
+  if (audioCodecName === 'aac') return 'mp4a.40.2'
 
   logger.warn('Cannot get audio codec of %s.', path, { audioStream })
 
@@ -126,7 +147,10 @@ async function getVideoFileResolution (path: string, existingProbe?: ffmpeg.Ffpr
   const size = await getVideoStreamSize(path, existingProbe)
 
   return {
-    videoFileResolution: Math.min(size.height, size.width),
+    width: size.width,
+    height: size.height,
+    ratio: Math.max(size.height, size.width) / Math.min(size.height, size.width),
+    resolution: Math.min(size.height, size.width),
     isPortraitMode: size.height > size.width
   }
 }
@@ -155,16 +179,25 @@ async function getMetadataFromFile (path: string, existingProbe?: ffmpeg.Ffprobe
   return new VideoFileMetadata(metadata)
 }
 
-async function getVideoFileBitrate (path: string, existingProbe?: ffmpeg.FfprobeData) {
+async function getVideoFileBitrate (path: string, existingProbe?: ffmpeg.FfprobeData): Promise<number> {
   const metadata = await getMetadataFromFile(path, existingProbe)
 
-  return metadata.format.bit_rate as number
+  let bitrate = metadata.format.bit_rate as number
+  if (bitrate && !isNaN(bitrate)) return bitrate
+
+  const videoStream = await getVideoStreamFromFile(path, existingProbe)
+  if (!videoStream) return undefined
+
+  bitrate = videoStream?.bit_rate
+  if (bitrate && !isNaN(bitrate)) return bitrate
+
+  return undefined
 }
 
 async function getDurationFromVideoFile (path: string, existingProbe?: ffmpeg.FfprobeData) {
   const metadata = await getMetadataFromFile(path, existingProbe)
 
-  return Math.floor(metadata.format.duration)
+  return Math.round(metadata.format.duration)
 }
 
 async function getVideoStreamFromFile (path: string, existingProbe?: ffmpeg.FfprobeData) {
@@ -188,6 +221,7 @@ function computeResolutionsToTranscode (videoFileResolution: number, type: 'vod'
     VideoResolution.H_720P,
     VideoResolution.H_240P,
     VideoResolution.H_1080P,
+    VideoResolution.H_1440P,
     VideoResolution.H_4K
   ]
 
@@ -201,6 +235,8 @@ function computeResolutionsToTranscode (videoFileResolution: number, type: 'vod'
 }
 
 async function canDoQuickTranscode (path: string): Promise<boolean> {
+  if (CONFIG.TRANSCODING.PROFILE !== 'default') return false
+
   const probe = await ffprobePromise(path)
 
   return await canDoQuickVideoTranscode(path, probe) &&
@@ -211,7 +247,7 @@ async function canDoQuickVideoTranscode (path: string, probe?: ffmpeg.FfprobeDat
   const videoStream = await getVideoStreamFromFile(path, probe)
   const fps = await getVideoFileFPS(path, probe)
   const bitRate = await getVideoFileBitrate(path, probe)
-  const resolution = await getVideoFileResolution(path, probe)
+  const resolutionData = await getVideoFileResolution(path, probe)
 
   // If ffprobe did not manage to guess the bitrate
   if (!bitRate) return false
@@ -221,7 +257,7 @@ async function canDoQuickVideoTranscode (path: string, probe?: ffmpeg.FfprobeDat
   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
-  if (bitRate > getMaxBitrate(resolution.videoFileResolution, fps, VIDEO_TRANSCODING_FPS)) return false
+  if (bitRate > getMaxBitrate({ ...resolutionData, fps })) return false
 
   return true
 }
@@ -239,10 +275,14 @@ async function canDoQuickAudioTranscode (path: string, probe?: ffmpeg.FfprobeDat
   const maxAudioBitrate = getMaxAudioBitrate('aac', audioBitrate)
   if (maxAudioBitrate !== -1 && audioBitrate > maxAudioBitrate) return false
 
+  const channelLayout = parsedAudio.audioStream['channel_layout']
+  // Causes playback issues with Chrome
+  if (!channelLayout || channelLayout === 'unknown') return false
+
   return true
 }
 
-function getClosestFramerateStandard (fps: number, type: 'HD_STANDARD' | 'STANDARD'): number {
+function getClosestFramerateStandard <K extends keyof Pick<VideoTranscodingFPS, 'HD_STANDARD' | 'STANDARD'>> (fps: number, type: K) {
   return VIDEO_TRANSCODING_FPS[type].slice(0)
                                     .sort((a, b) => fps % a - fps % b)[0]
 }