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