_ Git - youtube-dl/blob - youtube_dl/extractor/common.py

   1 from __future__ import unicode_literals
   2
   3 import base64
   4 import datetime
   5 import hashlib
   6 import json
   7 import netrc
   8 import os
   9 import re
  10 import socket
  11 import sys
  12 import time
  13 import math
  14
  15 from ..compat import (
  16     compat_cookiejar,
  17     compat_cookies,
  18     compat_etree_fromstring,
  19     compat_getpass,
  20     compat_http_client,
  21     compat_os_name,
  22     compat_str,
  23     compat_urllib_error,
  24     compat_urllib_parse_unquote,
  25     compat_urllib_parse_urlencode,
  26     compat_urllib_request,
  27     compat_urlparse,
  28 )
  29 from ..downloader.f4m import remove_encrypted_media
  30 from ..utils import (
  31     NO_DEFAULT,
  32     age_restricted,
  33     base_url,
  34     bug_reports_message,
  35     clean_html,
  36     compiled_regex_type,
  37     determine_ext,
  38     error_to_compat_str,
  39     ExtractorError,
  40     fix_xml_ampersands,
  41     float_or_none,
  42     int_or_none,
  43     parse_iso8601,
  44     RegexNotFoundError,
  45     sanitize_filename,
  46     sanitized_Request,
  47     unescapeHTML,
  48     unified_strdate,
  49     unified_timestamp,
  50     url_basename,
  51     xpath_element,
  52     xpath_text,
  53     xpath_with_ns,
  54     determine_protocol,
  55     parse_duration,
  56     mimetype2ext,
  57     update_Request,
  58     update_url_query,
  59     parse_m3u8_attributes,
  60     extract_attributes,
  61     parse_codecs,
  62 )
  63
  64
  65 class InfoExtractor(object):
  66     """Information Extractor class.
  67
  68     Information extractors are the classes that, given a URL, extract
  69     information about the video (or videos) the URL refers to. This
  70     information includes the real video URL, the video title, author and
  71     others. The information is stored in a dictionary which is then
  72     passed to the YoutubeDL. The YoutubeDL processes this
  73     information possibly downloading the video to the file system, among
  74     other possible outcomes.
  75
  76     The type field determines the type of the result.
  77     By far the most common value (and the default if _type is missing) is
  78     "video", which indicates a single video.
  79
  80     For a video, the dictionaries must include the following fields:
  81
  82     id:             Video identifier.
  83     title:          Video title, unescaped.
  84
  85     Additionally, it must contain either a formats entry or a url one:
  86
  87     formats:        A list of dictionaries for each format available, ordered
  88                     from worst to best quality.
  89
  90                     Potential fields:
  91                     * url        Mandatory. The URL of the video file
  92                     * manifest_url
  93                                  The URL of the manifest file in case of
  94                                  fragmented media (DASH, hls, hds)
  95                     * ext        Will be calculated from URL if missing
  96                     * format     A human-readable description of the format
  97                                  ("mp4 container with h264/opus").
  98                                  Calculated from the format_id, width, height.
  99                                  and format_note fields if missing.
 100                     * format_id  A short description of the format
 101                                  ("mp4_h264_opus" or "19").
 102                                 Technically optional, but strongly recommended.
 103                     * format_note Additional info about the format
 104                                  ("3D" or "DASH video")
 105                     * width      Width of the video, if known
 106                     * height     Height of the video, if known
 107                     * resolution Textual description of width and height
 108                     * tbr        Average bitrate of audio and video in KBit/s
 109                     * abr        Average audio bitrate in KBit/s
 110                     * acodec     Name of the audio codec in use
 111                     * asr        Audio sampling rate in Hertz
 112                     * vbr        Average video bitrate in KBit/s
 113                     * fps        Frame rate
 114                     * vcodec     Name of the video codec in use
 115                     * container  Name of the container format
 116                     * filesize   The number of bytes, if known in advance
 117                     * filesize_approx  An estimate for the number of bytes
 118                     * player_url SWF Player URL (used for rtmpdump).
 119                     * protocol   The protocol that will be used for the actual
 120                                  download, lower-case.
 121                                  "http", "https", "rtsp", "rtmp", "rtmpe",
 122                                  "m3u8", "m3u8_native" or "http_dash_segments".
 123                     * fragments  A list of fragments of the fragmented media,
 124                                  with the following entries:
 125                                  * "url" (mandatory) - fragment's URL
 126                                  * "duration" (optional, int or float)
 127                                  * "filesize" (optional, int)
 128                     * preference Order number of this format. If this field is
 129                                  present and not None, the formats get sorted
 130                                  by this field, regardless of all other values.
 131                                  -1 for default (order by other properties),
 132                                  -2 or smaller for less than default.
 133                                  < -1000 to hide the format (if there is
 134                                     another one which is strictly better)
 135                     * language   Language code, e.g. "de" or "en-US".
 136                     * language_preference  Is this in the language mentioned in
 137                                  the URL?
 138                                  10 if it's what the URL is about,
 139                                  -1 for default (don't know),
 140                                  -10 otherwise, other values reserved for now.
 141                     * quality    Order number of the video quality of this
 142                                  format, irrespective of the file format.
 143                                  -1 for default (order by other properties),
 144                                  -2 or smaller for less than default.
 145                     * source_preference  Order number for this video source
 146                                   (quality takes higher priority)
 147                                  -1 for default (order by other properties),
 148                                  -2 or smaller for less than default.
 149                     * http_headers  A dictionary of additional HTTP headers
 150                                  to add to the request.
 151                     * stretched_ratio  If given and not 1, indicates that the
 152                                  video's pixels are not square.
 153                                  width : height ratio as float.
 154                     * no_resume  The server does not support resuming the
 155                                  (HTTP or RTMP) download. Boolean.
 156
 157     url:            Final video URL.
 158     ext:            Video filename extension.
 159     format:         The video format, defaults to ext (used for --get-format)
 160     player_url:     SWF Player URL (used for rtmpdump).
 161
 162     The following fields are optional:
 163
 164     alt_title:      A secondary title of the video.
 165     display_id      An alternative identifier for the video, not necessarily
 166                     unique, but available before title. Typically, id is
 167                     something like "4234987", title "Dancing naked mole rats",
 168                     and display_id "dancing-naked-mole-rats"
 169     thumbnails:     A list of dictionaries, with the following entries:
 170                         * "id" (optional, string) - Thumbnail format ID
 171                         * "url"
 172                         * "preference" (optional, int) - quality of the image
 173                         * "width" (optional, int)
 174                         * "height" (optional, int)
 175                         * "resolution" (optional, string "{width}x{height"},
 176                                         deprecated)
 177                         * "filesize" (optional, int)
 178     thumbnail:      Full URL to a video thumbnail image.
 179     description:    Full video description.
 180     uploader:       Full name of the video uploader.
 181     license:        License name the video is licensed under.
 182     creator:        The creator of the video.
 183     release_date:   The date (YYYYMMDD) when the video was released.
 184     timestamp:      UNIX timestamp of the moment the video became available.
 185     upload_date:    Video upload date (YYYYMMDD).
 186                     If not explicitly set, calculated from timestamp.
 187     uploader_id:    Nickname or id of the video uploader.
 188     uploader_url:   Full URL to a personal webpage of the video uploader.
 189     location:       Physical location where the video was filmed.
 190     subtitles:      The available subtitles as a dictionary in the format
 191                     {language: subformats}. "subformats" is a list sorted from
 192                     lower to higher preference, each element is a dictionary
 193                     with the "ext" entry and one of:
 194                         * "data": The subtitles file contents
 195                         * "url": A URL pointing to the subtitles file
 196                     "ext" will be calculated from URL if missing
 197     automatic_captions: Like 'subtitles', used by the YoutubeIE for
 198                     automatically generated captions
 199     duration:       Length of the video in seconds, as an integer or float.
 200     view_count:     How many users have watched the video on the platform.
 201     like_count:     Number of positive ratings of the video
 202     dislike_count:  Number of negative ratings of the video
 203     repost_count:   Number of reposts of the video
 204     average_rating: Average rating give by users, the scale used depends on the webpage
 205     comment_count:  Number of comments on the video
 206     comments:       A list of comments, each with one or more of the following
 207                     properties (all but one of text or html optional):
 208                         * "author" - human-readable name of the comment author
 209                         * "author_id" - user ID of the comment author
 210                         * "id" - Comment ID
 211                         * "html" - Comment as HTML
 212                         * "text" - Plain text of the comment
 213                         * "timestamp" - UNIX timestamp of comment
 214                         * "parent" - ID of the comment this one is replying to.
 215                                      Set to "root" to indicate that this is a
 216                                      comment to the original video.
 217     age_limit:      Age restriction for the video, as an integer (years)
 218     webpage_url:    The URL to the video webpage, if given to youtube-dl it
 219                     should allow to get the same result again. (It will be set
 220                     by YoutubeDL if it's missing)
 221     categories:     A list of categories that the video falls in, for example
 222                     ["Sports", "Berlin"]
 223     tags:           A list of tags assigned to the video, e.g. ["sweden", "pop music"]
 224     is_live:        True, False, or None (=unknown). Whether this video is a
 225                     live stream that goes on instead of a fixed-length video.
 226     start_time:     Time in seconds where the reproduction should start, as
 227                     specified in the URL.
 228     end_time:       Time in seconds where the reproduction should end, as
 229                     specified in the URL.
 230
 231     The following fields should only be used when the video belongs to some logical
 232     chapter or section:
 233
 234     chapter:        Name or title of the chapter the video belongs to.
 235     chapter_number: Number of the chapter the video belongs to, as an integer.
 236     chapter_id:     Id of the chapter the video belongs to, as a unicode string.
 237
 238     The following fields should only be used when the video is an episode of some
 239     series, programme or podcast:
 240
 241     series:         Title of the series or programme the video episode belongs to.
 242     season:         Title of the season the video episode belongs to.
 243     season_number:  Number of the season the video episode belongs to, as an integer.
 244     season_id:      Id of the season the video episode belongs to, as a unicode string.
 245     episode:        Title of the video episode. Unlike mandatory video title field,
 246                     this field should denote the exact title of the video episode
 247                     without any kind of decoration.
 248     episode_number: Number of the video episode within a season, as an integer.
 249     episode_id:     Id of the video episode, as a unicode string.
 250
 251     The following fields should only be used when the media is a track or a part of
 252     a music album:
 253
 254     track:          Title of the track.
 255     track_number:   Number of the track within an album or a disc, as an integer.
 256     track_id:       Id of the track (useful in case of custom indexing, e.g. 6.iii),
 257                     as a unicode string.
 258     artist:         Artist(s) of the track.
 259     genre:          Genre(s) of the track.
 260     album:          Title of the album the track belongs to.
 261     album_type:     Type of the album (e.g. "Demo", "Full-length", "Split", "Compilation", etc).
 262     album_artist:   List of all artists appeared on the album (e.g.
 263                     "Ash Borer / Fell Voices" or "Various Artists", useful for splits
 264                     and compilations).
 265     disc_number:    Number of the disc or other physical medium the track belongs to,
 266                     as an integer.
 267     release_year:   Year (YYYY) when the album was released.
 268
 269     Unless mentioned otherwise, the fields should be Unicode strings.
 270
 271     Unless mentioned otherwise, None is equivalent to absence of information.
 272
 273
 274     _type "playlist" indicates multiple videos.
 275     There must be a key "entries", which is a list, an iterable, or a PagedList
 276     object, each element of which is a valid dictionary by this specification.
 277
 278     Additionally, playlists can have "title", "description" and "id" attributes
 279     with the same semantics as videos (see above).
 280
 281
 282     _type "multi_video" indicates that there are multiple videos that
 283     form a single show, for examples multiple acts of an opera or TV episode.
 284     It must have an entries key like a playlist and contain all the keys
 285     required for a video at the same time.
 286
 287
 288     _type "url" indicates that the video must be extracted from another
 289     location, possibly by a different extractor. Its only required key is:
 290     "url" - the next URL to extract.
 291     The key "ie_key" can be set to the class name (minus the trailing "IE",
 292     e.g. "Youtube") if the extractor class is known in advance.
 293     Additionally, the dictionary may have any properties of the resolved entity
 294     known in advance, for example "title" if the title of the referred video is
 295     known ahead of time.
 296
 297
 298     _type "url_transparent" entities have the same specification as "url", but
 299     indicate that the given additional information is more precise than the one
 300     associated with the resolved URL.
 301     This is useful when a site employs a video service that hosts the video and
 302     its technical metadata, but that video service does not embed a useful
 303     title, description etc.
 304
 305
 306     Subclasses of this one should re-define the _real_initialize() and
 307     _real_extract() methods and define a _VALID_URL regexp.
 308     Probably, they should also be added to the list of extractors.
 309
 310     Finally, the _WORKING attribute should be set to False for broken IEs
 311     in order to warn the users and skip the tests.
 312     """
 313
 314     _ready = False
 315     _downloader = None
 316     _WORKING = True
 317
 318     def __init__(self, downloader=None):
 319         """Constructor. Receives an optional downloader."""
 320         self._ready = False
 321         self.set_downloader(downloader)
 322
 323     @classmethod
 324     def suitable(cls, url):
 325         """Receives a URL and returns True if suitable for this IE."""
 326
 327         # This does not use has/getattr intentionally - we want to know whether
 328         # we have cached the regexp for *this* class, whereas getattr would also
 329         # match the superclass
 330         if '_VALID_URL_RE' not in cls.__dict__:
 331             cls._VALID_URL_RE = re.compile(cls._VALID_URL)
 332         return cls._VALID_URL_RE.match(url) is not None
 333
 334     @classmethod
 335     def _match_id(cls, url):
 336         if '_VALID_URL_RE' not in cls.__dict__:
 337             cls._VALID_URL_RE = re.compile(cls._VALID_URL)
 338         m = cls._VALID_URL_RE.match(url)
 339         assert m
 340         return m.group('id')
 341
 342     @classmethod
 343     def working(cls):
 344         """Getter method for _WORKING."""
 345         return cls._WORKING
 346
 347     def initialize(self):
 348         """Initializes an instance (authentication, etc)."""
 349         if not self._ready:
 350             self._real_initialize()
 351             self._ready = True
 352
 353     def extract(self, url):
 354         """Extracts URL information and returns it in list of dicts."""
 355         try:
 356             self.initialize()
 357             return self._real_extract(url)
 358         except ExtractorError:
 359             raise
 360         except compat_http_client.IncompleteRead as e:
 361             raise ExtractorError('A network error has occurred.', cause=e, expected=True)
 362         except (KeyError, StopIteration) as e:
 363             raise ExtractorError('An extractor error has occurred.', cause=e)
 364
 365     def set_downloader(self, downloader):
 366         """Sets the downloader for this IE."""
 367         self._downloader = downloader
 368
 369     def _real_initialize(self):
 370         """Real initialization process. Redefine in subclasses."""
 371         pass
 372
 373     def _real_extract(self, url):
 374         """Real extraction process. Redefine in subclasses."""
 375         pass
 376
 377     @classmethod
 378     def ie_key(cls):
 379         """A string for getting the InfoExtractor with get_info_extractor"""
 380         return compat_str(cls.__name__[:-2])
 381
 382     @property
 383     def IE_NAME(self):
 384         return compat_str(type(self).__name__[:-2])
 385
 386     def _request_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True, data=None, headers={}, query={}):
 387         """ Returns the response handle """
 388         if note is None:
 389             self.report_download_webpage(video_id)
 390         elif note is not False:
 391             if video_id is None:
 392                 self.to_screen('%s' % (note,))
 393             else:
 394                 self.to_screen('%s: %s' % (video_id, note))
 395         if isinstance(url_or_request, compat_urllib_request.Request):
 396             url_or_request = update_Request(
 397                 url_or_request, data=data, headers=headers, query=query)
 398         else:
 399             if query:
 400                 url_or_request = update_url_query(url_or_request, query)
 401             if data is not None or headers:
 402                 url_or_request = sanitized_Request(url_or_request, data, headers)
 403         try:
 404             return self._downloader.urlopen(url_or_request)
 405         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 406             if errnote is False:
 407                 return False
 408             if errnote is None:
 409                 errnote = 'Unable to download webpage'
 410
 411             errmsg = '%s: %s' % (errnote, error_to_compat_str(err))
 412             if fatal:
 413                 raise ExtractorError(errmsg, sys.exc_info()[2], cause=err)
 414             else:
 415                 self._downloader.report_warning(errmsg)
 416                 return False
 417
 418     def _download_webpage_handle(self, url_or_request, video_id, note=None, errnote=None, fatal=True, encoding=None, data=None, headers={}, query={}):
 419         """ Returns a tuple (page content as string, URL handle) """
 420         # Strip hashes from the URL (#1038)
 421         if isinstance(url_or_request, (compat_str, str)):
 422             url_or_request = url_or_request.partition('#')[0]
 423
 424         urlh = self._request_webpage(url_or_request, video_id, note, errnote, fatal, data=data, headers=headers, query=query)
 425         if urlh is False:
 426             assert not fatal
 427             return False
 428         content = self._webpage_read_content(urlh, url_or_request, video_id, note, errnote, fatal, encoding=encoding)
 429         return (content, urlh)
 430
 431     @staticmethod
 432     def _guess_encoding_from_content(content_type, webpage_bytes):
 433         m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
 434         if m:
 435             encoding = m.group(1)
 436         else:
 437             m = re.search(br'<meta[^>]+charset=[\'"]?([^\'")]+)[ /\'">]',
 438                           webpage_bytes[:1024])
 439             if m:
 440                 encoding = m.group(1).decode('ascii')
 441             elif webpage_bytes.startswith(b'\xff\xfe'):
 442                 encoding = 'utf-16'
 443             else:
 444                 encoding = 'utf-8'
 445
 446         return encoding
 447
 448     def _webpage_read_content(self, urlh, url_or_request, video_id, note=None, errnote=None, fatal=True, prefix=None, encoding=None):
 449         content_type = urlh.headers.get('Content-Type', '')
 450         webpage_bytes = urlh.read()
 451         if prefix is not None:
 452             webpage_bytes = prefix + webpage_bytes
 453         if not encoding:
 454             encoding = self._guess_encoding_from_content(content_type, webpage_bytes)
 455         if self._downloader.params.get('dump_intermediate_pages', False):
 456             try:
 457                 url = url_or_request.get_full_url()
 458             except AttributeError:
 459                 url = url_or_request
 460             self.to_screen('Dumping request to ' + url)
 461             dump = base64.b64encode(webpage_bytes).decode('ascii')
 462             self._downloader.to_screen(dump)
 463         if self._downloader.params.get('write_pages', False):
 464             try:
 465                 url = url_or_request.get_full_url()
 466             except AttributeError:
 467                 url = url_or_request
 468             basen = '%s_%s' % (video_id, url)
 469             if len(basen) > 240:
 470                 h = '___' + hashlib.md5(basen.encode('utf-8')).hexdigest()
 471                 basen = basen[:240 - len(h)] + h
 472             raw_filename = basen + '.dump'
 473             filename = sanitize_filename(raw_filename, restricted=True)
 474             self.to_screen('Saving request to ' + filename)
 475             # Working around MAX_PATH limitation on Windows (see
 476             # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx)
 477             if compat_os_name == 'nt':
 478                 absfilepath = os.path.abspath(filename)
 479                 if len(absfilepath) > 259:
 480                     filename = '\\\\?\\' + absfilepath
 481             with open(filename, 'wb') as outf:
 482                 outf.write(webpage_bytes)
 483
 484         try:
 485             content = webpage_bytes.decode(encoding, 'replace')
 486         except LookupError:
 487             content = webpage_bytes.decode('utf-8', 'replace')
 488
 489         if ('<title>Access to this site is blocked</title>' in content and
 490                 'Websense' in content[:512]):
 491             msg = 'Access to this webpage has been blocked by Websense filtering software in your network.'
 492             blocked_iframe = self._html_search_regex(
 493                 r'<iframe src="([^"]+)"', content,
 494                 'Websense information URL', default=None)
 495             if blocked_iframe:
 496                 msg += ' Visit %s for more details' % blocked_iframe
 497             raise ExtractorError(msg, expected=True)
 498         if '<title>The URL you requested has been blocked</title>' in content[:512]:
 499             msg = (
 500                 'Access to this webpage has been blocked by Indian censorship. '
 501                 'Use a VPN or proxy server (with --proxy) to route around it.')
 502             block_msg = self._html_search_regex(
 503                 r'</h1><p>(.*?)</p>',
 504                 content, 'block message', default=None)
 505             if block_msg:
 506                 msg += ' (Message: "%s")' % block_msg.replace('\n', ' ')
 507             raise ExtractorError(msg, expected=True)
 508
 509         return content
 510
 511     def _download_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True, tries=1, timeout=5, encoding=None, data=None, headers={}, query={}):
 512         """ Returns the data of the page as a string """
 513         success = False
 514         try_count = 0
 515         while success is False:
 516             try:
 517                 res = self._download_webpage_handle(url_or_request, video_id, note, errnote, fatal, encoding=encoding, data=data, headers=headers, query=query)
 518                 success = True
 519             except compat_http_client.IncompleteRead as e:
 520                 try_count += 1
 521                 if try_count >= tries:
 522                     raise e
 523                 self._sleep(timeout, video_id)
 524         if res is False:
 525             return res
 526         else:
 527             content, _ = res
 528             return content
 529
 530     def _download_xml(self, url_or_request, video_id,
 531                       note='Downloading XML', errnote='Unable to download XML',
 532                       transform_source=None, fatal=True, encoding=None, data=None, headers={}, query={}):
 533         """Return the xml as an xml.etree.ElementTree.Element"""
 534         xml_string = self._download_webpage(
 535             url_or_request, video_id, note, errnote, fatal=fatal, encoding=encoding, data=data, headers=headers, query=query)
 536         if xml_string is False:
 537             return xml_string
 538         if transform_source:
 539             xml_string = transform_source(xml_string)
 540         return compat_etree_fromstring(xml_string.encode('utf-8'))
 541
 542     def _download_json(self, url_or_request, video_id,
 543                        note='Downloading JSON metadata',
 544                        errnote='Unable to download JSON metadata',
 545                        transform_source=None,
 546                        fatal=True, encoding=None, data=None, headers={}, query={}):
 547         json_string = self._download_webpage(
 548             url_or_request, video_id, note, errnote, fatal=fatal,
 549             encoding=encoding, data=data, headers=headers, query=query)
 550         if (not fatal) and json_string is False:
 551             return None
 552         return self._parse_json(
 553             json_string, video_id, transform_source=transform_source, fatal=fatal)
 554
 555     def _parse_json(self, json_string, video_id, transform_source=None, fatal=True):
 556         if transform_source:
 557             json_string = transform_source(json_string)
 558         try:
 559             return json.loads(json_string)
 560         except ValueError as ve:
 561             errmsg = '%s: Failed to parse JSON ' % video_id
 562             if fatal:
 563                 raise ExtractorError(errmsg, cause=ve)
 564             else:
 565                 self.report_warning(errmsg + str(ve))
 566
 567     def report_warning(self, msg, video_id=None):
 568         idstr = '' if video_id is None else '%s: ' % video_id
 569         self._downloader.report_warning(
 570             '[%s] %s%s' % (self.IE_NAME, idstr, msg))
 571
 572     def to_screen(self, msg):
 573         """Print msg to screen, prefixing it with '[ie_name]'"""
 574         self._downloader.to_screen('[%s] %s' % (self.IE_NAME, msg))
 575
 576     def report_extraction(self, id_or_name):
 577         """Report information extraction."""
 578         self.to_screen('%s: Extracting information' % id_or_name)
 579
 580     def report_download_webpage(self, video_id):
 581         """Report webpage download."""
 582         self.to_screen('%s: Downloading webpage' % video_id)
 583
 584     def report_age_confirmation(self):
 585         """Report attempt to confirm age."""
 586         self.to_screen('Confirming age')
 587
 588     def report_login(self):
 589         """Report attempt to log in."""
 590         self.to_screen('Logging in')
 591
 592     @staticmethod
 593     def raise_login_required(msg='This video is only available for registered users'):
 594         raise ExtractorError(
 595             '%s. Use --username and --password or --netrc to provide account credentials.' % msg,
 596             expected=True)
 597
 598     @staticmethod
 599     def raise_geo_restricted(msg='This video is not available from your location due to geo restriction'):
 600         raise ExtractorError(
 601             '%s. You might want to use --proxy to workaround.' % msg,
 602             expected=True)
 603
 604     # Methods for following #608
 605     @staticmethod
 606     def url_result(url, ie=None, video_id=None, video_title=None):
 607         """Returns a URL that points to a page that should be processed"""
 608         # TODO: ie should be the class used for getting the info
 609         video_info = {'_type': 'url',
 610                       'url': url,
 611                       'ie_key': ie}
 612         if video_id is not None:
 613             video_info['id'] = video_id
 614         if video_title is not None:
 615             video_info['title'] = video_title
 616         return video_info
 617
 618     @staticmethod
 619     def playlist_result(entries, playlist_id=None, playlist_title=None, playlist_description=None):
 620         """Returns a playlist"""
 621         video_info = {'_type': 'playlist',
 622                       'entries': entries}
 623         if playlist_id:
 624             video_info['id'] = playlist_id
 625         if playlist_title:
 626             video_info['title'] = playlist_title
 627         if playlist_description:
 628             video_info['description'] = playlist_description
 629         return video_info
 630
 631     def _search_regex(self, pattern, string, name, default=NO_DEFAULT, fatal=True, flags=0, group=None):
 632         """
 633         Perform a regex search on the given string, using a single or a list of
 634         patterns returning the first matching group.
 635         In case of failure return a default value or raise a WARNING or a
 636         RegexNotFoundError, depending on fatal, specifying the field name.
 637         """
 638         if isinstance(pattern, (str, compat_str, compiled_regex_type)):
 639             mobj = re.search(pattern, string, flags)
 640         else:
 641             for p in pattern:
 642                 mobj = re.search(p, string, flags)
 643                 if mobj:
 644                     break
 645
 646         if not self._downloader.params.get('no_color') and compat_os_name != 'nt' and sys.stderr.isatty():
 647             _name = '\033[0;34m%s\033[0m' % name
 648         else:
 649             _name = name
 650
 651         if mobj:
 652             if group is None:
 653                 # return the first matching group
 654                 return next(g for g in mobj.groups() if g is not None)
 655             else:
 656                 return mobj.group(group)
 657         elif default is not NO_DEFAULT:
 658             return default
 659         elif fatal:
 660             raise RegexNotFoundError('Unable to extract %s' % _name)
 661         else:
 662             self._downloader.report_warning('unable to extract %s' % _name + bug_reports_message())
 663             return None
 664
 665     def _html_search_regex(self, pattern, string, name, default=NO_DEFAULT, fatal=True, flags=0, group=None):
 666         """
 667         Like _search_regex, but strips HTML tags and unescapes entities.
 668         """
 669         res = self._search_regex(pattern, string, name, default, fatal, flags, group)
 670         if res:
 671             return clean_html(res).strip()
 672         else:
 673             return res
 674
 675     def _get_netrc_login_info(self, netrc_machine=None):
 676         username = None
 677         password = None
 678         netrc_machine = netrc_machine or self._NETRC_MACHINE
 679
 680         if self._downloader.params.get('usenetrc', False):
 681             try:
 682                 info = netrc.netrc().authenticators(netrc_machine)
 683                 if info is not None:
 684                     username = info[0]
 685                     password = info[2]
 686                 else:
 687                     raise netrc.NetrcParseError(
 688                         'No authenticators for %s' % netrc_machine)
 689             except (IOError, netrc.NetrcParseError) as err:
 690                 self._downloader.report_warning(
 691                     'parsing .netrc: %s' % error_to_compat_str(err))
 692
 693         return username, password
 694
 695     def _get_login_info(self, username_option='username', password_option='password', netrc_machine=None):
 696         """
 697         Get the login info as (username, password)
 698         First look for the manually specified credentials using username_option
 699         and password_option as keys in params dictionary. If no such credentials
 700         available look in the netrc file using the netrc_machine or _NETRC_MACHINE
 701         value.
 702         If there's no info available, return (None, None)
 703         """
 704         if self._downloader is None:
 705             return (None, None)
 706
 707         downloader_params = self._downloader.params
 708
 709         # Attempt to use provided username and password or .netrc data
 710         if downloader_params.get(username_option) is not None:
 711             username = downloader_params[username_option]
 712             password = downloader_params[password_option]
 713         else:
 714             username, password = self._get_netrc_login_info(netrc_machine)
 715
 716         return username, password
 717
 718     def _get_tfa_info(self, note='two-factor verification code'):
 719         """
 720         Get the two-factor authentication info
 721         TODO - asking the user will be required for sms/phone verify
 722         currently just uses the command line option
 723         If there's no info available, return None
 724         """
 725         if self._downloader is None:
 726             return None
 727         downloader_params = self._downloader.params
 728
 729         if downloader_params.get('twofactor') is not None:
 730             return downloader_params['twofactor']
 731
 732         return compat_getpass('Type %s and press [Return]: ' % note)
 733
 734     # Helper functions for extracting OpenGraph info
 735     @staticmethod
 736     def _og_regexes(prop):
 737         content_re = r'content=(?:"([^"]+?)"|\'([^\']+?)\'|\s*([^\s"\'=<>`]+?))'
 738         property_re = (r'(?:name|property)=(?:\'og:%(prop)s\'|"og:%(prop)s"|\s*og:%(prop)s\b)'
 739                        % {'prop': re.escape(prop)})
 740         template = r'<meta[^>]+?%s[^>]+?%s'
 741         return [
 742             template % (property_re, content_re),
 743             template % (content_re, property_re),
 744         ]
 745
 746     @staticmethod
 747     def _meta_regex(prop):
 748         return r'''(?isx)<meta
 749                     (?=[^>]+(?:itemprop|name|property|id|http-equiv)=(["\']?)%s\1)
 750                     [^>]+?content=(["\'])(?P<content>.*?)\2''' % re.escape(prop)
 751
 752     def _og_search_property(self, prop, html, name=None, **kargs):
 753         if not isinstance(prop, (list, tuple)):
 754             prop = [prop]
 755         if name is None:
 756             name = 'OpenGraph %s' % prop[0]
 757         og_regexes = []
 758         for p in prop:
 759             og_regexes.extend(self._og_regexes(p))
 760         escaped = self._search_regex(og_regexes, html, name, flags=re.DOTALL, **kargs)
 761         if escaped is None:
 762             return None
 763         return unescapeHTML(escaped)
 764
 765     def _og_search_thumbnail(self, html, **kargs):
 766         return self._og_search_property('image', html, 'thumbnail URL', fatal=False, **kargs)
 767
 768     def _og_search_description(self, html, **kargs):
 769         return self._og_search_property('description', html, fatal=False, **kargs)
 770
 771     def _og_search_title(self, html, **kargs):
 772         return self._og_search_property('title', html, **kargs)
 773
 774     def _og_search_video_url(self, html, name='video url', secure=True, **kargs):
 775         regexes = self._og_regexes('video') + self._og_regexes('video:url')
 776         if secure:
 777             regexes = self._og_regexes('video:secure_url') + regexes
 778         return self._html_search_regex(regexes, html, name, **kargs)
 779
 780     def _og_search_url(self, html, **kargs):
 781         return self._og_search_property('url', html, **kargs)
 782
 783     def _html_search_meta(self, name, html, display_name=None, fatal=False, **kwargs):
 784         if not isinstance(name, (list, tuple)):
 785             name = [name]
 786         if display_name is None:
 787             display_name = name[0]
 788         return self._html_search_regex(
 789             [self._meta_regex(n) for n in name],
 790             html, display_name, fatal=fatal, group='content', **kwargs)
 791
 792     def _dc_search_uploader(self, html):
 793         return self._html_search_meta('dc.creator', html, 'uploader')
 794
 795     def _rta_search(self, html):
 796         # See http://www.rtalabel.org/index.php?content=howtofaq#single
 797         if re.search(r'(?ix)<meta\s+name="rating"\s+'
 798                      r'     content="RTA-5042-1996-1400-1577-RTA"',
 799                      html):
 800             return 18
 801         return 0
 802
 803     def _media_rating_search(self, html):
 804         # See http://www.tjg-designs.com/WP/metadata-code-examples-adding-metadata-to-your-web-pages/
 805         rating = self._html_search_meta('rating', html)
 806
 807         if not rating:
 808             return None
 809
 810         RATING_TABLE = {
 811             'safe for kids': 0,
 812             'general': 8,
 813             '14 years': 14,
 814             'mature': 17,
 815             'restricted': 19,
 816         }
 817         return RATING_TABLE.get(rating.lower())
 818
 819     def _family_friendly_search(self, html):
 820         # See http://schema.org/VideoObject
 821         family_friendly = self._html_search_meta('isFamilyFriendly', html)
 822
 823         if not family_friendly:
 824             return None
 825
 826         RATING_TABLE = {
 827             '1': 0,
 828             'true': 0,
 829             '0': 18,
 830             'false': 18,
 831         }
 832         return RATING_TABLE.get(family_friendly.lower())
 833
 834     def _twitter_search_player(self, html):
 835         return self._html_search_meta('twitter:player', html,
 836                                       'twitter card player')
 837
 838     def _search_json_ld(self, html, video_id, expected_type=None, **kwargs):
 839         json_ld = self._search_regex(
 840             r'(?s)<script[^>]+type=(["\'])application/ld\+json\1[^>]*>(?P<json_ld>.+?)</script>',
 841             html, 'JSON-LD', group='json_ld', **kwargs)
 842         default = kwargs.get('default', NO_DEFAULT)
 843         if not json_ld:
 844             return default if default is not NO_DEFAULT else {}
 845         # JSON-LD may be malformed and thus `fatal` should be respected.
 846         # At the same time `default` may be passed that assumes `fatal=False`
 847         # for _search_regex. Let's simulate the same behavior here as well.
 848         fatal = kwargs.get('fatal', True) if default == NO_DEFAULT else False
 849         return self._json_ld(json_ld, video_id, fatal=fatal, expected_type=expected_type)
 850
 851     def _json_ld(self, json_ld, video_id, fatal=True, expected_type=None):
 852         if isinstance(json_ld, compat_str):
 853             json_ld = self._parse_json(json_ld, video_id, fatal=fatal)
 854         if not json_ld:
 855             return {}
 856         info = {}
 857         if not isinstance(json_ld, (list, tuple, dict)):
 858             return info
 859         if isinstance(json_ld, dict):
 860             json_ld = [json_ld]
 861         for e in json_ld:
 862             if e.get('@context') == 'http://schema.org':
 863                 item_type = e.get('@type')
 864                 if expected_type is not None and expected_type != item_type:
 865                     return info
 866                 if item_type == 'TVEpisode':
 867                     info.update({
 868                         'episode': unescapeHTML(e.get('name')),
 869                         'episode_number': int_or_none(e.get('episodeNumber')),
 870                         'description': unescapeHTML(e.get('description')),
 871                     })
 872                     part_of_season = e.get('partOfSeason')
 873                     if isinstance(part_of_season, dict) and part_of_season.get('@type') == 'TVSeason':
 874                         info['season_number'] = int_or_none(part_of_season.get('seasonNumber'))
 875                     part_of_series = e.get('partOfSeries') or e.get('partOfTVSeries')
 876                     if isinstance(part_of_series, dict) and part_of_series.get('@type') == 'TVSeries':
 877                         info['series'] = unescapeHTML(part_of_series.get('name'))
 878                 elif item_type == 'Article':
 879                     info.update({
 880                         'timestamp': parse_iso8601(e.get('datePublished')),
 881                         'title': unescapeHTML(e.get('headline')),
 882                         'description': unescapeHTML(e.get('articleBody')),
 883                     })
 884                 elif item_type == 'VideoObject':
 885                     info.update({
 886                         'url': e.get('contentUrl'),
 887                         'title': unescapeHTML(e.get('name')),
 888                         'description': unescapeHTML(e.get('description')),
 889                         'thumbnail': e.get('thumbnailUrl') or e.get('thumbnailURL'),
 890                         'duration': parse_duration(e.get('duration')),
 891                         'timestamp': unified_timestamp(e.get('uploadDate')),
 892                         'filesize': float_or_none(e.get('contentSize')),
 893                         'tbr': int_or_none(e.get('bitrate')),
 894                         'width': int_or_none(e.get('width')),
 895                         'height': int_or_none(e.get('height')),
 896                     })
 897                 break
 898         return dict((k, v) for k, v in info.items() if v is not None)
 899
 900     @staticmethod
 901     def _hidden_inputs(html):
 902         html = re.sub(r'<!--(?:(?!<!--).)*-->', '', html)
 903         hidden_inputs = {}
 904         for input in re.findall(r'(?i)(<input[^>]+>)', html):
 905             attrs = extract_attributes(input)
 906             if not input:
 907                 continue
 908             if attrs.get('type') not in ('hidden', 'submit'):
 909                 continue
 910             name = attrs.get('name') or attrs.get('id')
 911             value = attrs.get('value')
 912             if name and value is not None:
 913                 hidden_inputs[name] = value
 914         return hidden_inputs
 915
 916     def _form_hidden_inputs(self, form_id, html):
 917         form = self._search_regex(
 918             r'(?is)<form[^>]+?id=(["\'])%s\1[^>]*>(?P<form>.+?)</form>' % form_id,
 919             html, '%s form' % form_id, group='form')
 920         return self._hidden_inputs(form)
 921
 922     def _sort_formats(self, formats, field_preference=None):
 923         if not formats:
 924             raise ExtractorError('No video formats found')
 925
 926         for f in formats:
 927             # Automatically determine tbr when missing based on abr and vbr (improves
 928             # formats sorting in some cases)
 929             if 'tbr' not in f and f.get('abr') is not None and f.get('vbr') is not None:
 930                 f['tbr'] = f['abr'] + f['vbr']
 931
 932         def _formats_key(f):
 933             # TODO remove the following workaround
 934             from ..utils import determine_ext
 935             if not f.get('ext') and 'url' in f:
 936                 f['ext'] = determine_ext(f['url'])
 937
 938             if isinstance(field_preference, (list, tuple)):
 939                 return tuple(
 940                     f.get(field)
 941                     if f.get(field) is not None
 942                     else ('' if field == 'format_id' else -1)
 943                     for field in field_preference)
 944
 945             preference = f.get('preference')
 946             if preference is None:
 947                 preference = 0
 948                 if f.get('ext') in ['f4f', 'f4m']:  # Not yet supported
 949                     preference -= 0.5
 950
 951             protocol = f.get('protocol') or determine_protocol(f)
 952             proto_preference = 0 if protocol in ['http', 'https'] else (-0.5 if protocol == 'rtsp' else -0.1)
 953
 954             if f.get('vcodec') == 'none':  # audio only
 955                 preference -= 50
 956                 if self._downloader.params.get('prefer_free_formats'):
 957                     ORDER = ['aac', 'mp3', 'm4a', 'webm', 'ogg', 'opus']
 958                 else:
 959                     ORDER = ['webm', 'opus', 'ogg', 'mp3', 'aac', 'm4a']
 960                 ext_preference = 0
 961                 try:
 962                     audio_ext_preference = ORDER.index(f['ext'])
 963                 except ValueError:
 964                     audio_ext_preference = -1
 965             else:
 966                 if f.get('acodec') == 'none':  # video only
 967                     preference -= 40
 968                 if self._downloader.params.get('prefer_free_formats'):
 969                     ORDER = ['flv', 'mp4', 'webm']
 970                 else:
 971                     ORDER = ['webm', 'flv', 'mp4']
 972                 try:
 973                     ext_preference = ORDER.index(f['ext'])
 974                 except ValueError:
 975                     ext_preference = -1
 976                 audio_ext_preference = 0
 977
 978             return (
 979                 preference,
 980                 f.get('language_preference') if f.get('language_preference') is not None else -1,
 981                 f.get('quality') if f.get('quality') is not None else -1,
 982                 f.get('tbr') if f.get('tbr') is not None else -1,
 983                 f.get('filesize') if f.get('filesize') is not None else -1,
 984                 f.get('vbr') if f.get('vbr') is not None else -1,
 985                 f.get('height') if f.get('height') is not None else -1,
 986                 f.get('width') if f.get('width') is not None else -1,
 987                 proto_preference,
 988                 ext_preference,
 989                 f.get('abr') if f.get('abr') is not None else -1,
 990                 audio_ext_preference,
 991                 f.get('fps') if f.get('fps') is not None else -1,
 992                 f.get('filesize_approx') if f.get('filesize_approx') is not None else -1,
 993                 f.get('source_preference') if f.get('source_preference') is not None else -1,
 994                 f.get('format_id') if f.get('format_id') is not None else '',
 995             )
 996         formats.sort(key=_formats_key)
 997
 998     def _check_formats(self, formats, video_id):
 999         if formats:
