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

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