def _get_live_streams(self):
stream_id = _id_map[self.channel_path]
if stream_id == "ruv":
qualities_rtmp = ["720p", "480p", "360p", "240p"]
for i, quality in enumerate(qualities_rtmp):
yield quality, RTMPStream(
self.session, {
"rtmp": RTMP_LIVE_URL.format(stream_id, i + 1),
"pageUrl": self.url,
"live": True
})
qualities_hls = ["240p", "360p", "480p", "720p"]
for i, quality_hls in enumerate(qualities_hls):
yield quality_hls, HLSStream(self.session,
HLS_RUV_LIVE_URL.format(i + 1))
else:
yield "audio", RTMPStream(
self.session, {
"rtmp": RTMP_LIVE_URL.format(stream_id, 1),
"pageUrl": self.url,
"live": True
})
yield "audio", HLSStream(self.session,
HLS_RADIO_LIVE_URL.format(stream_id))
def _get_streams(self):
page = http.get(self.url)
try:
channel, _, _, _, online, visibility, is_flash = self._get_stream_arguments(
page)
except ValueError:
return
if not online:
self.logger.error("This stream is currently offline")
return
channel_server_res = http.post(API_CHANNEL_INFO,
data={"loadbalancinginfo": channel})
if is_flash:
return {
"live":
RTMPStream(
self.session, {
"rtmp": RTMP_URL.format(channel_server_res.text),
"playpath": RTMP_PLAYPATH.format(channel, visibility),
"pageUrl": self.url,
"live": True
})
}
else:
return HLSStream.parse_variant_playlist(
self.session,
HLS_URL.format(channel_server_res.text, channel, visibility),
verify=False)
def _get_streams(self):
flashvars = http.get(self.url, schema=_flashvars_schema)
if not flashvars:
return
params = {
"rt": "json",
"lc": "en_US",
"pt": "view",
"bpw": "",
"bid": flashvars["id"],
"adok": "",
"bno": ""
}
if re.search(_url_re_tw, self.url):
res = http.get(VIEW_LIVE_API_URL_TW, params=params)
elif re.search(_url_re_jp, self.url):
res = http.get(VIEW_LIVE_API_URL_JP, params=params)
else:
res = http.get(VIEW_LIVE_API_URL, params=params)
streams = http.json(res, schema=_view_live_schema)
for stream in streams:
stream_name = "{0}p".format(stream["bps"])
stream_params = {"rtmp": stream["purl"], "live": True}
yield stream_name, RTMPStream(self.session, stream_params)
def _create_stream(self, stream, is_live):
stream_name = "{0}p".format(stream["height"])
stream_type = stream["mediaType"]
stream_url = stream["url"]
if stream_type in ("hls", "mp4"):
if urlparse(stream_url).path.endswith("m3u8"):
try:
streams = HLSStream.parse_variant_playlist(
self.session, stream_url)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
except IOError as err:
self.logger.error("Failed to extract HLS streams: {0}",
err)
else:
yield stream_name, HTTPStream(self.session, stream_url)
elif stream_type == "rtmp":
params = {
"rtmp": stream["streamer"],
"playpath": stream["url"],
"swfVfy": SWF_URL,
"pageUrl": self.url,
}
if is_live:
params["live"] = True
else:
params["playpath"] = "mp4:{0}".format(params["playpath"])
stream = RTMPStream(self.session, params)
yield stream_name, stream
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_sarpurinn_streams(self):
res = http.get(self.url)
match = _rtmp_url_re.search(res.text)
if not match:
yield
token = match.group("id")
status = match.group("status")
extension = match.group("ext")
date = match.group("date")
if not date:
date = ""
if extension == "mp3":
key = "audio"
else:
key = "576p"
# HLS on Sarpurinn is currently only available on videos
yield key, HLSStream(
self.session,
HLS_SARPURINN_URL.format(status, date, token, extension))
yield key, RTMPStream(
self.session, {
"rtmp": RTMP_SARPURINN_URL.format(status, date, token,
extension),
"pageUrl": self.url,
"live": True
})
def _get_live_streams(self, params, swf_url):
for key, quality in QUALITY_MAP.items():
key_url = "{0}URL".format(key)
url = params.get(key_url)
if not url:
continue
try:
res = http.get(url, exception=IOError)
except IOError:
continue
if quality == "hds":
streams = HDSStream.parse_manifest(self.session, res.url)
for name, stream in streams.items():
if key == "source":
name += "+"
yield name, stream
elif res.text.startswith("rtmp"):
match = _rtmp_re.match(res.text)
if not match:
continue
stream = RTMPStream(
self.session, {
"rtmp": match.group("host"),
"app": match.group("app"),
"playpath": match.group("playpath"),
"swfVfy": swf_url,
"live": True
})
yield quality, stream
def _create_rtmp_stream(self, rtmp, playpath, live):
return RTMPStream(
self.session, {
"rtmp": rtmp,
"playpath": playpath,
"pageUrl": self.url,
"swfVfy": SWF_URL,
"live": live
})
def _get_streams(self):
res = http.get(self.url)
match = _streams_re.findall(res.content.decode('utf-8'))
for url, stream_type in match:
if stream_type == "rtmp/mp4" and RTMPStream.is_usable(
self.session):
params = {
"rtmp": url,
"pageUrl": self.url,
"live": True,
}
yield 'live', RTMPStream(self.session, params)
elif stream_type == "application/x-mpegURL":
for s in HLSStream.parse_variant_playlist(self.session,
url).items():
yield s
elif stream_type == "video/mp4":
yield 'vod', HTTPStream(self.session, url)
def _get_streams(self):
url_match = _url_re.match(self.url)
stream_url = _stream_url.format(channel=url_match.group(1))
res = self.session.http.get(stream_url)
match = _stream_re.search(res.text)
if match:
params = dict(rtmp="rtmp://stream.connectcast.tv/live",
playpath=match.group(1),
live=True)
return dict(live=RTMPStream(self.session, params))
def _get_rtmp_streams(self, info):
name = QUALITY_MAP.get(info["_quality"], "live")
params = {
"rtmp": info["_server"].strip(),
"playpath": info["_stream"],
"pageUrl": self.url,
"swfVfy": SWF_URL,
"live": True
}
stream = RTMPStream(self.session, params)
yield name, stream
def _get_streams(self):
stream_url = http.get(self.url, schema=_schema)
if not stream_url:
return
stream = RTMPStream(self.session, {
"rtmp": stream_url,
"pageUrl": self.url,
"live": True
})
return dict(live=stream)
def _create_rtmp_stream(self, cdn, stream_name):
parsed = urlparse(cdn)
params = {
"rtmp": cdn,
"app": parsed.path[1:],
"playpath": stream_name,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"live": True
}
return RTMPStream(self.session, params)
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 _create_rtmp_stream(self, rtmp, swf_url, bitrate):
quality = self._get_quality(bitrate["label"])
url = bitrate["url"]
stream = RTMPStream(
self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": url,
"swfVfy": swf_url,
"live": True
})
return quality, stream
def _get_streams(self):
match = _url_re.match(self.url)
channel_name = match.group("channel")
form = {
"cid": channel_name,
"watchTime": 0,
"firstConnect": 1,
"ip": "NaN"
}
res = http.post(API_URL, data=form, headers=HEADERS)
params = parse_query(res.text, schema=_schema)
if params["status"] <= 0:
return
if params["block_type"] != 0:
if params["block_type"] == BLOCK_TYPE_VIEWING_LIMIT:
msg = BLOCKED_MSG_FORMAT.format(
params.get("block_time", "UNKNOWN"),
params.get("reconnect_time", "UNKNOWN"))
raise PluginError(msg)
elif params["block_type"] == BLOCK_TYPE_NO_SLOTS:
raise PluginError("No free slots available")
else:
raise PluginError("Blocked for unknown reasons")
if "token" not in params:
raise PluginError("Server seems busy, retry again later")
streams = {}
stream_names = ["sd"]
if params["multibitrate"]:
stream_names += ["hd"]
for stream_name in stream_names:
playpath = params["playpath"]
if stream_name == "hd":
playpath += "HI"
stream = RTMPStream(
self.session, {
"rtmp": "{0}/{1}".format(params["rtmp"], playpath),
"pageUrl": self.url,
"swfVfy": SWF_URL,
"weeb": params["token"],
"live": True
})
streams[stream_name] = stream
return streams
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
streamurl = getStreamURL(channel)
if not streamurl:
return
streams = {}
streams["live"] = RTMPStream(self.session, {
"rtmp": streamurl,
"live": True
})
return streams
def _get_plu_streams(self, cid):
res = http.get(PLU_STREAM_INFO_URL % cid)
info = http.json(res, schema=_plu_schema)
for source in info["urls"]:
quality = self._get_quality(source["resolution"])
if source["ext"] == "m3u8":
yield quality, HLSStream(self.session, source["securityUrl"])
elif source["ext"] == "flv":
yield quality, HTTPStream(self.session, source["securityUrl"])
elif source["ext"] == "rtmp":
yield quality, RTMPStream(self.session, {
"rtmp": source["securityUrl"],
"live": True
})
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 _create_rtmp_stream(self, video):
name, stream_url = video
params = {
"rtmp": stream_url,
"pageUrl": self.url,
"swfVfy": self._get_swf_url(),
}
if stream_url.endswith(".mp4"):
tcurl, playpath = rtmpparse(stream_url)
params["rtmp"] = tcurl
params["playpath"] = playpath
else:
params["live"] = True
return name, RTMPStream(self.session, params)
def _create_rtmp_stream(self, url):
parsed = urlparse(url)
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
params = {
"rtmp": url,
"app": app,
"pageUrl": self.url,
"live": True
}
stream = RTMPStream(self.session, params)
return "live", stream
def _get_streams(self):
match = _url_re.match(self.url)
info = http.get(PLAYER_URL, params=match.groupdict(), schema=_schema)
if not info["path"]:
return
app, playpath = info["path"]
stream = RTMPStream(
self.session, {
"rtmp": "rtmp://{0}/{1}".format(info["server_ip"], app),
"playpath": playpath,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"live": True
})
return dict(live=stream)
def _get_streams(self):
res = http.get(self.url, schema=_schema)
streams = {}
for url in res["urls"]:
parsed = urlparse(url)
if parsed.scheme.startswith("rtmp"):
params = {"rtmp": url, "pageUrl": self.url, "live": True}
if res["swf"]:
params["swfVfy"] = res["swf"]
stream = RTMPStream(self.session, params)
streams["live"] = stream
elif parsed.scheme.startswith("http"):
name = splitext(parsed.path)[1][1:]
stream = HTTPStream(self.session, url)
streams[name] = stream
return streams
def _get_rtmp_stream(self, swfurl):
res = http.get(swfurl)
swf = swfdecompress(res.content)
match = _rtmp_re.search(swf)
if not match:
return
res = http.get(match.group(1))
rtmp, playpath = rtmpparse(res.text)
params = {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": playpath,
"swfUrl": swfurl,
"live": True
}
return RTMPStream(self.session, params)
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
channel = match.group("channel")
if video_id:
return self._get_playlist(vod=video_id)
elif channel:
return {
'live':
RTMPStream(
self.session,
dict(rtmp=LIVE_STREAM_URL,
app="live",
pageUrl=self.url,
playpath=channel,
live=True))
}
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):
res = self.url
streamname = _url_re.search(res).group(1)
streams = {}
stream = RTMPStream(
self.session, {
"rtmp": ROOT_URL.format(streamname),
"pageUrl": PAGE_URL,
"live": True,
"app": "live",
"flashVer": "LNX 11,2,202,280",
"swfVfy":
"https://www.tigerdile.com/wp-content/jwplayer.flash.swf",
"playpath": streamname,
})
streams["live"] = stream
return streams
def _get_streams(self):
res = http.get(self.url)
match = _swf_player_re.search(res.text)
if match is None:
return
swfUrl = "http://vaughnlive.tv" + match.group(1)
match = _url_re.match(self.url)
params = {}
params["channel"] = match.group("channel").lower()
params["domain"] = DOMAIN_MAP.get(match.group("domain"),
match.group("domain"))
params["version"] = PLAYER_VERSION
params["ms"] = random.randint(0, 999)
params["random"] = random.random()
info = http.get(INFO_URL.format(**params), schema=_schema)
app = "live"
if info["server"] in [
"198.255.17.18:1337", "198.255.17.66:1337", "50.7.188.2:1337"
]:
if info["ingest"] == "SJC":
app = "live-sjc"
elif info["ingest"] == "NYC":
app = "live-nyc"
elif info["ingest"] == "ORD":
app = "live-ord"
elif info["ingest"] == "AMS":
app = "live-ams"
elif info["ingest"] == "DEN":
app = "live-den"
stream = RTMPStream(
self.session, {
"rtmp": "rtmp://{0}/live".format(info["server"]),
"app": "{0}?{1}".format(app, info["token"]),
"swfVfy": swfUrl,
"pageUrl": self.url,
"live": True,
"playpath": "{domain}_{channel}".format(**params),
})
return dict(live=stream)
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):
match = _url_re.match(self.url)
if not match:
return
channel_name = match.group(1)
res = http.get(STREAMS_URL.format(channel_name))
streams = http.json(res, schema=_streams_schema)
if streams["type"] not in ("multi", "stream"):
return
for stream in streams["data"]:
if stream["slug"] != channel_name:
continue
if not stream["live"]:
return
streams = {}
try:
streams.update(
HLSStream.parse_variant_playlist(
self.session, HLS_URL.format(stream["id"])))
except IOError as e:
# fix for hosted offline streams
if "404 Client Error" in str(e):
return
raise
streams["rtmp"] = RTMPStream(
self.session, {
"rtmp": RTMP_URL.format(stream["id"]),
"pageUrl": self.url,
"live": True
})
return streams
return
