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 When this method returns None, the postprocessing chain is
49 stopped. However, this method may return an information
50 dictionary that will be passed to the next postprocessing
51 object in the chain. It can be the one it received after
54 In addition, this method may raise a PostProcessingError
55 exception that will be taken into account by the downloader
58 return information # by default, do nothing
60 class FFmpegPostProcessorError(BaseException):
61 def __init__(self, message):
62 self.message = message
64 class AudioConversionError(BaseException):
65 def __init__(self, message):
66 self.message = message
68 class FFmpegPostProcessor(PostProcessor):
69 def __init__(self,downloader=None):
70 PostProcessor.__init__(self, downloader)
71 self._exes = self.detect_executables()
74 def detect_executables():
77 subprocess.Popen([exe, '-version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
81 programs = ['avprobe', 'avconv', 'ffmpeg', 'ffprobe']
82 return dict((program, executable(program)) for program in programs)
84 def run_ffmpeg(self, path, out_path, opts):
85 if not self._exes['ffmpeg'] and not self._exes['avconv']:
86 raise FFmpegPostProcessorError('ffmpeg or avconv not found. Please install one.')
87 cmd = ([self._exes['avconv'] or self._exes['ffmpeg'], '-y', '-i', encodeFilename(path)]
89 [encodeFilename(self._ffmpeg_filename_argument(out_path))])
90 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
91 stdout,stderr = p.communicate()
93 msg = stderr.strip().split('\n')[-1]
94 raise FFmpegPostProcessorError(msg)
96 def _ffmpeg_filename_argument(self, fn):
97 # ffmpeg broke --, see https://ffmpeg.org/trac/ffmpeg/ticket/2127 for details
98 if fn.startswith(u'-'):
102 class FFmpegExtractAudioPP(FFmpegPostProcessor):
103 def __init__(self, downloader=None, preferredcodec=None, preferredquality=None, keepvideo=False, nopostoverwrites=False):
104 FFmpegPostProcessor.__init__(self, downloader)
105 if preferredcodec is None:
106 preferredcodec = 'best'
107 self._preferredcodec = preferredcodec
108 self._preferredquality = preferredquality
109 self._keepvideo = keepvideo
110 self._nopostoverwrites = nopostoverwrites
112 def get_audio_codec(self, path):
113 if not self._exes['ffprobe'] and not self._exes['avprobe']: return None
115 cmd = [self._exes['avprobe'] or self._exes['ffprobe'], '-show_streams', encodeFilename(self._ffmpeg_filename_argument(path))]
116 handle = subprocess.Popen(cmd, stderr=compat_subprocess_get_DEVNULL(), stdout=subprocess.PIPE)
117 output = handle.communicate()[0]
118 if handle.wait() != 0:
120 except (IOError, OSError):
123 for line in output.decode('ascii', 'ignore').split('\n'):
124 if line.startswith('codec_name='):
125 audio_codec = line.split('=')[1].strip()
126 elif line.strip() == 'codec_type=audio' and audio_codec is not None:
130 def run_ffmpeg(self, path, out_path, codec, more_opts):
131 if not self._exes['ffmpeg'] and not self._exes['avconv']:
132 raise AudioConversionError('ffmpeg or avconv not found. Please install one.')
136 acodec_opts = ['-acodec', codec]
137 opts = ['-vn'] + acodec_opts + more_opts
139 FFmpegPostProcessor.run_ffmpeg(self, path, out_path, opts)
140 except FFmpegPostProcessorError as err:
141 raise AudioConversionError(err.message)
143 def run(self, information):
144 path = information['filepath']
146 filecodec = self.get_audio_codec(path)
147 if filecodec is None:
148 self._downloader.to_stderr(u'WARNING: unable to obtain file audio codec with ffprobe')
152 if self._preferredcodec == 'best' or self._preferredcodec == filecodec or (self._preferredcodec == 'm4a' and filecodec == 'aac'):
153 if self._preferredcodec == 'm4a' and filecodec == 'aac':
154 # Lossless, but in another container
156 extension = self._preferredcodec
157 more_opts = [self._exes['avconv'] and '-bsf:a' or '-absf', 'aac_adtstoasc']
158 elif filecodec in ['aac', 'mp3', 'vorbis', 'opus']:
159 # Lossless if possible
161 extension = filecodec
162 if filecodec == 'aac':
163 more_opts = ['-f', 'adts']
164 if filecodec == 'vorbis':
168 acodec = 'libmp3lame'
171 if self._preferredquality is not None:
172 if int(self._preferredquality) < 10:
173 more_opts += [self._exes['avconv'] and '-q:a' or '-aq', self._preferredquality]
175 more_opts += [self._exes['avconv'] and '-b:a' or '-ab', self._preferredquality + 'k']
177 # We convert the audio (lossy)
178 acodec = {'mp3': 'libmp3lame', 'aac': 'aac', 'm4a': 'aac', 'opus': 'opus', 'vorbis': 'libvorbis', 'wav': None}[self._preferredcodec]
179 extension = self._preferredcodec
181 if self._preferredquality is not None:
182 if int(self._preferredquality) < 10:
183 more_opts += [self._exes['avconv'] and '-q:a' or '-aq', self._preferredquality]
185 more_opts += [self._exes['avconv'] and '-b:a' or '-ab', self._preferredquality + 'k']
186 if self._preferredcodec == 'aac':
187 more_opts += ['-f', 'adts']
188 if self._preferredcodec == 'm4a':
189 more_opts += [self._exes['avconv'] and '-bsf:a' or '-absf', 'aac_adtstoasc']
190 if self._preferredcodec == 'vorbis':
192 if self._preferredcodec == 'wav':
194 more_opts += ['-f', 'wav']
196 prefix, sep, ext = path.rpartition(u'.') # not os.path.splitext, since the latter does not work on unicode in all setups
197 new_path = prefix + sep + extension
199 if self._nopostoverwrites and os.path.exists(encodeFilename(new_path)):
200 self._downloader.to_screen(u'[youtube] Post-process file %s exists, skipping' % new_path)
202 self._downloader.to_screen(u'[' + (self._exes['avconv'] and 'avconv' or 'ffmpeg') + '] Destination: ' + new_path)
203 self.run_ffmpeg(path, new_path, acodec, more_opts)
205 etype,e,tb = sys.exc_info()
206 if isinstance(e, AudioConversionError):
207 self._downloader.to_stderr(u'ERROR: audio conversion failed: ' + e.message)
209 self._downloader.to_stderr(u'ERROR: error running ' + (self._exes['avconv'] and 'avconv' or 'ffmpeg'))
212 # Try to update the date time for extracted audio file.
213 if information.get('filetime') is not None:
215 os.utime(encodeFilename(new_path), (time.time(), information['filetime']))
217 self._downloader.to_stderr(u'WARNING: Cannot update utime of audio file')
219 if not self._keepvideo:
221 os.remove(encodeFilename(path))
222 except (IOError, OSError):
223 self._downloader.to_stderr(u'WARNING: Unable to remove downloaded video file')
226 information['filepath'] = new_path
229 class FFmpegVideoConvertor(FFmpegPostProcessor):
230 def __init__(self, downloader=None,preferedformat=None):
231 FFmpegPostProcessor.__init__(self,downloader)
232 self._preferedformat=preferedformat
234 def run(self, information):
235 path = information['filepath']
236 prefix, sep, ext = path.rpartition(u'.')
237 outpath = prefix + sep + self._preferedformat
238 if not self._preferedformat or information['format'] == self._preferedformat:
240 self._downloader.to_screen(u'['+'ffmpeg'+'] Converting video from %s to %s, Destination: ' % (information['format'], self._preferedformat) +outpath)
241 self.run_ffmpeg(path, outpath, [])
242 information['filepath'] = outpath
243 information['format'] = self._preferedformat