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

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from __future__ import absolute_import
   5
   6 import math
   7 import io
   8 import os
   9 import re
  10 import socket
  11 import subprocess
  12 import sys
  13 import time
  14 import traceback
  15
  16 if os.name == 'nt':
  17     import ctypes
  18
  19 from .utils import *
  20
  21
  22 class FileDownloader(object):
  23     """File Downloader class.
  24
  25     File downloader objects are the ones responsible of downloading the
  26     actual video file and writing it to disk if the user has requested
  27     it, among some other tasks. In most cases there should be one per
  28     program. As, given a video URL, the downloader doesn't know how to
  29     extract all the needed information, task that InfoExtractors do, it
  30     has to pass the URL to one of them.
  31
  32     For this, file downloader objects have a method that allows
  33     InfoExtractors to be registered in a given order. When it is passed
  34     a URL, the file downloader handles it to the first InfoExtractor it
  35     finds that reports being able to handle it. The InfoExtractor extracts
  36     all the information about the video or videos the URL refers to, and
  37     asks the FileDownloader to process the video information, possibly
  38     downloading the video.
  39
  40     File downloaders accept a lot of parameters. In order not to saturate
  41     the object constructor with arguments, it receives a dictionary of
  42     options instead. These options are available through the params
  43     attribute for the InfoExtractors to use. The FileDownloader also
  44     registers itself as the downloader in charge for the InfoExtractors
  45     that are added to it, so this is a "mutual registration".
  46
  47     Available options:
  48
  49     username:          Username for authentication purposes.
  50     password:          Password for authentication purposes.
  51     usenetrc:          Use netrc for authentication instead.
  52     quiet:             Do not print messages to stdout.
  53     forceurl:          Force printing final URL.
  54     forcetitle:        Force printing title.
  55     forcethumbnail:    Force printing thumbnail URL.
  56     forcedescription:  Force printing description.
  57     forcefilename:     Force printing final filename.
  58     simulate:          Do not download the video files.
  59     format:            Video format code.
  60     format_limit:      Highest quality format to try.
  61     outtmpl:           Template for output names.
  62     restrictfilenames: Do not allow "&" and spaces in file names
  63     ignoreerrors:      Do not stop on download errors.
  64     ratelimit:         Download speed limit, in bytes/sec.
  65     nooverwrites:      Prevent overwriting files.
  66     retries:           Number of times to retry for HTTP error 5xx
  67     buffersize:        Size of download buffer in bytes.
  68     noresizebuffer:    Do not automatically resize the download buffer.
  69     continuedl:        Try to continue downloads if possible.
  70     noprogress:        Do not print the progress bar.
  71     playliststart:     Playlist item to start at.
  72     playlistend:       Playlist item to end at.
  73     matchtitle:        Download only matching titles.
  74     rejecttitle:       Reject downloads for matching titles.
  75     logtostderr:       Log messages to stderr instead of stdout.
  76     consoletitle:      Display progress in console window's titlebar.
  77     nopart:            Do not use temporary .part files.
  78     updatetime:        Use the Last-modified header to set output file timestamps.
  79     writedescription:  Write the video description to a .description file
  80     writeinfojson:     Write the video description to a .info.json file
  81     writesubtitles:    Write the video subtitles to a .srt file
  82     subtitleslang:     Language of the subtitles to download
  83     test:              Download only first bytes to test the downloader.
  84     keepvideo:         Keep the video file after post-processing
  85     min_filesize:      Skip files smaller than this size
  86     max_filesize:      Skip files larger than this size
  87     """
  88
  89     params = None
  90     _ies = []
  91     _pps = []
  92     _download_retcode = None
  93     _num_downloads = None
  94     _screen_file = None
  95
  96     def __init__(self, params):
  97         """Create a FileDownloader object with the given options."""
  98         self._ies = []
  99         self._pps = []
 100         self._progress_hooks = []
 101         self._download_retcode = 0
 102         self._num_downloads = 0
 103         self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
 104         self.params = params
 105
 106         if '%(stitle)s' in self.params['outtmpl']:
 107             self.report_warning(u'%(stitle)s is deprecated. Use the %(title)s and the --restrict-filenames flag(which also secures %(uploader)s et al) instead.')
 108
 109     @staticmethod
 110     def format_bytes(bytes):
 111         if bytes is None:
 112             return 'N/A'
 113         if type(bytes) is str:
 114             bytes = float(bytes)
 115         if bytes == 0.0:
 116             exponent = 0
 117         else:
 118             exponent = int(math.log(bytes, 1024.0))
 119         suffix = 'bkMGTPEZY'[exponent]
 120         converted = float(bytes) / float(1024 ** exponent)
 121         return '%.2f%s' % (converted, suffix)
 122
 123     @staticmethod
 124     def calc_percent(byte_counter, data_len):
 125         if data_len is None:
 126             return '---.-%'
 127         return '%6s' % ('%3.1f%%' % (float(byte_counter) / float(data_len) * 100.0))
 128
 129     @staticmethod
 130     def calc_eta(start, now, total, current):
 131         if total is None:
 132             return '--:--'
 133         dif = now - start
 134         if current == 0 or dif < 0.001: # One millisecond
 135             return '--:--'
 136         rate = float(current) / dif
 137         eta = int((float(total) - float(current)) / rate)
 138         (eta_mins, eta_secs) = divmod(eta, 60)
 139         if eta_mins > 99:
 140             return '--:--'
 141         return '%02d:%02d' % (eta_mins, eta_secs)
 142
 143     @staticmethod
 144     def calc_speed(start, now, bytes):
 145         dif = now - start
 146         if bytes == 0 or dif < 0.001: # One millisecond
 147             return '%10s' % '---b/s'
 148         return '%10s' % ('%s/s' % FileDownloader.format_bytes(float(bytes) / dif))
 149
 150     @staticmethod
 151     def best_block_size(elapsed_time, bytes):
 152         new_min = max(bytes / 2.0, 1.0)
 153         new_max = min(max(bytes * 2.0, 1.0), 4194304) # Do not surpass 4 MB
 154         if elapsed_time < 0.001:
 155             return int(new_max)
 156         rate = bytes / elapsed_time
 157         if rate > new_max:
 158             return int(new_max)
 159         if rate < new_min:
 160             return int(new_min)
 161         return int(rate)
 162
 163     @staticmethod
 164     def parse_bytes(bytestr):
 165         """Parse a string indicating a byte quantity into an integer."""
 166         matchobj = re.match(r'(?i)^(\d+(?:\.\d+)?)([kMGTPEZY]?)$', bytestr)
 167         if matchobj is None:
 168             return None
 169         number = float(matchobj.group(1))
 170         multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
 171         return int(round(number * multiplier))
 172
 173     def add_info_extractor(self, ie):
 174         """Add an InfoExtractor object to the end of the list."""
 175         self._ies.append(ie)
 176         ie.set_downloader(self)
 177
 178     def add_post_processor(self, pp):
 179         """Add a PostProcessor object to the end of the chain."""
 180         self._pps.append(pp)
 181         pp.set_downloader(self)
 182
 183     def to_screen(self, message, skip_eol=False):
 184         """Print message to stdout if not in quiet mode."""
 185         assert type(message) == type(u'')
 186         if not self.params.get('quiet', False):
 187             terminator = [u'\n', u''][skip_eol]
 188             output = message + terminator
 189             if 'b' in getattr(self._screen_file, 'mode', '') or sys.version_info[0] < 3: # Python 2 lies about the mode of sys.stdout/sys.stderr
 190                 output = output.encode(preferredencoding(), 'ignore')
 191             self._screen_file.write(output)
 192             self._screen_file.flush()
 193
 194     def to_stderr(self, message):
 195         """Print message to stderr."""
 196         assert type(message) == type(u'')
 197         output = message + u'\n'
 198         if 'b' in getattr(self._screen_file, 'mode', '') or sys.version_info[0] < 3: # Python 2 lies about the mode of sys.stdout/sys.stderr
 199             output = output.encode(preferredencoding())
 200         sys.stderr.write(output)
 201
 202     def to_cons_title(self, message):
 203         """Set console/terminal window title to message."""
 204         if not self.params.get('consoletitle', False):
 205             return
 206         if os.name == 'nt' and ctypes.windll.kernel32.GetConsoleWindow():
 207             # c_wchar_p() might not be necessary if `message` is
 208             # already of type unicode()
 209             ctypes.windll.kernel32.SetConsoleTitleW(ctypes.c_wchar_p(message))
 210         elif 'TERM' in os.environ:
 211             self.to_screen('\033]0;%s\007' % message, skip_eol=True)
 212
 213     def fixed_template(self):
 214         """Checks if the output template is fixed."""
 215         return (re.search(u'(?u)%\\(.+?\\)s', self.params['outtmpl']) is None)
 216
 217     def trouble(self, message=None, tb=None):
 218         """Determine action to take when a download problem appears.
 219
 220         Depending on if the downloader has been configured to ignore
 221         download errors or not, this method may throw an exception or
 222         not when errors are found, after printing the message.
 223
 224         tb, if given, is additional traceback information.
 225         """
 226         if message is not None:
 227             self.to_stderr(message)
 228         if self.params.get('verbose'):
 229             if tb is None:
 230                 tb_data = traceback.format_list(traceback.extract_stack())
 231                 tb = u''.join(tb_data)
 232             self.to_stderr(tb)
 233         if not self.params.get('ignoreerrors', False):
 234             raise DownloadError(message)
 235         self._download_retcode = 1
 236
 237     def report_warning(self, message):
 238         '''
 239         Print the message to stderr, it will be prefixed with 'WARNING:'
 240         If stderr is a tty file the 'WARNING:' will be colored
 241         '''
 242         if sys.stderr.isatty():
 243             _msg_header=u'\033[0;33mWARNING:\033[0m'
 244         else:
 245             _msg_header=u'WARNING:'
 246         warning_message=u'%s %s' % (_msg_header,message)
 247         self.to_stderr(warning_message)
 248
 249     def slow_down(self, start_time, byte_counter):
 250         """Sleep if the download speed is over the rate limit."""
 251         rate_limit = self.params.get('ratelimit', None)
 252         if rate_limit is None or byte_counter == 0:
 253             return
 254         now = time.time()
 255         elapsed = now - start_time
 256         if elapsed <= 0.0:
 257             return
 258         speed = float(byte_counter) / elapsed
 259         if speed > rate_limit:
 260             time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
 261
 262     def temp_name(self, filename):
 263         """Returns a temporary filename for the given filename."""
 264         if self.params.get('nopart', False) or filename == u'-' or \
 265                 (os.path.exists(encodeFilename(filename)) and not os.path.isfile(encodeFilename(filename))):
 266             return filename
 267         return filename + u'.part'
 268
 269     def undo_temp_name(self, filename):
 270         if filename.endswith(u'.part'):
 271             return filename[:-len(u'.part')]
 272         return filename
 273
 274     def try_rename(self, old_filename, new_filename):
 275         try:
 276             if old_filename == new_filename:
 277                 return
 278             os.rename(encodeFilename(old_filename), encodeFilename(new_filename))
 279         except (IOError, OSError) as err:
 280             self.trouble(u'ERROR: unable to rename file')
 281
 282     def try_utime(self, filename, last_modified_hdr):
 283         """Try to set the last-modified time of the given file."""
 284         if last_modified_hdr is None:
 285             return
 286         if not os.path.isfile(encodeFilename(filename)):
 287             return
 288         timestr = last_modified_hdr
 289         if timestr is None:
 290             return
 291         filetime = timeconvert(timestr)
 292         if filetime is None:
 293             return filetime
 294         try:
 295             os.utime(filename, (time.time(), filetime))
 296         except:
 297             pass
 298         return filetime
 299
 300     def report_writedescription(self, descfn):
 301         """ Report that the description file is being written """
 302         self.to_screen(u'[info] Writing video description to: ' + descfn)
 303
 304     def report_writesubtitles(self, srtfn):
 305         """ Report that the subtitles file is being written """
 306         self.to_screen(u'[info] Writing video subtitles to: ' + srtfn)
 307
 308     def report_writeinfojson(self, infofn):
 309         """ Report that the metadata file has been written """
 310         self.to_screen(u'[info] Video description metadata as JSON to: ' + infofn)
 311
 312     def report_destination(self, filename):
 313         """Report destination filename."""
 314         self.to_screen(u'[download] Destination: ' + filename)
 315
 316     def report_progress(self, percent_str, data_len_str, speed_str, eta_str):
 317         """Report download progress."""
 318         if self.params.get('noprogress', False):
 319             return
 320         if self.params.get('progress_with_newline', False):
 321             self.to_screen(u'[download] %s of %s at %s ETA %s' %
 322                 (percent_str, data_len_str, speed_str, eta_str))
 323         else:
 324             self.to_screen(u'\r[download] %s of %s at %s ETA %s' %
 325                 (percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
 326         self.to_cons_title(u'youtube-dl - %s of %s at %s ETA %s' %
 327                 (percent_str.strip(), data_len_str.strip(), speed_str.strip(), eta_str.strip()))
 328
 329     def report_resuming_byte(self, resume_len):
 330         """Report attempt to resume at given byte."""
 331         self.to_screen(u'[download] Resuming download at byte %s' % resume_len)
 332
 333     def report_retry(self, count, retries):
 334         """Report retry in case of HTTP error 5xx"""
 335         self.to_screen(u'[download] Got server HTTP error. Retrying (attempt %d of %d)...' % (count, retries))
 336
 337     def report_file_already_downloaded(self, file_name):
 338         """Report file has already been fully downloaded."""
 339         try:
 340             self.to_screen(u'[download] %s has already been downloaded' % file_name)
 341         except (UnicodeEncodeError) as err:
 342             self.to_screen(u'[download] The file has already been downloaded')
 343
 344     def report_unable_to_resume(self):
 345         """Report it was impossible to resume download."""
 346         self.to_screen(u'[download] Unable to resume')
 347
 348     def report_finish(self):
 349         """Report download finished."""
 350         if self.params.get('noprogress', False):
 351             self.to_screen(u'[download] Download completed')
 352         else:
 353             self.to_screen(u'')
 354
 355     def increment_downloads(self):
 356         """Increment the ordinal that assigns a number to each file."""
 357         self._num_downloads += 1
 358
 359     def prepare_filename(self, info_dict):
 360         """Generate the output filename."""
 361         try:
 362             template_dict = dict(info_dict)
 363
 364             template_dict['epoch'] = int(time.time())
 365             template_dict['autonumber'] = u'%05d' % self._num_downloads
 366
 367             sanitize = lambda k,v: sanitize_filename(
 368                 u'NA' if v is None else compat_str(v),
 369                 restricted=self.params.get('restrictfilenames'),
 370                 is_id=(k==u'id'))
 371             template_dict = dict((k, sanitize(k, v)) for k,v in template_dict.items())
 372
 373             filename = self.params['outtmpl'] % template_dict
 374             return filename
 375         except (ValueError, KeyError) as err:
 376             self.trouble(u'ERROR: invalid system charset or erroneous output template')
 377             return None
 378
 379     def _match_entry(self, info_dict):
 380         """ Returns None iff the file should be downloaded """
 381
 382         title = info_dict['title']
 383         matchtitle = self.params.get('matchtitle', False)
 384         if matchtitle:
 385             if not re.search(matchtitle, title, re.IGNORECASE):
 386                 return u'[download] "' + title + '" title did not match pattern "' + matchtitle + '"'
 387         rejecttitle = self.params.get('rejecttitle', False)
 388         if rejecttitle:
 389             if re.search(rejecttitle, title, re.IGNORECASE):
 390                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
 391         return None
 392
 393     def extract_info(self, url):
 394         '''
 395         Returns a list with a dictionary for each video we find.
 396          '''
 397         suitable_found = False
 398         for ie in self._ies:
 399             # Go to next InfoExtractor if not suitable
 400             if not ie.suitable(url):
 401                 continue
 402
 403             # Warn if the _WORKING attribute is False
 404             if not ie.working():
 405                 self.to_stderr(u'WARNING: the program functionality for this site has been marked as broken, '
 406                                u'and will probably not work. If you want to go on, use the -i option.')
 407
 408             # Suitable InfoExtractor found
 409             suitable_found = True
 410
 411             # Extract information from URL and process it
 412             try:
 413                 videos = ie.extract(url)
 414                 for video in videos or []:
 415                     if not 'extractor' in video:
 416                         #The extractor has already been set somewher else
 417                         video['extractor'] = ie.IE_NAME
 418                 return videos
 419             except ExtractorError as de: # An error we somewhat expected
 420                 self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
 421                 break
 422             except Exception as e:
 423                 if self.params.get('ignoreerrors', False):
 424                     self.trouble(u'ERROR: ' + compat_str(e), tb=compat_str(traceback.format_exc()))
 425                     break
 426                 else:
 427                     raise
 428         if not suitable_found:
 429                 self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
 430     def extract_info_iterable(self, urls):
 431         '''
 432             Return the videos founded for the urls
 433         '''
 434         results = []
 435         for url in urls:
 436             results.extend(self.extract_info(url))
 437         return results
 438
 439     def process_info(self, info_dict):
 440         """Process a single dictionary returned by an InfoExtractor."""
 441
 442         # Keep for backwards compatibility
 443         info_dict['stitle'] = info_dict['title']
 444
 445         if not 'format' in info_dict:
 446             info_dict['format'] = info_dict['ext']
 447
 448         reason = self._match_entry(info_dict)
 449         if reason is not None:
 450             self.to_screen(u'[download] ' + reason)
 451             return
 452
 453         max_downloads = self.params.get('max_downloads')
 454         if max_downloads is not None:
 455             if self._num_downloads > int(max_downloads):
 456                 raise MaxDownloadsReached()
 457
 458         filename = self.prepare_filename(info_dict)
 459
 460         # Forced printings
 461         if self.params.get('forcetitle', False):
 462             compat_print(info_dict['title'])
 463         if self.params.get('forceurl', False):
 464             compat_print(info_dict['url'])
 465         if self.params.get('forcethumbnail', False) and 'thumbnail' in info_dict:
 466             compat_print(info_dict['thumbnail'])
 467         if self.params.get('forcedescription', False) and 'description' in info_dict:
 468             compat_print(info_dict['description'])
 469         if self.params.get('forcefilename', False) and filename is not None:
 470             compat_print(filename)
 471         if self.params.get('forceformat', False):
 472             compat_print(info_dict['format'])
 473
 474         # Do nothing else if in simulate mode
 475         if self.params.get('simulate', False):
 476             return
 477
 478         if filename is None:
 479             return
 480
 481         try:
 482             dn = os.path.dirname(encodeFilename(filename))
 483             if dn != '' and not os.path.exists(dn): # dn is already encoded
 484                 os.makedirs(dn)
 485         except (OSError, IOError) as err:
 486             self.trouble(u'ERROR: unable to create directory ' + compat_str(err))
 487             return
 488
 489         if self.params.get('writedescription', False):
 490             try:
 491                 descfn = filename + u'.description'
 492                 self.report_writedescription(descfn)
 493                 with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
 494                     descfile.write(info_dict['description'])
 495             except (OSError, IOError):
 496                 self.trouble(u'ERROR: Cannot write description file ' + descfn)
 497                 return
 498
 499         if self.params.get('writesubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
 500             # subtitles download errors are already managed as troubles in relevant IE
 501             # that way it will silently go on when used with unsupporting IE
 502             try:
 503                 srtfn = filename.rsplit('.', 1)[0] + u'.srt'
 504                 self.report_writesubtitles(srtfn)
 505                 with io.open(encodeFilename(srtfn), 'w', encoding='utf-8') as srtfile:
 506                     srtfile.write(info_dict['subtitles'])
 507             except (OSError, IOError):
 508                 self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
 509                 return
 510
 511         if self.params.get('writeinfojson', False):
 512             infofn = filename + u'.info.json'
 513             self.report_writeinfojson(infofn)
 514             try:
 515                 json_info_dict = dict((k, v) for k,v in info_dict.items() if not k in ['urlhandle'])
 516                 write_json_file(json_info_dict, encodeFilename(infofn))
 517             except (OSError, IOError):
 518                 self.trouble(u'ERROR: Cannot write metadata to JSON file ' + infofn)
 519                 return
 520
 521         if not self.params.get('skip_download', False):
 522             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(filename)):
 523                 success = True
 524             else:
 525                 try:
 526                     success = self._do_download(filename, info_dict)
 527                 except (OSError, IOError) as err:
 528                     raise UnavailableVideoError()
 529                 except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 530                     self.trouble(u'ERROR: unable to download video data: %s' % str(err))
 531                     return
 532                 except (ContentTooShortError, ) as err:
 533                     self.trouble(u'ERROR: content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
 534                     return
 535
 536             if success:
 537                 try:
 538                     self.post_process(filename, info_dict)
 539                 except (PostProcessingError) as err:
 540                     self.trouble(u'ERROR: postprocessing: %s' % str(err))
 541                     return
 542
 543     def download(self, url_list):
 544         """Download a given list of URLs."""
 545         if len(url_list) > 1 and self.fixed_template():
 546             raise SameFileError(self.params['outtmpl'])
 547
 548         for url in url_list:
 549             videos = self.extract_info(url)
 550
 551             for video in videos or []:
 552                 try:
 553                     self.increment_downloads()
 554                     self.process_info(video)
 555                 except UnavailableVideoError:
 556                     self.trouble(u'\nERROR: unable to download video')
 557
 558         return self._download_retcode
 559
 560     def post_process(self, filename, ie_info):
 561         """Run all the postprocessors on the given file."""
 562         info = dict(ie_info)
 563         info['filepath'] = filename
 564         keep_video = None
 565         for pp in self._pps:
 566             try:
 567                 keep_video_wish,new_info = pp.run(info)
 568                 if keep_video_wish is not None:
 569                     if keep_video_wish:
 570                         keep_video = keep_video_wish
 571                     elif keep_video is None:
 572                         # No clear decision yet, let IE decide
 573                         keep_video = keep_video_wish
 574             except PostProcessingError as e:
 575                 self.to_stderr(u'ERROR: ' + e.msg)
 576         if keep_video is False and not self.params.get('keepvideo', False):
 577             try:
 578                 self.to_screen(u'Deleting original file %s (pass -k to keep)' % filename)
 579                 os.remove(encodeFilename(filename))
 580             except (IOError, OSError):
 581                 self.report_warning(u'Unable to remove downloaded video file')
 582
 583     def _download_with_rtmpdump(self, filename, url, player_url, page_url):
 584         self.report_destination(filename)
 585         tmpfilename = self.temp_name(filename)
 586
 587         # Check for rtmpdump first
 588         try:
 589             subprocess.call(['rtmpdump', '-h'], stdout=(open(os.path.devnull, 'w')), stderr=subprocess.STDOUT)
 590         except (OSError, IOError):
 591             self.trouble(u'ERROR: RTMP download detected but "rtmpdump" could not be run')
 592             return False
 593
 594         # Download using rtmpdump. rtmpdump returns exit code 2 when
 595         # the connection was interrumpted and resuming appears to be
 596         # possible. This is part of rtmpdump's normal usage, AFAIK.
 597         basic_args = ['rtmpdump', '-q', '-r', url, '-o', tmpfilename]
 598         if player_url is not None:
 599             basic_args += ['-W', player_url]
 600         if page_url is not None:
 601             basic_args += ['--pageUrl', page_url]
 602         args = basic_args + [[], ['-e', '-k', '1']][self.params.get('continuedl', False)]
 603         if self.params.get('verbose', False):
 604             try:
 605                 import pipes
 606                 shell_quote = lambda args: ' '.join(map(pipes.quote, args))
 607             except ImportError:
 608                 shell_quote = repr
 609             self.to_screen(u'[debug] rtmpdump command line: ' + shell_quote(args))
 610         retval = subprocess.call(args)
 611         while retval == 2 or retval == 1:
 612             prevsize = os.path.getsize(encodeFilename(tmpfilename))
 613             self.to_screen(u'\r[rtmpdump] %s bytes' % prevsize, skip_eol=True)
 614             time.sleep(5.0) # This seems to be needed
 615             retval = subprocess.call(basic_args + ['-e'] + [[], ['-k', '1']][retval == 1])
 616             cursize = os.path.getsize(encodeFilename(tmpfilename))
 617             if prevsize == cursize and retval == 1:
 618                 break
 619              # Some rtmp streams seem abort after ~ 99.8%. Don't complain for those
 620             if prevsize == cursize and retval == 2 and cursize > 1024:
 621                 self.to_screen(u'\r[rtmpdump] Could not download the whole video. This can happen for some advertisements.')
 622                 retval = 0
 623                 break
 624         if retval == 0:
 625             fsize = os.path.getsize(encodeFilename(tmpfilename))
 626             self.to_screen(u'\r[rtmpdump] %s bytes' % fsize)
 627             self.try_rename(tmpfilename, filename)
 628             self._hook_progress({
 629                 'downloaded_bytes': fsize,
 630                 'total_bytes': fsize,
 631                 'filename': filename,
 632                 'status': 'finished',
 633             })
 634             return True
 635         else:
 636             self.trouble(u'\nERROR: rtmpdump exited with code %d' % retval)
 637             return False
 638
 639     def _do_download(self, filename, info_dict):
 640         url = info_dict['url']
 641
 642         # Check file already present
 643         if self.params.get('continuedl', False) and os.path.isfile(encodeFilename(filename)) and not self.params.get('nopart', False):
 644             self.report_file_already_downloaded(filename)
 645             self._hook_progress({
 646                 'filename': filename,
 647                 'status': 'finished',
 648             })
 649             return True
 650
 651         # Attempt to download using rtmpdump
 652         if url.startswith('rtmp'):
 653             return self._download_with_rtmpdump(filename, url,
 654                                                 info_dict.get('player_url', None),
 655                                                 info_dict.get('page_url', None))
 656
 657         tmpfilename = self.temp_name(filename)
 658         stream = None
 659
 660         # Do not include the Accept-Encoding header
 661         headers = {'Youtubedl-no-compression': 'True'}
 662         if 'user_agent' in info_dict:
 663             headers['Youtubedl-user-agent'] = info_dict['user_agent']
 664         basic_request = compat_urllib_request.Request(url, None, headers)
 665         request = compat_urllib_request.Request(url, None, headers)
 666
 667         if self.params.get('test', False):
 668             request.add_header('Range','bytes=0-10240')
 669
 670         # Establish possible resume length
 671         if os.path.isfile(encodeFilename(tmpfilename)):
 672             resume_len = os.path.getsize(encodeFilename(tmpfilename))
 673         else:
 674             resume_len = 0
 675
 676         open_mode = 'wb'
 677         if resume_len != 0:
 678             if self.params.get('continuedl', False):
 679                 self.report_resuming_byte(resume_len)
 680                 request.add_header('Range','bytes=%d-' % resume_len)
 681                 open_mode = 'ab'
 682             else:
 683                 resume_len = 0
 684
 685         count = 0
 686         retries = self.params.get('retries', 0)
 687         while count <= retries:
 688             # Establish connection
 689             try:
 690                 if count == 0 and 'urlhandle' in info_dict:
 691                     data = info_dict['urlhandle']
 692                 data = compat_urllib_request.urlopen(request)
 693                 break
 694             except (compat_urllib_error.HTTPError, ) as err:
 695                 if (err.code < 500 or err.code >= 600) and err.code != 416:
 696                     # Unexpected HTTP error
 697                     raise
 698                 elif err.code == 416:
 699                     # Unable to resume (requested range not satisfiable)
 700                     try:
 701                         # Open the connection again without the range header
 702                         data = compat_urllib_request.urlopen(basic_request)
 703                         content_length = data.info()['Content-Length']
 704                     except (compat_urllib_error.HTTPError, ) as err:
 705                         if err.code < 500 or err.code >= 600:
 706                             raise
 707                     else:
 708                         # Examine the reported length
 709                         if (content_length is not None and
 710                                 (resume_len - 100 < int(content_length) < resume_len + 100)):
 711                             # The file had already been fully downloaded.
 712                             # Explanation to the above condition: in issue #175 it was revealed that
 713                             # YouTube sometimes adds or removes a few bytes from the end of the file,
 714                             # changing the file size slightly and causing problems for some users. So
 715                             # I decided to implement a suggested change and consider the file
 716                             # completely downloaded if the file size differs less than 100 bytes from
 717                             # the one in the hard drive.
 718                             self.report_file_already_downloaded(filename)
 719                             self.try_rename(tmpfilename, filename)
 720                             self._hook_progress({
 721                                 'filename': filename,
 722                                 'status': 'finished',
 723                             })
 724                             return True
 725                         else:
 726                             # The length does not match, we start the download over
 727                             self.report_unable_to_resume()
 728                             open_mode = 'wb'
 729                             break
 730             # Retry
 731             count += 1
 732             if count <= retries:
 733                 self.report_retry(count, retries)
 734
 735         if count > retries:
 736             self.trouble(u'ERROR: giving up after %s retries' % retries)
 737             return False
 738
 739         data_len = data.info().get('Content-length', None)
 740         if data_len is not None:
 741             data_len = int(data_len) + resume_len
 742             min_data_len = self.params.get("min_filesize", None)
 743             max_data_len =  self.params.get("max_filesize", None)
 744             if min_data_len is not None and data_len < min_data_len:
 745                 self.to_screen(u'\r[download] File is smaller than min-filesize (%s bytes < %s bytes). Aborting.' % (data_len, min_data_len))
 746                 return False
 747             if max_data_len is not None and data_len > max_data_len:
 748                 self.to_screen(u'\r[download] File is larger than max-filesize (%s bytes > %s bytes). Aborting.' % (data_len, max_data_len))
 749                 return False
 750
 751         data_len_str = self.format_bytes(data_len)
 752         byte_counter = 0 + resume_len
 753         block_size = self.params.get('buffersize', 1024)
 754         start = time.time()
 755         while True:
 756             # Download and write
 757             before = time.time()
 758             data_block = data.read(block_size)
 759             after = time.time()
 760             if len(data_block) == 0:
 761                 break
 762             byte_counter += len(data_block)
 763
 764             # Open file just in time
 765             if stream is None:
 766                 try:
 767                     (stream, tmpfilename) = sanitize_open(tmpfilename, open_mode)
 768                     assert stream is not None
 769                     filename = self.undo_temp_name(tmpfilename)
 770                     self.report_destination(filename)
 771                 except (OSError, IOError) as err:
 772                     self.trouble(u'ERROR: unable to open for writing: %s' % str(err))
 773                     return False
 774             try:
 775                 stream.write(data_block)
 776             except (IOError, OSError) as err:
 777                 self.trouble(u'\nERROR: unable to write data: %s' % str(err))
 778                 return False
 779             if not self.params.get('noresizebuffer', False):
 780                 block_size = self.best_block_size(after - before, len(data_block))
 781
 782             # Progress message
 783             speed_str = self.calc_speed(start, time.time(), byte_counter - resume_len)
 784             if data_len is None:
 785                 self.report_progress('Unknown %', data_len_str, speed_str, 'Unknown ETA')
 786             else:
 787                 percent_str = self.calc_percent(byte_counter, data_len)
 788                 eta_str = self.calc_eta(start, time.time(), data_len - resume_len, byte_counter - resume_len)
 789                 self.report_progress(percent_str, data_len_str, speed_str, eta_str)
 790
 791             self._hook_progress({
 792                 'downloaded_bytes': byte_counter,
 793                 'total_bytes': data_len,
 794                 'tmpfilename': tmpfilename,
 795                 'filename': filename,
 796                 'status': 'downloading',
 797             })
 798
 799             # Apply rate limit
 800             self.slow_down(start, byte_counter - resume_len)
 801
 802         if stream is None:
 803             self.trouble(u'\nERROR: Did not get any data blocks')
 804             return False
 805         stream.close()
 806         self.report_finish()
 807         if data_len is not None and byte_counter != data_len:
 808             raise ContentTooShortError(byte_counter, int(data_len))
 809         self.try_rename(tmpfilename, filename)
 810
 811         # Update file modification time
 812         if self.params.get('updatetime', True):
 813             info_dict['filetime'] = self.try_utime(filename, data.info().get('last-modified', None))
 814
 815         self._hook_progress({
 816             'downloaded_bytes': byte_counter,
 817             'total_bytes': byte_counter,
 818             'filename': filename,
 819             'status': 'finished',
 820         })
 821
 822         return True
 823
 824     def _hook_progress(self, status):
 825         for ph in self._progress_hooks:
 826             ph(status)
 827
 828     def add_progress_hook(self, ph):
 829         """ ph gets called on download progress, with a dictionary with the entries
 830         * filename: The final filename
 831         * status: One of "downloading" and "finished"
 832
 833         It can also have some of the following entries:
 834
 835         * downloaded_bytes: Bytes on disks
 836         * total_bytes: Total bytes, None if unknown
 837         * tmpfilename: The filename we're currently writing to
 838
 839         Hooks are guaranteed to be called at least once (with status "finished")
 840         if the download is successful.
 841         """
 842         self._progress_hooks.append(ph)