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