Raphaël G. Git Repositories - youtubedl/blob - youtube_dl/downloader/hls.py

   1 from __future__ import unicode_literals
   2
   3 import os
   4 import re
   5 import subprocess
   6 import sys
   7
   8 from .common import FileDownloader
   9 from .fragment import FragmentFD
  10
  11 from ..compat import compat_urlparse
  12 from ..postprocessor.ffmpeg import FFmpegPostProcessor
  13 from ..utils import (
  14     encodeArgument,
  15     encodeFilename,
  16     sanitize_open,
  17     handle_youtubedl_headers,
  18 )
  19
  20
  21 class HlsFD(FileDownloader):
  22     def real_download(self, filename, info_dict):
  23         url = info_dict['url']
  24         self.report_destination(filename)
  25         tmpfilename = self.temp_name(filename)
  26
  27         ffpp = FFmpegPostProcessor(downloader=self)
  28         if not ffpp.available:
  29             self.report_error('m3u8 download detected but ffmpeg or avconv could not be found. Please install one.')
  30             return False
  31         ffpp.check_version()
  32
  33         args = [ffpp.executable, '-y']
  34
  35         if info_dict['http_headers'] and re.match(r'^https?://', url):
  36             # Trailing \r\n after each HTTP header is important to prevent warning from ffmpeg/avconv:
  37             # [http @ 00000000003d2fa0] No trailing CRLF found in HTTP header.
  38             headers = handle_youtubedl_headers(info_dict['http_headers'])
  39             args += [
  40                 '-headers',
  41                 ''.join('%s: %s\r\n' % (key, val) for key, val in headers.items())]
  42
  43         args += ['-i', url, '-c', 'copy']
  44         if self.params.get('hls_use_mpegts', False):
  45             args += ['-f', 'mpegts']
  46         else:
  47             args += ['-f', 'mp4', '-bsf:a', 'aac_adtstoasc']
  48
  49         args = [encodeArgument(opt) for opt in args]
  50         args.append(encodeFilename(ffpp._ffmpeg_filename_argument(tmpfilename), True))
  51
  52         self._debug_cmd(args)
  53
  54         proc = subprocess.Popen(args, stdin=subprocess.PIPE)
  55         try:
  56             retval = proc.wait()
  57         except KeyboardInterrupt:
  58             # subprocces.run would send the SIGKILL signal to ffmpeg and the
  59             # mp4 file couldn't be played, but if we ask ffmpeg to quit it
  60             # produces a file that is playable (this is mostly useful for live
  61             # streams). Note that Windows is not affected and produces playable
  62             # files (see https://github.com/rg3/youtube-dl/issues/8300).
  63             if sys.platform != 'win32':
  64                 proc.communicate(b'q')
  65             raise
  66         if retval == 0:
  67             fsize = os.path.getsize(encodeFilename(tmpfilename))
  68             self.to_screen('\r[%s] %s bytes' % (args[0], fsize))
  69             self.try_rename(tmpfilename, filename)
  70             self._hook_progress({
  71                 'downloaded_bytes': fsize,
  72                 'total_bytes': fsize,
  73                 'filename': filename,
  74                 'status': 'finished',
  75             })
  76             return True
  77         else:
  78             self.to_stderr('\n')
  79             self.report_error('%s exited with code %d' % (ffpp.basename, retval))
  80             return False
  81
  82
  83 class NativeHlsFD(FragmentFD):
  84     """ A more limited implementation that does not require ffmpeg """
  85
  86     FD_NAME = 'hlsnative'
  87
  88     def real_download(self, filename, info_dict):
  89         man_url = info_dict['url']
  90         self.to_screen('[%s] Downloading m3u8 manifest' % self.FD_NAME)
  91         manifest = self.ydl.urlopen(man_url).read()
  92
  93         s = manifest.decode('utf-8', 'ignore')
  94         fragment_urls = []
  95         for line in s.splitlines():
  96             line = line.strip()
  97             if line and not line.startswith('#'):
  98                 segment_url = (
  99                     line
 100                     if re.match(r'^https?://', line)
 101                     else compat_urlparse.urljoin(man_url, line))
 102                 fragment_urls.append(segment_url)
 103                 # We only download the first fragment during the test
 104                 if self.params.get('test', False):
 105                     break
 106
 107         ctx = {
 108             'filename': filename,
 109             'total_frags': len(fragment_urls),
 110         }
 111
 112         self._prepare_and_start_frag_download(ctx)
 113
 114         frags_filenames = []
 115         for i, frag_url in enumerate(fragment_urls):
 116             frag_filename = '%s-Frag%d' % (ctx['tmpfilename'], i)
 117             success = ctx['dl'].download(frag_filename, {'url': frag_url})
 118             if not success:
 119                 return False
 120             down, frag_sanitized = sanitize_open(frag_filename, 'rb')
 121             ctx['dest_stream'].write(down.read())
 122             down.close()
 123             frags_filenames.append(frag_sanitized)
 124
 125         self._finish_frag_download(ctx)
 126
 127         for frag_file in frags_filenames:
 128             os.remove(encodeFilename(frag_file))
 129
 130         return True