X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fhelpers%2Fffprobe-utils.ts;h=5b1ad9066b215d4b6b975e23ac1bdbbe07d81aee;hb=e25f83ce2106750b552133da232a9a0810ceb9b0;hp=6159d3963bb3eceb493d357a058ed1f68e144462;hpb=daf6e4801052d3ca6be2fafd20bae2323b1ce175;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/helpers/ffprobe-utils.ts b/server/helpers/ffprobe-utils.ts
index 6159d3963..5b1ad9066 100644
--- a/server/helpers/ffprobe-utils.ts
+++ b/server/helpers/ffprobe-utils.ts
@@ -5,6 +5,12 @@ import { CONFIG } from '../initializers/config'
 import { VIDEO_TRANSCODING_FPS } from '../initializers/constants'
 import { logger } from './logger'
 
+/**
+ *
+ * Helpers to run ffprobe and extract data from the JSON output
+ *
+ */
+
 function ffprobePromise (path: string) {
   return new Promise<ffmpeg.FfprobeData>((res, rej) => {
     ffmpeg.ffprobe(path, (err, data) => {
@@ -37,38 +43,37 @@ async function getAudioStream (videoPath: string, existingProbe?: ffmpeg.Ffprobe
 }
 
 function getMaxAudioBitrate (type: 'aac' | 'mp3' | string, bitrate: number) {
-  const baseKbitrate = 384
-  const toBits = (kbits: number) => kbits * 8000
+  const maxKBitrate = 384
+  const kToBits = (kbits: number) => kbits * 1000
+
+  // If we did not manage to get the bitrate, use an average value
+  if (!bitrate) return 256
 
   if (type === 'aac') {
     switch (true) {
-      case bitrate > toBits(baseKbitrate):
-        return baseKbitrate
+      case bitrate > kToBits(maxKBitrate):
+        return maxKBitrate
 
       default:
         return -1 // we interpret it as a signal to copy the audio stream as is
     }
   }
 
-  if (type === 'mp3') {
-    /*
-      a 192kbit/sec mp3 doesn't hold as much information as a 192kbit/sec aac.
-      That's why, when using aac, we can go to lower kbit/sec. The equivalences
-      made here are not made to be accurate, especially with good mp3 encoders.
-      */
-    switch (true) {
-      case bitrate <= toBits(192):
-        return 128
+  /*
+    a 192kbit/sec mp3 doesn't hold as much information as a 192kbit/sec aac.
+    That's why, when using aac, we can go to lower kbit/sec. The equivalences
+    made here are not made to be accurate, especially with good mp3 encoders.
+    */
+  switch (true) {
+    case bitrate <= kToBits(192):
+      return 128
 
-      case bitrate <= toBits(384):
-        return 256
+    case bitrate <= kToBits(384):
+      return 256
 
-      default:
-        return baseKbitrate
-    }
+    default:
+      return maxKBitrate
   }
-
-  return undefined
 }
 
 async function getVideoStreamSize (path: string, existingProbe?: ffmpeg.FfprobeData) {
@@ -159,7 +164,7 @@ async function getVideoFileBitrate (path: string, existingProbe?: ffmpeg.Ffprobe
 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) {
@@ -183,6 +188,7 @@ function computeResolutionsToTranscode (videoFileResolution: number, type: 'vod'
     VideoResolution.H_720P,
     VideoResolution.H_240P,
     VideoResolution.H_1080P,
+    VideoResolution.H_1440P,
     VideoResolution.H_4K
   ]
 
@@ -196,15 +202,23 @@ 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)
 
-  // NOTE: This could be optimized by running ffprobe only once (but it runs fast anyway)
+  return await canDoQuickVideoTranscode(path, probe) &&
+         await canDoQuickAudioTranscode(path, probe)
+}
+
+async function canDoQuickVideoTranscode (path: string, probe?: ffmpeg.FfprobeData): Promise<boolean> {
   const videoStream = await getVideoStreamFromFile(path, probe)
-  const parsedAudio = await getAudioStream(path, probe)
   const fps = await getVideoFileFPS(path, probe)
   const bitRate = await getVideoFileBitrate(path, probe)
   const resolution = await getVideoFileResolution(path, probe)
 
+  // If ffprobe did not manage to guess the bitrate
+  if (!bitRate) return false
+
   // check video params
   if (videoStream == null) return false
   if (videoStream['codec_name'] !== 'h264') return false
@@ -212,15 +226,21 @@ async function canDoQuickTranscode (path: string): Promise<boolean> {
   if (fps < VIDEO_TRANSCODING_FPS.MIN || fps > VIDEO_TRANSCODING_FPS.MAX) return false
   if (bitRate > getMaxBitrate(resolution.videoFileResolution, fps, VIDEO_TRANSCODING_FPS)) return false
 
-  // check audio params (if audio stream exists)
-  if (parsedAudio.audioStream) {
-    if (parsedAudio.audioStream['codec_name'] !== 'aac') return false
+  return true
+}
 
-    const audioBitrate = parsedAudio.bitrate
+async function canDoQuickAudioTranscode (path: string, probe?: ffmpeg.FfprobeData): Promise<boolean> {
+  const parsedAudio = await getAudioStream(path, probe)
 
-    const maxAudioBitrate = getMaxAudioBitrate('aac', audioBitrate)
-    if (maxAudioBitrate !== -1 && audioBitrate > maxAudioBitrate) return false
-  }
+  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
 
   return true
 }
@@ -230,6 +250,26 @@ function getClosestFramerateStandard (fps: number, type: 'HD_STANDARD' | 'STANDA
                                     .sort((a, b) => fps % a - fps % b)[0]
 }
 
+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')
+  else if (fps < VIDEO_TRANSCODING_FPS.MIN) fps = VIDEO_TRANSCODING_FPS.MIN
+
+  return fps
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -239,11 +279,16 @@ export {
   getVideoFileResolution,
   getMetadataFromFile,
   getMaxAudioBitrate,
+  getVideoStreamFromFile,
   getDurationFromVideoFile,
   getAudioStream,
+  computeFPS,
   getVideoFileFPS,
+  ffprobePromise,
   getClosestFramerateStandard,
   computeResolutionsToTranscode,
   getVideoFileBitrate,
-  canDoQuickTranscode
+  canDoQuickTranscode,
+  canDoQuickVideoTranscode,
+  canDoQuickAudioTranscode
 }