youtube_dl/downloader/hls.py

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