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