yt_dlp/extractor/hbo.py

   1 import re
   2
   3 from .common import InfoExtractor
   4 from ..utils import (
   5     xpath_text,
   6     xpath_element,
   7     int_or_none,
   8     parse_duration,
   9     urljoin,
  10 )
  11
  12
  13 class HBOBaseIE(InfoExtractor):
  14     _FORMATS_INFO = {
  15         'pro7': {
  16             'width': 1280,
  17             'height': 720,
  18         },
  19         '1920': {
  20             'width': 1280,
  21             'height': 720,
  22         },
  23         'pro6': {
  24             'width': 768,
  25             'height': 432,
  26         },
  27         '640': {
  28             'width': 768,
  29             'height': 432,
  30         },
  31         'pro5': {
  32             'width': 640,
  33             'height': 360,
  34         },
  35         'highwifi': {
  36             'width': 640,
  37             'height': 360,
  38         },
  39         'high3g': {
  40             'width': 640,
  41             'height': 360,
  42         },
  43         'medwifi': {
  44             'width': 400,
  45             'height': 224,
  46         },
  47         'med3g': {
  48             'width': 400,
  49             'height': 224,
  50         },
  51     }
  52
  53     def _extract_info(self, url, display_id):
  54         video_data = self._download_xml(url, display_id)
  55         video_id = xpath_text(video_data, 'id', fatal=True)
  56         episode_title = title = xpath_text(video_data, 'title', fatal=True)
  57         series = xpath_text(video_data, 'program')
  58         if series:
  59             title = '%s - %s' % (series, title)
  60
  61         formats = []
  62         for source in xpath_element(video_data, 'videos', 'sources', True):
  63             if source.tag == 'size':
  64                 path = xpath_text(source, './/path')
  65                 if not path:
  66                     continue
  67                 width = source.attrib.get('width')
  68                 format_info = self._FORMATS_INFO.get(width, {})
  69                 height = format_info.get('height')
  70                 fmt = {
  71                     'url': path,
  72                     'format_id': 'http%s' % ('-%dp' % height if height else ''),
  73                     'width': format_info.get('width'),
  74                     'height': height,
  75                 }
  76                 rtmp = re.search(r'^(?P<url>rtmpe?://[^/]+/(?P<app>.+))/(?P<playpath>mp4:.+)$', path)
  77                 if rtmp:
  78                     fmt.update({
  79                         'url': rtmp.group('url'),
  80                         'play_path': rtmp.group('playpath'),
  81                         'app': rtmp.group('app'),
  82                         'ext': 'flv',
  83                         'format_id': fmt['format_id'].replace('http', 'rtmp'),
  84                     })
  85                 formats.append(fmt)
  86             else:
  87                 video_url = source.text
  88                 if not video_url:
  89                     continue
  90                 if source.tag == 'tarball':
  91                     formats.extend(self._extract_m3u8_formats(
  92                         video_url.replace('.tar', '/base_index_w8.m3u8'),
  93                         video_id, 'mp4', 'm3u8_native', m3u8_id='hls', fatal=False))
  94                 elif source.tag == 'hls':
  95                     m3u8_formats = self._extract_m3u8_formats(
  96                         video_url.replace('.tar', '/base_index.m3u8'),
  97                         video_id, 'mp4', 'm3u8_native', m3u8_id='hls', fatal=False)
  98                     for f in m3u8_formats:
  99                         if f.get('vcodec') == 'none' and not f.get('tbr'):
 100                             f['tbr'] = int_or_none(self._search_regex(
 101                                 r'-(\d+)k/', f['url'], 'tbr', default=None))
 102                     formats.extend(m3u8_formats)
 103                 elif source.tag == 'dash':
 104                     formats.extend(self._extract_mpd_formats(
 105                         video_url.replace('.tar', '/manifest.mpd'),
 106                         video_id, mpd_id='dash', fatal=False))
 107                 else:
 108                     format_info = self._FORMATS_INFO.get(source.tag, {})
 109                     formats.append({
 110                         'format_id': 'http-%s' % source.tag,
 111                         'url': video_url,
 112                         'width': format_info.get('width'),
 113                         'height': format_info.get('height'),
 114                     })
 115
 116         thumbnails = []
 117         card_sizes = xpath_element(video_data, 'titleCardSizes')
 118         if card_sizes is not None:
 119             for size in card_sizes:
 120                 path = xpath_text(size, 'path')
 121                 if not path:
 122                     continue
 123                 width = int_or_none(size.get('width'))
 124                 thumbnails.append({
 125                     'id': width,
 126                     'url': path,
 127                     'width': width,
 128                 })
 129
 130         subtitles = None
 131         caption_url = xpath_text(video_data, 'captionUrl')
 132         if caption_url:
 133             subtitles = {
 134                 'en': [{
 135                     'url': caption_url,
 136                     'ext': 'ttml'
 137                 }],
 138             }
 139
 140         return {
 141             'id': video_id,
 142             'title': title,
 143             'duration': parse_duration(xpath_text(video_data, 'duration/tv14')),
 144             'series': series,
 145             'episode': episode_title,
 146             'formats': formats,
 147             'thumbnails': thumbnails,
 148             'subtitles': subtitles,
 149         }
 150
 151
 152 class HBOIE(HBOBaseIE):
 153     IE_NAME = 'hbo'
 154     _VALID_URL = r'https?://(?:www\.)?hbo\.com/(?:video|embed)(?:/[^/]+)*/(?P<id>[^/?#]+)'
 155     _TEST = {
 156         'url': 'https://www.hbo.com/video/game-of-thrones/seasons/season-8/videos/trailer',
 157         'md5': '8126210656f433c452a21367f9ad85b3',
 158         'info_dict': {
 159             'id': '22113301',
 160             'ext': 'mp4',
 161             'title': 'Game of Thrones - Trailer',
 162         },
 163         'expected_warnings': ['Unknown MIME type application/mp4 in DASH manifest'],
 164     }
 165
 166     def _real_extract(self, url):
 167         display_id = self._match_id(url)
 168         webpage = self._download_webpage(url, display_id)
 169         location_path = self._parse_json(self._html_search_regex(
 170             r'data-state="({.+?})"', webpage, 'state'), display_id)['video']['locationUrl']
 171         return self._extract_info(urljoin(url, location_path), display_id)