2 # -*- coding: utf-8 -*-
4 from __future__ import absolute_import
14 class PostProcessor(object):
15 """Post Processor class.
17 PostProcessor objects can be added to downloaders with their
18 add_post_processor() method. When the downloader has finished a
19 successful download, it will take its internal chain of PostProcessors
20 and start calling the run() method on each one of them, first with
21 an initial argument and then with the returned value of the previous
24 The chain will be stopped if one of them ever returns None or the end
25 of the chain is reached.
27 PostProcessor objects follow a "mutual registration" process similar
28 to InfoExtractor objects.
33 def __init__(self, downloader=None):
34 self._downloader = downloader
36 def set_downloader(self, downloader):
37 """Sets the downloader for this PP."""
38 self._downloader = downloader
40 def run(self, information):
41 """Run the PostProcessor.
43 The "information" argument is a dictionary like the ones
44 composed by InfoExtractors. The only difference is that this
45 one has an extra field called "filepath" that points to the
48 This method returns a tuple, the first element of which describes
49 whether the original file should be kept (i.e. not deleted - None for
50 no preference), and the second of which is the updated information.
52 In addition, this method may raise a PostProcessingError
53 exception if post processing fails.
55 return None, information # by default, keep file and do nothing
57 class FFmpegPostProcessorError(PostProcessingError):
60 class AudioConversionError(PostProcessingError):
63 class FFmpegPostProcessor(PostProcessor):
64 def __init__(self,downloader=None):
65 PostProcessor.__init__(self, downloader)
66 self._exes = self.detect_executables()
69 def detect_executables():
72 subprocess.Popen([exe, '-version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
76 programs = ['avprobe', 'avconv', 'ffmpeg', 'ffprobe']
77 return dict((program, executable(program)) for program in programs)
79 def run_ffmpeg(self, path, out_path, opts):
80 if not self._exes['ffmpeg'] and not self._exes['avconv']:
81 raise FFmpegPostProcessorError(u'ffmpeg or avconv not found. Please install one.')
82 cmd = ([self._exes['avconv'] or self._exes['ffmpeg'], '-y', '-i', encodeFilename(path)]
84 [encodeFilename(self._ffmpeg_filename_argument(out_path))])
85 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
86 stdout,stderr = p.communicate()
88 msg = stderr.strip().split('\n')[-1]
89 raise FFmpegPostProcessorError(msg.decode('utf-8', 'replace'))
91 def _ffmpeg_filename_argument(self, fn):
92 # ffmpeg broke --, see https://ffmpeg.org/trac/ffmpeg/ticket/2127 for details
93 if fn.startswith(u'-'):
97 class FFmpegExtractAudioPP(FFmpegPostProcessor):
98 def __init__(self, downloader=None, preferredcodec=None, preferredquality=None, nopostoverwrites=False):
99 FFmpegPostProcessor.__init__(self, downloader)
100 if preferredcodec is None:
101 preferredcodec = 'best'
102 self._preferredcodec = preferredcodec
103 self._preferredquality = preferredquality
104 self._nopostoverwrites = nopostoverwrites
106 def get_audio_codec(self, path):
107 if not self._exes['ffprobe'] and not self._exes['avprobe']: return None
109 cmd = [self._exes['avprobe'] or self._exes['ffprobe'], '-show_streams', encodeFilename(self._ffmpeg_filename_argument(path))]
110 handle = subprocess.Popen(cmd, stderr=compat_subprocess_get_DEVNULL(), stdout=subprocess.PIPE)
111 output = handle.communicate()[0]
112 if handle.wait() != 0:
114 except (IOError, OSError):
117 for line in output.decode('ascii', 'ignore').split('\n'):
118 if line.startswith('codec_name='):
119 audio_codec = line.split('=')[1].strip()
120 elif line.strip() == 'codec_type=audio' and audio_codec is not None:
124 def run_ffmpeg(self, path, out_path, codec, more_opts):
125 if not self._exes['ffmpeg'] and not self._exes['avconv']:
126 raise AudioConversionError('ffmpeg or avconv not found. Please install one.')
130 acodec_opts = ['-acodec', codec]
131 opts = ['-vn'] + acodec_opts + more_opts
133 FFmpegPostProcessor.run_ffmpeg(self, path, out_path, opts)
134 except FFmpegPostProcessorError as err:
135 raise AudioConversionError(err.message)
137 def run(self, information):
138 path = information['filepath']
140 filecodec = self.get_audio_codec(path)
141 if filecodec is None:
142 raise PostProcessingError(u'WARNING: unable to obtain file audio codec with ffprobe')
145 if self._preferredcodec == 'best' or self._preferredcodec == filecodec or (self._preferredcodec == 'm4a' and filecodec == 'aac'):
146 if filecodec == 'aac' and self._preferredcodec in ['m4a', 'best']:
147 # Lossless, but in another container
150 more_opts = [self._exes['avconv'] and '-bsf:a' or '-absf', 'aac_adtstoasc']
151 elif filecodec in ['aac', 'mp3', 'vorbis', 'opus']:
152 # Lossless if possible
154 extension = filecodec
155 if filecodec == 'aac':
156 more_opts = ['-f', 'adts']
157 if filecodec == 'vorbis':
161 acodec = 'libmp3lame'
164 if self._preferredquality is not None:
165 if int(self._preferredquality) < 10:
166 more_opts += [self._exes['avconv'] and '-q:a' or '-aq', self._preferredquality]
168 more_opts += [self._exes['avconv'] and '-b:a' or '-ab', self._preferredquality + 'k']
170 # We convert the audio (lossy)
171 acodec = {'mp3': 'libmp3lame', 'aac': 'aac', 'm4a': 'aac', 'opus': 'opus', 'vorbis': 'libvorbis', 'wav': None}[self._preferredcodec]
172 extension = self._preferredcodec
174 if self._preferredquality is not None:
175 if int(self._preferredquality) < 10:
176 more_opts += [self._exes['avconv'] and '-q:a' or '-aq', self._preferredquality]
178 more_opts += [self._exes['avconv'] and '-b:a' or '-ab', self._preferredquality + 'k']
179 if self._preferredcodec == 'aac':
180 more_opts += ['-f', 'adts']
181 if self._preferredcodec == 'm4a':
182 more_opts += [self._exes['avconv'] and '-bsf:a' or '-absf', 'aac_adtstoasc']
183 if self._preferredcodec == 'vorbis':
185 if self._preferredcodec == 'wav':
187 more_opts += ['-f', 'wav']
189 prefix, sep, ext = path.rpartition(u'.') # not os.path.splitext, since the latter does not work on unicode in all setups
190 new_path = prefix + sep + extension
192 # If we download foo.mp3 and convert it to... foo.mp3, then don't delete foo.mp3, silly.
194 self._nopostoverwrites = True
197 if self._nopostoverwrites and os.path.exists(encodeFilename(new_path)):
198 self._downloader.to_screen(u'[youtube] Post-process file %s exists, skipping' % new_path)
200 self._downloader.to_screen(u'[' + (self._exes['avconv'] and 'avconv' or 'ffmpeg') + '] Destination: ' + new_path)
201 self.run_ffmpeg(path, new_path, acodec, more_opts)
203 etype,e,tb = sys.exc_info()
204 if isinstance(e, AudioConversionError):
205 msg = u'audio conversion failed: ' + e.message
207 msg = u'error running ' + (self._exes['avconv'] and 'avconv' or 'ffmpeg')
208 raise PostProcessingError(msg)
210 # Try to update the date time for extracted audio file.
211 if information.get('filetime') is not None:
213 os.utime(encodeFilename(new_path), (time.time(), information['filetime']))
215 self._downloader.to_stderr(u'WARNING: Cannot update utime of audio file')
217 information['filepath'] = new_path
218 return self._nopostoverwrites,information
220 class FFmpegVideoConvertor(FFmpegPostProcessor):
221 def __init__(self, downloader=None,preferedformat=None):
222 super(FFmpegVideoConvertor, self).__init__(downloader)
223 self._preferedformat=preferedformat
225 def run(self, information):
226 path = information['filepath']
227 prefix, sep, ext = path.rpartition(u'.')
228 outpath = prefix + sep + self._preferedformat
229 if information['ext'] == self._preferedformat:
230 self._downloader.to_screen(u'[ffmpeg] Not converting video file %s - already is in target format %s' % (path, self._preferedformat))
231 return True,information
232 self._downloader.to_screen(u'['+'ffmpeg'+'] Converting video from %s to %s, Destination: ' % (information['ext'], self._preferedformat) +outpath)
233 self.run_ffmpeg(path, outpath, [])
234 information['filepath'] = outpath
235 information['format'] = self._preferedformat
236 information['ext'] = self._preferedformat
237 return False,information