import base64
+import random
import re
import urllib.parse
unified_timestamp,
update_url_query,
)
+from ..utils.traversal import traverse_obj
class RadikoBaseIE(InfoExtractor):
+ _GEO_BYPASS = False
_FULL_KEY = None
-
- def _auth_client(self):
+ _HOSTS_FOR_TIME_FREE_FFMPEG_UNSUPPORTED = (
+ 'https://c-rpaa.smartstream.ne.jp',
+ 'https://si-c-radiko.smartstream.ne.jp',
+ 'https://tf-f-rpaa-radiko.smartstream.ne.jp',
+ 'https://tf-c-rpaa-radiko.smartstream.ne.jp',
+ 'https://si-f-radiko.smartstream.ne.jp',
+ 'https://rpaa.smartstream.ne.jp',
+ )
+ _HOSTS_FOR_TIME_FREE_FFMPEG_SUPPORTED = (
+ 'https://rd-wowza-radiko.radiko-cf.com',
+ 'https://radiko.jp',
+ 'https://f-radiko.smartstream.ne.jp',
+ )
+ # Following URL forcibly connects not Time Free but Live
+ _HOSTS_FOR_LIVE = (
+ 'https://c-radiko.smartstream.ne.jp',
+ )
+
+ def _negotiate_token(self):
_, auth1_handle = self._download_webpage_handle(
'https://radiko.jp/v2/api/auth1', None, 'Downloading authentication page',
headers={
'x-radiko-device': 'pc',
'x-radiko-user': 'dummy_user',
})
- auth1_header = auth1_handle.info()
+ auth1_header = auth1_handle.headers
auth_token = auth1_header['X-Radiko-AuthToken']
kl = int(auth1_header['X-Radiko-KeyLength'])
'x-radiko-partialkey': partial_key,
}).split(',')[0]
+ if area_id == 'OUT':
+ self.raise_geo_restricted(countries=['JP'])
+
auth_data = (auth_token, area_id)
self.cache.store('radiko', 'auth_data', auth_data)
return auth_data
+ def _auth_client(self):
+ cachedata = self.cache.load('radiko', 'auth_data')
+ if cachedata is not None:
+ response = self._download_webpage(
+ 'https://radiko.jp/v2/api/auth_check', None, 'Checking cached token', expected_status=401,
+ headers={'X-Radiko-AuthToken': cachedata[0], 'X-Radiko-AreaId': cachedata[1]})
+ if response == 'OK':
+ return cachedata
+ return self._negotiate_token()
+
def _extract_full_key(self):
if self._FULL_KEY:
return self._FULL_KEY
if full_key:
full_key = full_key.encode()
- else: # use full key ever known
+ else: # use only full key ever known
full_key = b'bcd151073c03b352e1ef2fd66c32209da9ca0afa'
self._FULL_KEY = full_key
m3u8_playlist_data = self._download_xml(
f'https://radiko.jp/v3/station/stream/pc_html5/{station}.xml', video_id,
note='Downloading stream information')
- m3u8_urls = m3u8_playlist_data.findall('.//url')
formats = []
found = set()
- for url_tag in m3u8_urls:
- pcu = url_tag.find('playlist_create_url')
- url_attrib = url_tag.attrib
- playlist_url = update_url_query(pcu.text, {
+
+ timefree_int = 0 if is_onair else 1
+
+ for element in m3u8_playlist_data.findall(f'.//url[@timefree="{timefree_int}"]/playlist_create_url'):
+ pcu = element.text
+ if pcu in found:
+ continue
+ found.add(pcu)
+ playlist_url = update_url_query(pcu, {
'station_id': station,
**query,
'l': '15',
- 'lsid': '88ecea37e968c1f17d5413312d9f8003',
+ 'lsid': ''.join(random.choices('0123456789abcdef', k=32)),
'type': 'b',
})
- if playlist_url in found:
- continue
- else:
- found.add(playlist_url)
time_to_skip = None if is_onair else cursor - ft
'X-Radiko-AuthToken': auth_token,
})
for sf in subformats:
- if re.fullmatch(r'[cf]-radiko\.smartstream\.ne\.jp', domain):
- # Prioritize live radio vs playback based on extractor
- sf['preference'] = 100 if is_onair else -100
- if not is_onair and url_attrib['timefree'] == '1' and time_to_skip:
- sf['downloader_options'] = {'ffmpeg_args': ['-ss', time_to_skip]}
+ if (is_onair ^ pcu.startswith(self._HOSTS_FOR_LIVE)) or (
+ not is_onair and pcu.startswith(self._HOSTS_FOR_TIME_FREE_FFMPEG_UNSUPPORTED)):
+ sf['preference'] = -100
+ sf['format_note'] = 'not preferred'
+ if not is_onair and timefree_int == 1 and time_to_skip:
+ sf['downloader_options'] = {'ffmpeg_args': ['-ss', str(time_to_skip)]}
formats.extend(subformats)
return formats
+ def _extract_performers(self, prog):
+ return traverse_obj(prog, (
+ 'pfm/text()', ..., {lambda x: re.split(r'[/／、 ,，]', x)}, ..., {str.strip})) or None
+
class RadikoIE(RadikoBaseIE):
_VALID_URL = r'https?://(?:www\.)?radiko\.jp/#!/ts/(?P<station>[A-Z0-9-]+)/(?P<id>\d+)'
vid_int = unified_timestamp(video_id, False)
prog, station_program, ft, radio_begin, radio_end = self._find_program(video_id, station, vid_int)
- auth_cache = self.cache.load('radiko', 'auth_data')
- for attempt in range(2):
- auth_token, area_id = (not attempt and auth_cache) or self._auth_client()
- formats = self._extract_formats(
- video_id=video_id, station=station, is_onair=False,
- ft=ft, cursor=vid_int, auth_token=auth_token, area_id=area_id,
- query={
- 'start_at': radio_begin,
- 'ft': radio_begin,
- 'end_at': radio_end,
- 'to': radio_end,
- 'seek': video_id,
- })
- if formats:
- break
+ auth_token, area_id = self._auth_client()
return {
'id': video_id,
'title': try_call(lambda: prog.find('title').text),
+ 'cast': self._extract_performers(prog),
'description': clean_html(try_call(lambda: prog.find('info').text)),
'uploader': try_call(lambda: station_program.find('.//name').text),
'uploader_id': station,
'timestamp': vid_int,
- 'formats': formats,
+ 'duration': try_call(lambda: unified_timestamp(radio_end, False) - unified_timestamp(radio_begin, False)),
'is_live': True,
+ 'formats': self._extract_formats(
+ video_id=video_id, station=station, is_onair=False,
+ ft=ft, cursor=vid_int, auth_token=auth_token, area_id=area_id,
+ query={
+ 'start_at': radio_begin,
+ 'ft': radio_begin,
+ 'end_at': radio_end,
+ 'to': radio_end,
+ 'seek': video_id
+ }
+ ),
}
return {
'id': station,
'title': title,
+ 'cast': self._extract_performers(prog),
'description': description,
'uploader': station_name,
'uploader_id': station,
projects / yt-dlp.git / blobdiff