]> git.immae.eu Git - github/Chocobozzz/PeerTube.git/blame - server/helpers/ffmpeg-utils.ts
emit more specific status codes on video upload (#3423)
[github/Chocobozzz/PeerTube.git] / server / helpers / ffmpeg-utils.ts
CommitLineData
14d3270f 1import * as ffmpeg from 'fluent-ffmpeg'
053aed43 2import { readFile, remove, writeFile } from 'fs-extra'
09209296 3import { dirname, join } from 'path'
884d2c39 4import { FFMPEG_NICE, VIDEO_LIVE, VIDEO_TRANSCODING_ENCODERS } from '@server/initializers/constants'
5a547f69 5import { VideoResolution } from '../../shared/models/videos'
c6c0fa6c
C
6import { checkFFmpegEncoders } from '../initializers/checker-before-init'
7import { CONFIG } from '../initializers/config'
884d2c39 8import { computeFPS, getAudioStream, getVideoFileFPS } from './ffprobe-utils'
26670720 9import { processImage } from './image-utils'
6fdc553a 10import { logger } from './logger'
14d3270f 11
6b67897e
C
12/**
13 *
14 * Functions that run transcoding/muxing ffmpeg processes
15 * Mainly called by lib/video-transcoding.ts and lib/live-manager.ts
16 *
17 */
18
9252a33d
C
19// ---------------------------------------------------------------------------
20// Encoder options
21// ---------------------------------------------------------------------------
22
23// Options builders
24
25export type EncoderOptionsBuilder = (params: {
26 input: string
27 resolution: VideoResolution
28 fps?: number
5a547f69 29 streamNum?: number
9252a33d
C
30}) => Promise<EncoderOptions> | EncoderOptions
31
32// Options types
33
34export interface EncoderOptions {
5a547f69 35 copy?: boolean
9252a33d
C
36 outputOptions: string[]
37}
38
39// All our encoders
40
41export interface EncoderProfile <T> {
42 [ profile: string ]: T
43
44 default: T
45}
46
47export type AvailableEncoders = {
48 [ id in 'live' | 'vod' ]: {
5a547f69 49 [ encoder in 'libx264' | 'aac' | 'libfdk_aac' ]?: EncoderProfile<EncoderOptionsBuilder>
9252a33d
C
50 }
51}
52
53// ---------------------------------------------------------------------------
54// Image manipulation
55// ---------------------------------------------------------------------------
56
57function convertWebPToJPG (path: string, destination: string): Promise<void> {
58 const command = ffmpeg(path)
59 .output(destination)
60
61 return runCommand(command)
62}
63
64function processGIF (
65 path: string,
66 destination: string,
f619de0e 67 newSize: { width: number, height: number }
9252a33d 68): Promise<void> {
f619de0e
C
69 const command = ffmpeg(path)
70 .fps(20)
71 .size(`${newSize.width}x${newSize.height}`)
72 .output(destination)
9252a33d 73
f619de0e 74 return runCommand(command)
9252a33d
C
75}
76
26670720
C
77async function generateImageFromVideoFile (fromPath: string, folder: string, imageName: string, size: { width: number, height: number }) {
78 const pendingImageName = 'pending-' + imageName
79
14d3270f 80 const options = {
26670720 81 filename: pendingImageName,
14d3270f
C
82 count: 1,
83 folder
84 }
85
26670720 86 const pendingImagePath = join(folder, pendingImageName)
6fdc553a
C
87
88 try {
89 await new Promise<string>((res, rej) => {
7160878c 90 ffmpeg(fromPath, { niceness: FFMPEG_NICE.THUMBNAIL })
6fdc553a
C
91 .on('error', rej)
92 .on('end', () => res(imageName))
93 .thumbnail(options)
94 })
95
96 const destination = join(folder, imageName)
2fb5b3a5 97 await processImage(pendingImagePath, destination, size)
6fdc553a 98 } catch (err) {
d5b7d911 99 logger.error('Cannot generate image from video %s.', fromPath, { err })
6fdc553a
C
100
101 try {
62689b94 102 await remove(pendingImagePath)
6fdc553a 103 } catch (err) {
d5b7d911 104 logger.debug('Cannot remove pending image path after generation error.', { err })
6fdc553a
C
105 }
106 }
14d3270f
C
107}
108
daf6e480
C
109// ---------------------------------------------------------------------------
110// Transcode meta function
111// ---------------------------------------------------------------------------
112
2650d6d4 113type TranscodeOptionsType = 'hls' | 'hls-from-ts' | 'quick-transcode' | 'video' | 'merge-audio' | 'only-audio'
536598cf
C
114
115interface BaseTranscodeOptions {
116 type: TranscodeOptionsType
9252a33d 117
14d3270f
C
118 inputPath: string
119 outputPath: string
9252a33d
C
120
121 availableEncoders: AvailableEncoders
122 profile: string
123
09209296 124 resolution: VideoResolution
9252a33d 125
056aa7f2 126 isPortraitMode?: boolean
536598cf 127}
09209296 128
536598cf
C
129interface HLSTranscodeOptions extends BaseTranscodeOptions {
130 type: 'hls'
d7a25329 131 copyCodecs: boolean
536598cf 132 hlsPlaylist: {
4c280004
C
133 videoFilename: string
134 }
14d3270f
C
135}
136
2650d6d4
C
137interface HLSFromTSTranscodeOptions extends BaseTranscodeOptions {
138 type: 'hls-from-ts'
139
e772bdf1
C
140 isAAC: boolean
141
2650d6d4
C
142 hlsPlaylist: {
143 videoFilename: string
144 }
145}
146
536598cf
C
147interface QuickTranscodeOptions extends BaseTranscodeOptions {
148 type: 'quick-transcode'
149}
150
151interface VideoTranscodeOptions extends BaseTranscodeOptions {
152 type: 'video'
153}
154
155interface MergeAudioTranscodeOptions extends BaseTranscodeOptions {
156 type: 'merge-audio'
157 audioPath: string
158}
159
3a149e9f
C
160interface OnlyAudioTranscodeOptions extends BaseTranscodeOptions {
161 type: 'only-audio'
5c7d6508 162}
163
a1587156
C
164type TranscodeOptions =
165 HLSTranscodeOptions
2650d6d4 166 | HLSFromTSTranscodeOptions
3a149e9f
C
167 | VideoTranscodeOptions
168 | MergeAudioTranscodeOptions
169 | OnlyAudioTranscodeOptions
170 | QuickTranscodeOptions
536598cf 171
daf6e480
C
172const builders: {
173 [ type in TranscodeOptionsType ]: (c: ffmpeg.FfmpegCommand, o?: TranscodeOptions) => Promise<ffmpeg.FfmpegCommand> | ffmpeg.FfmpegCommand
174} = {
175 'quick-transcode': buildQuickTranscodeCommand,
176 'hls': buildHLSVODCommand,
2650d6d4 177 'hls-from-ts': buildHLSVODFromTSCommand,
daf6e480
C
178 'merge-audio': buildAudioMergeCommand,
179 'only-audio': buildOnlyAudioCommand,
9252a33d 180 'video': buildx264VODCommand
daf6e480
C
181}
182
183async function transcode (options: TranscodeOptions) {
9e2b2e76
C
184 logger.debug('Will run transcode.', { options })
185
55223d65 186 let command = getFFmpeg(options.inputPath, 'vod')
daf6e480 187 .output(options.outputPath)
14d3270f 188
daf6e480 189 command = await builders[options.type](command, options)
7ed2c1a4 190
daf6e480 191 await runCommand(command)
5ba49f26 192
daf6e480 193 await fixHLSPlaylistIfNeeded(options)
837666fe
RK
194}
195
9252a33d
C
196// ---------------------------------------------------------------------------
197// Live muxing/transcoding functions
198// ---------------------------------------------------------------------------
123f6193 199
5a547f69
C
200async function getLiveTranscodingCommand (options: {
201 rtmpUrl: string
202 outPath: string
203 resolutions: number[]
204 fps: number
5a547f69
C
205
206 availableEncoders: AvailableEncoders
207 profile: string
208}) {
937581b8 209 const { rtmpUrl, outPath, resolutions, fps, availableEncoders, profile } = options
5a547f69
C
210 const input = rtmpUrl
211
55223d65 212 const command = getFFmpeg(input, 'live')
c6c0fa6c
C
213
214 const varStreamMap: string[] = []
215
216 command.complexFilter([
217 {
218 inputs: '[v:0]',
219 filter: 'split',
220 options: resolutions.length,
221 outputs: resolutions.map(r => `vtemp${r}`)
222 },
223
224 ...resolutions.map(r => ({
225 inputs: `vtemp${r}`,
226 filter: 'scale',
227 options: `w=-2:h=${r}`,
228 outputs: `vout${r}`
229 }))
230 ])
231
c6c0fa6c 232 command.outputOption('-preset superfast')
49bcdb0d 233 command.outputOption('-sc_threshold 0')
c6c0fa6c 234
ce4a50b9
C
235 addDefaultEncoderGlobalParams({ command })
236
c6c0fa6c
C
237 for (let i = 0; i < resolutions.length; i++) {
238 const resolution = resolutions[i]
884d2c39
C
239 const resolutionFPS = computeFPS(fps, resolution)
240
241 const baseEncoderBuilderParams = {
242 input,
243 availableEncoders,
244 profile,
245 fps: resolutionFPS,
246 resolution,
247 streamNum: i,
248 videoType: 'live' as 'live'
249 }
5a547f69
C
250
251 {
252 const builderResult = await getEncoderBuilderResult(Object.assign({}, baseEncoderBuilderParams, { streamType: 'VIDEO' }))
253 if (!builderResult) {
254 throw new Error('No available live video encoder found')
255 }
256
257 command.outputOption(`-map [vout${resolution}]`)
258
884d2c39 259 addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i })
5a547f69
C
260
261 logger.debug('Apply ffmpeg live video params from %s.', builderResult.encoder, builderResult)
c6c0fa6c 262
5a547f69
C
263 command.outputOption(`${buildStreamSuffix('-c:v', i)} ${builderResult.encoder}`)
264 command.addOutputOptions(builderResult.result.outputOptions)
265 }
266
267 {
268 const builderResult = await getEncoderBuilderResult(Object.assign({}, baseEncoderBuilderParams, { streamType: 'AUDIO' }))
269 if (!builderResult) {
270 throw new Error('No available live audio encoder found')
271 }
c6c0fa6c 272
5a547f69
C
273 command.outputOption('-map a:0')
274
884d2c39 275 addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i })
5a547f69
C
276
277 logger.debug('Apply ffmpeg live audio params from %s.', builderResult.encoder, builderResult)
278
279 command.outputOption(`${buildStreamSuffix('-c:a', i)} ${builderResult.encoder}`)
280 command.addOutputOptions(builderResult.result.outputOptions)
281 }
c6c0fa6c
C
282
283 varStreamMap.push(`v:${i},a:${i}`)
284 }
285
937581b8 286 addDefaultLiveHLSParams(command, outPath)
c6c0fa6c
C
287
288 command.outputOption('-var_stream_map', varStreamMap.join(' '))
289
c6c0fa6c
C
290 return command
291}
292
937581b8 293function getLiveMuxingCommand (rtmpUrl: string, outPath: string) {
55223d65 294 const command = getFFmpeg(rtmpUrl, 'live')
c6c0fa6c
C
295
296 command.outputOption('-c:v copy')
297 command.outputOption('-c:a copy')
298 command.outputOption('-map 0:a?')
299 command.outputOption('-map 0:v?')
300
937581b8 301 addDefaultLiveHLSParams(command, outPath)
c6c0fa6c 302
c6c0fa6c
C
303 return command
304}
305
5a547f69
C
306function buildStreamSuffix (base: string, streamNum?: number) {
307 if (streamNum !== undefined) {
308 return `${base}:${streamNum}`
309 }
310
311 return base
312}
313
14d3270f
C
314// ---------------------------------------------------------------------------
315
316export {
9252a33d
C
317 getLiveTranscodingCommand,
318 getLiveMuxingCommand,
5a547f69 319 buildStreamSuffix,
18782242 320 convertWebPToJPG,
123f6193 321 processGIF,
14d3270f 322 generateImageFromVideoFile,
536598cf
C
323 TranscodeOptions,
324 TranscodeOptionsType,
2650d6d4 325 transcode
73c69591
C
326}
327
328// ---------------------------------------------------------------------------
329
9252a33d
C
330// ---------------------------------------------------------------------------
331// Default options
332// ---------------------------------------------------------------------------
333
ce4a50b9
C
334function addDefaultEncoderGlobalParams (options: {
335 command: ffmpeg.FfmpegCommand
336}) {
337 const { command } = options
338
339 // avoid issues when transcoding some files: https://trac.ffmpeg.org/ticket/6375
340 command.outputOption('-max_muxing_queue_size 1024')
341 // strip all metadata
342 .outputOption('-map_metadata -1')
343 // NOTE: b-strategy 1 - heuristic algorithm, 16 is optimal B-frames for it
344 .outputOption('-b_strategy 1')
345 // NOTE: Why 16: https://github.com/Chocobozzz/PeerTube/pull/774. b-strategy 2 -> B-frames<16
346 .outputOption('-bf 16')
347 // allows import of source material with incompatible pixel formats (e.g. MJPEG video)
348 .outputOption('-pix_fmt yuv420p')
349}
350
5a547f69
C
351function addDefaultEncoderParams (options: {
352 command: ffmpeg.FfmpegCommand
353 encoder: 'libx264' | string
354 streamNum?: number
355 fps?: number
356}) {
357 const { command, encoder, fps, streamNum } = options
358
359 if (encoder === 'libx264') {
360 // 3.1 is the minimal resource allocation for our highest supported resolution
ce4a50b9 361 command.outputOption(buildStreamSuffix('-level:v', streamNum) + ' 3.1')
5a547f69
C
362
363 if (fps) {
364 // Keyframe interval of 2 seconds for faster seeking and resolution switching.
365 // https://streaminglearningcenter.com/blogs/whats-the-right-keyframe-interval.html
366 // https://superuser.com/a/908325
ce4a50b9 367 command.outputOption(buildStreamSuffix('-g:v', streamNum) + ' ' + (fps * 2))
5a547f69
C
368 }
369 }
c6c0fa6c
C
370}
371
937581b8 372function addDefaultLiveHLSParams (command: ffmpeg.FfmpegCommand, outPath: string) {
68e70a74 373 command.outputOption('-hls_time ' + VIDEO_LIVE.SEGMENT_TIME_SECONDS)
fb719404 374 command.outputOption('-hls_list_size ' + VIDEO_LIVE.SEGMENTS_LIST_SIZE)
49bcdb0d 375 command.outputOption('-hls_flags delete_segments+independent_segments')
21226063 376 command.outputOption(`-hls_segment_filename ${join(outPath, '%v-%06d.ts')}`)
c6c0fa6c
C
377 command.outputOption('-master_pl_name master.m3u8')
378 command.outputOption(`-f hls`)
379
380 command.output(join(outPath, '%v.m3u8'))
381}
382
9252a33d
C
383// ---------------------------------------------------------------------------
384// Transcode VOD command builders
385// ---------------------------------------------------------------------------
386
387async function buildx264VODCommand (command: ffmpeg.FfmpegCommand, options: TranscodeOptions) {
14aed608 388 let fps = await getVideoFileFPS(options.inputPath)
884d2c39 389 fps = computeFPS(fps, options.resolution)
14aed608 390
9252a33d 391 command = await presetVideo(command, options.inputPath, options, fps)
14aed608
C
392
393 if (options.resolution !== undefined) {
394 // '?x720' or '720x?' for example
5a547f69
C
395 const size = options.isPortraitMode === true
396 ? `${options.resolution}x?`
397 : `?x${options.resolution}`
398
14aed608
C
399 command = command.size(size)
400 }
401
14aed608
C
402 return command
403}
404
536598cf
C
405async function buildAudioMergeCommand (command: ffmpeg.FfmpegCommand, options: MergeAudioTranscodeOptions) {
406 command = command.loop(undefined)
407
9252a33d
C
408 command = await presetVideo(command, options.audioPath, options)
409
9252a33d 410 command.outputOption('-preset:v veryfast')
536598cf
C
411
412 command = command.input(options.audioPath)
413 .videoFilter('scale=trunc(iw/2)*2:trunc(ih/2)*2') // Avoid "height not divisible by 2" error
414 .outputOption('-tune stillimage')
415 .outputOption('-shortest')
416
417 return command
418}
419
daf6e480 420function buildOnlyAudioCommand (command: ffmpeg.FfmpegCommand, _options: OnlyAudioTranscodeOptions) {
a1587156 421 command = presetOnlyAudio(command)
5c7d6508 422
423 return command
424}
425
a1587156
C
426function buildQuickTranscodeCommand (command: ffmpeg.FfmpegCommand) {
427 command = presetCopy(command)
536598cf
C
428
429 command = command.outputOption('-map_metadata -1') // strip all metadata
430 .outputOption('-movflags faststart')
431
432 return command
433}
434
2650d6d4
C
435function addCommonHLSVODCommandOptions (command: ffmpeg.FfmpegCommand, outputPath: string) {
436 return command.outputOption('-hls_time 4')
437 .outputOption('-hls_list_size 0')
438 .outputOption('-hls_playlist_type vod')
439 .outputOption('-hls_segment_filename ' + outputPath)
440 .outputOption('-hls_segment_type fmp4')
441 .outputOption('-f hls')
442 .outputOption('-hls_flags single_file')
443}
444
c6c0fa6c 445async function buildHLSVODCommand (command: ffmpeg.FfmpegCommand, options: HLSTranscodeOptions) {
14aed608
C
446 const videoPath = getHLSVideoPath(options)
447
a1587156 448 if (options.copyCodecs) command = presetCopy(command)
1c320673 449 else if (options.resolution === VideoResolution.H_NOVIDEO) command = presetOnlyAudio(command)
9252a33d 450 else command = await buildx264VODCommand(command, options)
14aed608 451
2650d6d4
C
452 addCommonHLSVODCommandOptions(command, videoPath)
453
454 return command
455}
456
457async function buildHLSVODFromTSCommand (command: ffmpeg.FfmpegCommand, options: HLSFromTSTranscodeOptions) {
458 const videoPath = getHLSVideoPath(options)
459
3851e732 460 command.outputOption('-c copy')
e772bdf1
C
461
462 if (options.isAAC) {
463 // Required for example when copying an AAC stream from an MPEG-TS
464 // Since it's a bitstream filter, we don't need to reencode the audio
465 command.outputOption('-bsf:a aac_adtstoasc')
466 }
2650d6d4
C
467
468 addCommonHLSVODCommandOptions(command, videoPath)
14aed608
C
469
470 return command
471}
472
536598cf 473async function fixHLSPlaylistIfNeeded (options: TranscodeOptions) {
2650d6d4 474 if (options.type !== 'hls' && options.type !== 'hls-from-ts') return
7f8f8bdb 475
7f8f8bdb
C
476 const fileContent = await readFile(options.outputPath)
477
478 const videoFileName = options.hlsPlaylist.videoFilename
479 const videoFilePath = getHLSVideoPath(options)
480
536598cf 481 // Fix wrong mapping with some ffmpeg versions
7f8f8bdb
C
482 const newContent = fileContent.toString()
483 .replace(`#EXT-X-MAP:URI="${videoFilePath}",`, `#EXT-X-MAP:URI="${videoFileName}",`)
484
485 await writeFile(options.outputPath, newContent)
486}
487
2650d6d4 488function getHLSVideoPath (options: HLSTranscodeOptions | HLSFromTSTranscodeOptions) {
9252a33d 489 return `${dirname(options.outputPath)}/${options.hlsPlaylist.videoFilename}`
4176e227
RK
490}
491
9252a33d
C
492// ---------------------------------------------------------------------------
493// Transcoding presets
494// ---------------------------------------------------------------------------
495
5a547f69
C
496async function getEncoderBuilderResult (options: {
497 streamType: string
498 input: string
499
500 availableEncoders: AvailableEncoders
501 profile: string
502
503 videoType: 'vod' | 'live'
504
505 resolution: number
506 fps?: number
507 streamNum?: number
508}) {
509 const { availableEncoders, input, profile, resolution, streamType, fps, streamNum, videoType } = options
510
511 const encodersToTry: string[] = VIDEO_TRANSCODING_ENCODERS[streamType]
512
513 for (const encoder of encodersToTry) {
514 if (!(await checkFFmpegEncoders()).get(encoder) || !availableEncoders[videoType][encoder]) continue
515
516 const builderProfiles: EncoderProfile<EncoderOptionsBuilder> = availableEncoders[videoType][encoder]
517 let builder = builderProfiles[profile]
518
519 if (!builder) {
520 logger.debug('Profile %s for encoder %s not available. Fallback to default.', profile, encoder)
521 builder = builderProfiles.default
522 }
523
524 const result = await builder({ input, resolution: resolution, fps, streamNum })
525
526 return {
527 result,
528
529 // If we don't have output options, then copy the input stream
530 encoder: result.copy === true
531 ? 'copy'
532 : encoder
533 }
534 }
535
536 return null
537}
538
9252a33d
C
539async function presetVideo (
540 command: ffmpeg.FfmpegCommand,
541 input: string,
542 transcodeOptions: TranscodeOptions,
543 fps?: number
544) {
cdf4cb9e 545 let localCommand = command
4176e227 546 .format('mp4')
4176e227 547 .outputOption('-movflags faststart')
4176e227 548
ce4a50b9
C
549 addDefaultEncoderGlobalParams({ command })
550
9252a33d 551 // Audio encoder
daf6e480 552 const parsedAudio = await getAudioStream(input)
4176e227 553
9252a33d 554 let streamsToProcess = [ 'AUDIO', 'VIDEO' ]
9252a33d 555
cdf4cb9e
C
556 if (!parsedAudio.audioStream) {
557 localCommand = localCommand.noAudio()
9252a33d
C
558 streamsToProcess = [ 'VIDEO' ]
559 }
536598cf 560
5a547f69
C
561 for (const streamType of streamsToProcess) {
562 const { profile, resolution, availableEncoders } = transcodeOptions
563
564 const builderResult = await getEncoderBuilderResult({
565 streamType,
566 input,
567 resolution,
568 availableEncoders,
569 profile,
570 fps,
571 videoType: 'vod' as 'vod'
572 })
9252a33d 573
5a547f69
C
574 if (!builderResult) {
575 throw new Error('No available encoder found for stream ' + streamType)
576 }
9252a33d 577
5a547f69 578 logger.debug('Apply ffmpeg params from %s.', builderResult.encoder, builderResult)
9252a33d 579
5a547f69
C
580 if (streamType === 'VIDEO') {
581 localCommand.videoCodec(builderResult.encoder)
582 } else if (streamType === 'AUDIO') {
583 localCommand.audioCodec(builderResult.encoder)
9252a33d
C
584 }
585
5a547f69
C
586 command.addOutputOptions(builderResult.result.outputOptions)
587 addDefaultEncoderParams({ command: localCommand, encoder: builderResult.encoder, fps })
536598cf 588 }
bcf21a37 589
cdf4cb9e 590 return localCommand
4176e227 591}
14aed608 592
a1587156 593function presetCopy (command: ffmpeg.FfmpegCommand): ffmpeg.FfmpegCommand {
14aed608
C
594 return command
595 .format('mp4')
596 .videoCodec('copy')
597 .audioCodec('copy')
598}
5c7d6508 599
a1587156 600function presetOnlyAudio (command: ffmpeg.FfmpegCommand): ffmpeg.FfmpegCommand {
5c7d6508 601 return command
602 .format('mp4')
603 .audioCodec('copy')
604 .noVideo()
605}
c6c0fa6c 606
9252a33d
C
607// ---------------------------------------------------------------------------
608// Utils
609// ---------------------------------------------------------------------------
610
55223d65 611function getFFmpeg (input: string, type: 'live' | 'vod') {
c6c0fa6c
C
612 // We set cwd explicitly because ffmpeg appears to create temporary files when trancoding which fails in read-only file systems
613 const command = ffmpeg(input, { niceness: FFMPEG_NICE.TRANSCODING, cwd: CONFIG.STORAGE.TMP_DIR })
614
55223d65
C
615 const threads = type === 'live'
616 ? CONFIG.LIVE.TRANSCODING.THREADS
617 : CONFIG.TRANSCODING.THREADS
618
619 if (threads > 0) {
c6c0fa6c 620 // If we don't set any threads ffmpeg will chose automatically
55223d65 621 command.outputOption('-threads ' + threads)
c6c0fa6c
C
622 }
623
624 return command
625}
9252a33d
C
626
627async function runCommand (command: ffmpeg.FfmpegCommand, onEnd?: Function) {
628 return new Promise<void>((res, rej) => {
629 command.on('error', (err, stdout, stderr) => {
630 if (onEnd) onEnd()
631
632 logger.error('Error in transcoding job.', { stdout, stderr })
633 rej(err)
634 })
635
636 command.on('end', () => {
637 if (onEnd) onEnd()
638
639 res()
640 })
641
642 command.run()
643 })
644}