error_message = u'%s %s' % (_msg_header, message)
self.trouble(error_message, tb)
- def slow_down(self, start_time, byte_counter):
- """Sleep if the download speed is over the rate limit."""
- rate_limit = self.params.get('ratelimit', None)
- if rate_limit is None or byte_counter == 0:
- return
- now = time.time()
- elapsed = now - start_time
- if elapsed <= 0.0:
- return
- speed = float(byte_counter) / elapsed
- if speed > rate_limit:
- time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
-
def report_writedescription(self, descfn):
""" Report that the description file is being written """
self.to_screen(u'[info] Writing video description to: ' + descfn)
result_type = ie_result.get('_type', 'video') # If not given we suppose it's a video, support the default old system
if result_type == 'video':
ie_result.update(extra_info)
- if 'playlist' not in ie_result:
- # It isn't part of a playlist
- ie_result['playlist'] = None
- ie_result['playlist_index'] = None
- if download:
- self.process_info(ie_result)
- return ie_result
+ return self.process_video_result(ie_result)
elif result_type == 'url':
# We have to add extra_info to the results because it may be
# contained in a playlist
else:
raise Exception('Invalid result type: %s' % result_type)
+ def select_format(self, format_spec, available_formats):
+ if format_spec == 'best' or format_spec is None:
+ return available_formats[-1]
+ elif format_spec == 'worst':
+ return available_formats[0]
+ else:
+ extensions = [u'mp4', u'flv', u'webm', u'3gp']
+ if format_spec in extensions:
+ filter_f = lambda f: f['ext'] == format_spec
+ else:
+ filter_f = lambda f: f['format_id'] == format_spec
+ matches = list(filter(filter_f ,available_formats))
+ if matches:
+ return matches[-1]
+ return None
+
+ def process_video_result(self, info_dict, download=True):
+ assert info_dict.get('_type', 'video') == 'video'
+
+ if 'playlist' not in info_dict:
+ # It isn't part of a playlist
+ info_dict['playlist'] = None
+ info_dict['playlist_index'] = None
+
+ # This extractors handle format selection themselves
+ if info_dict['extractor'] in [u'youtube', u'Youku', u'YouPorn', u'mixcloud']:
+ self.process_info(info_dict)
+ return info_dict
+
+ # We now pick which formats have to be downloaded
+ if info_dict.get('formats') is None:
+ # There's only one format available
+ formats = [info_dict]
+ else:
+ formats = info_dict['formats']
+
+ # We check that all the formats have the format and format_id fields
+ for (i, format) in enumerate(formats):
+ if format.get('format_id') is None:
+ format['format_id'] = compat_str(i)
+ if format.get('format') is None:
+ format['format'] = u'{id} - {res}{note}'.format(
+ id=format['format_id'],
+ res=self.format_resolution(format),
+ note = u' ({})'.format(format['format_note']) if format.get('format_note') is not None else '',
+ )
+
+ if self.params.get('listformats', None):
+ self.list_formats(info_dict)
+ return
+
+ format_limit = self.params.get('format_limit', None)
+ if format_limit:
+ formats = list(takewhile_inclusive(
+ lambda f: f['format_id'] != format_limit, formats
+ ))
+ if self.params.get('prefer_free_formats'):
+ def _free_formats_key(f):
+ try:
+ ext_ord = [u'flv', u'mp4', u'webm'].index(f['ext'])
+ except ValueError:
+ ext_ord = -1
+ # We only compare the extension if they have the same height and width
+ return (f.get('height'), f.get('width'), ext_ord)
+ formats = sorted(formats, key=_free_formats_key)
+
+ req_format = self.params.get('format', 'best')
+ if req_format is None:
+ req_format = 'best'
+ formats_to_download = []
+ # The -1 is for supporting YoutubeIE
+ if req_format in ('-1', 'all'):
+ formats_to_download = formats
+ else:
+ # We can accept formats requestd in the format: 34/5/best, we pick
+ # the first that is available, starting from left
+ req_formats = req_format.split('/')
+ for rf in req_formats:
+ selected_format = self.select_format(rf, formats)
+ if selected_format is not None:
+ formats_to_download = [selected_format]
+ break
+ if not formats_to_download:
+ raise ExtractorError(u'requested format not available')
+
+ if download:
+ if len(formats_to_download) > 1:
+ self.to_screen(u'[info] %s: downloading video in %s formats' % (info_dict['id'], len(formats_to_download)))
+ for format in formats_to_download:
+ new_info = dict(info_dict)
+ new_info.update(format)
+ self.process_info(new_info)
+ # We update the info dict with the best quality format (backwards compatibility)
+ info_dict.update(formats_to_download[-1])
+ return info_dict
+
def process_info(self, info_dict):
"""Process a single resolved IE result."""
vid_id = info_dict['extractor'] + u' ' + info_dict['id']
with locked_file(fn, 'a', encoding='utf-8') as archive_file:
archive_file.write(vid_id + u'\n')
+
+ @staticmethod
+ def format_resolution(format):
+ if format.get('height') is not None:
+ if format.get('width') is not None:
+ res = u'%sx%s' % (format['width'], format['height'])
+ else:
+ res = u'%sp' % format['height']
+ else:
+ res = '???'
+ return res
+
+ def list_formats(self, info_dict):
+ formats_s = []
+ for format in info_dict.get('formats', [info_dict]):
+ formats_s.append(u'%-15s: %-5s %-15s[%s]' % (
+ format['format_id'],
+ format['ext'],
+ format.get('format_note') or '-',
+ self.format_resolution(format),
+ )
+ )
+ if len(formats_s) != 1:
+ formats_s[0] += ' (worst)'
+ formats_s[-1] += ' (best)'
+ formats_s = "\n".join(formats_s)
+ self.to_screen(u'[info] Available formats for %s:\n'
+ u'format code extension note resolution\n%s' % (
+ info_dict['id'], formats_s))
projects / youtube-dl / blobdiff