_ Git - youtube-dl/blob - youtube_dl/PostProcessor.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 import os
   5 import subprocess
   6 import sys
   7 import time
   8
   9 from utils import *
  10
  11
  12 class PostProcessor(object):
  13     """Post Processor class.
  14
  15     PostProcessor objects can be added to downloaders with their
  16     add_post_processor() method. When the downloader has finished a
  17     successful download, it will take its internal chain of PostProcessors
  18     and start calling the run() method on each one of them, first with
  19     an initial argument and then with the returned value of the previous
  20     PostProcessor.
  21
  22     The chain will be stopped if one of them ever returns None or the end
  23     of the chain is reached.
  24
  25     PostProcessor objects follow a "mutual registration" process similar
  26     to InfoExtractor objects.
  27     """
  28
  29     _downloader = None
  30
  31     def __init__(self, downloader=None):
  32         self._downloader = downloader
  33
  34     def set_downloader(self, downloader):
  35         """Sets the downloader for this PP."""
  36         self._downloader = downloader
  37
  38     def run(self, information):
  39         """Run the PostProcessor.
  40
  41         The "information" argument is a dictionary like the ones
  42         composed by InfoExtractors. The only difference is that this
  43         one has an extra field called "filepath" that points to the
  44         downloaded file.
  45
  46         When this method returns None, the postprocessing chain is
  47         stopped. However, this method may return an information
  48         dictionary that will be passed to the next postprocessing
  49         object in the chain. It can be the one it received after
  50         changing some fields.
  51
  52         In addition, this method may raise a PostProcessingError
  53         exception that will be taken into account by the downloader
  54         it was called from.
  55         """
  56         return information # by default, do nothing
  57
  58 class AudioConversionError(BaseException):
  59     def __init__(self, message):
  60         self.message = message
  61
  62 class FFmpegExtractAudioPP(PostProcessor):
  63     def __init__(self, downloader=None, preferredcodec=None, preferredquality=None, keepvideo=False):
  64         PostProcessor.__init__(self, downloader)
  65         if preferredcodec is None:
  66             preferredcodec = 'best'
  67         self._preferredcodec = preferredcodec
  68         self._preferredquality = preferredquality
  69         self._keepvideo = keepvideo
  70         self._exes = self.detect_executables()
  71
  72     @staticmethod
  73     def detect_executables():
  74         def executable(exe):
  75             try:
  76                 subprocess.Popen([exe, '-version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
  77             except OSError:
  78                 return False
  79             return exe
  80         programs = ['avprobe', 'avconv', 'ffmpeg', 'ffprobe']
  81         return dict((program, executable(program)) for program in programs)
  82
  83     def get_audio_codec(self, path):
  84         if not self._exes['ffprobe'] and not self._exes['avprobe']: return None
  85         try:
  86             cmd = [self._exes['avprobe'] or self._exes['ffprobe'], '-show_streams', '--', encodeFilename(path)]
  87             handle = subprocess.Popen(cmd, stderr=file(os.path.devnull, 'w'), stdout=subprocess.PIPE)
  88             output = handle.communicate()[0]
  89             if handle.wait() != 0:
  90                 return None
  91         except (IOError, OSError):
  92             return None
  93         audio_codec = None
  94         for line in output.split('\n'):
  95             if line.startswith('codec_name='):
  96                 audio_codec = line.split('=')[1].strip()
  97             elif line.strip() == 'codec_type=audio' and audio_codec is not None:
  98                 return audio_codec
  99         return None
 100
 101     def run_ffmpeg(self, path, out_path, codec, more_opts):
 102         if not self._exes['ffmpeg'] and not self._exes['avconv']:
 103             raise AudioConversionError('ffmpeg or avconv not found. Please install one.')
 104         if codec is None:
 105             acodec_opts = []
 106         else:
 107             acodec_opts = ['-acodec', codec]
 108         cmd = ([self._exes['avconv'] or self._exes['ffmpeg'], '-y', '-i', encodeFilename(path), '-vn']
 109                + acodec_opts + more_opts +
 110                ['--', encodeFilename(out_path)])
 111         p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 112         stdout,stderr = p.communicate()
 113         if p.returncode != 0:
 114             msg = stderr.strip().split('\n')[-1]
 115             raise AudioConversionError(msg)
 116
 117     def run(self, information):
 118         path = information['filepath']
 119
 120         filecodec = self.get_audio_codec(path)
 121         if filecodec is None:
 122             self._downloader.to_stderr(u'WARNING: unable to obtain file audio codec with ffprobe')
 123             return None
 124
 125         more_opts = []
 126         if self._preferredcodec == 'best' or self._preferredcodec == filecodec or (self._preferredcodec == 'm4a' and filecodec == 'aac'):
 127             if self._preferredcodec == 'm4a' and filecodec == 'aac':
 128                 # Lossless, but in another container
 129                 acodec = 'copy'
 130                 extension = self._preferredcodec
 131                 more_opts = [self._exes['avconv'] and '-bsf:a' or '-absf', 'aac_adtstoasc']
 132             elif filecodec in ['aac', 'mp3', 'vorbis']:
 133                 # Lossless if possible
 134                 acodec = 'copy'
 135                 extension = filecodec
 136                 if filecodec == 'aac':
 137                     more_opts = ['-f', 'adts']
 138                 if filecodec == 'vorbis':
 139                     extension = 'ogg'
 140             else:
 141                 # MP3 otherwise.
 142                 acodec = 'libmp3lame'
 143                 extension = 'mp3'
 144                 more_opts = []
 145                 if self._preferredquality is not None:
 146                     if int(self._preferredquality) < 10:
 147                         more_opts += [self._exes['avconv'] and '-q:a' or '-aq', self._preferredquality]
 148                     else:
 149                         more_opts += [self._exes['avconv'] and '-b:a' or '-ab', self._preferredquality + 'k']
 150         else:
 151             # We convert the audio (lossy)
 152             acodec = {'mp3': 'libmp3lame', 'aac': 'aac', 'm4a': 'aac', 'vorbis': 'libvorbis', 'wav': None}[self._preferredcodec]
 153             extension = self._preferredcodec
 154             more_opts = []
 155             if self._preferredquality is not None:
 156                 if int(self._preferredquality) < 10:
 157                     more_opts += [self._exes['avconv'] and '-q:a' or '-aq', self._preferredquality]
 158                 else:
 159                     more_opts += [self._exes['avconv'] and '-b:a' or '-ab', self._preferredquality + 'k']
 160             if self._preferredcodec == 'aac':
 161                 more_opts += ['-f', 'adts']
 162             if self._preferredcodec == 'm4a':
 163                 more_opts += [self._exes['avconv'] and '-bsf:a' or '-absf', 'aac_adtstoasc']
 164             if self._preferredcodec == 'vorbis':
 165                 extension = 'ogg'
 166             if self._preferredcodec == 'wav':
 167                 extension = 'wav'
 168                 more_opts += ['-f', 'wav']
 169
 170         prefix, sep, ext = path.rpartition(u'.') # not os.path.splitext, since the latter does not work on unicode in all setups
 171         new_path = prefix + sep + extension
 172         self._downloader.to_screen(u'[' + (self._exes['avconv'] and 'avconv' or 'ffmpeg') + '] Destination: ' + new_path)
 173         try:
 174             self.run_ffmpeg(path, new_path, acodec, more_opts)
 175         except:
 176             etype,e,tb = sys.exc_info()
 177             if isinstance(e, AudioConversionError):
 178                 self._downloader.to_stderr(u'ERROR: audio conversion failed: ' + e.message)
 179             else:
 180                 self._downloader.to_stderr(u'ERROR: error running ' + (self._exes['avconv'] and 'avconv' or 'ffmpeg'))
 181             return None
 182
 183         # Try to update the date time for extracted audio file.
 184         if information.get('filetime') is not None:
 185             try:
 186                 os.utime(encodeFilename(new_path), (time.time(), information['filetime']))
 187             except:
 188                 self._downloader.to_stderr(u'WARNING: Cannot update utime of audio file')
 189
 190         if not self._keepvideo:
 191             try:
 192                 os.remove(encodeFilename(path))
 193             except (IOError, OSError):
 194                 self._downloader.to_stderr(u'WARNING: Unable to remove downloaded video file')
 195                 return None
 196
 197         information['filepath'] = new_path
 198         return information