packages/peertube-runner/server/process/shared/process-vod.ts

   1 import { remove } from 'fs-extra'
   2 import { join } from 'path'
   3 import { buildUUID } from '@shared/extra-utils'
   4 import {
   5   RunnerJobVODAudioMergeTranscodingPayload,
   6   RunnerJobVODHLSTranscodingPayload,
   7   RunnerJobVODWebVideoTranscodingPayload,
   8   VODAudioMergeTranscodingSuccess,
   9   VODHLSTranscodingSuccess,
  10   VODWebVideoTranscodingSuccess
  11 } from '@shared/models'
  12 import { ConfigManager } from '../../../shared/config-manager'
  13 import { buildFFmpegVOD, downloadInputFile, ProcessOptions } from './common'
  14
  15 export async function processWebVideoTranscoding (options: ProcessOptions<RunnerJobVODWebVideoTranscodingPayload>) {
  16   const { server, job, runnerToken } = options
  17   const payload = job.payload
  18
  19   const inputPath = await downloadInputFile({ url: payload.input.videoFileUrl, runnerToken, job })
  20
  21   const ffmpegVod = buildFFmpegVOD({ job, server, runnerToken })
  22
  23   const outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), `output-${buildUUID()}.mp4`)
  24
  25   try {
  26     await ffmpegVod.transcode({
  27       type: 'video',
  28
  29       inputPath,
  30
  31       outputPath,
  32
  33       inputFileMutexReleaser: () => {},
  34
  35       resolution: payload.output.resolution,
  36       fps: payload.output.fps
  37     })
  38
  39     const successBody: VODWebVideoTranscodingSuccess = {
  40       videoFile: outputPath
  41     }
  42
  43     await server.runnerJobs.success({
  44       jobToken: job.jobToken,
  45       jobUUID: job.uuid,
  46       runnerToken,
  47       payload: successBody
  48     })
  49   } finally {
  50     await remove(inputPath)
  51     await remove(outputPath)
  52   }
  53 }
  54
  55 export async function processHLSTranscoding (options: ProcessOptions<RunnerJobVODHLSTranscodingPayload>) {
  56   const { server, job, runnerToken } = options
  57   const payload = job.payload
  58
  59   const inputPath = await downloadInputFile({ url: payload.input.videoFileUrl, runnerToken, job })
  60   const uuid = buildUUID()
  61
  62   const outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), `${uuid}-${payload.output.resolution}.m3u8`)
  63   const videoFilename = `${uuid}-${payload.output.resolution}-fragmented.mp4`
  64   const videoPath = join(join(ConfigManager.Instance.getTranscodingDirectory(), videoFilename))
  65
  66   const ffmpegVod = buildFFmpegVOD({ job, server, runnerToken })
  67
  68   try {
  69     await ffmpegVod.transcode({
  70       type: 'hls',
  71       copyCodecs: false,
  72       inputPath,
  73       hlsPlaylist: { videoFilename },
  74       outputPath,
  75
  76       inputFileMutexReleaser: () => {},
  77
  78       resolution: payload.output.resolution,
  79       fps: payload.output.fps
  80     })
  81
  82     const successBody: VODHLSTranscodingSuccess = {
  83       resolutionPlaylistFile: outputPath,
  84       videoFile: videoPath
  85     }
  86
  87     await server.runnerJobs.success({
  88       jobToken: job.jobToken,
  89       jobUUID: job.uuid,
  90       runnerToken,
  91       payload: successBody
  92     })
  93   } finally {
  94     await remove(inputPath)
  95     await remove(outputPath)
  96     await remove(videoPath)
  97   }
  98 }
  99
 100 export async function processAudioMergeTranscoding (options: ProcessOptions<RunnerJobVODAudioMergeTranscodingPayload>) {
 101   const { server, job, runnerToken } = options
 102   const payload = job.payload
 103
 104   const audioPath = await downloadInputFile({ url: payload.input.audioFileUrl, runnerToken, job })
 105   const inputPath = await downloadInputFile({ url: payload.input.previewFileUrl, runnerToken, job })
 106
 107   const outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), `output-${buildUUID()}.mp4`)
 108
 109   const ffmpegVod = buildFFmpegVOD({ job, server, runnerToken })
 110
 111   try {
 112     await ffmpegVod.transcode({
 113       type: 'merge-audio',
 114
 115       audioPath,
 116       inputPath,
 117
 118       outputPath,
 119
 120       inputFileMutexReleaser: () => {},
 121
 122       resolution: payload.output.resolution,
 123       fps: payload.output.fps
 124     })
 125
 126     const successBody: VODAudioMergeTranscodingSuccess = {
 127       videoFile: outputPath
 128     }
 129
 130     await server.runnerJobs.success({
 131       jobToken: job.jobToken,
 132       jobUUID: job.uuid,
 133       runnerToken,
 134       payload: successBody
 135     })
 136   } finally {
 137     await remove(audioPath)
 138     await remove(inputPath)
 139     await remove(outputPath)
 140   }
 141 }