server/tests/plugins/plugin-transcoding.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import { expect } from 'chai'
   5 import { join } from 'path'
   6 import { getAudioStream, getVideoFileFPS, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
   7 import { ServerConfig, VideoDetails, VideoPrivacy } from '@shared/models'
   8 import {
   9   buildServerDirectory,
  10   createLive,
  11   getConfig,
  12   getPluginTestPath,
  13   getVideo,
  14   installPlugin,
  15   sendRTMPStreamInVideo,
  16   setAccessTokensToServers,
  17   setDefaultVideoChannel,
  18   uninstallPlugin,
  19   updateCustomSubConfig,
  20   uploadVideoAndGetId,
  21   waitJobs,
  22   waitUntilLivePublished
  23 } from '../../../shared/extra-utils'
  24 import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
  25
  26 async function createLiveWrapper (server: ServerInfo) {
  27   const liveAttributes = {
  28     name: 'live video',
  29     channelId: server.videoChannel.id,
  30     privacy: VideoPrivacy.PUBLIC
  31   }
  32
  33   const res = await createLive(server.url, server.accessToken, liveAttributes)
  34   return res.body.video.uuid
  35 }
  36
  37 function updateConf (server: ServerInfo, vodProfile: string, liveProfile: string) {
  38   return updateCustomSubConfig(server.url, server.accessToken, {
  39     transcoding: {
  40       enabled: true,
  41       profile: vodProfile,
  42       hls: {
  43         enabled: true
  44       },
  45       webtorrent: {
  46         enabled: true
  47       },
  48       resolutions: {
  49         '240p': true,
  50         '360p': false,
  51         '480p': false,
  52         '720p': true
  53       }
  54     },
  55     live: {
  56       transcoding: {
  57         profile: liveProfile,
  58         enabled: true,
  59         resolutions: {
  60           '240p': true,
  61           '360p': false,
  62           '480p': false,
  63           '720p': true
  64         }
  65       }
  66     }
  67   })
  68 }
  69
  70 describe('Test transcoding plugins', function () {
  71   let server: ServerInfo
  72
  73   before(async function () {
  74     this.timeout(60000)
  75
  76     server = await flushAndRunServer(1)
  77     await setAccessTokensToServers([ server ])
  78     await setDefaultVideoChannel([ server ])
  79
  80     await updateConf(server, 'default', 'default')
  81   })
  82
  83   describe('When using a plugin adding profiles to existing encoders', function () {
  84
  85     async function checkVideoFPS (uuid: string, type: 'above' | 'below', fps: number) {
  86       const res = await getVideo(server.url, uuid)
  87       const video = res.body as VideoDetails
  88       const files = video.files.concat(...video.streamingPlaylists.map(p => p.files))
  89
  90       for (const file of files) {
  91         if (type === 'above') {
  92           expect(file.fps).to.be.above(fps)
  93         } else {
  94           expect(file.fps).to.be.below(fps)
  95         }
  96       }
  97     }
  98
  99     async function checkLiveFPS (uuid: string, type: 'above' | 'below', fps: number) {
 100       const playlistUrl = `${server.url}/static/streaming-playlists/hls/${uuid}/0.m3u8`
 101       const videoFPS = await getVideoFileFPS(playlistUrl)
 102
 103       if (type === 'above') {
 104         expect(videoFPS).to.be.above(fps)
 105       } else {
 106         expect(videoFPS).to.be.below(fps)
 107       }
 108     }
 109
 110     before(async function () {
 111       await installPlugin({
 112         url: server.url,
 113         accessToken: server.accessToken,
 114         path: getPluginTestPath('-transcoding-one')
 115       })
 116     })
 117
 118     it('Should have the appropriate available profiles', async function () {
 119       const res = await getConfig(server.url)
 120       const config = res.body as ServerConfig
 121
 122       expect(config.transcoding.availableProfiles).to.have.members([ 'default', 'low-vod', 'video-filters-vod', 'input-options-vod' ])
 123       expect(config.live.transcoding.availableProfiles).to.have.members([ 'default', 'low-live', 'input-options-live' ])
 124     })
 125
 126     it('Should not use the plugin profile if not chosen by the admin', async function () {
 127       this.timeout(120000)
 128
 129       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 130       await waitJobs([ server ])
 131
 132       await checkVideoFPS(videoUUID, 'above', 20)
 133     })
 134
 135     it('Should use the vod profile', async function () {
 136       this.timeout(120000)
 137
 138       await updateConf(server, 'low-vod', 'default')
 139
 140       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 141       await waitJobs([ server ])
 142
 143       await checkVideoFPS(videoUUID, 'below', 12)
 144     })
 145
 146     it('Should apply video filters in vod profile', async function () {
 147       this.timeout(120000)
 148
 149       await updateConf(server, 'video-filters-vod', 'default')
 150
 151       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 152       await waitJobs([ server ])
 153
 154       await checkVideoFPS(videoUUID, 'below', 12)
 155     })
 156
 157     it('Should apply input options in vod profile', async function () {
 158       this.timeout(120000)
 159
 160       await updateConf(server, 'input-options-vod', 'default')
 161
 162       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 163       await waitJobs([ server ])
 164
 165       await checkVideoFPS(videoUUID, 'below', 6)
 166     })
 167
 168     it('Should not use the plugin profile if not chosen by the admin', async function () {
 169       this.timeout(120000)
 170
 171       const liveVideoId = await createLiveWrapper(server)
 172
 173       await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
 174       await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
 175       await waitJobs([ server ])
 176
 177       await checkLiveFPS(liveVideoId, 'above', 20)
 178     })
 179
 180     it('Should use the live profile', async function () {
 181       this.timeout(120000)
 182
 183       await updateConf(server, 'low-vod', 'low-live')
 184
 185       const liveVideoId = await createLiveWrapper(server)
 186
 187       await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
 188       await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
 189       await waitJobs([ server ])
 190
 191       await checkLiveFPS(liveVideoId, 'below', 12)
 192     })
 193
 194     it('Should apply the input options on live profile', async function () {
 195       this.timeout(120000)
 196
 197       await updateConf(server, 'low-vod', 'input-options-live')
 198
 199       const liveVideoId = await createLiveWrapper(server)
 200
 201       await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
 202       await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
 203       await waitJobs([ server ])
 204
 205       await checkLiveFPS(liveVideoId, 'below', 6)
 206     })
 207
 208     it('Should default to the default profile if the specified profile does not exist', async function () {
 209       this.timeout(120000)
 210
 211       await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-test-transcoding-one' })
 212
 213       const res = await getConfig(server.url)
 214       const config = res.body as ServerConfig
 215
 216       expect(config.transcoding.availableProfiles).to.deep.equal([ 'default' ])
 217       expect(config.live.transcoding.availableProfiles).to.deep.equal([ 'default' ])
 218
 219       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 220       await waitJobs([ server ])
 221
 222       await checkVideoFPS(videoUUID, 'above', 20)
 223     })
 224
 225   })
 226
 227   describe('When using a plugin adding new encoders', function () {
 228
 229     before(async function () {
 230       await installPlugin({
 231         url: server.url,
 232         accessToken: server.accessToken,
 233         path: getPluginTestPath('-transcoding-two')
 234       })
 235
 236       await updateConf(server, 'test-vod-profile', 'test-live-profile')
 237     })
 238
 239     it('Should use the new vod encoders', async function () {
 240       this.timeout(240000)
 241
 242       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video', fixture: 'video_short_240p.mp4' })).uuid
 243       await waitJobs([ server ])
 244
 245       const path = buildServerDirectory(server, join('videos', videoUUID + '-240.mp4'))
 246       const audioProbe = await getAudioStream(path)
 247       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 248
 249       const videoProbe = await getVideoStreamFromFile(path)
 250       expect(videoProbe.codec_name).to.equal('vp9')
 251     })
 252
 253     it('Should use the new live encoders', async function () {
 254       this.timeout(120000)
 255
 256       const liveVideoId = await createLiveWrapper(server)
 257
 258       await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
 259       await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
 260       await waitJobs([ server ])
 261
 262       const playlistUrl = `${server.url}/static/streaming-playlists/hls/${liveVideoId}/0.m3u8`
 263       const audioProbe = await getAudioStream(playlistUrl)
 264       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 265
 266       const videoProbe = await getVideoStreamFromFile(playlistUrl)
 267       expect(videoProbe.codec_name).to.equal('h264')
 268     })
 269   })
 270
 271   after(async function () {
 272     await cleanupTests([ server ])
 273   })
 274 })