def _parse_smil(self, url, swf_url):
res = http.get(url)
smil = http.xml(res, "SMIL config", schema=_smil_schema)
for src, bitrate in smil["videos"]:
url = urljoin(smil["http_base"], src)
yield bitrate, AkamaiHDStream(self.session, url, swf=swf_url)
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
res = http.get(ASSET_URL.format(video_id))
assets = http.xml(res, schema=_asset_schema)
streams = {}
for asset in assets:
base = asset["base"]
url = asset["url"]
if urlparse(url).path.endswith(".f4m"):
streams.update(
HDSStream.parse_manifest(self.session, url, pvswf=SWF_URL)
)
elif base.startswith("rtmp"):
name = "{0}k".format(asset["bitrate"])
params = {
"rtmp": asset["base"],
"playpath": url,
"live": True
}
streams[name] = RTMPStream(self.session, params)
return streams
def _get_streams(self):
# get the HLS xml from the same sub domain as the main url, defaulting to www
sdomain = _url_re.match(self.url).group(1) or "www"
res = http.get(API_URL.format(sdomain))
stream_url = http.xml(res, schema=_schema)
return HLSStream.parse_variant_playlist(self.session, stream_url)
def _get_streams(self):
res = http.get(self.url)
match = _meta_xmlurl_id_re.search(res.text)
if not match:
return
xml_info_url = STREAMS_INFO_URL.format(match.group(1))
video_info_res = http.get(xml_info_url)
parsed_info = http.xml(video_info_res)
live_el = parsed_info.find("live")
live = live_el is not None and live_el.text == "1"
streams = {}
hdsurl_el = parsed_info.find("hdsurl")
if hdsurl_el is not None and hdsurl_el.text is not None:
hdsurl = hdsurl_el.text
streams.update(HDSStream.parse_manifest(self.session, hdsurl))
if live:
vurls_el = parsed_info.find("vurls")
if vurls_el is not None:
for i, vurl_el in enumerate(vurls_el):
bitrate = vurl_el.get("bitrate")
name = bitrate + "k" if bitrate is not None else "rtmp{0}".format(
i)
params = {
"rtmp": vurl_el.text,
}
streams[name] = RTMPStream(self.session, params)
parsed_urls = set()
mobileurls_el = parsed_info.find("mobileurls")
if mobileurls_el is not None:
for mobileurl_el in mobileurls_el:
text = mobileurl_el.text
if not text:
continue
if text in parsed_urls:
continue
parsed_urls.add(text)
url = urlparse(text)
if url[0] == "http" and url[2].endswith("m3u8"):
streams.update(
HLSStream.parse_variant_playlist(self.session, text))
return streams
def _get_smil_streams(self, info):
res = http.get(info["_stream"])
smil = http.xml(res, "SMIL config", schema=_smil_schema)
for video in smil["videos"]:
url = "{0}/{1}{2}".format(smil["base"], video, HDCORE_PARAMETER)
streams = HDSStream.parse_manifest(self.session,
url,
pvswf=SWF_URL)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
res = http.get(STREAM_INFO_URL.format(channel))
urls = http.xml(res, schema=_livestream_schema)
streams = {}
for (name, parser), url in urls.items():
try:
streams.update(parser(self.session, url))
except IOError as err:
self.logger.warning("Unable to extract {0} streams: {1}", name, err)
return streams
def _get_rtmp_stream(self, channel_name):
params = {
"l": "info",
"a": "xmlClipPath",
"clip_id": channel_name,
"rid": time()
}
res = http.get(API_URL, params=params)
rtmp_url = http.xml(res, schema=_rtmp_schema)
return RTMPStream(self.session, {
"rtmp": rtmp_url,
"swfVfy": SWF_URL,
"live": True
})
def _get_streams(self):
cubeid = self._get_live_cubeid()
if not cubeid:
return
res = http.get(API_URL_LIVE, params=dict(cubeid=cubeid))
entries = http.xml(res, schema=_entries_schema)
streams = {}
for url in entries:
try:
streams.update(
HLSStream.parse_variant_playlist(self.session, url))
except IOError as err:
self.logger.error("Failed to open playlist: {0}", err)
return streams
def _get_playlist(self, **params):
res = http.get(PLAYLIST_URL, params=params)
playlist = http.xml(res, schema=_playlist_schema)
streams = {}
for video in playlist["videos"]:
name = "{0}p".format(video["height"])
stream = RTMPStream(
self.session, {
"rtmp": "{0}/{1}".format(playlist["base"], video["src"]),
"app": urlparse(playlist["base"]).path[1:],
"pageUrl": self.url,
"rtmp": playlist["base"],
"playpath": video["src"],
"live": True
})
streams[name] = stream
return streams
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
res = http.get(CHANNEL_INFO.format(channel))
channel_info = http.json(res)
if not channel_info["online"]:
return
res = http.get(CHANNEL_MANIFEST.format(channel_info["id"]))
assets = http.xml(res, schema=_assets_schema)
streams = {}
for video in assets["videos"]:
name = "{0}p".format(video["height"])
stream = RTMPStream(
self.session,
{"rtmp": "{0}/{1}".format(assets["base"], video["src"])})
streams[name] = stream
return streams
def _get_streams(self):
"""
Find all the streams for the ITV url
:return: Mapping of quality to stream
"""
soap_message = self._soap_request()
headers = {
'Content-Length': '{0:d}'.format(len(soap_message)),
'Content-Type': 'text/xml; charset=utf-8',
'Host': 'mercury.itv.com',
'Origin': 'http://www.itv.com',
'Referer':
'http://www.itv.com/Mercury/Mercury_VideoPlayer.swf?v=null',
'SOAPAction': "http://tempuri.org/PlaylistService/GetPlaylist",
'User-Agent': ITV_PLAYER_USER_AGENT,
"X-Requested-With": "ShockwaveFlash/16.0.0.305"
}
res = http.post("http://mercury.itv.com/PlaylistService.svc?wsdl",
headers=headers,
data=soap_message)
# Parse XML
xmldoc = http.xml(res)
# Check that geo region has been accepted
faultcode = xmldoc.find('.//faultcode')
if faultcode is not None:
if 'InvalidGeoRegion' in faultcode.text:
self.logger.error('Failed to retrieve playlist data '
'(invalid geo region)')
return None
# Look for <MediaFiles> tag (RTMP streams)
mediafiles = xmldoc.find('.//VideoEntries//MediaFiles')
# Look for <ManifestFile> tag (HDS streams)
manifestfile = xmldoc.find('.//VideoEntries//ManifestFile')
# No streams
if not mediafiles and not manifestfile:
return None
streams = {}
# Proxy not needed for media retrieval (Note: probably better to use flag)
# for x in ('http', 'https'):
# if x in http.proxies:
# http.proxies.pop(x);
# Parse RTMP streams
if mediafiles:
rtmp = mediafiles.attrib['base']
for mediafile in mediafiles.findall("MediaFile"):
playpath = mediafile.find("URL").text
rtmp_url = urlparse(rtmp)
app = (rtmp_url.path[1:] + '?' + rtmp_url.query).rstrip('?')
live = app == "live"
params = dict(
rtmp="{u.scheme}://{u.netloc}{u.path}".format(u=rtmp_url),
app=app.rstrip('?'),
playpath=playpath,
swfVfy=LIVE_SWF_URL if live else ONDEMAND_SWF_URL,
timeout=10)
if live:
params['live'] = True
bitrate = int(mediafile.attrib['bitrate']) / 1000
quality = "{0:d}k".format(int(bitrate))
streams[quality] = RTMPStream(self.session, params)
# Parse HDS streams
if manifestfile:
url = manifestfile.find('URL').text
if urlparse(url).path.endswith('f4m'):
streams.update(
HDSStream.parse_manifest(self.session,
url,
pvswf=LIVE_SWF_URL))
return streams
def _get_live_cubeid(self):
res = http.get(API_URL_APP, params=dict(mode="get_live"))
root = http.xml(res)
return root.findtext("./cube/cubeid")