server/tests/api/videos/video-transcoder.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import * as chai from 'chai'
   4 import 'mocha'
   5 import { omit } from 'lodash'
   6 import { getMaxBitrate, VideoDetails, VideoResolution, VideoState } from '../../../../shared/models/videos'
   7 import {
   8   audio,
   9   canDoQuickTranscode,
  10   getVideoFileBitrate,
  11   getVideoFileFPS,
  12   getVideoFileResolution,
  13   getMetadataFromFile
  14 } from '../../../helpers/ffmpeg-utils'
  15 import {
  16   buildAbsoluteFixturePath,
  17   cleanupTests,
  18   doubleFollow,
  19   flushAndRunMultipleServers,
  20   generateHighBitrateVideo,
  21   generateVideoWithFramerate,
  22   getMyVideos,
  23   getVideo,
  24   getVideoFileMetadataUrl,
  25   getVideosList,
  26   makeGetRequest,
  27   root,
  28   ServerInfo,
  29   setAccessTokensToServers,
  30   uploadVideo,
  31   waitJobs,
  32   webtorrentAdd
  33 } from '../../../../shared/extra-utils'
  34 import { join } from 'path'
  35 import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
  36 import { FfprobeData } from 'fluent-ffmpeg'
  37
  38 const expect = chai.expect
  39
  40 describe('Test video transcoding', function () {
  41   let servers: ServerInfo[] = []
  42
  43   before(async function () {
  44     this.timeout(30000)
  45
  46     // Run servers
  47     servers = await flushAndRunMultipleServers(2)
  48
  49     await setAccessTokensToServers(servers)
  50
  51     await doubleFollow(servers[0], servers[1])
  52   })
  53
  54   it('Should not transcode video on server 1', async function () {
  55     this.timeout(60000)
  56
  57     const videoAttributes = {
  58       name: 'my super name for server 1',
  59       description: 'my super description for server 1',
  60       fixture: 'video_short.webm'
  61     }
  62     await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
  63
  64     await waitJobs(servers)
  65
  66     for (const server of servers) {
  67       const res = await getVideosList(server.url)
  68       const video = res.body.data[0]
  69
  70       const res2 = await getVideo(server.url, video.id)
  71       const videoDetails = res2.body
  72       expect(videoDetails.files).to.have.lengthOf(1)
  73
  74       const magnetUri = videoDetails.files[0].magnetUri
  75       expect(magnetUri).to.match(/\.webm/)
  76
  77       const torrent = await webtorrentAdd(magnetUri, true)
  78       expect(torrent.files).to.be.an('array')
  79       expect(torrent.files.length).to.equal(1)
  80       expect(torrent.files[0].path).match(/\.webm$/)
  81     }
  82   })
  83
  84   it('Should transcode video on server 2', async function () {
  85     this.timeout(60000)
  86
  87     const videoAttributes = {
  88       name: 'my super name for server 2',
  89       description: 'my super description for server 2',
  90       fixture: 'video_short.webm'
  91     }
  92     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
  93
  94     await waitJobs(servers)
  95
  96     for (const server of servers) {
  97       const res = await getVideosList(server.url)
  98
  99       const video = res.body.data.find(v => v.name === videoAttributes.name)
 100       const res2 = await getVideo(server.url, video.id)
 101       const videoDetails = res2.body
 102
 103       expect(videoDetails.files).to.have.lengthOf(4)
 104
 105       const magnetUri = videoDetails.files[0].magnetUri
 106       expect(magnetUri).to.match(/\.mp4/)
 107
 108       const torrent = await webtorrentAdd(magnetUri, true)
 109       expect(torrent.files).to.be.an('array')
 110       expect(torrent.files.length).to.equal(1)
 111       expect(torrent.files[0].path).match(/\.mp4$/)
 112     }
 113   })
 114
 115   it('Should transcode high bit rate mp3 to proper bit rate', async function () {
 116     this.timeout(60000)
 117
 118     const videoAttributes = {
 119       name: 'mp3_256k',
 120       fixture: 'video_short_mp3_256k.mp4'
 121     }
 122     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 123
 124     await waitJobs(servers)
 125
 126     for (const server of servers) {
 127       const res = await getVideosList(server.url)
 128
 129       const video = res.body.data.find(v => v.name === videoAttributes.name)
 130       const res2 = await getVideo(server.url, video.id)
 131       const videoDetails: VideoDetails = res2.body
 132
 133       expect(videoDetails.files).to.have.lengthOf(4)
 134
 135       const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-240.mp4')
 136       const probe = await audio.get(path)
 137
 138       if (probe.audioStream) {
 139         expect(probe.audioStream['codec_name']).to.be.equal('aac')
 140         expect(probe.audioStream['bit_rate']).to.be.at.most(384 * 8000)
 141       } else {
 142         this.fail('Could not retrieve the audio stream on ' + probe.absolutePath)
 143       }
 144     }
 145   })
 146
 147   it('Should transcode video with no audio and have no audio itself', async function () {
 148     this.timeout(60000)
 149
 150     const videoAttributes = {
 151       name: 'no_audio',
 152       fixture: 'video_short_no_audio.mp4'
 153     }
 154     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 155
 156     await waitJobs(servers)
 157
 158     for (const server of servers) {
 159       const res = await getVideosList(server.url)
 160
 161       const video = res.body.data.find(v => v.name === videoAttributes.name)
 162       const res2 = await getVideo(server.url, video.id)
 163       const videoDetails: VideoDetails = res2.body
 164
 165       expect(videoDetails.files).to.have.lengthOf(4)
 166       const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-240.mp4')
 167       const probe = await audio.get(path)
 168       expect(probe).to.not.have.property('audioStream')
 169     }
 170   })
 171
 172   it('Should leave the audio untouched, but properly transcode the video', async function () {
 173     this.timeout(60000)
 174
 175     const videoAttributes = {
 176       name: 'untouched_audio',
 177       fixture: 'video_short.mp4'
 178     }
 179     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 180
 181     await waitJobs(servers)
 182
 183     for (const server of servers) {
 184       const res = await getVideosList(server.url)
 185
 186       const video = res.body.data.find(v => v.name === videoAttributes.name)
 187       const res2 = await getVideo(server.url, video.id)
 188       const videoDetails: VideoDetails = res2.body
 189
 190       expect(videoDetails.files).to.have.lengthOf(4)
 191       const fixturePath = buildAbsoluteFixturePath(videoAttributes.fixture)
 192       const fixtureVideoProbe = await audio.get(fixturePath)
 193       const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-240.mp4')
 194       const videoProbe = await audio.get(path)
 195       if (videoProbe.audioStream && fixtureVideoProbe.audioStream) {
 196         const toOmit = [ 'max_bit_rate', 'duration', 'duration_ts', 'nb_frames', 'start_time', 'start_pts' ]
 197         expect(omit(videoProbe.audioStream, toOmit)).to.be.deep.equal(omit(fixtureVideoProbe.audioStream, toOmit))
 198       } else {
 199         this.fail('Could not retrieve the audio stream on ' + videoProbe.absolutePath)
 200       }
 201     }
 202   })
 203
 204   it('Should transcode a 60 FPS video', async function () {
 205     this.timeout(60000)
 206
 207     const videoAttributes = {
 208       name: 'my super 30fps name for server 2',
 209       description: 'my super 30fps description for server 2',
 210       fixture: '60fps_720p_small.mp4'
 211     }
 212     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 213
 214     await waitJobs(servers)
 215
 216     for (const server of servers) {
 217       const res = await getVideosList(server.url)
 218
 219       const video = res.body.data.find(v => v.name === videoAttributes.name)
 220       const res2 = await getVideo(server.url, video.id)
 221       const videoDetails: VideoDetails = res2.body
 222
 223       expect(videoDetails.files).to.have.lengthOf(4)
 224       expect(videoDetails.files[0].fps).to.be.above(58).and.below(62)
 225       expect(videoDetails.files[1].fps).to.be.below(31)
 226       expect(videoDetails.files[2].fps).to.be.below(31)
 227       expect(videoDetails.files[3].fps).to.be.below(31)
 228
 229       for (const resolution of [ '240', '360', '480' ]) {
 230         const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-' + resolution + '.mp4')
 231         const fps = await getVideoFileFPS(path)
 232
 233         expect(fps).to.be.below(31)
 234       }
 235
 236       const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-720.mp4')
 237       const fps = await getVideoFileFPS(path)
 238
 239       expect(fps).to.be.above(58).and.below(62)
 240     }
 241   })
 242
 243   it('Should wait for transcoding before publishing the video', async function () {
 244     this.timeout(80000)
 245
 246     {
 247       // Upload the video, but wait transcoding
 248       const videoAttributes = {
 249         name: 'waiting video',
 250         fixture: 'video_short1.webm',
 251         waitTranscoding: true
 252       }
 253       const resVideo = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 254       const videoId = resVideo.body.video.uuid
 255
 256       // Should be in transcode state
 257       const { body } = await getVideo(servers[1].url, videoId)
 258       expect(body.name).to.equal('waiting video')
 259       expect(body.state.id).to.equal(VideoState.TO_TRANSCODE)
 260       expect(body.state.label).to.equal('To transcode')
 261       expect(body.waitTranscoding).to.be.true
 262
 263       // Should have my video
 264       const resMyVideos = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 10)
 265       const videoToFindInMine = resMyVideos.body.data.find(v => v.name === videoAttributes.name)
 266       expect(videoToFindInMine).not.to.be.undefined
 267       expect(videoToFindInMine.state.id).to.equal(VideoState.TO_TRANSCODE)
 268       expect(videoToFindInMine.state.label).to.equal('To transcode')
 269       expect(videoToFindInMine.waitTranscoding).to.be.true
 270
 271       // Should not list this video
 272       const resVideos = await getVideosList(servers[1].url)
 273       const videoToFindInList = resVideos.body.data.find(v => v.name === videoAttributes.name)
 274       expect(videoToFindInList).to.be.undefined
 275
 276       // Server 1 should not have the video yet
 277       await getVideo(servers[0].url, videoId, 404)
 278     }
 279
 280     await waitJobs(servers)
 281
 282     for (const server of servers) {
 283       const res = await getVideosList(server.url)
 284       const videoToFind = res.body.data.find(v => v.name === 'waiting video')
 285       expect(videoToFind).not.to.be.undefined
 286
 287       const res2 = await getVideo(server.url, videoToFind.id)
 288       const videoDetails: VideoDetails = res2.body
 289
 290       expect(videoDetails.state.id).to.equal(VideoState.PUBLISHED)
 291       expect(videoDetails.state.label).to.equal('Published')
 292       expect(videoDetails.waitTranscoding).to.be.true
 293     }
 294   })
 295
 296   it('Should respect maximum bitrate values', async function () {
 297     this.timeout(160000)
 298
 299     let tempFixturePath: string
 300
 301     {
 302       tempFixturePath = await generateHighBitrateVideo()
 303
 304       const bitrate = await getVideoFileBitrate(tempFixturePath)
 305       expect(bitrate).to.be.above(getMaxBitrate(VideoResolution.H_1080P, 25, VIDEO_TRANSCODING_FPS))
 306     }
 307
 308     const videoAttributes = {
 309       name: 'high bitrate video',
 310       description: 'high bitrate video',
 311       fixture: tempFixturePath
 312     }
 313
 314     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 315
 316     await waitJobs(servers)
 317
 318     for (const server of servers) {
 319       const res = await getVideosList(server.url)
 320
 321       const video = res.body.data.find(v => v.name === videoAttributes.name)
 322
 323       for (const resolution of [ '240', '360', '480', '720', '1080' ]) {
 324         const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-' + resolution + '.mp4')
 325         const bitrate = await getVideoFileBitrate(path)
 326         const fps = await getVideoFileFPS(path)
 327         const resolution2 = await getVideoFileResolution(path)
 328
 329         expect(resolution2.videoFileResolution.toString()).to.equal(resolution)
 330         expect(bitrate).to.be.below(getMaxBitrate(resolution2.videoFileResolution, fps, VIDEO_TRANSCODING_FPS))
 331       }
 332     }
 333   })
 334
 335   it('Should accept and transcode additional extensions', async function () {
 336     this.timeout(300000)
 337
 338     let tempFixturePath: string
 339
 340     {
 341       tempFixturePath = await generateHighBitrateVideo()
 342
 343       const bitrate = await getVideoFileBitrate(tempFixturePath)
 344       expect(bitrate).to.be.above(getMaxBitrate(VideoResolution.H_1080P, 25, VIDEO_TRANSCODING_FPS))
 345     }
 346
 347     for (const fixture of [ 'video_short.mkv', 'video_short.avi' ]) {
 348       const videoAttributes = {
 349         name: fixture,
 350         fixture
 351       }
 352
 353       await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 354
 355       await waitJobs(servers)
 356
 357       for (const server of servers) {
 358         const res = await getVideosList(server.url)
 359
 360         const video = res.body.data.find(v => v.name === videoAttributes.name)
 361         const res2 = await getVideo(server.url, video.id)
 362         const videoDetails = res2.body
 363
 364         expect(videoDetails.files).to.have.lengthOf(4)
 365
 366         const magnetUri = videoDetails.files[0].magnetUri
 367         expect(magnetUri).to.contain('.mp4')
 368       }
 369     }
 370   })
 371
 372   it('Should correctly detect if quick transcode is possible', async function () {
 373     this.timeout(10000)
 374
 375     expect(await canDoQuickTranscode(buildAbsoluteFixturePath('video_short.mp4'))).to.be.true
 376     expect(await canDoQuickTranscode(buildAbsoluteFixturePath('video_short.webm'))).to.be.false
 377   })
 378
 379   it('Should merge an audio file with the preview file', async function () {
 380     this.timeout(60000)
 381
 382     const videoAttributesArg = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
 383     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg)
 384
 385     await waitJobs(servers)
 386
 387     for (const server of servers) {
 388       const res = await getVideosList(server.url)
 389
 390       const video = res.body.data.find(v => v.name === 'audio_with_preview')
 391       const res2 = await getVideo(server.url, video.id)
 392       const videoDetails: VideoDetails = res2.body
 393
 394       expect(videoDetails.files).to.have.lengthOf(1)
 395
 396       await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, statusCodeExpected: 200 })
 397       await makeGetRequest({ url: server.url, path: videoDetails.previewPath, statusCodeExpected: 200 })
 398
 399       const magnetUri = videoDetails.files[0].magnetUri
 400       expect(magnetUri).to.contain('.mp4')
 401     }
 402   })
 403
 404   it('Should upload an audio file and choose a default background image', async function () {
 405     this.timeout(60000)
 406
 407     const videoAttributesArg = { name: 'audio_without_preview', fixture: 'sample.ogg' }
 408     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg)
 409
 410     await waitJobs(servers)
 411
 412     for (const server of servers) {
 413       const res = await getVideosList(server.url)
 414
 415       const video = res.body.data.find(v => v.name === 'audio_without_preview')
 416       const res2 = await getVideo(server.url, video.id)
 417       const videoDetails = res2.body
 418
 419       expect(videoDetails.files).to.have.lengthOf(1)
 420
 421       await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, statusCodeExpected: 200 })
 422       await makeGetRequest({ url: server.url, path: videoDetails.previewPath, statusCodeExpected: 200 })
 423
 424       const magnetUri = videoDetails.files[0].magnetUri
 425       expect(magnetUri).to.contain('.mp4')
 426     }
 427   })
 428
 429   it('Should downscale to the closest divisor standard framerate', async function () {
 430     this.timeout(160000)
 431
 432     let tempFixturePath: string
 433
 434     {
 435       tempFixturePath = await generateVideoWithFramerate(59)
 436
 437       const fps = await getVideoFileFPS(tempFixturePath)
 438       expect(fps).to.be.equal(59)
 439     }
 440
 441     const videoAttributes = {
 442       name: '59fps video',
 443       description: '59fps video',
 444       fixture: tempFixturePath
 445     }
 446
 447     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 448
 449     await waitJobs(servers)
 450
 451     for (const server of servers) {
 452       const res = await getVideosList(server.url)
 453
 454       const video = res.body.data.find(v => v.name === videoAttributes.name)
 455
 456       {
 457         const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-240.mp4')
 458         const fps = await getVideoFileFPS(path)
 459         expect(fps).to.be.equal(25)
 460       }
 461
 462       {
 463         const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', video.uuid + '-720.mp4')
 464         const fps = await getVideoFileFPS(path)
 465         expect(fps).to.be.equal(59)
 466       }
 467     }
 468   })
 469
 470   it('Should provide valid ffprobe data', async function () {
 471     this.timeout(160000)
 472
 473     const videoAttributes = {
 474       name: 'my super name for server 1',
 475       description: 'my super description for server 1',
 476       fixture: 'video_short.webm'
 477     }
 478     await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 479
 480     await waitJobs(servers)
 481
 482     const res = await getVideosList(servers[1].url)
 483
 484     const videoOnOrigin = res.body.data.find(v => v.name === videoAttributes.name)
 485     const res2 = await getVideo(servers[1].url, videoOnOrigin.id)
 486     const videoOnOriginDetails: VideoDetails = res2.body
 487
 488     {
 489       const path = join(root(), 'test' + servers[1].internalServerNumber, 'videos', videoOnOrigin.uuid + '-240.mp4')
 490       const metadata = await getMetadataFromFile(path)
 491       for (const p of [
 492         // expected format properties
 493         'format.encoder',
 494         'format.format_long_name',
 495         'format.size',
 496         'format.bit_rate',
 497         // expected stream properties
 498         'stream[0].codec_long_name',
 499         'stream[0].profile',
 500         'stream[0].width',
 501         'stream[0].height',
 502         'stream[0].display_aspect_ratio',
 503         'stream[0].avg_frame_rate',
 504         'stream[0].pix_fmt'
 505       ]) {
 506         expect(metadata).to.have.nested.property(p)
 507       }
 508       expect(metadata).to.not.have.nested.property('format.filename')
 509     }
 510
 511     for (const server of servers) {
 512       const res = await getVideosList(server.url)
 513
 514       const video = res.body.data.find(v => v.name === videoAttributes.name)
 515       const res2 = await getVideo(server.url, video.id)
 516       const videoDetails = res2.body
 517
 518       const videoFiles = videoDetails.files
 519       for (const [ index, file ] of videoFiles.entries()) {
 520         expect(file.metadata).to.be.undefined
 521         expect(file.metadataUrl).to.contain(servers[1].url)
 522         expect(file.metadataUrl).to.contain(videoOnOrigin.uuid)
 523
 524         const res3 = await getVideoFileMetadataUrl(file.metadataUrl)
 525         const metadata: FfprobeData = res3.body
 526         expect(metadata).to.have.nested.property('format.size')
 527         expect(metadata.format.size).to.equal(videoOnOriginDetails.files[index].metadata.format.size)
 528       }
 529     }
 530   })
 531
 532   after(async function () {
 533     await cleanupTests(servers)
 534   })
 535 })