aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/helpers/youtube-dl.ts
blob: 0392ec4c7ca3a2277e0b312df84a654adec1ccb9 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
import { createWriteStream } from 'fs'
import { ensureDir, move, pathExists, remove, writeFile } from 'fs-extra'
import { join } from 'path'
import { CONFIG } from '@server/initializers/config'
import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
import { VideoResolution } from '../../shared/models/videos'
import { CONSTRAINTS_FIELDS, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES } from '../initializers/constants'
import { peertubeTruncate, pipelinePromise, root } from './core-utils'
import { isVideoFileExtnameValid } from './custom-validators/videos'
import { logger } from './logger'
import { peertubeGot } from './requests'
import { generateVideoImportTmpPath } from './utils'

export type YoutubeDLInfo = {
  name?: string
  description?: string
  category?: number
  language?: string
  licence?: number
  nsfw?: boolean
  tags?: string[]
  thumbnailUrl?: string
  ext?: string
  originallyPublishedAt?: Date
}

export type YoutubeDLSubs = {
  language: string
  filename: string
  path: string
}[]

const processOptions = {
  maxBuffer: 1024 * 1024 * 10 // 10MB
}

class YoutubeDL {

  constructor (private readonly url: string = '', private readonly enabledResolutions: number[] = []) {

  }

  getYoutubeDLInfo (opts?: string[]): Promise<YoutubeDLInfo> {
    return new Promise<YoutubeDLInfo>((res, rej) => {
      let args = opts || []

      if (CONFIG.IMPORT.VIDEOS.HTTP.FORCE_IPV4) {
        args.push('--force-ipv4')
      }

      args = this.wrapWithProxyOptions(args)
      args = [ '-f', this.getYoutubeDLVideoFormat() ].concat(args)

      YoutubeDL.safeGetYoutubeDL()
        .then(youtubeDL => {
          youtubeDL.getInfo(this.url, args, processOptions, (err, info) => {
            if (err) return rej(err)
            if (info.is_live === true) return rej(new Error('Cannot download a live streaming.'))

            const obj = this.buildVideoInfo(this.normalizeObject(info))
            if (obj.name && obj.name.length < CONSTRAINTS_FIELDS.VIDEOS.NAME.min) obj.name += ' video'

            return res(obj)
          })
        })
        .catch(err => rej(err))
    })
  }

  getYoutubeDLSubs (opts?: object): Promise<YoutubeDLSubs> {
    return new Promise<YoutubeDLSubs>((res, rej) => {
      const cwd = CONFIG.STORAGE.TMP_DIR
      const options = opts || { all: true, format: 'vtt', cwd }

      YoutubeDL.safeGetYoutubeDL()
        .then(youtubeDL => {
          youtubeDL.getSubs(this.url, options, (err, files) => {
            if (err) return rej(err)
            if (!files) return []

            logger.debug('Get subtitles from youtube dl.', { url: this.url, files })

            const subtitles = files.reduce((acc, filename) => {
              const matched = filename.match(/\.([a-z]{2})(-[a-z]+)?\.(vtt|ttml)/i)
              if (!matched || !matched[1]) return acc

              return [
                ...acc,
                {
                  language: matched[1],
                  path: join(cwd, filename),
                  filename
                }
              ]
            }, [])

            return res(subtitles)
          })
        })
        .catch(err => rej(err))
    })
  }

  getYoutubeDLVideoFormat () {
    /**
     * list of format selectors in order or preference
     * see https://github.com/ytdl-org/youtube-dl#format-selection
     *
     * case #1 asks for a mp4 using h264 (avc1) and the exact resolution in the hope
     * of being able to do a "quick-transcode"
     * case #2 is the first fallback. No "quick-transcode" means we can get anything else (like vp9)
     * case #3 is the resolution-degraded equivalent of #1, and already a pretty safe fallback
     *
     * in any case we avoid AV1, see https://github.com/Chocobozzz/PeerTube/issues/3499
     **/
    const resolution = this.enabledResolutions.length === 0
      ? VideoResolution.H_720P
      : Math.max(...this.enabledResolutions)

    return [
      `bestvideo[vcodec^=avc1][height=${resolution}]+bestaudio[ext=m4a]`, // case #1
      `bestvideo[vcodec!*=av01][vcodec!*=vp9.2][height=${resolution}]+bestaudio`, // case #2
      `bestvideo[vcodec^=avc1][height<=${resolution}]+bestaudio[ext=m4a]`, // case #3
      `bestvideo[vcodec!*=av01][vcodec!*=vp9.2]+bestaudio`,
      'best[vcodec!*=av01][vcodec!*=vp9.2]', // case fallback for known formats
      'best' // Ultimate fallback
    ].join('/')
  }

