logo

youtube-dl

[mirror] Download/Watch videos from video hostersgit clone https://hacktivis.me/git/mirror/youtube-dl.git

rai.py (22552B)

    

  1. # coding: utf-8
  2. from __future__ import unicode_literals
  4. import re
  6. from .common import InfoExtractor
  7. from ..compat import (
  8.     compat_str,
  9.     compat_urlparse,
  10. )
  11. from ..utils import (
  12.     determine_ext,
  13.     ExtractorError,
  14.     find_xpath_attr,
  15.     fix_xml_ampersands,
  16.     GeoRestrictedError,
  17.     HEADRequest,
  18.     int_or_none,
  19.     parse_duration,
  20.     remove_start,
  21.     strip_or_none,
  22.     try_get,
  23.     unified_strdate,
  24.     unified_timestamp,
  25.     update_url_query,
  26.     urljoin,
  27.     xpath_text,
  28. )
  31. class RaiBaseIE(InfoExtractor):
  32.     _UUID_RE = r'[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}'
  33.     _GEO_COUNTRIES = ['IT']
  34.     _GEO_BYPASS = False
  36.     def _extract_relinker_info(self, relinker_url, video_id):
  37.         if not re.match(r'https?://', relinker_url):
  38.             return {'formats': [{'url': relinker_url}]}
  40.         formats = []
  41.         geoprotection = None
  42.         is_live = None
  43.         duration = None
  45.         for platform in ('mon', 'flash', 'native'):
  46.             relinker = self._download_xml(
  47.                 relinker_url, video_id,
  48.                 note='Downloading XML metadata for platform %s' % platform,
  49.                 transform_source=fix_xml_ampersands,
  50.                 query={'output': 45, 'pl': platform},
  51.                 headers=self.geo_verification_headers())
  53.             if not geoprotection:
  54.                 geoprotection = xpath_text(
  55.                     relinker, './geoprotection', default=None) == 'Y'
  57.             if not is_live:
  58.                 is_live = xpath_text(
  59.                     relinker, './is_live', default=None) == 'Y'
  60.             if not duration:
  61.                 duration = parse_duration(xpath_text(
  62.                     relinker, './duration', default=None))
  64.             url_elem = find_xpath_attr(relinker, './url', 'type', 'content')
  65.             if url_elem is None:
  66.                 continue
  68.             media_url = url_elem.text
  70.             # This does not imply geo restriction (e.g.
  71.             # http://www.raisport.rai.it/dl/raiSport/media/rassegna-stampa-04a9f4bd-b563-40cf-82a6-aad3529cb4a9.html)
  72.             if '/video_no_available.mp4' in media_url:
  73.                 continue
  75.             ext = determine_ext(media_url)
  76.             if (ext == 'm3u8' and platform != 'mon') or (ext == 'f4m' and platform != 'flash'):
  77.                 continue
  79.             if ext == 'm3u8' or 'format=m3u8' in media_url or platform == 'mon':
  80.                 formats.extend(self._extract_m3u8_formats(
  81.                     media_url, video_id, 'mp4', 'm3u8_native',
  82.                     m3u8_id='hls', fatal=False))
  83.             elif ext == 'f4m' or platform == 'flash':
  84.                 manifest_url = update_url_query(
  85.                     media_url.replace('manifest#live_hds.f4m', 'manifest.f4m'),
  86.                     {'hdcore': '3.7.0', 'plugin': 'aasp-3.7.0.39.44'})
  87.                 formats.extend(self._extract_f4m_formats(
  88.                     manifest_url, video_id, f4m_id='hds', fatal=False))
  89.             else:
  90.                 bitrate = int_or_none(xpath_text(relinker, 'bitrate'))
  91.                 formats.append({
  92.                     'url': media_url,
  93.                     'tbr': bitrate if bitrate > 0 else None,
  94.                     'format_id': 'http-%d' % bitrate if bitrate > 0 else 'http',
  95.                 })
  97.         if not formats and geoprotection is True:
  98.             self.raise_geo_restricted(countries=self._GEO_COUNTRIES)
  100.         formats.extend(self._create_http_urls(relinker_url, formats))
  102.         return dict((k, v) for k, v in {
  103.             'is_live': is_live,
  104.             'duration': duration,
  105.             'formats': formats,
  106.         }.items() if v is not None)
  108.     def _create_http_urls(self, relinker_url, fmts):
  109.         _RELINKER_REG = r'https?://(?P<host>[^/]+?)/(?:i/)?(?P<extra>[^/]+?)/(?P<path>.+?)/(?P<id>\w+)(?:_(?P<quality>[\d\,]+))?(?:\.mp4|/playlist\.m3u8).+?'
  110.         _MP4_TMPL = '%s&overrideUserAgentRule=mp4-%s'
  111.         _QUALITY = {
  112.             # tbr: w, h
  113.             '250': [352, 198],
  114.             '400': [512, 288],
  115.             '700': [512, 288],
  116.             '800': [700, 394],
  117.             '1200': [736, 414],
  118.             '1800': [1024, 576],
  119.             '2400': [1280, 720],
  120.             '3200': [1440, 810],
  121.             '3600': [1440, 810],
  122.             '5000': [1920, 1080],
  123.             '10000': [1920, 1080],
  124.         }
  126.         def test_url(url):
  127.             resp = self._request_webpage(
  128.                 HEADRequest(url), None, headers={'User-Agent': 'Rai'},
  129.                 fatal=False, errnote=False, note=False)
  131.             if resp is False:
  132.                 return False
  134.             if resp.code == 200:
  135.                 return False if resp.url == url else resp.url
  136.             return None
  138.         def get_format_info(tbr):
  139.             import math
  140.             br = int_or_none(tbr)
  141.             if len(fmts) == 1 and not br:
  142.                 br = fmts[0].get('tbr')
  143.             if br > 300:
  144.                 tbr = compat_str(math.floor(br / 100) * 100)
  145.             else:
  146.                 tbr = '250'
  148.             # try extracting info from available m3u8 formats
  149.             format_copy = None
  150.             for f in fmts:
  151.                 if f.get('tbr'):
  152.                     br_limit = math.floor(br / 100)
  153.                     if br_limit - 1 <= math.floor(f['tbr'] / 100) <= br_limit + 1:
  154.                         format_copy = f.copy()
  155.             return {
  156.                 'width': format_copy.get('width'),
  157.                 'height': format_copy.get('height'),
  158.                 'tbr': format_copy.get('tbr'),
  159.                 'vcodec': format_copy.get('vcodec'),
  160.                 'acodec': format_copy.get('acodec'),
  161.                 'fps': format_copy.get('fps'),
  162.                 'format_id': 'https-%s' % tbr,
  163.             } if format_copy else {
  164.                 'width': _QUALITY[tbr][0],
  165.                 'height': _QUALITY[tbr][1],
  166.                 'format_id': 'https-%s' % tbr,
  167.                 'tbr': int(tbr),
  168.             }
  170.         loc = test_url(_MP4_TMPL % (relinker_url, '*'))
  171.         if not isinstance(loc, compat_str):
  172.             return []
  174.         mobj = re.match(
  175.             _RELINKER_REG,
  176.             test_url(relinker_url) or '')
  177.         if not mobj:
  178.             return []
  180.         available_qualities = mobj.group('quality').split(',') if mobj.group('quality') else ['*']
  181.         available_qualities = [i for i in available_qualities if i]
  183.         formats = []
  184.         for q in available_qualities:
  185.             fmt = {
  186.                 'url': _MP4_TMPL % (relinker_url, q),
  187.                 'protocol': 'https',
  188.                 'ext': 'mp4',
  189.             }
  190.             fmt.update(get_format_info(q))
  191.             formats.append(fmt)
  192.         return formats
  194.     @staticmethod
  195.     def _extract_subtitles(url, video_data):
  196.         STL_EXT = 'stl'
  197.         SRT_EXT = 'srt'
  198.         subtitles = {}
  199.         subtitles_array = video_data.get('subtitlesArray') or []
  200.         for k in ('subtitles', 'subtitlesUrl'):
  201.             subtitles_array.append({'url': video_data.get(k)})
  202.         for subtitle in subtitles_array:
  203.             sub_url = subtitle.get('url')
  204.             if sub_url and isinstance(sub_url, compat_str):
  205.                 sub_lang = subtitle.get('language') or 'it'
  206.                 sub_url = urljoin(url, sub_url)
  207.                 sub_ext = determine_ext(sub_url, SRT_EXT)
  208.                 subtitles.setdefault(sub_lang, []).append({
  209.                     'ext': sub_ext,
  210.                     'url': sub_url,
  211.                 })
  212.                 if STL_EXT == sub_ext:
  213.                     subtitles[sub_lang].append({
  214.                         'ext': SRT_EXT,
  215.                         'url': sub_url[:-len(STL_EXT)] + SRT_EXT,
  216.                     })
  217.         return subtitles
  220. class RaiPlayIE(RaiBaseIE):
  221.     _VALID_URL = r'(?P<base>https?://(?:www\.)?raiplay\.it/.+?-(?P<id>%s))\.(?:html|json)' % RaiBaseIE._UUID_RE
  222.     _TESTS = [{
  223.         'url': 'http://www.raiplay.it/video/2014/04/Report-del-07042014-cb27157f-9dd0-4aee-b788-b1f67643a391.html',
  224.         'md5': '8970abf8caf8aef4696e7b1f2adfc696',
  225.         'info_dict': {
  226.             'id': 'cb27157f-9dd0-4aee-b788-b1f67643a391',
  227.             'ext': 'mp4',
  228.             'title': 'Report del 07/04/2014',
  229.             'alt_title': 'St 2013/14 - Espresso nel caffè - 07/04/2014',
  230.             'description': 'md5:d730c168a58f4bb35600fc2f881ec04e',
  231.             'thumbnail': r're:^https?://.*\.jpg$',
  232.             'uploader': 'Rai Gulp',
  233.             'duration': 6160,
  234.             'series': 'Report',
  235.             'season': '2013/14',
  236.             'subtitles': {
  237.                 'it': 'count:2',
  238.             },
  239.         },
  240.         'params': {
  241.             'skip_download': True,
  242.         },
  243.     }, {
  244.         # 1080p direct mp4 url
  245.         'url': 'https://www.raiplay.it/video/2021/03/Leonardo-S1E1-b5703b02-82ee-475a-85b6-c9e4a8adf642.html',
  246.         'md5': '2e501e8651d72f05ffe8f5d286ad560b',
  247.         'info_dict': {
  248.             'id': 'b5703b02-82ee-475a-85b6-c9e4a8adf642',
  249.             'ext': 'mp4',
  250.             'title': 'Leonardo - S1E1',
  251.             'alt_title': 'St 1 Ep 1 - Episodio 1',
  252.             'description': 'md5:f5360cd267d2de146e4e3879a5a47d31',
  253.             'thumbnail': r're:^https?://.*\.jpg$',
  254.             'uploader': 'Rai 1',
  255.             'duration': 3229,
  256.             'series': 'Leonardo',
  257.             'season': 'Season 1',
  258.         },
  259.     }, {
  260.         'url': 'http://www.raiplay.it/video/2016/11/gazebotraindesi-efebe701-969c-4593-92f3-285f0d1ce750.html?',
  261.         'only_matching': True,
  262.     }, {
  263.         # subtitles at 'subtitlesArray' key (see #27698)
  264.         'url': 'https://www.raiplay.it/video/2020/12/Report---04-01-2021-2e90f1de-8eee-4de4-ac0e-78d21db5b600.html',
  265.         'only_matching': True,
  266.     }, {
  267.         # DRM protected
  268.         'url': 'https://www.raiplay.it/video/2020/09/Lo-straordinario-mondo-di-Zoey-S1E1-Lo-straordinario-potere-di-Zoey-ed493918-1d32-44b7-8454-862e473d00ff.html',
  269.         'only_matching': True,
  270.     }]
  272.     def _real_extract(self, url):
  273.         base, video_id = re.match(self._VALID_URL, url).groups()
  275.         media = self._download_json(
  276.             base + '.json', video_id, 'Downloading video JSON')
  278.         if try_get(
  279.                 media,
  280.                 (lambda x: x['rights_management']['rights']['drm'],
  281.                  lambda x: x['program_info']['rights_management']['rights']['drm']),
  282.                 dict):
  283.             raise ExtractorError('This video is DRM protected.', expected=True)
  285.         title = media['name']
  287.         video = media['video']
  289.         relinker_info = self._extract_relinker_info(video['content_url'], video_id)
  290.         self._sort_formats(relinker_info['formats'])
  292.         thumbnails = []
  293.         for _, value in media.get('images', {}).items():
  294.             if value:
  295.                 thumbnails.append({
  296.                     'url': urljoin(url, value),
  297.                 })
  299.         date_published = media.get('date_published')
  300.         time_published = media.get('time_published')
  301.         if date_published and time_published:
  302.             date_published += ' ' + time_published
  304.         subtitles = self._extract_subtitles(url, video)
  306.         program_info = media.get('program_info') or {}
  307.         season = media.get('season')
  309.         info = {
  310.             'id': remove_start(media.get('id'), 'ContentItem-') or video_id,
  311.             'display_id': video_id,
  312.             'title': self._live_title(title) if relinker_info.get(
  313.                 'is_live') else title,
  314.             'alt_title': strip_or_none(media.get('subtitle')),
  315.             'description': media.get('description'),
  316.             'uploader': strip_or_none(media.get('channel')),
  317.             'creator': strip_or_none(media.get('editor') or None),
  318.             'duration': parse_duration(video.get('duration')),
  319.             'timestamp': unified_timestamp(date_published),
  320.             'thumbnails': thumbnails,
  321.             'series': program_info.get('name'),
  322.             'season_number': int_or_none(season),
  323.             'season': season if (season and not season.isdigit()) else None,
  324.             'episode': media.get('episode_title'),
  325.             'episode_number': int_or_none(media.get('episode')),
  326.             'subtitles': subtitles,
  327.         }
  329.         info.update(relinker_info)
  330.         return info
  333. class RaiPlayLiveIE(RaiPlayIE):
  334.     _VALID_URL = r'(?P<base>https?://(?:www\.)?raiplay\.it/dirette/(?P<id>[^/?#&]+))'
  335.     _TESTS = [{
  336.         'url': 'http://www.raiplay.it/dirette/rainews24',
  337.         'info_dict': {
  338.             'id': 'd784ad40-e0ae-4a69-aa76-37519d238a9c',
  339.             'display_id': 'rainews24',
  340.             'ext': 'mp4',
  341.             'title': 're:^Diretta di Rai News 24 [0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}$',
  342.             'description': 'md5:4d00bcf6dc98b27c6ec480de329d1497',
  343.             'uploader': 'Rai News 24',
  344.             'creator': 'Rai News 24',
  345.             'is_live': True,
  346.         },
  347.         'params': {
  348.             'skip_download': True,
  349.         },
  350.     }]
  353. class RaiPlayPlaylistIE(InfoExtractor):
  354.     _VALID_URL = r'(?P<base>https?://(?:www\.)?raiplay\.it/programmi/(?P<id>[^/?#&]+))'
  355.     _TESTS = [{
  356.         'url': 'http://www.raiplay.it/programmi/nondirloalmiocapo/',
  357.         'info_dict': {
  358.             'id': 'nondirloalmiocapo',
  359.             'title': 'Non dirlo al mio capo',
  360.             'description': 'md5:98ab6b98f7f44c2843fd7d6f045f153b',
  361.         },
  362.         'playlist_mincount': 12,
  363.     }]
  365.     def _real_extract(self, url):
  366.         base, playlist_id = re.match(self._VALID_URL, url).groups()
  368.         program = self._download_json(
  369.             base + '.json', playlist_id, 'Downloading program JSON')
  371.         entries = []
  372.         for b in (program.get('blocks') or []):
  373.             for s in (b.get('sets') or []):
  374.                 s_id = s.get('id')
  375.                 if not s_id:
  376.                     continue
  377.                 medias = self._download_json(
  378.                     '%s/%s.json' % (base, s_id), s_id,
  379.                     'Downloading content set JSON', fatal=False)
  380.                 if not medias:
  381.                     continue
  382.                 for m in (medias.get('items') or []):
  383.                     path_id = m.get('path_id')
  384.                     if not path_id:
  385.                         continue
  386.                     video_url = urljoin(url, path_id)
  387.                     entries.append(self.url_result(
  388.                         video_url, ie=RaiPlayIE.ie_key(),
  389.                         video_id=RaiPlayIE._match_id(video_url)))
  391.         return self.playlist_result(
  392.             entries, playlist_id, program.get('name'),
  393.             try_get(program, lambda x: x['program_info']['description']))
  396. class RaiIE(RaiBaseIE):
  397.     _VALID_URL = r'https?://[^/]+\.(?:rai\.(?:it|tv)|rainews\.it)/.+?-(?P<id>%s)(?:-.+?)?\.html' % RaiBaseIE._UUID_RE
  398.     _TESTS = [{
  399.         # var uniquename = "ContentItem-..."
  400.         # data-id="ContentItem-..."
  401.         'url': 'http://www.raisport.rai.it/dl/raiSport/media/rassegna-stampa-04a9f4bd-b563-40cf-82a6-aad3529cb4a9.html',
  402.         'info_dict': {
  403.             'id': '04a9f4bd-b563-40cf-82a6-aad3529cb4a9',
  404.             'ext': 'mp4',
  405.             'title': 'TG PRIMO TEMPO',
  406.             'thumbnail': r're:^https?://.*\.jpg$',
  407.             'duration': 1758,
  408.             'upload_date': '20140612',
  409.         },
  410.         'skip': 'This content is available only in Italy',
  411.     }, {
  412.         # with ContentItem in many metas
  413.         'url': 'http://www.rainews.it/dl/rainews/media/Weekend-al-cinema-da-Hollywood-arriva-il-thriller-di-Tate-Taylor-La-ragazza-del-treno-1632c009-c843-4836-bb65-80c33084a64b.html',
  414.         'info_dict': {
  415.             'id': '1632c009-c843-4836-bb65-80c33084a64b',
  416.             'ext': 'mp4',
  417.             'title': 'Weekend al cinema, da Hollywood arriva il thriller di Tate Taylor "La ragazza del treno"',
  418.             'description': 'I film in uscita questa settimana.',
  419.             'thumbnail': r're:^https?://.*\.png$',
  420.             'duration': 833,
  421.             'upload_date': '20161103',
  422.         }
  423.     }, {
  424.         # with ContentItem in og:url
  425.         'url': 'http://www.rai.it/dl/RaiTV/programmi/media/ContentItem-efb17665-691c-45d5-a60c-5301333cbb0c.html',
  426.         'md5': '06345bd97c932f19ffb129973d07a020',
  427.         'info_dict': {
  428.             'id': 'efb17665-691c-45d5-a60c-5301333cbb0c',
  429.             'ext': 'mp4',
  430.             'title': 'TG1 ore 20:00 del 03/11/2016',
  431.             'description': 'TG1 edizione integrale ore 20:00 del giorno 03/11/2016',
  432.             'thumbnail': r're:^https?://.*\.jpg$',
  433.             'duration': 2214,
  434.             'upload_date': '20161103',
  435.         }
  436.     }, {
  437.         # initEdizione('ContentItem-...'
  438.         'url': 'http://www.tg1.rai.it/dl/tg1/2010/edizioni/ContentSet-9b6e0cba-4bef-4aef-8cf0-9f7f665b7dfb-tg1.html?item=undefined',
  439.         'info_dict': {
  440.             'id': 'c2187016-8484-4e3a-8ac8-35e475b07303',
  441.             'ext': 'mp4',
  442.             'title': r're:TG1 ore \d{2}:\d{2} del \d{2}/\d{2}/\d{4}',
  443.             'duration': 2274,
  444.             'upload_date': '20170401',
  445.         },
  446.         'skip': 'Changes daily',
  447.     }, {
  448.         # HLS live stream with ContentItem in og:url
  449.         'url': 'http://www.rainews.it/dl/rainews/live/ContentItem-3156f2f2-dc70-4953-8e2f-70d7489d4ce9.html',
  450.         'info_dict': {
  451.             'id': '3156f2f2-dc70-4953-8e2f-70d7489d4ce9',
  452.             'ext': 'mp4',
  453.             'title': 'La diretta di Rainews24',
  454.         },
  455.         'params': {
  456.             'skip_download': True,
  457.         },
  458.     }, {
  459.         # ContentItem in iframe (see #12652) and subtitle at 'subtitlesUrl' key
  460.         'url': 'http://www.presadiretta.rai.it/dl/portali/site/puntata/ContentItem-3ed19d13-26c2-46ff-a551-b10828262f1b.html',
  461.         'info_dict': {
  462.             'id': '1ad6dc64-444a-42a4-9bea-e5419ad2f5fd',
  463.             'ext': 'mp4',
  464.             'title': 'Partiti acchiappavoti - Presa diretta del 13/09/2015',
  465.             'description': 'md5:d291b03407ec505f95f27970c0b025f4',
  466.             'upload_date': '20150913',
  467.             'subtitles': {
  468.                 'it': 'count:2',
  469.             },
  470.         },
  471.         'params': {
  472.             'skip_download': True,
  473.         },
  474.     }, {
  475.         # Direct MMS URL
  476.         'url': 'http://www.rai.it/dl/RaiTV/programmi/media/ContentItem-b63a4089-ac28-48cf-bca5-9f5b5bc46df5.html',
  477.         'only_matching': True,
  478.     }, {
  479.         'url': 'https://www.rainews.it/tgr/marche/notiziari/video/2019/02/ContentItem-6ba945a2-889c-4a80-bdeb-8489c70a8db9.html',
  480.         'only_matching': True,
  481.     }]
  483.     def _extract_from_content_id(self, content_id, url):
  484.         media = self._download_json(
  485.             'http://www.rai.tv/dl/RaiTV/programmi/media/ContentItem-%s.html?json' % content_id,
  486.             content_id, 'Downloading video JSON')
  488.         title = media['name'].strip()
  490.         media_type = media['type']
  491.         if 'Audio' in media_type:
  492.             relinker_info = {
  493.                 'formats': [{
  494.                     'format_id': media.get('formatoAudio'),
  495.                     'url': media['audioUrl'],
  496.                     'ext': media.get('formatoAudio'),
  497.                 }]
  498.             }
  499.         elif 'Video' in media_type:
  500.             relinker_info = self._extract_relinker_info(media['mediaUri'], content_id)
  501.         else:
  502.             raise ExtractorError('not a media file')
  504.         self._sort_formats(relinker_info['formats'])
  506.         thumbnails = []
  507.         for image_type in ('image', 'image_medium', 'image_300'):
  508.             thumbnail_url = media.get(image_type)
  509.             if thumbnail_url:
  510.                 thumbnails.append({
  511.                     'url': compat_urlparse.urljoin(url, thumbnail_url),
  512.                 })
  514.         subtitles = self._extract_subtitles(url, media)
  516.         info = {
  517.             'id': content_id,
  518.             'title': title,
  519.             'description': strip_or_none(media.get('desc')),
  520.             'thumbnails': thumbnails,
  521.             'uploader': media.get('author'),
  522.             'upload_date': unified_strdate(media.get('date')),
  523.             'duration': parse_duration(media.get('length')),
  524.             'subtitles': subtitles,
  525.         }
  527.         info.update(relinker_info)
  529.         return info
  531.     def _real_extract(self, url):
  532.         video_id = self._match_id(url)
  534.         webpage = self._download_webpage(url, video_id)
  536.         content_item_id = None
  538.         content_item_url = self._html_search_meta(
  539.             ('og:url', 'og:video', 'og:video:secure_url', 'twitter:url',
  540.              'twitter:player', 'jsonlink'), webpage, default=None)
  541.         if content_item_url:
  542.             content_item_id = self._search_regex(
  543.                 r'ContentItem-(%s)' % self._UUID_RE, content_item_url,
  544.                 'content item id', default=None)
  546.         if not content_item_id:
  547.             content_item_id = self._search_regex(
  548.                 r'''(?x)
  549.                     (?:
  550.                         (?:initEdizione|drawMediaRaiTV)\(|
  551.                         <(?:[^>]+\bdata-id|var\s+uniquename)=|
  552.                         <iframe[^>]+\bsrc=
  553.                     )
  554.                     (["\'])
  555.                     (?:(?!\1).)*\bContentItem-(?P<id>%s)
  556.                 ''' % self._UUID_RE,
  557.                 webpage, 'content item id', default=None, group='id')
  559.         content_item_ids = set()
  560.         if content_item_id:
  561.             content_item_ids.add(content_item_id)
  562.         if video_id not in content_item_ids:
  563.             content_item_ids.add(video_id)
  565.         for content_item_id in content_item_ids:
  566.             try:
  567.                 return self._extract_from_content_id(content_item_id, url)
  568.             except GeoRestrictedError:
  569.                 raise
  570.             except ExtractorError:
  571.                 pass
  573.         relinker_url = self._proto_relative_url(self._search_regex(
  574.             r'''(?x)
  575.                 (?:
  576.                     var\s+videoURL|
  577.                     mediaInfo\.mediaUri
  578.                 )\s*=\s*
  579.                 ([\'"])
  580.                 (?P<url>
  581.                     (?:https?:)?
  582.                     //mediapolis(?:vod)?\.rai\.it/relinker/relinkerServlet\.htm\?
  583.                     (?:(?!\1).)*\bcont=(?:(?!\1).)+)\1
  584.             ''',
  585.             webpage, 'relinker URL', group='url'))
  587.         relinker_info = self._extract_relinker_info(
  588.             urljoin(url, relinker_url), video_id)
  589.         self._sort_formats(relinker_info['formats'])
  591.         title = self._search_regex(
  592.             r'var\s+videoTitolo\s*=\s*([\'"])(?P<title>[^\'"]+)\1',
  593.             webpage, 'title', group='title',
  594.             default=None) or self._og_search_title(webpage)
  596.         info = {
  597.             'id': video_id,
  598.             'title': title,
  599.         }
  601.         info.update(relinker_info)
  603.         return info