You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

680 lines
23 KiB

10 years ago
10 years ago
10 years ago
10 years ago
10 years ago
10 years ago
  1. from __future__ import unicode_literals
  2. import io
  3. import os
  4. import subprocess
  5. import time
  6. from .common import AudioConversionError, PostProcessor
  7. from ..compat import (
  8. compat_subprocess_get_DEVNULL,
  9. )
  10. from ..utils import (
  11. encodeArgument,
  12. encodeFilename,
  13. get_exe_version,
  14. is_outdated_version,
  15. PostProcessingError,
  16. prepend_extension,
  17. shell_quote,
  18. subtitles_filename,
  19. )
  20. class FFmpegPostProcessorError(PostProcessingError):
  21. pass
  22. class FFmpegPostProcessor(PostProcessor):
  23. def __init__(self, downloader=None, deletetempfiles=False):
  24. PostProcessor.__init__(self, downloader)
  25. self._deletetempfiles = deletetempfiles
  26. self._determine_executables()
  27. def check_version(self):
  28. if not self.available:
  29. raise FFmpegPostProcessorError('ffmpeg or avconv not found. Please install one.')
  30. required_version = '10-0' if self.basename == 'avconv' else '1.0'
  31. if is_outdated_version(
  32. self._versions[self.basename], required_version):
  33. warning = 'Your copy of %s is outdated, update %s to version %s or newer if you encounter any errors.' % (
  34. self.basename, self.basename, required_version)
  35. if self._downloader:
  36. self._downloader.report_warning(warning)
  37. @staticmethod
  38. def get_versions(downloader=None):
  39. return FFmpegPostProcessor(downloader)._versions
  40. def _determine_executables(self):
  41. programs = ['avprobe', 'avconv', 'ffmpeg', 'ffprobe']
  42. prefer_ffmpeg = self._downloader.params.get('prefer_ffmpeg', False)
  43. self.basename = None
  44. self.probe_basename = None
  45. self._paths = None
  46. self._versions = None
  47. if self._downloader:
  48. location = self._downloader.params.get('ffmpeg_location')
  49. if location is not None:
  50. if not os.path.exists(location):
  51. self._downloader.report_warning(
  52. 'ffmpeg-location %s does not exist! '
  53. 'Continuing without avconv/ffmpeg.' % (location))
  54. self._versions = {}
  55. return
  56. elif not os.path.isdir(location):
  57. basename = os.path.splitext(os.path.basename(location))[0]
  58. if basename not in programs:
  59. self._downloader.report_warning(
  60. 'Cannot identify executable %s, its basename should be one of %s. '
  61. 'Continuing without avconv/ffmpeg.' %
  62. (location, ', '.join(programs)))
  63. self._versions = {}
  64. return None
  65. location = os.path.dirname(os.path.abspath(location))
  66. if basename in ('ffmpeg', 'ffprobe'):
  67. prefer_ffmpeg = True
  68. self._paths = dict(
  69. (p, os.path.join(location, p)) for p in programs)
  70. self._versions = dict(
  71. (p, get_exe_version(self._paths[p], args=['-version']))
  72. for p in programs)
  73. if self._versions is None:
  74. self._versions = dict(
  75. (p, get_exe_version(p, args=['-version'])) for p in programs)
  76. self._paths = dict((p, p) for p in programs)
  77. if prefer_ffmpeg:
  78. prefs = ('ffmpeg', 'avconv')
  79. else:
  80. prefs = ('avconv', 'ffmpeg')
  81. for p in prefs:
  82. if self._versions[p]:
  83. self.basename = p
  84. break
  85. if prefer_ffmpeg:
  86. prefs = ('ffprobe', 'avprobe')
  87. else:
  88. prefs = ('avprobe', 'ffprobe')
  89. for p in prefs:
  90. if self._versions[p]:
  91. self.probe_basename = p
  92. break
  93. @property
  94. def available(self):
  95. return self.basename is not None
  96. @property
  97. def executable(self):
  98. return self._paths[self.basename]
  99. @property
  100. def probe_available(self):
  101. return self.probe_basename is not None
  102. @property
  103. def probe_executable(self):
  104. return self._paths[self.probe_basename]
  105. def run_ffmpeg_multiple_files(self, input_paths, out_path, opts):
  106. self.check_version()
  107. oldest_mtime = min(
  108. os.stat(encodeFilename(path)).st_mtime for path in input_paths)
  109. files_cmd = []
  110. for path in input_paths:
  111. files_cmd.extend([encodeArgument('-i'), encodeFilename(path, True)])
  112. cmd = ([encodeFilename(self.executable, True), encodeArgument('-y')] +
  113. files_cmd +
  114. [encodeArgument(o) for o in opts] +
  115. [encodeFilename(self._ffmpeg_filename_argument(out_path), True)])
  116. if self._downloader.params.get('verbose', False):
  117. self._downloader.to_screen('[debug] ffmpeg command line: %s' % shell_quote(cmd))
  118. p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
  119. stdout, stderr = p.communicate()
  120. if p.returncode != 0:
  121. stderr = stderr.decode('utf-8', 'replace')
  122. msg = stderr.strip().split('\n')[-1]
  123. raise FFmpegPostProcessorError(msg)
  124. os.utime(encodeFilename(out_path), (oldest_mtime, oldest_mtime))
  125. if self._deletetempfiles:
  126. for ipath in input_paths:
  127. os.remove(ipath)
  128. def run_ffmpeg(self, path, out_path, opts):
  129. self.run_ffmpeg_multiple_files([path], out_path, opts)
  130. def _ffmpeg_filename_argument(self, fn):
  131. # ffmpeg broke --, see https://ffmpeg.org/trac/ffmpeg/ticket/2127 for details
  132. if fn.startswith('-'):
  133. return './' + fn
  134. return fn
  135. class FFmpegExtractAudioPP(FFmpegPostProcessor):
  136. def __init__(self, downloader=None, preferredcodec=None, preferredquality=None, nopostoverwrites=False):
  137. FFmpegPostProcessor.__init__(self, downloader)
  138. if preferredcodec is None:
  139. preferredcodec = 'best'
  140. self._preferredcodec = preferredcodec
  141. self._preferredquality = preferredquality
  142. self._nopostoverwrites = nopostoverwrites
  143. def get_audio_codec(self, path):
  144. if not self.probe_available:
  145. raise PostProcessingError('ffprobe or avprobe not found. Please install one.')
  146. try:
  147. cmd = [
  148. encodeFilename(self.probe_executable, True),
  149. encodeArgument('-show_streams'),
  150. encodeFilename(self._ffmpeg_filename_argument(path), True)]
  151. if self._downloader.params.get('verbose', False):
  152. self._downloader.to_screen('[debug] %s command line: %s' % (self.basename, shell_quote(cmd)))
  153. handle = subprocess.Popen(cmd, stderr=compat_subprocess_get_DEVNULL(), stdout=subprocess.PIPE, stdin=subprocess.PIPE)
  154. output = handle.communicate()[0]
  155. if handle.wait() != 0:
  156. return None
  157. except (IOError, OSError):
  158. return None
  159. audio_codec = None
  160. for line in output.decode('ascii', 'ignore').split('\n'):
  161. if line.startswith('codec_name='):
  162. audio_codec = line.split('=')[1].strip()
  163. elif line.strip() == 'codec_type=audio' and audio_codec is not None:
  164. return audio_codec
  165. return None
  166. def run_ffmpeg(self, path, out_path, codec, more_opts):
  167. if codec is None:
  168. acodec_opts = []
  169. else:
  170. acodec_opts = ['-acodec', codec]
  171. opts = ['-vn'] + acodec_opts + more_opts
  172. try:
  173. FFmpegPostProcessor.run_ffmpeg(self, path, out_path, opts)
  174. except FFmpegPostProcessorError as err:
  175. raise AudioConversionError(err.msg)
  176. def run(self, information):
  177. path = information['filepath']
  178. filecodec = self.get_audio_codec(path)
  179. if filecodec is None:
  180. raise PostProcessingError('WARNING: unable to obtain file audio codec with ffprobe')
  181. more_opts = []
  182. if self._preferredcodec == 'best' or self._preferredcodec == filecodec or (self._preferredcodec == 'm4a' and filecodec == 'aac'):
  183. if filecodec == 'aac' and self._preferredcodec in ['m4a', 'best']:
  184. # Lossless, but in another container
  185. acodec = 'copy'
  186. extension = 'm4a'
  187. more_opts = ['-bsf:a', 'aac_adtstoasc']
  188. elif filecodec in ['aac', 'mp3', 'vorbis', 'opus']:
  189. # Lossless if possible
  190. acodec = 'copy'
  191. extension = filecodec
  192. if filecodec == 'aac':
  193. more_opts = ['-f', 'adts']
  194. if filecodec == 'vorbis':
  195. extension = 'ogg'
  196. else:
  197. # MP3 otherwise.
  198. acodec = 'libmp3lame'
  199. extension = 'mp3'
  200. more_opts = []
  201. if self._preferredquality is not None:
  202. if int(self._preferredquality) < 10:
  203. more_opts += ['-q:a', self._preferredquality]
  204. else:
  205. more_opts += ['-b:a', self._preferredquality + 'k']
  206. else:
  207. # We convert the audio (lossy)
  208. acodec = {'mp3': 'libmp3lame', 'aac': 'aac', 'm4a': 'aac', 'opus': 'opus', 'vorbis': 'libvorbis', 'wav': None}[self._preferredcodec]
  209. extension = self._preferredcodec
  210. more_opts = []
  211. if self._preferredquality is not None:
  212. # The opus codec doesn't support the -aq option
  213. if int(self._preferredquality) < 10 and extension != 'opus':
  214. more_opts += ['-q:a', self._preferredquality]
  215. else:
  216. more_opts += ['-b:a', self._preferredquality + 'k']
  217. if self._preferredcodec == 'aac':
  218. more_opts += ['-f', 'adts']
  219. if self._preferredcodec == 'm4a':
  220. more_opts += ['-bsf:a', 'aac_adtstoasc']
  221. if self._preferredcodec == 'vorbis':
  222. extension = 'ogg'
  223. if self._preferredcodec == 'wav':
  224. extension = 'wav'
  225. more_opts += ['-f', 'wav']
  226. prefix, sep, ext = path.rpartition('.') # not os.path.splitext, since the latter does not work on unicode in all setups
  227. new_path = prefix + sep + extension
  228. # If we download foo.mp3 and convert it to... foo.mp3, then don't delete foo.mp3, silly.
  229. if new_path == path:
  230. self._nopostoverwrites = True
  231. try:
  232. if self._nopostoverwrites and os.path.exists(encodeFilename(new_path)):
  233. self._downloader.to_screen('[youtube] Post-process file %s exists, skipping' % new_path)
  234. else:
  235. self._downloader.to_screen('[' + self.basename + '] Destination: ' + new_path)
  236. self.run_ffmpeg(path, new_path, acodec, more_opts)
  237. except AudioConversionError as e:
  238. raise PostProcessingError(
  239. 'audio conversion failed: ' + e.msg)
  240. except Exception:
  241. raise PostProcessingError('error running ' + self.basename)
  242. # Try to update the date time for extracted audio file.
  243. if information.get('filetime') is not None:
  244. try:
  245. os.utime(encodeFilename(new_path), (time.time(), information['filetime']))
  246. except Exception:
  247. self._downloader.report_warning('Cannot update utime of audio file')
  248. information['filepath'] = new_path
  249. return self._nopostoverwrites, information
  250. class FFmpegVideoConvertorPP(FFmpegPostProcessor):
  251. def __init__(self, downloader=None, preferedformat=None):
  252. super(FFmpegVideoConvertorPP, self).__init__(downloader)
  253. self._preferedformat = preferedformat
  254. def run(self, information):
  255. path = information['filepath']
  256. prefix, sep, ext = path.rpartition('.')
  257. outpath = prefix + sep + self._preferedformat
  258. if information['ext'] == self._preferedformat:
  259. self._downloader.to_screen('[ffmpeg] Not converting video file %s - already is in target format %s' % (path, self._preferedformat))
  260. return True, information
  261. self._downloader.to_screen('[' + 'ffmpeg' + '] Converting video from %s to %s, Destination: ' % (information['ext'], self._preferedformat) + outpath)
  262. self.run_ffmpeg(path, outpath, [])
  263. information['filepath'] = outpath
  264. information['format'] = self._preferedformat
  265. information['ext'] = self._preferedformat
  266. return False, information
  267. class FFmpegEmbedSubtitlePP(FFmpegPostProcessor):
  268. # See http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt
  269. _lang_map = {
  270. 'aa': 'aar',
  271. 'ab': 'abk',
  272. 'ae': 'ave',
  273. 'af': 'afr',
  274. 'ak': 'aka',
  275. 'am': 'amh',
  276. 'an': 'arg',
  277. 'ar': 'ara',
  278. 'as': 'asm',
  279. 'av': 'ava',
  280. 'ay': 'aym',
  281. 'az': 'aze',
  282. 'ba': 'bak',
  283. 'be': 'bel',
  284. 'bg': 'bul',
  285. 'bh': 'bih',
  286. 'bi': 'bis',
  287. 'bm': 'bam',
  288. 'bn': 'ben',
  289. 'bo': 'bod',
  290. 'br': 'bre',
  291. 'bs': 'bos',
  292. 'ca': 'cat',
  293. 'ce': 'che',
  294. 'ch': 'cha',
  295. 'co': 'cos',
  296. 'cr': 'cre',
  297. 'cs': 'ces',
  298. 'cu': 'chu',
  299. 'cv': 'chv',
  300. 'cy': 'cym',
  301. 'da': 'dan',
  302. 'de': 'deu',
  303. 'dv': 'div',
  304. 'dz': 'dzo',
  305. 'ee': 'ewe',
  306. 'el': 'ell',
  307. 'en': 'eng',
  308. 'eo': 'epo',
  309. 'es': 'spa',
  310. 'et': 'est',
  311. 'eu': 'eus',
  312. 'fa': 'fas',
  313. 'ff': 'ful',
  314. 'fi': 'fin',
  315. 'fj': 'fij',
  316. 'fo': 'fao',
  317. 'fr': 'fra',
  318. 'fy': 'fry',
  319. 'ga': 'gle',
  320. 'gd': 'gla',
  321. 'gl': 'glg',
  322. 'gn': 'grn',
  323. 'gu': 'guj',
  324. 'gv': 'glv',
  325. 'ha': 'hau',
  326. 'he': 'heb',
  327. 'hi': 'hin',
  328. 'ho': 'hmo',
  329. 'hr': 'hrv',
  330. 'ht': 'hat',
  331. 'hu': 'hun',
  332. 'hy': 'hye',
  333. 'hz': 'her',
  334. 'ia': 'ina',
  335. 'id': 'ind',
  336. 'ie': 'ile',
  337. 'ig': 'ibo',
  338. 'ii': 'iii',
  339. 'ik': 'ipk',
  340. 'io': 'ido',
  341. 'is': 'isl',
  342. 'it': 'ita',
  343. 'iu': 'iku',
  344. 'ja': 'jpn',
  345. 'jv': 'jav',
  346. 'ka': 'kat',
  347. 'kg': 'kon',
  348. 'ki': 'kik',
  349. 'kj': 'kua',
  350. 'kk': 'kaz',
  351. 'kl': 'kal',
  352. 'km': 'khm',
  353. 'kn': 'kan',
  354. 'ko': 'kor',
  355. 'kr': 'kau',
  356. 'ks': 'kas',
  357. 'ku': 'kur',
  358. 'kv': 'kom',
  359. 'kw': 'cor',
  360. 'ky': 'kir',
  361. 'la': 'lat',
  362. 'lb': 'ltz',
  363. 'lg': 'lug',
  364. 'li': 'lim',
  365. 'ln': 'lin',
  366. 'lo': 'lao',
  367. 'lt': 'lit',
  368. 'lu': 'lub',
  369. 'lv': 'lav',
  370. 'mg': 'mlg',
  371. 'mh': 'mah',
  372. 'mi': 'mri',
  373. 'mk': 'mkd',
  374. 'ml': 'mal',
  375. 'mn': 'mon',
  376. 'mr': 'mar',
  377. 'ms': 'msa',
  378. 'mt': 'mlt',
  379. 'my': 'mya',
  380. 'na': 'nau',
  381. 'nb': 'nob',
  382. 'nd': 'nde',
  383. 'ne': 'nep',
  384. 'ng': 'ndo',
  385. 'nl': 'nld',
  386. 'nn': 'nno',
  387. 'no': 'nor',
  388. 'nr': 'nbl',
  389. 'nv': 'nav',
  390. 'ny': 'nya',
  391. 'oc': 'oci',
  392. 'oj': 'oji',
  393. 'om': 'orm',
  394. 'or': 'ori',
  395. 'os': 'oss',
  396. 'pa': 'pan',
  397. 'pi': 'pli',
  398. 'pl': 'pol',
  399. 'ps': 'pus',
  400. 'pt': 'por',
  401. 'qu': 'que',
  402. 'rm': 'roh',
  403. 'rn': 'run',
  404. 'ro': 'ron',
  405. 'ru': 'rus',
  406. 'rw': 'kin',
  407. 'sa': 'san',
  408. 'sc': 'srd',
  409. 'sd': 'snd',
  410. 'se': 'sme',
  411. 'sg': 'sag',
  412. 'si': 'sin',
  413. 'sk': 'slk',
  414. 'sl': 'slv',
  415. 'sm': 'smo',
  416. 'sn': 'sna',
  417. 'so': 'som',
  418. 'sq': 'sqi',
  419. 'sr': 'srp',
  420. 'ss': 'ssw',
  421. 'st': 'sot',
  422. 'su': 'sun',
  423. 'sv': 'swe',
  424. 'sw': 'swa',
  425. 'ta': 'tam',
  426. 'te': 'tel',
  427. 'tg': 'tgk',
  428. 'th': 'tha',
  429. 'ti': 'tir',
  430. 'tk': 'tuk',
  431. 'tl': 'tgl',
  432. 'tn': 'tsn',
  433. 'to': 'ton',
  434. 'tr': 'tur',
  435. 'ts': 'tso',
  436. 'tt': 'tat',
  437. 'tw': 'twi',
  438. 'ty': 'tah',
  439. 'ug': 'uig',
  440. 'uk': 'ukr',
  441. 'ur': 'urd',
  442. 'uz': 'uzb',
  443. 've': 'ven',
  444. 'vi': 'vie',
  445. 'vo': 'vol',
  446. 'wa': 'wln',
  447. 'wo': 'wol',
  448. 'xh': 'xho',
  449. 'yi': 'yid',
  450. 'yo': 'yor',
  451. 'za': 'zha',
  452. 'zh': 'zho',
  453. 'zu': 'zul',
  454. }
  455. @classmethod
  456. def _conver_lang_code(cls, code):
  457. """Convert language code from ISO 639-1 to ISO 639-2/T"""
  458. return cls._lang_map.get(code[:2])
  459. def run(self, information):
  460. if information['ext'] != 'mp4':
  461. self._downloader.to_screen('[ffmpeg] Subtitles can only be embedded in mp4 files')
  462. return True, information
  463. subtitles = information.get('requested_subtitles')
  464. if not subtitles:
  465. self._downloader.to_screen('[ffmpeg] There aren\'t any subtitles to embed')
  466. return True, information
  467. sub_langs = list(subtitles.keys())
  468. filename = information['filepath']
  469. input_files = [filename] + [subtitles_filename(filename, lang, sub_info['ext']) for lang, sub_info in subtitles.items()]
  470. opts = [
  471. '-map', '0',
  472. '-c', 'copy',
  473. # Don't copy the existing subtitles, we may be running the
  474. # postprocessor a second time
  475. '-map', '-0:s',
  476. '-c:s', 'mov_text',
  477. ]
  478. for (i, lang) in enumerate(sub_langs):
  479. opts.extend(['-map', '%d:0' % (i + 1)])
  480. lang_code = self._conver_lang_code(lang)
  481. if lang_code is not None:
  482. opts.extend(['-metadata:s:s:%d' % i, 'language=%s' % lang_code])
  483. temp_filename = prepend_extension(filename, 'temp')
  484. self._downloader.to_screen('[ffmpeg] Embedding subtitles in \'%s\'' % filename)
  485. self.run_ffmpeg_multiple_files(input_files, temp_filename, opts)
  486. os.remove(encodeFilename(filename))
  487. os.rename(encodeFilename(temp_filename), encodeFilename(filename))
  488. return True, information
  489. class FFmpegMetadataPP(FFmpegPostProcessor):
  490. def run(self, info):
  491. metadata = {}
  492. if info.get('title') is not None:
  493. metadata['title'] = info['title']
  494. if info.get('upload_date') is not None:
  495. metadata['date'] = info['upload_date']
  496. if info.get('artist') is not None:
  497. metadata['artist'] = info['artist']
  498. elif info.get('uploader') is not None:
  499. metadata['artist'] = info['uploader']
  500. elif info.get('uploader_id') is not None:
  501. metadata['artist'] = info['uploader_id']
  502. if info.get('description') is not None:
  503. metadata['description'] = info['description']
  504. metadata['comment'] = info['description']
  505. if info.get('webpage_url') is not None:
  506. metadata['purl'] = info['webpage_url']
  507. if info.get('album') is not None:
  508. metadata['album'] = info['album']
  509. if not metadata:
  510. self._downloader.to_screen('[ffmpeg] There isn\'t any metadata to add')
  511. return True, info
  512. filename = info['filepath']
  513. temp_filename = prepend_extension(filename, 'temp')
  514. if info['ext'] == 'm4a':
  515. options = ['-vn', '-acodec', 'copy']
  516. else:
  517. options = ['-c', 'copy']
  518. for (name, value) in metadata.items():
  519. options.extend(['-metadata', '%s=%s' % (name, value)])
  520. self._downloader.to_screen('[ffmpeg] Adding metadata to \'%s\'' % filename)
  521. self.run_ffmpeg(filename, temp_filename, options)
  522. os.remove(encodeFilename(filename))
  523. os.rename(encodeFilename(temp_filename), encodeFilename(filename))
  524. return True, info
  525. class FFmpegMergerPP(FFmpegPostProcessor):
  526. def run(self, info):
  527. filename = info['filepath']
  528. args = ['-c', 'copy', '-map', '0:v:0', '-map', '1:a:0']
  529. self._downloader.to_screen('[ffmpeg] Merging formats into "%s"' % filename)
  530. self.run_ffmpeg_multiple_files(info['__files_to_merge'], filename, args)
  531. return True, info
  532. class FFmpegAudioFixPP(FFmpegPostProcessor):
  533. def run(self, info):
  534. filename = info['filepath']
  535. temp_filename = prepend_extension(filename, 'temp')
  536. options = ['-vn', '-acodec', 'copy']
  537. self._downloader.to_screen('[ffmpeg] Fixing audio file "%s"' % filename)
  538. self.run_ffmpeg(filename, temp_filename, options)
  539. os.remove(encodeFilename(filename))
  540. os.rename(encodeFilename(temp_filename), encodeFilename(filename))
  541. return True, info
  542. class FFmpegFixupStretchedPP(FFmpegPostProcessor):
  543. def run(self, info):
  544. stretched_ratio = info.get('stretched_ratio')
  545. if stretched_ratio is None or stretched_ratio == 1:
  546. return True, info
  547. filename = info['filepath']
  548. temp_filename = prepend_extension(filename, 'temp')
  549. options = ['-c', 'copy', '-aspect', '%f' % stretched_ratio]
  550. self._downloader.to_screen('[ffmpeg] Fixing aspect ratio in "%s"' % filename)
  551. self.run_ffmpeg(filename, temp_filename, options)
  552. os.remove(encodeFilename(filename))
  553. os.rename(encodeFilename(temp_filename), encodeFilename(filename))
  554. return True, info
  555. class FFmpegFixupM4aPP(FFmpegPostProcessor):
  556. def run(self, info):
  557. if info.get('container') != 'm4a_dash':
  558. return True, info
  559. filename = info['filepath']
  560. temp_filename = prepend_extension(filename, 'temp')
  561. options = ['-c', 'copy', '-f', 'mp4']
  562. self._downloader.to_screen('[ffmpeg] Correcting container in "%s"' % filename)
  563. self.run_ffmpeg(filename, temp_filename, options)
  564. os.remove(encodeFilename(filename))
  565. os.rename(encodeFilename(temp_filename), encodeFilename(filename))
  566. return True, info
  567. class FFmpegSubtitlesConvertorPP(FFmpegPostProcessor):
  568. def __init__(self, downloader=None, format=None):
  569. super(FFmpegSubtitlesConvertorPP, self).__init__(downloader)
  570. self.format = format
  571. def run(self, info):
  572. subs = info.get('requested_subtitles')
  573. filename = info['filepath']
  574. new_ext = self.format
  575. new_format = new_ext
  576. if new_format == 'vtt':
  577. new_format = 'webvtt'
  578. if subs is None:
  579. self._downloader.to_screen('[ffmpeg] There aren\'t any subtitles to convert')
  580. return True, info
  581. self._downloader.to_screen('[ffmpeg] Converting subtitles')
  582. for lang, sub in subs.items():
  583. ext = sub['ext']
  584. if ext == new_ext:
  585. self._downloader.to_screen(
  586. '[ffmpeg] Subtitle file for %s is already in the requested'
  587. 'format' % new_ext)
  588. continue
  589. new_file = subtitles_filename(filename, lang, new_ext)
  590. self.run_ffmpeg(
  591. subtitles_filename(filename, lang, ext),
  592. new_file, ['-f', new_format])
  593. with io.open(new_file, 'rt', encoding='utf-8') as f:
  594. subs[lang] = {
  595. 'ext': ext,
  596. 'data': f.read(),
  597. }
  598. return True, info