  downloadYoutubeDLVideo (fileExt: string, timeout: number) {
    // Leave empty the extension, youtube-dl will add it
    const pathWithoutExtension = generateVideoImportTmpPath(this.url, '')

    let timer

    logger.info('Importing youtubeDL video %s to %s', this.url, pathWithoutExtension)

    let options = [ '-f', this.getYoutubeDLVideoFormat(), '-o', pathWithoutExtension ]
    options = this.wrapWithProxyOptions(options)

    if (process.env.FFMPEG_PATH) {
      options = options.concat([ '--ffmpeg-location', process.env.FFMPEG_PATH ])
    }

    logger.debug('YoutubeDL options for %s.', this.url, { options })

    return new Promise<string>((res, rej) => {
      YoutubeDL.safeGetYoutubeDL()
        .then(youtubeDL => {
          youtubeDL.exec(this.url, options, processOptions, async err => {
            clearTimeout(timer)

            try {
              // If youtube-dl did not guess an extension for our file, just use .mp4 as default
              if (await pathExists(pathWithoutExtension)) {
                await move(pathWithoutExtension, pathWithoutExtension + '.mp4')
              }

              const path = await this.guessVideoPathWithExtension(pathWithoutExtension, fileExt)

              if (err) {
                remove(path)
                  .catch(err => logger.error('Cannot delete path on YoutubeDL error.', { err }))

                return rej(err)
              }

              return res(path)
            } catch (err) {
              return rej(err)
            }
          })

          timer = setTimeout(() => {
            const err = new Error('YoutubeDL download timeout.')

            this.guessVideoPathWithExtension(pathWithoutExtension, fileExt)
              .then(path => remove(path))
              .finally(() => rej(err))
              .catch(err => {
                logger.error('Cannot remove file in youtubeDL timeout.', { err })
                return rej(err)
              })
          }, timeout)
        })
        .catch(err => rej(err))
    })
  }

  buildOriginallyPublishedAt (obj: any) {
    let originallyPublishedAt: Date = null

    const uploadDateMatcher = /^(\d{4})(\d{2})(\d{2})$/.exec(obj.upload_date)
    if (uploadDateMatcher) {
      originallyPublishedAt = new Date()
      originallyPublishedAt.setHours(0, 0, 0, 0)

      const year = parseInt(uploadDateMatcher[1], 10)
      // Month starts from 0
      const month = parseInt(uploadDateMatcher[2], 10) - 1
      const day = parseInt(uploadDateMatcher[3], 10)

      originallyPublishedAt.setFullYear(year, month, day)
    }

    return originallyPublishedAt
  }

  private async guessVideoPathWithExtension (tmpPath: string, sourceExt: string) {
    if (!isVideoFileExtnameValid(sourceExt)) {
      throw new Error('Invalid video extension ' + sourceExt)
    }

    const extensions = [ sourceExt, '.mp4', '.mkv', '.webm' ]

    for (const extension of extensions) {
      const path = tmpPath + extension

      if (await pathExists(path)) return path
    }

    throw new Error('Cannot guess path of ' + tmpPath)
  }

  private normalizeObject (obj: any) {
    const newObj: any = {}

    for (const key of Object.keys(obj)) {
      // Deprecated key
      if (key === 'resolution') continue

      const value = obj[key]

      if (typeof value === 'string') {
        newObj[key] = value.normalize()
      } else {
        newObj[key] = value
      }
    }

    return newObj
  }

  private buildVideoInfo (obj: any): YoutubeDLInfo {
    return {
      name: this.titleTruncation(obj.title),
      description: this.descriptionTruncation(obj.description),
      category: this.getCategory(obj.categories),
      licence: this.getLicence(obj.license),
      language: this.getLanguage(obj.language),
      nsfw: this.isNSFW(obj),
      tags: this.getTags(obj.tags),
      thumbnailUrl: obj.thumbnail || undefined,
      originallyPublishedAt: this.buildOriginallyPublishedAt(obj),
      ext: obj.ext
    }
  }