1000             formats[:] = filter(
1001                 lambda f: self._is_valid_url(
1002                     f['url'], video_id,
1003                     item='%s video format' % f.get('format_id') if f.get('format_id') else 'video'),
1004                 formats)
1005
1006     @staticmethod
1007     def _remove_duplicate_formats(formats):
1008         format_urls = set()
1009         unique_formats = []
1010         for f in formats:
1011             if f['url'] not in format_urls:
1012                 format_urls.add(f['url'])
1013                 unique_formats.append(f)
1014         formats[:] = unique_formats
1015
1016     def _is_valid_url(self, url, video_id, item='video'):
1017         url = self._proto_relative_url(url, scheme='http:')
1018         # For now assume non HTTP(S) URLs always valid
1019         if not (url.startswith('http://') or url.startswith('https://')):
1020             return True
1021         try:
1022             self._request_webpage(url, video_id, 'Checking %s URL' % item)
1023             return True
1024         except ExtractorError as e:
1025             if isinstance(e.cause, compat_urllib_error.URLError):
1026                 self.to_screen(
1027                     '%s: %s URL is invalid, skipping' % (video_id, item))
1028                 return False
1029             raise
1030
1031     def http_scheme(self):
1032         """ Either "http:" or "https:", depending on the user's preferences """
1033         return (
1034             'http:'
1035             if self._downloader.params.get('prefer_insecure', False)
1036             else 'https:')
1037
1038     def _proto_relative_url(self, url, scheme=None):
1039         if url is None:
1040             return url
1041         if url.startswith('//'):
1042             if scheme is None:
1043                 scheme = self.http_scheme()
1044             return scheme + url
1045         else:
1046             return url
1047
1048     def _sleep(self, timeout, video_id, msg_template=None):
1049         if msg_template is None:
1050             msg_template = '%(video_id)s: Waiting for %(timeout)s seconds'
1051         msg = msg_template % {'video_id': video_id, 'timeout': timeout}
1052         self.to_screen(msg)
1053         time.sleep(timeout)
1054
1055     def _extract_f4m_formats(self, manifest_url, video_id, preference=None, f4m_id=None,
1056                              transform_source=lambda s: fix_xml_ampersands(s).strip(),
1057                              fatal=True, m3u8_id=None):
1058         manifest = self._download_xml(
1059             manifest_url, video_id, 'Downloading f4m manifest',
1060             'Unable to download f4m manifest',
1061             # Some manifests may be malformed, e.g. prosiebensat1 generated manifests
1062             # (see https://github.com/rg3/youtube-dl/issues/6215#issuecomment-121704244)
1063             transform_source=transform_source,
1064             fatal=fatal)
1065
1066         if manifest is False:
1067             return []
1068
1069         return self._parse_f4m_formats(
1070             manifest, manifest_url, video_id, preference=preference, f4m_id=f4m_id,
1071             transform_source=transform_source, fatal=fatal, m3u8_id=m3u8_id)
1072
1073     def _parse_f4m_formats(self, manifest, manifest_url, video_id, preference=None, f4m_id=None,
1074                            transform_source=lambda s: fix_xml_ampersands(s).strip(),
1075                            fatal=True, m3u8_id=None):
1076         # currently youtube-dl cannot decode the playerVerificationChallenge as Akamai uses Adobe Alchemy
1077         akamai_pv = manifest.find('{http://ns.adobe.com/f4m/1.0}pv-2.0')
1078         if akamai_pv is not None and ';' in akamai_pv.text:
1079             playerVerificationChallenge = akamai_pv.text.split(';')[0]
1080             if playerVerificationChallenge.strip() != '':
1081                 return []
1082
1083         formats = []
1084         manifest_version = '1.0'
1085         media_nodes = manifest.findall('{http://ns.adobe.com/f4m/1.0}media')
1086         if not media_nodes:
1087             manifest_version = '2.0'
1088             media_nodes = manifest.findall('{http://ns.adobe.com/f4m/2.0}media')
1089         # Remove unsupported DRM protected media from final formats
1090         # rendition (see https://github.com/rg3/youtube-dl/issues/8573).
1091         media_nodes = remove_encrypted_media(media_nodes)
1092         if not media_nodes:
1093             return formats
1094         base_url = xpath_text(
1095             manifest, ['{http://ns.adobe.com/f4m/1.0}baseURL', '{http://ns.adobe.com/f4m/2.0}baseURL'],
1096             'base URL', default=None)
1097         if base_url:
1098             base_url = base_url.strip()
1099
1100         bootstrap_info = xpath_element(
1101             manifest, ['{http://ns.adobe.com/f4m/1.0}bootstrapInfo', '{http://ns.adobe.com/f4m/2.0}bootstrapInfo'],
1102             'bootstrap info', default=None)
1103
1104         vcodec = None
1105         mime_type = xpath_text(
1106             manifest, ['{http://ns.adobe.com/f4m/1.0}mimeType', '{http://ns.adobe.com/f4m/2.0}mimeType'],
1107             'base URL', default=None)
1108         if mime_type and mime_type.startswith('audio/'):
1109             vcodec = 'none'
1110
1111         for i, media_el in enumerate(media_nodes):
1112             tbr = int_or_none(media_el.attrib.get('bitrate'))
1113             width = int_or_none(media_el.attrib.get('width'))
1114             height = int_or_none(media_el.attrib.get('height'))
1115             format_id = '-'.join(filter(None, [f4m_id, compat_str(i if tbr is None else tbr)]))
1116             # If <bootstrapInfo> is present, the specified f4m is a
1117             # stream-level manifest, and only set-level manifests may refer to
1118             # external resources.  See section 11.4 and section 4 of F4M spec
1119             if bootstrap_info is None:
1120                 media_url = None
1121                 # @href is introduced in 2.0, see section 11.6 of F4M spec
1122                 if manifest_version == '2.0':
1123                     media_url = media_el.attrib.get('href')
1124                 if media_url is None:
1125                     media_url = media_el.attrib.get('url')
1126                 if not media_url:
1127                     continue
1128                 manifest_url = (
1129                     media_url if media_url.startswith('http://') or media_url.startswith('https://')
1130                     else ((base_url or '/'.join(manifest_url.split('/')[:-1])) + '/' + media_url))
1131                 # If media_url is itself a f4m manifest do the recursive extraction
1132                 # since bitrates in parent manifest (this one) and media_url manifest
1133                 # may differ leading to inability to resolve the format by requested
1134                 # bitrate in f4m downloader
1135                 ext = determine_ext(manifest_url)
1136                 if ext == 'f4m':
1137                     f4m_formats = self._extract_f4m_formats(
1138                         manifest_url, video_id, preference=preference, f4m_id=f4m_id,
1139                         transform_source=transform_source, fatal=fatal)
1140                     # Sometimes stream-level manifest contains single media entry that
1141                     # does not contain any quality metadata (e.g. http://matchtv.ru/#live-player).
1142                     # At the same time parent's media entry in set-level manifest may
1143                     # contain it. We will copy it from parent in such cases.
1144                     if len(f4m_formats) == 1:
1145                         f = f4m_formats[0]
1146                         f.update({
1147                             'tbr': f.get('tbr') or tbr,
1148                             'width': f.get('width') or width,
1149                             'height': f.get('height') or height,
1150                             'format_id': f.get('format_id') if not tbr else format_id,
1151                             'vcodec': vcodec,
1152                         })
1153                     formats.extend(f4m_formats)
1154                     continue
1155                 elif ext == 'm3u8':
1156                     formats.extend(self._extract_m3u8_formats(
1157                         manifest_url, video_id, 'mp4', preference=preference,
1158                         m3u8_id=m3u8_id, fatal=fatal))
1159                     continue
1160             formats.append({
1161                 'format_id': format_id,
1162                 'url': manifest_url,
1163                 'manifest_url': manifest_url,
1164                 'ext': 'flv' if bootstrap_info is not None else None,
1165                 'tbr': tbr,
1166                 'width': width,
1167                 'height': height,
1168                 'vcodec': vcodec,
1169                 'preference': preference,
1170             })
1171         return formats
1172
1173     def _m3u8_meta_format(self, m3u8_url, ext=None, preference=None, m3u8_id=None):
1174         return {
1175             'format_id': '-'.join(filter(None, [m3u8_id, 'meta'])),
1176             'url': m3u8_url,
1177             'ext': ext,
1178             'protocol': 'm3u8',
1179             'preference': preference - 100 if preference else -100,
1180             'resolution': 'multiple',
1181             'format_note': 'Quality selection URL',
1182         }
1183
1184     def _extract_m3u8_formats(self, m3u8_url, video_id, ext=None,
1185                               entry_protocol='m3u8', preference=None,
1186                               m3u8_id=None, note=None, errnote=None,
1187                               fatal=True, live=False):
1188
1189         res = self._download_webpage_handle(
1190             m3u8_url, video_id,
1191             note=note or 'Downloading m3u8 information',
1192             errnote=errnote or 'Failed to download m3u8 information',
1193             fatal=fatal)
1194         if res is False:
1195             return []
1196         m3u8_doc, urlh = res
1197         m3u8_url = urlh.geturl()
1198
1199         formats = [self._m3u8_meta_format(m3u8_url, ext, preference, m3u8_id)]
1200
1201         format_url = lambda u: (
1202             u
1203             if re.match(r'^https?://', u)
1204             else compat_urlparse.urljoin(m3u8_url, u))
1205
1206         # We should try extracting formats only from master playlists [1], i.e.
1207         # playlists that describe available qualities. On the other hand media
1208         # playlists [2] should be returned as is since they contain just the media
1209         # without qualities renditions.
1210         # Fortunately, master playlist can be easily distinguished from media
1211         # playlist based on particular tags availability. As of [1, 2] master
1212         # playlist tags MUST NOT appear in a media playist and vice versa.
1213         # As of [3] #EXT-X-TARGETDURATION tag is REQUIRED for every media playlist
1214         # and MUST NOT appear in master playlist thus we can clearly detect media
1215         # playlist with this criterion.
1216         # 1. https://tools.ietf.org/html/draft-pantos-http-live-streaming-17#section-4.3.4
1217         # 2. https://tools.ietf.org/html/draft-pantos-http-live-streaming-17#section-4.3.3
1218         # 3. https://tools.ietf.org/html/draft-pantos-http-live-streaming-17#section-4.3.3.1
1219         if '#EXT-X-TARGETDURATION' in m3u8_doc:  # media playlist, return as is
1220             return [{
1221                 'url': m3u8_url,
1222                 'format_id': m3u8_id,
1223                 'ext': ext,
1224                 'protocol': entry_protocol,
1225                 'preference': preference,
1226             }]
1227         audio_groups = set()
1228         last_info = {}
1229         last_media = {}
1230         for line in m3u8_doc.splitlines():
1231             if line.startswith('#EXT-X-STREAM-INF:'):
1232                 last_info = parse_m3u8_attributes(line)
1233             elif line.startswith('#EXT-X-MEDIA:'):
1234                 media = parse_m3u8_attributes(line)
1235                 media_type = media.get('TYPE')
1236                 if media_type in ('VIDEO', 'AUDIO'):
1237                     media_url = media.get('URI')
1238                     if media_url:
1239                         format_id = []
1240                         for v in (media.get('GROUP-ID'), media.get('NAME')):
1241                             if v:
1242                                 format_id.append(v)
1243                         f = {
1244                             'format_id': '-'.join(format_id),
1245                             'url': format_url(media_url),
1246                             'language': media.get('LANGUAGE'),
1247                             'ext': ext,
1248                             'protocol': entry_protocol,
1249                             'preference': preference,
1250                         }
1251                         if media_type == 'AUDIO':
1252                             f['vcodec'] = 'none'
1253                             audio_groups.add(media['GROUP-ID'])
1254                         formats.append(f)
1255                     else:
1256                         # When there is no URI in EXT-X-MEDIA let this tag's
1257                         # data be used by regular URI lines below
1258                         last_media = media
1259             elif line.startswith('#') or not line.strip():
1260                 continue
1261             else:
1262                 tbr = int_or_none(last_info.get('AVERAGE-BANDWIDTH') or last_info.get('BANDWIDTH'), scale=1000)
1263                 format_id = []
1264                 if m3u8_id:
1265                     format_id.append(m3u8_id)
1266                 # Despite specification does not mention NAME attribute for
1267                 # EXT-X-STREAM-INF it still sometimes may be present
1268                 stream_name = last_info.get('NAME') or last_media.get('NAME')
1269                 # Bandwidth of live streams may differ over time thus making
1270                 # format_id unpredictable. So it's better to keep provided
1271                 # format_id intact.
1272                 if not live:
1273                     format_id.append(stream_name if stream_name else '%d' % (tbr if tbr else len(formats)))
1274                 manifest_url = format_url(line.strip())
1275                 f = {
1276                     'format_id': '-'.join(format_id),
1277                     'url': manifest_url,
1278                     'manifest_url': manifest_url,
1279                     'tbr': tbr,
1280                     'ext': ext,
1281                     'fps': float_or_none(last_info.get('FRAME-RATE')),
1282                     'protocol': entry_protocol,
1283                     'preference': preference,
1284                 }
1285                 resolution = last_info.get('RESOLUTION')
1286                 if resolution:
1287                     mobj = re.search(r'(?P<width>\d+)[xX](?P<height>\d+)', resolution)
1288                     if mobj:
1289                         f['width'] = int(mobj.group('width'))
1290                         f['height'] = int(mobj.group('height'))
1291                 # Unified Streaming Platform
1292                 mobj = re.search(
1293                     r'audio.*?(?:%3D|=)(\d+)(?:-video.*?(?:%3D|=)(\d+))?', f['url'])
1294                 if mobj:
1295                     abr, vbr = mobj.groups()
1296                     abr, vbr = float_or_none(abr, 1000), float_or_none(vbr, 1000)
1297                     f.update({
1298                         'vbr': vbr,
1299                         'abr': abr,
1300                     })
1301                 f.update(parse_codecs(last_info.get('CODECS')))
1302                 if last_info.get('AUDIO') in audio_groups:
1303                     # TODO: update acodec for for audio only formats with the same GROUP-ID
1304                     f['acodec'] = 'none'
1305                 formats.append(f)
1306                 last_info = {}
1307                 last_media = {}
1308         return formats
1309
1310     @staticmethod
1311     def _xpath_ns(path, namespace=None):
1312         if not namespace:
1313             return path
1314         out = []
1315         for c in path.split('/'):
1316             if not c or c == '.':
1317                 out.append(c)
1318             else:
1319                 out.append('{%s}%s' % (namespace, c))
1320         return '/'.join(out)
1321
1322     def _extract_smil_formats(self, smil_url, video_id, fatal=True, f4m_params=None, transform_source=None):
1323         smil = self._download_smil(smil_url, video_id, fatal=fatal, transform_source=transform_source)
1324
1325         if smil is False:
1326             assert not fatal
1327             return []
1328
1329         namespace = self._parse_smil_namespace(smil)
1330
1331         return self._parse_smil_formats(
1332             smil, smil_url, video_id, namespace=namespace, f4m_params=f4m_params)
1333
1334     def _extract_smil_info(self, smil_url, video_id, fatal=True, f4m_params=None):
1335         smil = self._download_smil(smil_url, video_id, fatal=fatal)
1336         if smil is False:
1337             return {}
1338         return self._parse_smil(smil, smil_url, video_id, f4m_params=f4m_params)
1339
1340     def _download_smil(self, smil_url, video_id, fatal=True, transform_source=None):
1341         return self._download_xml(
1342             smil_url, video_id, 'Downloading SMIL file',
1343             'Unable to download SMIL file', fatal=fatal, transform_source=transform_source)
1344
1345     def _parse_smil(self, smil, smil_url, video_id, f4m_params=None):
1346         namespace = self._parse_smil_namespace(smil)
1347
1348         formats = self._parse_smil_formats(
1349             smil, smil_url, video_id, namespace=namespace, f4m_params=f4m_params)
1350         subtitles = self._parse_smil_subtitles(smil, namespace=namespace)
1351
1352         video_id = os.path.splitext(url_basename(smil_url))[0]
1353         title = None
1354         description = None
1355         upload_date = None
1356         for meta in smil.findall(self._xpath_ns('./head/meta', namespace)):
1357             name = meta.attrib.get('name')
1358             content = meta.attrib.get('content')
1359             if not name or not content:
1360                 continue
1361             if not title and name == 'title':
1362                 title = content
1363             elif not description and name in ('description', 'abstract'):
1364                 description = content
1365             elif not upload_date and name == 'date':
1366                 upload_date = unified_strdate(content)
1367
1368         thumbnails = [{
1369             'id': image.get('type'),
1370             'url': image.get('src'),
1371             'width': int_or_none(image.get('width')),
1372             'height': int_or_none(image.get('height')),
1373         } for image in smil.findall(self._xpath_ns('.//image', namespace)) if image.get('src')]
1374
1375         return {
1376             'id': video_id,
1377             'title': title or video_id,
1378             'description': description,
1379             'upload_date': upload_date,
1380             'thumbnails': thumbnails,
1381             'formats': formats,
1382             'subtitles': subtitles,
1383         }
1384
1385     def _parse_smil_namespace(self, smil):
1386         return self._search_regex(
1387             r'(?i)^{([^}]+)?}smil$', smil.tag, 'namespace', default=None)
1388
1389     def _parse_smil_formats(self, smil, smil_url, video_id, namespace=None, f4m_params=None, transform_rtmp_url=None):
1390         base = smil_url
1391         for meta in smil.findall(self._xpath_ns('./head/meta', namespace)):
1392             b = meta.get('base') or meta.get('httpBase')
1393             if b:
1394                 base = b
1395                 break
1396
1397         formats = []
1398         rtmp_count = 0
1399         http_count = 0
1400         m3u8_count = 0
1401
1402         srcs = []
1403         media = smil.findall(self._xpath_ns('.//video', namespace)) + smil.findall(self._xpath_ns('.//audio', namespace))
1404         for medium in media:
1405             src = medium.get('src')
1406             if not src or src in srcs:
1407                 continue
1408             srcs.append(src)
1409
1410             bitrate = float_or_none(medium.get('system-bitrate') or medium.get('systemBitrate'), 1000)
1411             filesize = int_or_none(medium.get('size') or medium.get('fileSize'))
1412             width = int_or_none(medium.get('width'))
1413             height = int_or_none(medium.get('height'))
1414             proto = medium.get('proto')
1415             ext = medium.get('ext')
1416             src_ext = determine_ext(src)
1417             streamer = medium.get('streamer') or base
1418
1419             if proto == 'rtmp' or streamer.startswith('rtmp'):
1420                 rtmp_count += 1
1421                 formats.append({
1422                     'url': streamer,
1423                     'play_path': src,
1424                     'ext': 'flv',
1425                     'format_id': 'rtmp-%d' % (rtmp_count if bitrate is None else bitrate),
1426                     'tbr': bitrate,
1427                     'filesize': filesize,
1428                     'width': width,
1429                     'height': height,
1430                 })
1431                 if transform_rtmp_url:
1432                     streamer, src = transform_rtmp_url(streamer, src)
1433                     formats[-1].update({
1434                         'url': streamer,
1435                         'play_path': src,
1436                     })
1437                 continue
1438
1439             src_url = src if src.startswith('http') else compat_urlparse.urljoin(base, src)
1440             src_url = src_url.strip()
1441
1442             if proto == 'm3u8' or src_ext == 'm3u8':
1443                 m3u8_formats = self._extract_m3u8_formats(
1444                     src_url, video_id, ext or 'mp4', m3u8_id='hls', fatal=False)
1445                 if len(m3u8_formats) == 1:
1446                     m3u8_count += 1
1447                     m3u8_formats[0].update({
1448                         'format_id': 'hls-%d' % (m3u8_count if bitrate is None else bitrate),
1449                         'tbr': bitrate,
1450                         'width': width,
1451                         'height': height,
1452                     })
1453                 formats.extend(m3u8_formats)
1454                 continue
1455
1456             if src_ext == 'f4m':
1457                 f4m_url = src_url
1458                 if not f4m_params:
1459                     f4m_params = {
1460                         'hdcore': '3.2.0',
1461                         'plugin': 'flowplayer-3.2.0.1',
1462                     }
1463                 f4m_url += '&' if '?' in f4m_url else '?'
1464                 f4m_url += compat_urllib_parse_urlencode(f4m_params)
1465                 formats.extend(self._extract_f4m_formats(f4m_url, video_id, f4m_id='hds', fatal=False))
1466                 continue
1467
1468             if src_url.startswith('http') and self._is_valid_url(src, video_id):
1469                 http_count += 1
1470                 formats.append({
1471                     'url': src_url,
1472                     'ext': ext or src_ext or 'flv',
1473                     'format_id': 'http-%d' % (bitrate or http_count),
1474                     'tbr': bitrate,
1475                     'filesize': filesize,
1476                     'width': width,
1477                     'height': height,
1478                 })
1479                 continue
1480
1481         return formats
1482
1483     def _parse_smil_subtitles(self, smil, namespace=None, subtitles_lang='en'):
1484         urls = []
1485         subtitles = {}
1486         for num, textstream in enumerate(smil.findall(self._xpath_ns('.//textstream', namespace))):
1487             src = textstream.get('src')
1488             if not src or src in urls:
1489                 continue
1490             urls.append(src)
1491             ext = textstream.get('ext') or mimetype2ext(textstream.get('type')) or determine_ext(src)
1492             lang = textstream.get('systemLanguage') or textstream.get('systemLanguageName') or textstream.get('lang') or subtitles_lang
1493             subtitles.setdefault(lang, []).append({
1494                 'url': src,
1495                 'ext': ext,
1496             })
1497         return subtitles
1498
1499     def _extract_xspf_playlist(self, playlist_url, playlist_id, fatal=True):
1500         xspf = self._download_xml(
1501             playlist_url, playlist_id, 'Downloading xpsf playlist',
1502             'Unable to download xspf manifest', fatal=fatal)
1503         if xspf is False:
1504             return []
1505         return self._parse_xspf(xspf, playlist_id)
1506
1507     def _parse_xspf(self, playlist, playlist_id):
1508         NS_MAP = {
1509             'xspf': 'http://xspf.org/ns/0/',
1510             's1': 'http://static.streamone.nl/player/ns/0',
1511         }
1512
1513         entries = []
1514         for track in playlist.findall(xpath_with_ns('./xspf:trackList/xspf:track', NS_MAP)):
1515             title = xpath_text(
1516                 track, xpath_with_ns('./xspf:title', NS_MAP), 'title', default=playlist_id)
1517             description = xpath_text(
1518                 track, xpath_with_ns('./xspf:annotation', NS_MAP), 'description')
1519             thumbnail = xpath_text(
1520                 track, xpath_with_ns('./xspf:image', NS_MAP), 'thumbnail')
1521             duration = float_or_none(
1522                 xpath_text(track, xpath_with_ns('./xspf:duration', NS_MAP), 'duration'), 1000)
1523
1524             formats = [{
1525                 'url': location.text,
1526                 'format_id': location.get(xpath_with_ns('s1:label', NS_MAP)),
1527                 'width': int_or_none(location.get(xpath_with_ns('s1:width', NS_MAP))),
1528                 'height': int_or_none(location.get(xpath_with_ns('s1:height', NS_MAP))),
1529             } for location in track.findall(xpath_with_ns('./xspf:location', NS_MAP))]
1530             self._sort_formats(formats)
1531
1532             entries.append({
1533                 'id': playlist_id,
1534                 'title': title,
1535                 'description': description,
1536                 'thumbnail': thumbnail,
1537                 'duration': duration,
1538                 'formats': formats,
1539             })
1540         return entries
1541
1542     def _extract_mpd_formats(self, mpd_url, video_id, mpd_id=None, note=None, errnote=None, fatal=True, formats_dict={}):
1543         res = self._download_webpage_handle(
1544             mpd_url, video_id,
1545             note=note or 'Downloading MPD manifest',
1546             errnote=errnote or 'Failed to download MPD manifest',
1547             fatal=fatal)
1548         if res is False:
1549             return []
1550         mpd, urlh = res
1551         mpd_base_url = base_url(urlh.geturl())
1552
1553         return self._parse_mpd_formats(
1554             compat_etree_fromstring(mpd.encode('utf-8')), mpd_id, mpd_base_url,
1555             formats_dict=formats_dict, mpd_url=mpd_url)
1556
1557     def _parse_mpd_formats(self, mpd_doc, mpd_id=None, mpd_base_url='', formats_dict={}, mpd_url=None):
1558         """
1559         Parse formats from MPD manifest.
1560         References:
1561          1. MPEG-DASH Standard, ISO/IEC 23009-1:2014(E),
1562             http://standards.iso.org/ittf/PubliclyAvailableStandards/c065274_ISO_IEC_23009-1_2014.zip
1563          2. https://en.wikipedia.org/wiki/Dynamic_Adaptive_Streaming_over_HTTP
1564         """
1565         if mpd_doc.get('type') == 'dynamic':
1566             return []
1567
1568         namespace = self._search_regex(r'(?i)^{([^}]+)?}MPD$', mpd_doc.tag, 'namespace', default=None)
1569
1570         def _add_ns(path):
1571             return self._xpath_ns(path, namespace)
1572
1573         def is_drm_protected(element):
1574             return element.find(_add_ns('ContentProtection')) is not None
1575
1576         def extract_multisegment_info(element, ms_parent_info):
1577             ms_info = ms_parent_info.copy()
1578
1579             # As per [1, 5.3.9.2.2] SegmentList and SegmentTemplate share some
1580             # common attributes and elements.  We will only extract relevant
1581             # for us.
1582             def extract_common(source):
1583                 segment_timeline = source.find(_add_ns('SegmentTimeline'))
1584                 if segment_timeline is not None:
1585                     s_e = segment_timeline.findall(_add_ns('S'))
1586                     if s_e:
1587                         ms_info['total_number'] = 0
1588                         ms_info['s'] = []
1589                         for s in s_e:
1590                             r = int(s.get('r', 0))
1591                             ms_info['total_number'] += 1 + r
1592                             ms_info['s'].append({
1593                                 't': int(s.get('t', 0)),
1594                                 # @d is mandatory (see [1, 5.3.9.6.2, Table 17, page 60])
1595                                 'd': int(s.attrib['d']),
1596                                 'r': r,
1597                             })
1598                 start_number = source.get('startNumber')
1599                 if start_number:
1600                     ms_info['start_number'] = int(start_number)
1601                 timescale = source.get('timescale')
1602                 if timescale:
1603                     ms_info['timescale'] = int(timescale)
1604                 segment_duration = source.get('duration')
1605                 if segment_duration:
1606                     ms_info['segment_duration'] = int(segment_duration)
1607
1608             def extract_Initialization(source):
1609                 initialization = source.find(_add_ns('Initialization'))
1610                 if initialization is not None:
1611                     ms_info['initialization_url'] = initialization.attrib['sourceURL']
1612
1613             segment_list = element.find(_add_ns('SegmentList'))
1614             if segment_list is not None:
1615                 extract_common(segment_list)
1616                 extract_Initialization(segment_list)
1617                 segment_urls_e = segment_list.findall(_add_ns('SegmentURL'))
1618                 if segment_urls_e:
1619                     ms_info['segment_urls'] = [segment.attrib['media'] for segment in segment_urls_e]
1620             else:
1621                 segment_template = element.find(_add_ns('SegmentTemplate'))
1622                 if segment_template is not None:
1623                     extract_common(segment_template)
1624                     media_template = segment_template.get('media')
1625                     if media_template:
1626                         ms_info['media_template'] = media_template
1627                     initialization = segment_template.get('initialization')
1628                     if initialization:
1629                         ms_info['initialization_url'] = initialization
1630                     else:
1631                         extract_Initialization(segment_template)
1632             return ms_info
1633
1634         def combine_url(base_url, target_url):
1635             if re.match(r'^https?://', target_url):
1636                 return target_url
1637             return '%s%s%s' % (base_url, '' if base_url.endswith('/') else '/', target_url)
1638
1639         mpd_duration = parse_duration(mpd_doc.get('mediaPresentationDuration'))
1640         formats = []
1641         for period in mpd_doc.findall(_add_ns('Period')):
1642             period_duration = parse_duration(period.get('duration')) or mpd_duration
1643             period_ms_info = extract_multisegment_info(period, {
1644                 'start_number': 1,
1645                 'timescale': 1,
1646             })
1647             for adaptation_set in period.findall(_add_ns('AdaptationSet')):
1648                 if is_drm_protected(adaptation_set):
1649                     continue
1650                 adaption_set_ms_info = extract_multisegment_info(adaptation_set, period_ms_info)
1651                 for representation in adaptation_set.findall(_add_ns('Representation')):
1652                     if is_drm_protected(representation):
1653                         continue
1654                     representation_attrib = adaptation_set.attrib.copy()
1655                     representation_attrib.update(representation.attrib)
1656                     # According to [1, 5.3.7.2, Table 9, page 41], @mimeType is mandatory
1657                     mime_type = representation_attrib['mimeType']
1658                     content_type = mime_type.split('/')[0]
1659                     if content_type == 'text':
1660                         # TODO implement WebVTT downloading
1661                         pass
1662                     elif content_type == 'video' or content_type == 'audio':
1663                         base_url = ''
1664                         for element in (representation, adaptation_set, period, mpd_doc):
1665                             base_url_e = element.find(_add_ns('BaseURL'))
1666                             if base_url_e is not None:
1667                                 base_url = base_url_e.text + base_url
1668                                 if re.match(r'^https?://', base_url):
1669                                     break
1670                         if mpd_base_url and not re.match(r'^https?://', base_url):
1671                             if not mpd_base_url.endswith('/') and not base_url.startswith('/'):
1672                                 mpd_base_url += '/'
1673                             base_url = mpd_base_url + base_url
1674                         representation_id = representation_attrib.get('id')
1675                         lang = representation_attrib.get('lang')
1676                         url_el = representation.find(_add_ns('BaseURL'))
1677                         filesize = int_or_none(url_el.attrib.get('{http://youtube.com/yt/2012/10/10}contentLength') if url_el is not None else None)
1678                         f = {
1679                             'format_id': '%s-%s' % (mpd_id, representation_id) if mpd_id else representation_id,
1680                             'url': base_url,
1681                             'manifest_url': mpd_url,
1682                             'ext': mimetype2ext(mime_type),
1683                             'width': int_or_none(representation_attrib.get('width')),
1684                             'height': int_or_none(representation_attrib.get('height')),
1685                             'tbr': int_or_none(representation_attrib.get('bandwidth'), 1000),
1686                             'asr': int_or_none(representation_attrib.get('audioSamplingRate')),
1687                             'fps': int_or_none(representation_attrib.get('frameRate')),
1688                             'vcodec': 'none' if content_type == 'audio' else representation_attrib.get('codecs'),
1689                             'acodec': 'none' if content_type == 'video' else representation_attrib.get('codecs'),
1690                             'language': lang if lang not in ('mul', 'und', 'zxx', 'mis') else None,
1691                             'format_note': 'DASH %s' % content_type,
1692                             'filesize': filesize,
1693                         }
1694                         representation_ms_info = extract_multisegment_info(representation, adaption_set_ms_info)
1695                         if 'segment_urls' not in representation_ms_info and 'media_template' in representation_ms_info:
1696
1697                             media_template = representation_ms_info['media_template']
1698                             media_template = media_template.replace('$RepresentationID$', representation_id)
1699                             media_template = re.sub(r'\$(Number|Bandwidth|Time)\$', r'%(\1)d', media_template)
1700                             media_template = re.sub(r'\$(Number|Bandwidth|Time)%([^$]+)\$', r'%(\1)\2', media_template)
1701                             media_template.replace('$$', '$')
1702
1703                             # As per [1, 5.3.9.4.4, Table 16, page 55] $Number$ and $Time$
1704                             # can't be used at the same time
1705                             if '%(Number' in media_template and 's' not in representation_ms_info:
1706                                 segment_duration = None
1707                                 if 'total_number' not in representation_ms_info and 'segment_duration':
1708                                     segment_duration = float_or_none(representation_ms_info['segment_duration'], representation_ms_info['timescale'])
1709                                     representation_ms_info['total_number'] = int(math.ceil(float(period_duration) / segment_duration))
1710                                 representation_ms_info['fragments'] = [{
1711                                     'url': media_template % {
1712                                         'Number': segment_number,
1713                                         'Bandwidth': int_or_none(representation_attrib.get('bandwidth')),
1714                                     },
1715                                     'duration': segment_duration,
1716                                 } for segment_number in range(
1717                                     representation_ms_info['start_number'],
1718                                     representation_ms_info['total_number'] + representation_ms_info['start_number'])]
1719                             else:
1720                                 # $Number*$ or $Time$ in media template with S list available
1721                                 # Example $Number*$: http://www.svtplay.se/klipp/9023742/stopptid-om-bjorn-borg
1722                                 # Example $Time$: https://play.arkena.com/embed/avp/v2/player/media/b41dda37-d8e7-4d3f-b1b5-9a9db578bdfe/1/129411
1723                                 representation_ms_info['fragments'] = []
1724                                 segment_time = 0
1725                                 segment_d = None
1726                                 segment_number = representation_ms_info['start_number']
1727
1728                                 def add_segment_url():
1729                                     segment_url = media_template % {
1730                                         'Time': segment_time,
1731                                         'Bandwidth': int_or_none(representation_attrib.get('bandwidth')),
1732                                         'Number': segment_number,
1733                                     }
1734                                     representation_ms_info['fragments'].append({
1735                                         'url': segment_url,
1736                                         'duration': float_or_none(segment_d, representation_ms_info['timescale']),
1737                                     })
1738
1739                                 for num, s in enumerate(representation_ms_info['s']):
1740                                     segment_time = s.get('t') or segment_time
1741                                     segment_d = s['d']
1742                                     add_segment_url()
1743                                     segment_number += 1
1744                                     for r in range(s.get('r', 0)):
1745                                         segment_time += segment_d
1746                                         add_segment_url()
1747                                         segment_number += 1
1748                                     segment_time += segment_d
1749                         elif 'segment_urls' in representation_ms_info and 's' in representation_ms_info:
1750                             # No media template
1751                             # Example: https://www.youtube.com/watch?v=iXZV5uAYMJI
1752                             # or any YouTube dashsegments video
1753                             fragments = []
1754                             s_num = 0
1755                             for segment_url in representation_ms_info['segment_urls']:
1756                                 s = representation_ms_info['s'][s_num]
1757                                 for r in range(s.get('r', 0) + 1):
1758                                     fragments.append({
1759                                         'url': segment_url,
1760                                         'duration': float_or_none(s['d'], representation_ms_info['timescale']),
1761                                     })
1762                             representation_ms_info['fragments'] = fragments
1763                         # NB: MPD manifest may contain direct URLs to unfragmented media.
1764                         # No fragments key is present in this case.
1765                         if 'fragments' in representation_ms_info:
1766                             f.update({
1767                                 'fragments': [],
1768                                 'protocol': 'http_dash_segments',
1769                             })
1770                             if 'initialization_url' in representation_ms_info:
1771                                 initialization_url = representation_ms_info['initialization_url'].replace('$RepresentationID$', representation_id)
1772                                 if not f.get('url'):
1773                                     f['url'] = initialization_url
1774                                 f['fragments'].append({'url': initialization_url})
1775                             f['fragments'].extend(representation_ms_info['fragments'])
1776                             for fragment in f['fragments']:
1777                                 fragment['url'] = combine_url(base_url, fragment['url'])
1778                         try:
1779                             existing_format = next(
1780                                 fo for fo in formats
1781                                 if fo['format_id'] == representation_id)
1782                         except StopIteration:
1783                             full_info = formats_dict.get(representation_id, {}).copy()
1784                             full_info.update(f)
1785                             formats.append(full_info)
1786                         else:
1787                             existing_format.update(f)
1788                     else:
1789                         self.report_warning('Unknown MIME type %s in DASH manifest' % mime_type)
1790         return formats
1791
1792     def _extract_ism_formats(self, ism_url, video_id, ism_id=None, note=None, errnote=None, fatal=True):
1793         res = self._download_webpage_handle(
1794             ism_url, video_id,
1795             note=note or 'Downloading ISM manifest',
1796             errnote=errnote or 'Failed to download ISM manifest',
1797             fatal=fatal)
1798         if res is False:
1799             return []
1800         ism, urlh = res
1801
1802         return self._parse_ism_formats(
1803             compat_etree_fromstring(ism.encode('utf-8')), urlh.geturl(), ism_id)
1804
1805     def _parse_ism_formats(self, ism_doc, ism_url, ism_id=None):
1806         if ism_doc.get('IsLive') == 'TRUE' or ism_doc.find('Protection') is not None:
1807             return []
1808
1809         duration = int(ism_doc.attrib['Duration'])
1810         timescale = int_or_none(ism_doc.get('TimeScale')) or 10000000
1811
1812         formats = []
1813         for stream in ism_doc.findall('StreamIndex'):
1814             stream_type = stream.get('Type')
1815             if stream_type not in ('video', 'audio'):
1816                 continue
1817             url_pattern = stream.attrib['Url']
1818             stream_timescale = int_or_none(stream.get('TimeScale')) or timescale
1819             stream_name = stream.get('Name')
1820             for track in stream.findall('QualityLevel'):
1821                 fourcc = track.get('FourCC')
1822                 # TODO: add support for WVC1 and WMAP
1823                 if fourcc not in ('H264', 'AVC1', 'AACL'):
1824                     self.report_warning('%s is not a supported codec' % fourcc)
1825                     continue
1826                 tbr = int(track.attrib['Bitrate']) // 1000
1827                 width = int_or_none(track.get('MaxWidth'))
1828                 height = int_or_none(track.get('MaxHeight'))
1829                 sampling_rate = int_or_none(track.get('SamplingRate'))
1830
1831                 track_url_pattern = re.sub(r'{[Bb]itrate}', track.attrib['Bitrate'], url_pattern)
1832                 track_url_pattern = compat_urlparse.urljoin(ism_url, track_url_pattern)
1833
1834                 fragments = []
1835                 fragment_ctx = {
1836                     'time': 0,
1837                 }
1838                 stream_fragments = stream.findall('c')
1839                 for stream_fragment_index, stream_fragment in enumerate(stream_fragments):
1840                     fragment_ctx['time'] = int_or_none(stream_fragment.get('t')) or fragment_ctx['time']
1841                     fragment_repeat = int_or_none(stream_fragment.get('r')) or 1
1842                     fragment_ctx['duration'] = int_or_none(stream_fragment.get('d'))
1843                     if not fragment_ctx['duration']:
1844                         try:
1845                             next_fragment_time = int(stream_fragment[stream_fragment_index + 1].attrib['t'])
1846                         except IndexError:
1847                             next_fragment_time = duration
1848                         fragment_ctx['duration'] = (next_fragment_time - fragment_ctx['time']) / fragment_repeat
1849                     for _ in range(fragment_repeat):
1850                         fragments.append({
1851                             'url': re.sub(r'{start[ _]time}', compat_str(fragment_ctx['time']), track_url_pattern),
1852                             'duration': fragment_ctx['duration'] / stream_timescale,
1853                         })
1854                         fragment_ctx['time'] += fragment_ctx['duration']
1855
1856                 format_id = []
1857                 if ism_id:
1858                     format_id.append(ism_id)
1859                 if stream_name:
1860                     format_id.append(stream_name)
1861                 format_id.append(compat_str(tbr))
1862
1863                 formats.append({
1864                     'format_id': '-'.join(format_id),
1865                     'url': ism_url,
1866                     'manifest_url': ism_url,
1867                     'ext': 'ismv' if stream_type == 'video' else 'isma',
1868                     'width': width,
1869                     'height': height,
1870                     'tbr': tbr,
1871                     'asr': sampling_rate,
1872                     'vcodec': 'none' if stream_type == 'audio' else fourcc,
1873                     'acodec': 'none' if stream_type == 'video' else fourcc,
1874                     'protocol': 'ism',
1875                     'fragments': fragments,
1876                     '_download_params': {
1877                         'duration': duration,
1878                         'timescale': stream_timescale,
1879                         'width': width or 0,
1880                         'height': height or 0,
1881                         'fourcc': fourcc,
1882                         'codec_private_data': track.get('CodecPrivateData'),
1883                         'sampling_rate': sampling_rate,
1884                         'channels': int_or_none(track.get('Channels', 2)),
1885                         'bits_per_sample': int_or_none(track.get('BitsPerSample', 16)),
1886                         'nal_unit_length_field': int_or_none(track.get('NALUnitLengthField', 4)),
1887                     },
1888                 })
1889         return formats
1890
1891     def _parse_html5_media_entries(self, base_url, webpage, video_id, m3u8_id=None, m3u8_entry_protocol='m3u8'):
1892         def absolute_url(video_url):
1893             return compat_urlparse.urljoin(base_url, video_url)
1894
1895         def parse_content_type(content_type):
1896             if not content_type:
1897                 return {}
1898             ctr = re.search(r'(?P<mimetype>[^/]+/[^;]+)(?:;\s*codecs="?(?P<codecs>[^"]+))?', content_type)
1899             if ctr:
1900                 mimetype, codecs = ctr.groups()
1901                 f = parse_codecs(codecs)
1902                 f['ext'] = mimetype2ext(mimetype)
1903                 return f
1904             return {}
1905
1906         def _media_formats(src, cur_media_type):
1907             full_url = absolute_url(src)
1908             if determine_ext(full_url) == 'm3u8':
1909                 is_plain_url = False
1910                 formats = self._extract_m3u8_formats(
1911                     full_url, video_id, ext='mp4',
1912                     entry_protocol=m3u8_entry_protocol, m3u8_id=m3u8_id)
1913             else:
1914                 is_plain_url = True
1915                 formats = [{
1916                     'url': full_url,
1917                     'vcodec': 'none' if cur_media_type == 'audio' else None,
1918                 }]
1919             return is_plain_url, formats
1920
1921         entries = []
1922         media_tags = [(media_tag, media_type, '')
1923                       for media_tag, media_type
1924                       in re.findall(r'(?s)(<(video|audio)[^>]*/>)', webpage)]
1925         media_tags.extend(re.findall(r'(?s)(<(?P<tag>video|audio)[^>]*>)(.*?)</(?P=tag)>', webpage))
1926         for media_tag, media_type, media_content in media_tags:
1927             media_info = {
1928                 'formats': [],
1929                 'subtitles': {},
1930             }
1931             media_attributes = extract_attributes(media_tag)
1932             src = media_attributes.get('src')
1933             if src:
1934                 _, formats = _media_formats(src, media_type)
1935                 media_info['formats'].extend(formats)
1936             media_info['thumbnail'] = media_attributes.get('poster')
1937             if media_content:
1938                 for source_tag in re.findall(r'<source[^>]+>', media_content):
1939                     source_attributes = extract_attributes(source_tag)
1940                     src = source_attributes.get('src')
1941                     if not src:
1942                         continue
1943                     is_plain_url, formats = _media_formats(src, media_type)
1944                     if is_plain_url:
1945                         f = parse_content_type(source_attributes.get('type'))
1946                         f.update(formats[0])
1947                         media_info['formats'].append(f)
1948                     else:
1949                         media_info['formats'].extend(formats)
1950                 for track_tag in re.findall(r'<track[^>]+>', media_content):
1951                     track_attributes = extract_attributes(track_tag)
1952                     kind = track_attributes.get('kind')
1953                     if not kind or kind in ('subtitles', 'captions'):
1954                         src = track_attributes.get('src')
1955                         if not src:
1956                             continue
1957                         lang = track_attributes.get('srclang') or track_attributes.get('lang') or track_attributes.get('label')
1958                         media_info['subtitles'].setdefault(lang, []).append({
1959                             'url': absolute_url(src),
1960                         })
1961             if media_info['formats'] or media_info['subtitles']:
1962                 entries.append(media_info)
1963         return entries
1964
1965     def _extract_akamai_formats(self, manifest_url, video_id):
1966         formats = []
1967         hdcore_sign = 'hdcore=3.7.0'
1968         f4m_url = re.sub(r'(https?://.+?)/i/', r'\1/z/', manifest_url).replace('/master.m3u8', '/manifest.f4m')
1969         if 'hdcore=' not in f4m_url:
1970             f4m_url += ('&' if '?' in f4m_url else '?') + hdcore_sign
1971         f4m_formats = self._extract_f4m_formats(
1972             f4m_url, video_id, f4m_id='hds', fatal=False)
1973         for entry in f4m_formats:
1974             entry.update({'extra_param_to_segment_url': hdcore_sign})
1975         formats.extend(f4m_formats)
1976         m3u8_url = re.sub(r'(https?://.+?)/z/', r'\1/i/', manifest_url).replace('/manifest.f4m', '/master.m3u8')
1977         formats.extend(self._extract_m3u8_formats(
1978             m3u8_url, video_id, 'mp4', 'm3u8_native',
1979             m3u8_id='hls', fatal=False))
1980         return formats
1981
1982     def _extract_wowza_formats(self, url, video_id, m3u8_entry_protocol='m3u8_native', skip_protocols=[]):
1983         url = re.sub(r'/(?:manifest|playlist|jwplayer)\.(?:m3u8|f4m|mpd|smil)', '', url)
1984         url_base = self._search_regex(r'(?:https?|rtmp|rtsp)(://[^?]+)', url, 'format url')
1985         http_base_url = 'http' + url_base
1986         formats = []
1987         if 'm3u8' not in skip_protocols:
1988             formats.extend(self._extract_m3u8_formats(
1989                 http_base_url + '/playlist.m3u8', video_id, 'mp4',
1990                 m3u8_entry_protocol, m3u8_id='hls', fatal=False))
1991         if 'f4m' not in skip_protocols:
1992             formats.extend(self._extract_f4m_formats(
1993                 http_base_url + '/manifest.f4m',
1994                 video_id, f4m_id='hds', fatal=False))
1995         if 'dash' not in skip_protocols:
1996             formats.extend(self._extract_mpd_formats(
1997                 http_base_url + '/manifest.mpd',
1998                 video_id, mpd_id='dash', fatal=False))
1999         if re.search(r'(?:/smil:|\.smil)', url_base):
2000             if 'smil' not in skip_protocols:
2001                 rtmp_formats = self._extract_smil_formats(
2002                     http_base_url + '/jwplayer.smil',
2003                     video_id, fatal=False)
2004                 for rtmp_format in rtmp_formats:
2005                     rtsp_format = rtmp_format.copy()
2006                     rtsp_format['url'] = '%s/%s' % (rtmp_format['url'], rtmp_format['play_path'])
2007                     del rtsp_format['play_path']
2008                     del rtsp_format['ext']
2009                     rtsp_format.update({
2010                         'url': rtsp_format['url'].replace('rtmp://', 'rtsp://'),
2011                         'format_id': rtmp_format['format_id'].replace('rtmp', 'rtsp'),
2012                         'protocol': 'rtsp',
2013                     })
2014                     formats.extend([rtmp_format, rtsp_format])
2015         else:
2016             for protocol in ('rtmp', 'rtsp'):
2017                 if protocol not in skip_protocols:
2018                     formats.append({
2019                         'url': protocol + url_base,
2020                         'format_id': protocol,
2021                         'protocol': protocol,
2022                     })
2023         return formats
2024
2025     def _live_title(self, name):
2026         """ Generate the title for a live video """
2027         now = datetime.datetime.now()
2028         now_str = now.strftime('%Y-%m-%d %H:%M')
2029         return name + ' ' + now_str
2030
2031     def _int(self, v, name, fatal=False, **kwargs):
2032         res = int_or_none(v, **kwargs)
2033         if 'get_attr' in kwargs:
2034             print(getattr(v, kwargs['get_attr']))
2035         if res is None:
2036             msg = 'Failed to extract %s: Could not parse value %r' % (name, v)
2037             if fatal:
2038                 raise ExtractorError(msg)
2039             else:
2040                 self._downloader.report_warning(msg)
2041         return res
2042
2043     def _float(self, v, name, fatal=False, **kwargs):
2044         res = float_or_none(v, **kwargs)
2045         if res is None:
2046             msg = 'Failed to extract %s: Could not parse value %r' % (name, v)
2047             if fatal:
2048                 raise ExtractorError(msg)
2049             else:
2050                 self._downloader.report_warning(msg)
2051         return res
2052
2053     def _set_cookie(self, domain, name, value, expire_time=None):
2054         cookie = compat_cookiejar.Cookie(
2055             0, name, value, None, None, domain, None,
2056             None, '/', True, False, expire_time, '', None, None, None)
2057         self._downloader.cookiejar.set_cookie(cookie)
2058
2059     def _get_cookies(self, url):
2060         """ Return a compat_cookies.SimpleCookie with the cookies for the url """
2061         req = sanitized_Request(url)
2062         self._downloader.cookiejar.add_cookie_header(req)
2063         return compat_cookies.SimpleCookie(req.get_header('Cookie'))
2064
2065     def get_testcases(self, include_onlymatching=False):
2066         t = getattr(self, '_TEST', None)
2067         if t:
2068             assert not hasattr(self, '_TESTS'), \
2069                 '%s has _TEST and _TESTS' % type(self).__name__
2070             tests = [t]
2071         else:
2072             tests = getattr(self, '_TESTS', [])
2073         for t in tests:
2074             if not include_onlymatching and t.get('only_matching', False):
2075                 continue
2076             t['name'] = type(self).__name__[:-len('IE')]
2077             yield t
2078
2079     def is_suitable(self, age_limit):
2080         """ Test whether the extractor is generally suitable for the given
2081         age limit (i.e. pornographic sites are not, all others usually are) """
2082
2083         any_restricted = False
2084         for tc in self.get_testcases(include_onlymatching=False):
2085             if tc.get('playlist', []):
2086                 tc = tc['playlist'][0]
2087             is_restricted = age_restricted(
2088                 tc.get('info_dict', {}).get('age_limit'), age_limit)
2089             if not is_restricted:
2090                 return True
2091             any_restricted = any_restricted or is_restricted
2092         return not any_restricted
2093
2094     def extract_subtitles(self, *args, **kwargs):
2095         if (self._downloader.params.get('writesubtitles', False) or
2096                 self._downloader.params.get('listsubtitles')):
2097             return self._get_subtitles(*args, **kwargs)
2098         return {}
2099
2100     def _get_subtitles(self, *args, **kwargs):
2101         raise NotImplementedError('This method must be implemented by subclasses')
2102
2103     @staticmethod
2104     def _merge_subtitle_items(subtitle_list1, subtitle_list2):
2105         """ Merge subtitle items for one language. Items with duplicated URLs
2106         will be dropped. """
2107         list1_urls = set([item['url'] for item in subtitle_list1])
2108         ret = list(subtitle_list1)
2109         ret.extend([item for item in subtitle_list2 if item['url'] not in list1_urls])
2110         return ret
2111
2112     @classmethod
2113     def _merge_subtitles(cls, subtitle_dict1, subtitle_dict2):
2114         """ Merge two subtitle dictionaries, language by language. """
2115         ret = dict(subtitle_dict1)
2116         for lang in subtitle_dict2:
2117             ret[lang] = cls._merge_subtitle_items(subtitle_dict1.get(lang, []), subtitle_dict2[lang])
2118         return ret
2119
2120     def extract_automatic_captions(self, *args, **kwargs):
2121         if (self._downloader.params.get('writeautomaticsub', False) or
2122                 self._downloader.params.get('listsubtitles')):
2123             return self._get_automatic_captions(*args, **kwargs)
2124         return {}
2125
2126     def _get_automatic_captions(self, *args, **kwargs):
2127         raise NotImplementedError('This method must be implemented by subclasses')
2128
2129     def mark_watched(self, *args, **kwargs):
2130         if (self._downloader.params.get('mark_watched', False) and
2131                 (self._get_login_info()[0] is not None or
2132                     self._downloader.params.get('cookiefile') is not None)):
2133             self._mark_watched(*args, **kwargs)
2134
2135     def _mark_watched(self, *args, **kwargs):
2136         raise NotImplementedError('This method must be implemented by subclasses')
2137
2138     def geo_verification_headers(self):
2139         headers = {}
2140         geo_verification_proxy = self._downloader.params.get('geo_verification_proxy')
2141         if geo_verification_proxy:
2142             headers['Ytdl-request-proxy'] = geo_verification_proxy
2143         return headers
2144
2145     def _generic_id(self, url):
2146         return compat_urllib_parse_unquote(os.path.splitext(url.rstrip('/').split('/')[-1])[0])
2147
2148     def _generic_title(self, url):
2149         return compat_urllib_parse_unquote(os.path.splitext(url_basename(url))[0])
2150
2151
2152 class SearchInfoExtractor(InfoExtractor):
2153     """
2154     Base class for paged search queries extractors.
2155     They accept URLs in the format _SEARCH_KEY(|all|[0-9]):{query}
2156     Instances should define _SEARCH_KEY and _MAX_RESULTS.
2157     """
2158
2159     @classmethod
2160     def _make_valid_url(cls):
2161         return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
2162
2163     @classmethod
2164     def suitable(cls, url):
2165         return re.match(cls._make_valid_url(), url) is not None
2166
2167     def _real_extract(self, query):
2168         mobj = re.match(self._make_valid_url(), query)
2169         if mobj is None:
2170             raise ExtractorError('Invalid search query "%s"' % query)
2171
2172         prefix = mobj.group('prefix')
2173         query = mobj.group('query')
2174         if prefix == '':
2175             return self._get_n_results(query, 1)
2176         elif prefix == 'all':
2177             return self._get_n_results(query, self._MAX_RESULTS)
2178         else:
2179             n = int(prefix)
2180             if n <= 0:
2181                 raise ExtractorError('invalid download number %s for query "%s"' % (n, query))
2182             elif n > self._MAX_RESULTS:
2183                 self._downloader.report_warning('%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
2184                 n = self._MAX_RESULTS
2185             return self._get_n_results(query, n)
2186
2187     def _get_n_results(self, query, n):
2188         """Get a specified number of results for a query"""
2189         raise NotImplementedError('This method must be implemented by subclasses')
2190
2191     @property
2192     def SEARCH_KEY(self):
2193         return self._SEARCH_KEY