adding tests for audio conversions

6 files changed, 125 insertions, 27 deletions

diff --git a/client/src/app/+admin/config/edit-custom-config/edit-custom-config.component.ts b/client/src/app/+admin/config/edit-custom-config/edit-custom-config.component.ts
index 2edfb267e..e614c1892 100644
--- a/client/src/app/+admin/config/edit-custom-config/edit-custom-config.component.ts
+++ b/client/src/app/+admin/config/edit-custom-config/edit-custom-config.component.ts
@@ -29,7 +29,7 @@ export class EditCustomConfigComponent extends FormReactive implements OnInit {
     { value: 50 * 1024 * 1024 * 1024, label: '50GB' }
   ]
   transcodingThreadOptions = [
-    { value: 0, label: 'auto (not optimized)' },
+    { value: 0, label: 'Auto (via ffmpeg)' },
     { value: 1, label: '1' },
     { value: 2, label: '2' },
     { value: 4, label: '4' },
diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts
index c170fc1a8..ced56b82d 100644
--- a/server/helpers/ffmpeg-utils.ts
+++ b/server/helpers/ffmpeg-utils.ts
@@ -56,7 +56,7 @@ async function generateImageFromVideoFile (fromPath: string, folder: string, ima
 
   try {
     await new Promise<string>((res, rej) => {
-      ffmpeg(fromPath, { 'niceness': FFMPEG_NICE.THUMBNAIL })
+      ffmpeg(fromPath, { niceness: FFMPEG_NICE.THUMBNAIL })
         .on('error', rej)
         .on('end', () => res(imageName))
         .thumbnail(options)
@@ -84,11 +84,13 @@ type TranscodeOptions = {
 
 function transcode (options: TranscodeOptions) {
   return new Promise<void>(async (res, rej) => {
-    let command = ffmpeg(options.inputPath, { 'niceness': FFMPEG_NICE.TRANSCODING })
+    let command = ffmpeg(options.inputPath, { niceness: FFMPEG_NICE.TRANSCODING })
                     .output(options.outputPath)
                     .preset(standard)
+
     if (CONFIG.TRANSCODING.THREADS > 0) {
-      command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS) // if we don't set any threads ffmpeg will chose automatically
+      // if we don't set any threads ffmpeg will chose automatically
+      command = command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS)
     }
 
     let fps = await getVideoFileFPS(options.inputPath)
@@ -131,7 +133,8 @@ export {
   getDurationFromVideoFile,
   generateImageFromVideoFile,
   transcode,
-  getVideoFileFPS
+  getVideoFileFPS,
+  audio
 }
 
 // ---------------------------------------------------------------------------
@@ -191,17 +194,21 @@ namespace audio {
     // without position, ffprobe considers the last input only
     // we make it consider the first input only
     // if you pass a file path to pos, then ffprobe acts on that file directly
-    return new Promise<any>((res, rej) => {
-      _ffmpeg
-        .ffprobe(pos, (err,data) => {
-          if (err) return rej(err)
-
-          if ('streams' in data) {
-            return res(data['streams'].find(stream => stream['codec_type'] === 'audio'))
-          } else {
-            rej()
+    return new Promise<{ absolutePath: string, audioStream?: any }>((res, rej) => {
+      _ffmpeg.ffprobe(pos, (err,data) => {
+        if (err) return rej(err)
+
+        if ('streams' in data) {
+          const audioStream = data['streams'].find(stream => stream['codec_type'] === 'audio')
+          if (audioStream) {
+            return res({
+              absolutePath: data.format.filename,
+              audioStream
+            })
           }
-        })
+        }
+        return res({ absolutePath: data.format.filename })
+      })
     })
   }
 
@@ -212,7 +219,7 @@ namespace audio {
 
     export const aac = (bitrate: number): number => {
       switch (true) {
-      case bitrate > toBits(384):
+      case bitrate > toBits(baseKbitrate):
         return baseKbitrate
       default:
         return -1 // we interpret it as a signal to copy the audio stream as is
@@ -220,6 +227,11 @@ namespace audio {
     }
 
     export const mp3 = (bitrate: number): number => {
+      /*
+      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
@@ -248,16 +260,16 @@ async function standard (_ffmpeg) {
     .outputOption('-bf 16') // NOTE: Why 16: https://github.com/Chocobozzz/PeerTube/pull/774. b-strategy 2 -> B-frames<16
     .outputOption('-map_metadata -1') // strip all metadata
     .outputOption('-movflags faststart')
-  let _audio = audio.get(localFfmpeg)
-                    .then(res => res)
-                    .catch(_ => undefined)
+  const _audio = await audio.get(localFfmpeg)
 
-  if (!_audio) return localFfmpeg.noAudio()
+  if (!_audio.audioStream) {
+    return localFfmpeg.noAudio()
+  }
 
   // we try to reduce the ceiling bitrate by making rough correspondances of bitrates
   // of course this is far from perfect, but it might save some space in the end
-  if (audio.bitrate[_audio['codec_name']]) {
-    _bitrate = audio.bitrate[_audio['codec_name']](_audio['bit_rate'])
+  if (audio.bitrate[_audio.audioStream['codec_name']]) {
+    _bitrate = audio.bitrate[_audio.audioStream['codec_name']](_audio.audioStream['bit_rate'])
     if (_bitrate === -1) {
       return localFfmpeg.audioCodec('copy')
     }
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
index fe750253e..4a39ee3e3 100644
--- a/server/tests/api/videos/video-transcoder.ts
+++ b/server/tests/api/videos/video-transcoder.ts
@@ -2,9 +2,12 @@
 
 import * as chai from 'chai'
 import 'mocha'
+import { omit } from 'lodash'
+import * as ffmpeg from 'fluent-ffmpeg'
 import { VideoDetails, VideoState } from '../../../../shared/models/videos'
-import { getVideoFileFPS } from '../../../helpers/ffmpeg-utils'
+import { getVideoFileFPS, audio } from '../../../helpers/ffmpeg-utils'
 import {
+  buildAbsoluteFixturePath,
   doubleFollow,
   flushAndRunMultipleServers,
   getMyVideos,
@@ -91,6 +94,89 @@ describe('Test video transcoding', function () {
     expect(torrent.files[0].path).match(/\.mp4$/)
   })
 
+  it('Should transcode high bit rate mp3 to proper bit rate', async function () {
+    this.timeout(60000)
+
+    const videoAttributes = {
+      name: 'mp3_256k',
+      fixture: 'video_short_mp3_256k.mp4'
+    }
+    await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+
+    await waitJobs(servers)
+
+    const res = await getVideosList(servers[1].url)
+
+    const video = res.body.data.find(v => v.name === videoAttributes.name)
+    const res2 = await getVideo(servers[1].url, video.id)
+    const videoDetails: VideoDetails = res2.body
+
+    expect(videoDetails.files).to.have.lengthOf(4)
+
+    const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
+    const probe = await audio.get(ffmpeg, path)
+
+    if (probe.audioStream) {
+      expect(probe.audioStream['codec_name']).to.be.equal('aac')
+      expect(probe.audioStream['bit_rate']).to.be.at.most(384 * 8000)
+    } else {
+      this.fail('Could not retrieve the audio stream on ' + probe.absolutePath)
+    }
+  })
+
+  it('Should transcode video with no audio and have no audio itself', async function () {
+    this.timeout(60000)
+
+    const videoAttributes = {
+      name: 'no_audio',
+      fixture: 'video_short_no_audio.mp4'
+    }
+    await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+
+    await waitJobs(servers)
+
+    const res = await getVideosList(servers[1].url)
+
+    const video = res.body.data.find(v => v.name === videoAttributes.name)
+    const res2 = await getVideo(servers[1].url, video.id)
+    const videoDetails: VideoDetails = res2.body
+
+    expect(videoDetails.files).to.have.lengthOf(4)
+    const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
+    const probe = await audio.get(ffmpeg, path)
+    expect(probe).to.not.have.property('audioStream')
+  })
+
+  it('Should leave the audio untouched, but properly transcode the video', async function () {
+    this.timeout(60000)
+
+    const videoAttributes = {
+      name: 'untouched_audio',
+      fixture: 'video_short.mp4'
+    }
+    await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+
+    await waitJobs(servers)
+
+    const res = await getVideosList(servers[1].url)
+
+    const video = res.body.data.find(v => v.name === videoAttributes.name)
+    const res2 = await getVideo(servers[1].url, video.id)
+    const videoDetails: VideoDetails = res2.body
+
+    expect(videoDetails.files).to.have.lengthOf(4)
+    const fixturePath = buildAbsoluteFixturePath(videoAttributes.fixture)
+    const fixtureVideoProbe = await audio.get(ffmpeg, fixturePath)
+    const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
+    const videoProbe = await audio.get(ffmpeg, path)
+    if (videoProbe.audioStream && fixtureVideoProbe.audioStream) {
+      const toOmit = [ 'max_bit_rate', 'duration', 'duration_ts', 'nb_frames', 'start_time', 'start_pts' ]
+      expect(omit(videoProbe.audioStream, toOmit)).to.be.deep.equal(omit(fixtureVideoProbe.audioStream, toOmit))
+    } else {
+      this.fail('Could not retrieve the audio stream on ' + videoProbe.absolutePath)
+    }
+  })
+
   it('Should transcode a 60 FPS video', async function () {
     this.timeout(60000)
 
@@ -105,7 +191,7 @@ describe('Test video transcoding', function () {
 
     const res = await getVideosList(servers[1].url)
 
-    const video = res.body.data[0]
+    const video = res.body.data.find(v => v.name === videoAttributes.name)
     const res2 = await getVideo(servers[1].url, video.id)
     const videoDetails: VideoDetails = res2.body
 
@@ -154,7 +240,7 @@ describe('Test video transcoding', function () {
 
       // Should have my video
       const resMyVideos = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 10)
-      const videoToFindInMine = resMyVideos.body.data.find(v => v.name === 'waiting video')
+      const videoToFindInMine = resMyVideos.body.data.find(v => v.name === videoAttributes.name)
       expect(videoToFindInMine).not.to.be.undefined
       expect(videoToFindInMine.state.id).to.equal(VideoState.TO_TRANSCODE)
       expect(videoToFindInMine.state.label).to.equal('To transcode')
@@ -162,7 +248,7 @@ describe('Test video transcoding', function () {
 
       // Should not list this video
       const resVideos = await getVideosList(servers[1].url)
-      const videoToFindInList = resVideos.body.data.find(v => v.name === 'waiting video')
+      const videoToFindInList = resVideos.body.data.find(v => v.name === videoAttributes.name)
       expect(videoToFindInList).to.be.undefined
 
       // Server 1 should not have the video yet
diff --git a/server/tests/fixtures/video_short_mp3_256k.mp4 b/server/tests/fixtures/video_short_mp3_256k.mp4
new file mode 100644
index 000000000..4c1c7b45e
--- /dev/null
+++ b/server/tests/fixtures/video_short_mp3_256k.mp4
diff --git a/server/tests/fixtures/video_short_no_audio.mp4 b/server/tests/fixtures/video_short_no_audio.mp4
new file mode 100644
index 000000000..329d20fba
--- /dev/null
+++ b/server/tests/fixtures/video_short_no_audio.mp4
diff --git a/server/tests/utils/videos/videos.ts b/server/tests/utils/videos/videos.ts
index a9d449c58..b280cccda 100644
--- a/server/tests/utils/videos/videos.ts
+++ b/server/tests/utils/videos/videos.ts
@@ -523,7 +523,7 @@ async function completeVideoCheck (
     const minSize = attributeFile.size - ((10 * attributeFile.size) / 100)
     const maxSize = attributeFile.size + ((10 * attributeFile.size) / 100)
     expect(file.size,
-           'File size for resolution ' + file.resolution.label + ' outside confidence interval.')
+           'File size for resolution ' + file.resolution.label + ' outside confidence interval (' + minSize + '> size <' + maxSize + ')')
       .to.be.above(minSize).and.below(maxSize)
 
     {