  private titleTruncation (title: string) {
    return peertubeTruncate(title, {
      length: CONSTRAINTS_FIELDS.VIDEOS.NAME.max,
      separator: /,? +/,
      omission: ' […]'
    })
  }

  private descriptionTruncation (description: string) {
    if (!description || description.length < CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.min) return undefined

    return peertubeTruncate(description, {
      length: CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.max,
      separator: /,? +/,
      omission: ' […]'
    })
  }

  private isNSFW (info: any) {
    return info.age_limit && info.age_limit >= 16
  }

  private getTags (tags: any) {
    if (Array.isArray(tags) === false) return []

    return tags
      .filter(t => t.length < CONSTRAINTS_FIELDS.VIDEOS.TAG.max && t.length > CONSTRAINTS_FIELDS.VIDEOS.TAG.min)
      .map(t => t.normalize())
      .slice(0, 5)
  }

  private getLicence (licence: string) {
    if (!licence) return undefined

    if (licence.includes('Creative Commons Attribution')) return 1

    for (const key of Object.keys(VIDEO_LICENCES)) {
      const peertubeLicence = VIDEO_LICENCES[key]
      if (peertubeLicence.toLowerCase() === licence.toLowerCase()) return parseInt(key, 10)
    }

    return undefined
  }

  private getCategory (categories: string[]) {
    if (!categories) return undefined

    const categoryString = categories[0]
    if (!categoryString || typeof categoryString !== 'string') return undefined

    if (categoryString === 'News & Politics') return 11

    for (const key of Object.keys(VIDEO_CATEGORIES)) {
      const category = VIDEO_CATEGORIES[key]
      if (categoryString.toLowerCase() === category.toLowerCase()) return parseInt(key, 10)
    }

    return undefined
  }

  private getLanguage (language: string) {
    return VIDEO_LANGUAGES[language] ? language : undefined
  }

  private wrapWithProxyOptions (options: string[]) {
    if (CONFIG.IMPORT.VIDEOS.HTTP.PROXY.ENABLED) {
      logger.debug('Using proxy for YoutubeDL')

      return [ '--proxy', CONFIG.IMPORT.VIDEOS.HTTP.PROXY.URL ].concat(options)
    }

    return options
  }

  // Thanks: https://github.com/przemyslawpluta/node-youtube-dl/blob/master/lib/downloader.js
  // We rewrote it to avoid sync calls
  static async updateYoutubeDLBinary () {
    logger.info('Updating youtubeDL binary.')

    const binDirectory = join(root(), 'node_modules', 'youtube-dl', 'bin')
    const bin = join(binDirectory, 'youtube-dl')
    const detailsPath = join(binDirectory, 'details')
    const url = process.env.YOUTUBE_DL_DOWNLOAD_HOST || 'https://yt-dl.org/downloads/latest/youtube-dl'

    await ensureDir(binDirectory)

    try {
      const gotContext = { bodyKBLimit: 20_000 }

      const result = await peertubeGot(url, { followRedirect: false, context: gotContext })

      if (result.statusCode !== HttpStatusCode.FOUND_302) {
        logger.error('youtube-dl update error: did not get redirect for the latest version link. Status %d', result.statusCode)
        return
      }

      const newUrl = result.headers.location
      const newVersion = /\/(\d{4}\.\d\d\.\d\d(\.\d)?)\/youtube-dl$/.exec(newUrl)[1]

      const downloadFileStream = peertubeGot.stream(newUrl, { context: gotContext })
      const writeStream = createWriteStream(bin, { mode: 493 })

      await pipelinePromise(
        downloadFileStream,
        writeStream
      )

      const details = JSON.stringify({ version: newVersion, path: bin, exec: 'youtube-dl' })
      await writeFile(detailsPath, details, { encoding: 'utf8' })

      logger.info('youtube-dl updated to version %s.', newVersion)
    } catch (err) {
      logger.error('Cannot update youtube-dl.', { err })
    }
  }

  static async safeGetYoutubeDL () {
    let youtubeDL

    try {
      youtubeDL = require('youtube-dl')
    } catch (e) {
      // Download binary
      await this.updateYoutubeDLBinary()
      youtubeDL = require('youtube-dl')
    }

    return youtubeDL
  }
}

// ---------------------------------------------------------------------------

export {
  YoutubeDL
}