def _get_streams(self):
res = http.get(self.url, schema=_schema)
if not res:
return
owner = res["vars"]["owner"]
token = res["vars"].get("token", "null")
swf_url = res["swf"]
# Check if the stream is online
res = http.get(CHANNEL_DETAILS_URI.format(owner, token))
channel_details = http.json(res, schema=_channel_details_schema)
if not channel_details["channel"]["live"]:
return
stream_ip = http.get(REDIRECT_SERVICE_URI.format(owner)).text
streams = {}
streams["live"] = RTMPStream(
self.session,
{
"rtmp": RTMP_URL.format(stream_ip, channel_details["channel"]["slug"]),
"pageUrl": self.url,
"swfUrl": urljoin(self.url, swf_url),
"live": True,
},
)
return streams
def _get_vod_streams(self):
url = 'http://ida.omroep.nl/odi/?prid={}&puboptions=adaptive,h264_bb,h264_std,h264_sb&adaptive=no&part=1&token={}'.format(self.npo_id, self.get_token())
data = http.get(url, headers=HTTP_HEADERS).json()
streams = {}
stream = http.get(data['streams'][0].replace('jsonp', 'json'), headers=HTTP_HEADERS).json()
streams['best'] = streams['high'] = HTTPStream(self.session, stream['url'])
return streams
def _get_rtmp_streams(self, swfurl):
if not RTMPStream.is_usable(self.session):
raise NoStreamsError(self.url)
self.logger.debug("Fetching RTMP stream info")
res = http.get(swfurl)
swf = swfdecompress(res.content)
match = re.search("customURL[^h]+(https://.*?)\\\\", swf)
if not match:
raise NoStreamsError(self.url)
res = http.get(match.group(1))
rtmp, playpath = rtmpparse(res.text)
params = {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": playpath,
"live": True
}
match = re.search("file[^h]+(https?://.*?.swf)", swf)
if match:
params["swfUrl"] = match.group(1)
return RTMPStream(self.session, params)
def _get_streams(self):
channelname = urlparse(self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {
"Referer": self.url
}
res = http.get(self.PlayerURL.format(channelname), headers=headers)
match = re.search("'FlashVars', '(id=\d+)&s=(.+?)&", res.text)
if not match:
raise NoStreamsError(self.url)
channelname = "{0}?{1}".format(match.group(2), match.group(1))
res = http.get(self.BalancerURL, headers=headers)
match = re.search("redirect=(.+)", res.text)
if not match:
raise PluginError("Error retrieving RTMP address from loadbalancer")
rtmp = match.group(1)
streams = {}
streams["live"] = RTMPStream(self.session, {
"rtmp": "rtmp://{0}/live/{1}".format(rtmp, channelname),
"pageUrl": self.url,
"swfVfy": self.SWFURL,
"conn": "S:OK",
"live": True
})
return streams
def _get_rtmp_streams(self, swfurl):
if not RTMPStream.is_usable(self.session):
raise NoStreamsError(self.url)
self.logger.debug("Fetching RTMP stream info")
res = http.get(swfurl)
swf = swfdecompress(res.content)
match = re.search("customURL[^h]+(https://.*?)\\\\", swf)
if not match:
raise NoStreamsError(self.url)
res = http.get(match.group(1))
rtmp, playpath = rtmpparse(res.text)
params = {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": playpath,
"live": True
}
match = re.search("file[^h]+(https?://.*?.swf)", swf)
if match:
params["swfUrl"] = match.group(1)
return RTMPStream(self.session, params)
def _get_streams(self):
channelname = urlparse(
self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {"Referer": self.url}
res = http.get(self.PlayerURL.format(channelname), headers=headers)
match = re.search("'FlashVars', '(id=\d+)&s=(.+?)&", res.text)
if not match:
raise NoStreamsError(self.url)
channelname = "{0}?{1}".format(match.group(2), match.group(1))
res = http.get(self.BalancerURL, headers=headers)
match = re.search("redirect=(.+)", res.text)
if not match:
raise PluginError(
"Error retrieving RTMP address from loadbalancer")
rtmp = match.group(1)
streams = {}
streams["live"] = RTMPStream(
self.session, {
"rtmp": "rtmp://{0}/live/{1}".format(rtmp, channelname),
"pageUrl": self.url,
"swfVfy": self.SWFURL,
"conn": "S:OK",
"live": True
})
return streams
def _get_streams(self):
res = http.get(self.url)
channel_id = self._find_channel_id(res.text)
if not channel_id:
return
stream_id = self._get_stream_id(channel_id)
if not stream_id:
return
res = http.get(STREAM_API_URL.format(stream_id),
params=dict(format="all"))
items = http.json(res, schema=_stream_schema)
streams = {}
for stream in items:
parser = STREAM_TYPES[stream["format"]]
try:
streams.update(parser(self.session, stream["url"]))
except IOError as err:
if not re.search(r"(404|400) Client Error", str(err)):
self.logger.error("Failed to extract {0} streams: {1}",
stream["format"].upper(), err)
return streams
def _get_streams(self):
res = http.get(self.url)
channel_id = self._find_channel_id(res.text)
if not channel_id:
return
stream_id = self._get_stream_id(channel_id)
if not stream_id:
return
res = http.get(STREAM_API_URL.format(stream_id),
params=dict(format="all"))
json = http.json(res)
data = verifyjson(json, "data")
items = verifyjson(data, "items")
streams = {}
for stream in filter(valid_stream, items):
parser = STREAM_TYPES[stream["format"]]
try:
streams.update(parser(self.session, stream["url"]))
except IOError as err:
if not re.search(r"(404|400) Client Error", str(err)):
self.logger.error("Failed to extract {0} streams: {1}",
stream["format"].upper(), err)
return streams
def _get_streams(self):
info = http.get(self.url, schema=_schema)
if not info:
return
headers = {"Referer": self.url}
res = http.get(info["token_url"], headers=headers)
token = http.json(res, schema=_token_schema)
parsed = urlparse(info["rtmp_url"])
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
params = {
"rtmp": info["rtmp_url"],
"app": app,
"pageUrl": self.url,
"swfVfy": info["swf_url"],
"playpath": info["rtmp_playpath"],
"token": token,
"live": True
}
stream = RTMPStream(self.session, params)
return dict(live=stream)
def _get_streams(self):
self.logger.debug("Fetching stream info")
res = http.get(self.url)
match = re.search("\"User_channelid\".+?value=\"(.+?)\"", res.text)
if not match:
raise NoStreamsError(self.url)
headers = {
"Referer": self.url
}
res = http.get(self.PlayerURL.format(match.group(1)), headers=headers)
match = re.search("stream:\s+'(rtmp://.+?)'", res.text)
if not match:
raise NoStreamsError(self.url)
rtmp = match.group(1)
streams = {}
streams["live"] = RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfVfy": self.SWFURL,
"live": True
})
return streams
def _choose_server(self, json):
res = http.get(self.GEOIPURL)
loc = http.json(res)
loc = [loc["latitude"], loc["longitude"]]
sel_dist = float("inf")
i = 0
primary = -1
secondary = -1
for server in json["server"]:
res = http.get(self.GEOURL+server["server"]["name"]+"&sensor=false")
cord = http.json(res)
cord = [cord["results"][0]["geometry"]["location"]["lat"], cord["results"][0]["geometry"]["location"]["lng"]]
cur_dist = self._distance(loc, cord)
if cur_dist < sel_dist:
sel_dist = cur_dist
if server["server"]["used"] < 90:
# nearest server with load < 90%
primary = i
else:
# nearest server with load > 90%
secondary = i
i += 1
if primary == -1:
# if all servers have load over 90% use nearest one
return secondary
return primary
def _get_streams(self):
self.logger.debug("Fetching stream info")
res = http.get(self.url)
match = re.search("\"User_channelid\".+?value=\"(.+?)\"", res.text)
if not match:
raise NoStreamsError(self.url)
headers = {"Referer": self.url}
res = http.get(self.PlayerURL.format(match.group(1)), headers=headers)
match = re.search("stream:\s+'(rtmp://.+?)'", res.text)
if not match:
raise NoStreamsError(self.url)
rtmp = match.group(1)
streams = {}
streams["live"] = RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfVfy": self.SWFURL,
"live": True
})
return streams
def _get_streams(self):
match = _url_re.match(self.url)
if not match:
return
channel, media_id = match.group("channel", "media_id")
if channel != "video":
res = http.get(LIVE_API.format(channel))
livestream = http.json(res, schema=_live_schema)
if not livestream["media_is_live"]:
return
media_id = livestream["media_id"]
media_type = "live"
else:
media_type = "video"
res = http.get(PLAYER_API.format(media_type, media_id))
player = http.json(res, schema=_player_schema)
if media_type == "live":
swf_url = SWF_URL
for playlist in player.get("playlist", []):
bitrates = playlist.get("bitrates")
provider = playlist.get("connectionProvider")
rtmp = None
if bitrates:
rtmp = playlist.get("netConnectionUrl")
elif provider and provider in player["plugins"]:
provider = player["plugins"][provider]
swf_name = provider["url"]
swf_url = SWF_BASE + swf_name
rtmp = provider["netConnectionUrl"]
bitrates = player["clip"]["bitrates"]
else:
continue
for bitrate in bitrates:
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
})
yield quality, stream
else:
base_url = player["clip"]["baseUrl"] or VOD_BASE_URL
for bitrate in player["clip"]["bitrates"]:
url = base_url + "/" + bitrate["url"]
quality = self._get_quality(bitrate["label"])
if urlparse(url).path.endswith("m3u8"):
stream = HLSStream(self.session, url)
else:
stream = HTTPStream(self.session, url)
yield quality, stream
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if not res:
return
owner = res["vars"]["owner"]
token = res["vars"].get("token", "null")
swf_url = res["swf"]
# Check if the stream is online
res = http.get(CHANNEL_DETAILS_URI.format(owner, token))
channel_details = http.json(res, schema=_channel_details_schema)
if not channel_details["channel"]["live"]:
return
stream_ip = http.get(REDIRECT_SERVICE_URI.format(owner)).text
streams = {}
streams["live"] = RTMPStream(
self.session, {
"rtmp":
RTMP_URL.format(stream_ip, channel_details["channel"]["slug"]),
"pageUrl":
self.url,
"swfUrl":
urljoin(self.url, swf_url),
"live":
True
})
return streams
def _get_vod_streams(self, channelname):
res = http.get(self.url)
match = re.search('autoURL%22%3A%22(.*?)%22', res.text)
if not match:
raise PluginError('Error retrieving manifest url')
manifest_url = unquote(match.group(1)).replace('\\', '')
try:
res = http.get(manifest_url)
manifest = http.json(res)
except:
raise PluginError('Error retrieving manifest')
# A fallback host (http://proxy-xx...) is sometimes provided
# that we could make us of.
streams = {}
for params in manifest.get('alternates', []):
name = params.get('name')
template = params.get('template')
if not (name and template):
continue
name = '{0}p'.format(name)
streams[name] = self._create_flv_playlist(template)
return streams
def _get_streams(self):
res = http.get(self.url)
match = _embed_re.search(res.text)
if match:
res = http.get(match.group(1))
match = _aptoma_id_re.search(res.text)
if not match:
return
aptoma_id = match.group(1)
if not _live_re.search(res.text):
res = http.get(METADATA_URL.format(aptoma_id))
metadata = http.json(res)
video_id = metadata["videoId"]
else:
video_id = aptoma_id
res = http.get(VIDEO_INFO_URL, params=dict(id=video_id))
video = http.json(res, schema=_video_schema)
streams = {}
for fmt, providers in video["formats"].items():
for name, provider in providers.items():
for ext, playlists in provider.items():
for playlist in playlists:
url = PLAYLIST_URL_FORMAT.format(**playlist)
parser = STREAM_TYPES[fmt]
try:
streams.update(parser(self.session, url))
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}",
fmt.upper(), err)
return streams
def _get_vod_streams(self, channelname):
res = http.get(self.url)
match = re.search('autoURL%22%3A%22(.*?)%22', res.text)
if not match:
raise PluginError('Error retrieving manifest url')
manifest_url = unquote(match.group(1)).replace('\\', '')
try:
res = http.get(manifest_url)
manifest = http.json(res)
except:
raise PluginError('Error retrieving manifest')
# A fallback host (http://proxy-xx...) is sometimes provided
# that we could make us of.
streams = {}
for params in manifest.get('alternates', []):
name = params.get('name')
template = params.get('template')
if not (name and template):
continue
name = '{0}p'.format(name)
streams[name] = self._create_flv_playlist(template)
return streams
def _get_stream_info(self, url):
res = http.get(url, headers=HEADERS)
match = re.search("embed.swf\?p=(\d+)", res.text)
if not match:
return
program = match.group(1)
res = http.get(BEAT_PROGRAM.format(program), headers=HEADERS)
return http.json(res, schema=_schema)
def _get_stream_info(self, url):
res = http.get(url, headers=HEADERS)
match = re.search("embed.swf\?p=(\d+)", res.text)
if not match:
return
program = match.group(1)
res = http.get(BEAT_PROGRAM.format(program), headers=HEADERS)
return http.json(res)
def _get_live_streams(self):
meta = self._get_meta()
stream = filter(lambda x: x['type'] == 'hls', meta['streams'])[0]['url']
url = 'http://ida.omroep.nl/aapi/?type=jsonp&stream={}&token={}'.format(stream, self.get_token())
streamdata = http.get(url, headers=HTTP_HEADERS).json()
deeplink = http.get(streamdata['stream'], headers=HTTP_HEADERS).content
deeplink = re.compile('"(.*?)"', re.DOTALL + re.IGNORECASE).search(deeplink).group(1)
playlist_url = deeplink.replace("\\/", "/")
return HLSStream.parse_variant_playlist(self.session, playlist_url)
def _get_streams(self):
self.logger.debug("Fetching stream info")
media_is_live = 0
match = re.search(r".*hitbox.tv/([^/]*)/?(\d+)?", self.url)
if not match:
raise NoStreamsError(self.url)
stream_name, media_id = match.groups()
if stream_name != "video":
res = http.get(LIVE_API.format(stream_name))
json = http.json(res)
livestream = verifyjson(json, "livestream")
media_id = verifyjson(livestream[0], "media_id")
media_is_live = int(verifyjson(livestream[0], "media_is_live"))
if not media_is_live:
raise NoStreamsError(self.url)
media_type = "live" if media_is_live else "video"
res = http.get(PLAYER_API.format(media_type, media_id))
json = http.json(res)
clip = verifyjson(json, "clip")
live = verifyjson(clip, "live")
bitrates = verifyjson(clip, "bitrates")
streams = {}
if live:
for bitrate in bitrates:
connection_provider = clip.get("connectionProvider",
"clustering")
plugins = verifyjson(json, "plugins")
provider_plugin = verifyjson(plugins, connection_provider)
swf = verifyjson(provider_plugin, "url")
rtmp = verifyjson(provider_plugin, "netConnectionUrl")
quality = self._get_quality(verifyjson(bitrate, "label"))
url = verifyjson(bitrate, "url")
streams[quality] = RTMPStream(
self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": url,
"swfVfy": SWF_BASE + swf,
"live": True
})
else:
for bitrate in bitrates:
base_url = verifyjson(clip, "baseUrl")
url = verifyjson(bitrate, "url")
quality = self._get_quality(verifyjson(bitrate, "label"))
streams[quality] = HTTPStream(self.session,
base_url + "/" + url)
return streams
def _get_streams(self):
# If email option given, try to login
if self.options.get("email"):
res = http.get(self.LOGINPAGEURL)
match = re.search('<meta content="([^"]+)" name="csrf-token"',
res.text)
if not match:
raise PluginError("Missing CSRF Token: " + self.LOGINPAGEURL)
csrf_token = match.group(1)
email = self.options.get("email")
password = self.options.get("password")
res = http.post(
self.LOGINPOSTURL,
data={
'authenticity_token': csrf_token,
'channel_id': '',
'commit': 'Login',
'plan_id': '',
'session[email]': email,
'session[password]': password,
'utf8': "\xE2\x9C\x93", # Check Mark Character
})
self.logger.debug("Login account info: {0}", res.text)
result = http.json(res)
if result.get('email', 'no-mail') != email:
raise PluginError("Invalid account")
res = http.get(self.url)
streams = {}
if RTMPStream.is_usable(self.session):
try:
rtmpstreams = self._get_rtmp_streams(res.text)
streams.update(rtmpstreams)
except PluginError as err:
self.logger.error("Error when fetching RTMP stream info: {0}",
str(err))
else:
self.logger.warning(
"rtmpdump is not usable, only HLS streams will be available")
try:
hlsstreams = self._get_hls_streams(res.text)
streams.update(hlsstreams)
except PluginError as err:
self.logger.error("Error when fetching HLS stream info: {0}",
str(err))
return streams
def _get_streams(self):
self.logger.debug("Fetching stream info")
media_is_live = 0
match = re.search(r".*hitbox.tv/([^/]*)/?(\d+)?", self.url)
if not match:
raise NoStreamsError(self.url)
stream_name, media_id = match.groups()
if stream_name != "video":
res = http.get(LIVE_API.format(stream_name))
json = http.json(res)
livestream = verifyjson(json, "livestream")
media_id = verifyjson(livestream[0], "media_id")
media_is_live = int(verifyjson(livestream[0], "media_is_live"))
if not media_is_live:
raise NoStreamsError(self.url)
media_type = "live" if media_is_live else "video"
res = http.get(PLAYER_API.format(media_type, media_id))
json = http.json(res)
clip = verifyjson(json, "clip")
live = verifyjson(clip, "live")
bitrates = verifyjson(clip, "bitrates")
streams = {}
if live:
for bitrate in bitrates:
connection_provider = clip.get("connectionProvider", "clustering")
plugins = verifyjson(json, "plugins")
provider_plugin = verifyjson(plugins, connection_provider)
swf = verifyjson(provider_plugin, "url")
rtmp = verifyjson(provider_plugin, "netConnectionUrl")
quality = self._get_quality(verifyjson(bitrate, "label"))
url = verifyjson(bitrate, "url")
streams[quality] = RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": url,
"swfVfy": SWF_BASE + swf,
"live": True
})
else:
for bitrate in bitrates:
base_url = verifyjson(clip, "baseUrl")
url = verifyjson(bitrate, "url")
quality = self._get_quality(verifyjson(bitrate, "label"))
streams[quality] = HTTPStream(self.session,
base_url + "/" + url)
return streams
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_streams(self):
url_match = _url_re.match(self.url)
if url_match:
# find the list of channels from the html in the page
res = http.get(self.url)
channel_map = dict(_channel_map_re.findall(res.text))
channel_id = channel_map.get(url_match.group(1))
# get the stream urls
res = http.get(STREAM_INFO_URL.format(id=channel_id))
stream_data = http.json(res, schema=_channel_schema)
return HLSStream.parse_variant_playlist(self.session, stream_data["stream"])
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_streams(self):
url_match = _url_re.match(self.url)
if url_match:
# find the list of channels from the html in the page
res = http.get(self.url)
channel_map = dict(_channel_map_re.findall(res.text))
channel_id = channel_map.get(url_match.group(1))
# get the stream urls
res = http.get(STREAM_INFO_URL.format(id=channel_id))
stream_data = http.json(res, schema=_channel_schema)
return HLSStream.parse_variant_playlist(self.session,
stream_data['stream'])
def _get_streams(self):
self.logger.debug("Fetching stream info")
media_is_live = 0
match = re.search(r".*hitbox.tv/([^/]*)/?(\d+)?", self.url)
if not match:
return
stream_name, media_id = match.groups()
if stream_name != "video":
res = http.get(LIVE_API.format(stream_name))
json = http.json(res)
livestream = verifyjson(json, "livestream")
media_id = verifyjson(livestream[0], "media_id")
media_is_live = int(verifyjson(livestream[0], "media_is_live"))
if not media_is_live:
return
media_type = "live" if media_is_live else "video"
res = http.get(PLAYER_API.format(media_type, media_id))
json = http.json(res)
clip = verifyjson(json, "clip")
live = verifyjson(clip, "live")
streams = {}
if live:
playlists = verifyjson(json, "playlist") or []
for playlist in filter(valid_playlist, playlists):
bitrates = playlist.get("bitrates")
rtmp = playlist.get("netConnectionUrl")
for bitrate in bitrates:
quality = self._get_quality(verifyjson(bitrate, "label"))
url = verifyjson(bitrate, "url")
streams[quality] = RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"playpath": url,
"swfVfy": SWF_URL,
"live": True
})
else:
bitrates = verifyjson(clip, "bitrates")
for bitrate in bitrates:
base_url = verifyjson(clip, "baseUrl")
url = verifyjson(bitrate, "url")
quality = self._get_quality(verifyjson(bitrate, "label"))
streams[quality] = HTTPStream(self.session,
base_url + "/" + url)
return streams
def _get_streams(self):
# If email option given, try to login
if self.options.get("email"):
res = http.get(self.LOGINPAGEURL)
match = re.search('<meta content="([^"]+)" name="csrf-token"', res.text)
if not match:
raise PluginError("Missing CSRF Token: " + self.LOGINPAGEURL)
csrf_token = match.group(1)
email = self.options.get("email")
password = self.options.get("password")
res = http.post(
self.LOGINPOSTURL,
data={
"authenticity_token": csrf_token,
"channel_id": "",
"commit": "Login",
"plan_id": "",
"session[email]": email,
"session[password]": password,
"utf8": "\xE2\x9C\x93", # Check Mark Character
},
)
self.logger.debug("Login account info: {0}", res.text)
result = http.json(res)
if result.get("email", "no-mail") != email:
raise PluginError("Invalid account")
res = http.get(self.url)
streams = {}
if RTMPStream.is_usable(self.session):
try:
rtmpstreams = self._get_rtmp_streams(res.text)
streams.update(rtmpstreams)
except PluginError as err:
self.logger.error("Error when fetching RTMP stream info: {0}", str(err))
else:
self.logger.warning("rtmpdump is not usable, only HLS streams will be available")
try:
hlsstreams = self._get_hls_streams(res.text)
streams.update(hlsstreams)
except PluginError as err:
self.logger.error("Error when fetching HLS stream info: {0}", str(err))
return streams
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if res["live"]:
return self._get_live_streams(res["lang"])
else:
return self._get_video_streams(res["videso"])
def _get_streams(self):
res = http.get(self.url)
# temporary fix until the jwplayer-parser works for this site again
# refer to: https://github.com/chrippa/livestreamer/issues/588
#
# not working:
# playlist = jwplayer.parse_playlist(res)
playlist = re.compile(r"playlist: (\[{.*?}\]),",
re.DOTALL + re.IGNORECASE).search(
res.content).group(1).strip()
playlist = playlist.replace('sources:', '"sources":')
playlist = playlist.replace('file:', '"file":')
playlist = json.loads(playlist)
if not playlist:
return
for item in playlist:
for source in item["sources"]:
filename = source["file"]
if filename.endswith(".smil"):
# TODO: Replace with "yield from" when dropping Python 2.
for stream in self._get_smil_streams(filename):
yield stream
elif filename.startswith("/"):
name = source.get("label", "vod")
url = BASE_VOD_URL + filename
yield name, HTTPStream(self.session, url)
break
def _api_call(self, entrypoint, params, schema=None):
"""Makes a call against the api.
:param entrypoint: API method to call.
:param params: parameters to include in the request data.
:param schema: schema to use to validate the data
"""
url = API_URL.format(entrypoint)
# Default params
params = dict(params)
params.update({
"version": API_VERSION,
"locale": API_LOCALE,
})
if self.session_id:
params["session_id"] = self.session_id
# The certificate used by Crunchyroll cannot be verified in some environments.
res = http.get(url, params=params, headers=API_HEADERS, verify=False)
json_res = http.json(res, schema=_api_schema)
if json_res["error"]:
err_msg = json_res.get("message", "Unknown error")
err_code = json_res.get("code", "unknown_error")
raise CrunchyrollAPIError(err_msg, err_code)
data = json_res.get("data")
if schema:
data = schema.validate(data, name="API response")
return data
def _get_player_params(self, retries=3):
res = http.get(self.url)
match = re.search("<param name=\"playerKey\" value=\"(.+)\" />",
res.text)
if not match:
# The HTML returned sometimes doesn't contain the parameters
if not retries:
raise PluginError("Missing key 'playerKey' in player params")
else:
return self._get_player_params(retries - 1)
key = match.group(1)
match = re.search("<param.+name=\"@videoPlayer\" value=\"(.+)\" />",
res.text)
if not match:
raise PluginError("Missing key 'videoPlayer' in player params")
video_player = match.group(1)
match = re.search("<param name=\"playerID\" value=\"(\d+)\" />",
res.text)
if not match:
raise PluginError("Missing key 'playerID' in player params")
player_id = match.group(1)
match = re.search("<!-- live on -->", res.text)
if not match:
match = re.search("<div id=\"channel_live\">", res.text)
is_live = not not match
return key, video_player, player_id, is_live
def _get_streams(self):
res = http.get(self.url)
match = _info_re.search(res.text)
if not match:
return
info = parse_json(match.group(1), schema=_schema)
stream_name = info["mode"]
mp4_url = info.get("mp4_url")
ios_url = info.get("ios_url")
swf_url = info.get("swf_url")
if mp4_url:
stream = HTTPStream(self.session, mp4_url)
yield stream_name, stream
if ios_url:
if urlparse(ios_url).path.endswith(".m3u8"):
streams = HLSStream.parse_variant_playlist(
self.session, ios_url)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
if swf_url:
stream = self._get_rtmp_stream(swf_url)
if stream:
yield stream_name, stream
def _create_streams(self, type_, video_id):
url = self._generate_security_url(type_, video_id)
res = http.get(url)
return HDSStream.parse_manifest(self.session,
res.text,
cookies=res.cookies)
def _get_streams(self):
res = http.get(self.StreamURL, data={"from": "ongamenet"})
match = re.search("var stream = \"(.+?)\";", res.text)
if not match:
raise NoStreamsError(self.url)
stream = match.group(1)
match = re.search("var server = \"(.+?)\";", res.text)
if not match:
raise NoStreamsError(self.url)
server = match.group(1)
streams = {}
streams["live"] = RTMPStream(self.session, {
"rtmp": server,
"playpath": stream,
"swfUrl": self.SWFURL,
"pageUrl": self.PageURL,
"live": True,
})
return streams
def _get_streams(self):
res = http.get(self.url, headers=HEADERS)
match = _embed_re.search(res.text)
if match:
url = match.group(0)
return self.session.streams(url)
def _api_call(self, entrypoint, params, schema=None):
"""Makes a call against the api.
:param entrypoint: API method to call.
:param params: parameters to include in the request data.
:param schema: schema to use to validate the data
"""
url = API_URL.format(entrypoint)
# Default params
params = dict(params)
params.update({
"version": API_VERSION,
"locale": API_LOCALE,
})
if self.session_id:
params["session_id"] = self.session_id
# The certificate used by Crunchyroll cannot be verified in some environments.
res = http.get(url, params=params, headers=API_HEADERS, verify=False)
json_res = http.json(res, schema=_api_schema)
if json_res["error"]:
err_msg = json_res.get("message", "Unknown error")
err_code = json_res.get("code", "unknown_error")
raise CrunchyrollAPIError(err_msg, err_code)
data = json_res.get("data")
if schema:
data = schema.validate(data, name="API response")
return data
def _get_streams(self):
res = http.get(self.StreamURL, data={"from": "ongamenet"})
match = re.search("var stream = \"(.+?)\";", res.text)
if not match:
raise NoStreamsError(self.url)
stream = match.group(1)
match = re.search("var server = \"(.+?)\";", res.text)
if not match:
raise NoStreamsError(self.url)
server = match.group(1)
streams = {}
streams["live"] = RTMPStream(
self.session, {
"rtmp": server,
"playpath": stream,
"swfUrl": self.SWFURL,
"pageUrl": self.PageURL,
"live": True,
})
return streams
def _get_streams(self):
match = _url_re.match(self.url)
parsed = urlparse(self.url)
if parsed.fragment:
channel_id = parsed.fragment
else:
channel_id = match.group("channel")
if not channel_id:
return
channel_id = channel_id.lower().replace("/", "_")
res = http.get(API_URL.format(channel_id))
info = http.json(res, schema=_schema)
if not info["success"]:
return
if info.get("isLive"):
name = "live"
else:
name = "vod"
stream = HTTPStream(self.session, info["payload"])
# Wrap the stream in a FLVPlaylist to verify the FLV tags
stream = FLVPlaylist(self.session, [stream])
return {name: stream}
def _get_player_params(self, retries=5):
match = _url_re.match(self.url)
domain = match.group('domain')
try:
res = http.get(CHANNEL_INFO_URL % str(domain))
except PluginError as err:
# The server sometimes gives us 404 for no reason
if "404" in str(err) and retries:
sleep(1)
return self._get_player_params(retries - 1)
else:
raise
channel_info = http.json(res)
channel_info = channel_info['data']
key = channel_info['player_key']
is_live = channel_info['is_live']
stream_video = channel_info['stream_video']
if stream_video:
video_player = "ref:" + stream_video['reference_id']
else:
is_live = False
player_id = channel_info['player_id']
return key, video_player, player_id, is_live
def _get_stream_info(self, assign_url, cdn, quality, broad_key, type):
headers = {
"Referer": self.url,
}
params = {
"rtmp": {
"return_type":
cdn,
"use_cors":
"true",
"cors_origin_url":
"play.afreecatv.com",
"broad_key":
"{broad_key}-flash-{quality}-{type}".format(
broad_key=broad_key, quality=quality, type=type),
"time":
1234.56
},
"hls": {
"return_type":
cdn,
"use_cors":
"true",
"cors_origin_url":
"play.afreecatv.com",
"broad_key":
"{broad_key}-flash-{quality}-{type}".format(
broad_key=broad_key, quality=quality, type=type),
"time":
1234.56
}
}
res = http.get(assign_url, params=params[type], headers=headers)
return http.json(res, schema=_stream_schema)
def _get_stream_info(self):
res = http.get(self.url)
match = re.search("window.config = ({.+})", res.text)
if match:
config = match.group(1)
return parse_json(config, "config JSON",
schema=_stream_config_schema)
def _get_player_params(self, retries=5):
match = _url_re.match(self.url);
domain = match.group('domain');
try:
res = http.get(CHANNEL_INFO_URL % str(domain))
except PluginError as err:
# The server sometimes gives us 404 for no reason
if "404" in str(err) and retries:
sleep(1)
return self._get_player_params(retries - 1)
else:
raise
channel_info = http.json(res)
channel_info = channel_info['data']
key = channel_info['player_key'];
is_live = channel_info['is_live'];
stream_video = channel_info['stream_video']
if stream_video:
video_player = "ref:" + stream_video['reference_id']
else:
is_live = False
player_id = channel_info['player_id']
return key, video_player, player_id, is_live
def _get_swf_url(self):
res = http.get(self.url)
match = _swf_url_re.search(res.text)
if not match:
raise PluginError("Unable to find SWF URL in the HTML")
return match.group(1)
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):
res = http.get(self.url)
match = _info_re.search(res.text)
if not match:
return
info = parse_json(match.group(1), schema=_schema)
stream_name = info["mode"]
mp4_url = info.get("mp4_url")
ios_url = info.get("ios_url")
swf_url = info.get("swf_url")
if mp4_url:
stream = HTTPStream(self.session, mp4_url)
yield stream_name, stream
if ios_url:
if urlparse(ios_url).path.endswith(".m3u8"):
streams = HLSStream.parse_variant_playlist(self.session, ios_url)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
if swf_url:
stream = self._get_rtmp_stream(swf_url)
if stream:
yield stream_name, stream
def _get_streams(self):
self.logger.debug("Fetching stream info")
res = http.get(self.url)
match = re.search("var info = (.*);", res.text)
if not match:
raise NoStreamsError(self.url)
json = parse_json(match.group(1))
if not isinstance(json, dict):
return
ios_url = json.get("ios_url")
swf_url = json.get("swf_url")
streams = {}
if ios_url:
hls = HLSStream.parse_variant_playlist(self.session, ios_url)
streams.update(hls)
if swf_url:
try:
streams["live"] = self._get_rtmp_streams(swf_url)
except NoStreamsError:
pass
return streams
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if res["live"]:
return self._get_live_streams(res["lang"])
else:
return self._get_video_streams(res["videso"])
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):
res = http.get(self.url)
# temporary fix until the jwplayer-parser works for this site again
# refer to: https://github.com/chrippa/livestreamer/issues/588
#
# not working:
# playlist = jwplayer.parse_playlist(res)
playlist = re.compile(r"playlist: (\[{.*?}\]),", re.DOTALL + re.IGNORECASE).search(res.content).group(1).strip()
playlist = playlist.replace('sources:', '"sources":')
playlist = playlist.replace('file:', '"file":')
playlist = json.loads(playlist)
if not playlist:
return
for item in playlist:
for source in item["sources"]:
filename = source["file"]
if filename.endswith(".smil"):
# TODO: Replace with "yield from" when dropping Python 2.
for stream in self._get_smil_streams(filename):
yield stream
elif filename.startswith("/"):
name = source.get("label", "vod")
url = BASE_VOD_URL + filename
yield name, HTTPStream(self.session, url)
break
def _find_broadcast(self, username):
res = http.get(CHANNEL_URL, headers=HEADERS,
params=dict(szBjId=username))
match = re.search(r"<thumb>.+\/(\d+)\.gif</thumb>", res.text)
if match:
return match.group(1)
def _get_streams_from_media(self, media_id):
res = http.get(STREAM_INFO_URL.format(media_id), cookies=COOKIES)
media = http.json(res, schema=_media_schema)
params = extra_params = swf_url = None
for __ in media:
for __ in __["layerList"]:
for __ in __.get("sequenceList", []):
for layer in __["layerList"]:
name = layer["name"]
if name == "video":
params = layer.get("param")
elif name == "reporting":
extra_params = layer.get("param", {})
extra_params = extra_params.get("extraParams", {})
if not params:
return
if extra_params:
swf_url = extra_params.get("videoSwfURL")
mode = params.get("mode")
if mode == "live":
return self._get_live_streams(params, swf_url)
elif mode == "vod":
return self._get_vod_streams(params)
def _get_swf_url(self):
res = http.get(self.url)
match = _swf_url_re.search(res.text)
if not match:
raise PluginError("Unable to find SWF URL in the HTML")
return match.group(1)
def _get_streams(self):
match = _url_re.match(self.url)
video_id = match.group("video_id")
res = http.get(API_URL, params=dict(ak="web", id=video_id))
fmts = http.xml(res, schema=_schema)
streams = {}
for fmt in fmts:
if fmt["type"] in STREAMING_TYPES:
name, parser = STREAMING_TYPES[fmt["type"]]
try:
streams.update(parser(self.session, fmt["url"]))
except IOError as err:
self.logger.error("Failed to extract {0} streams: {1}",
name, err)
elif fmt["type"] == "h264_aac_mp4_rtmp_zdfmeta_http":
name = fmt["quality"]
try:
streams[name] = self._create_rtmp_stream(fmt["url"])
except IOError as err:
self.logger.error("Failed to extract RTMP stream '{0}': {1}",
name, err)
return streams
def _get_streams(self):
json_url = http.get(self.url, schema=_schema)
if not json_url:
return
res = http.get(json_url)
video = http.json(res, schema=_video_schema)
if not video["videoJsonPlayer"]["VSR"]:
return
is_live = video["videoJsonPlayer"]["VTY"] == "LIVE"
vsr = video["videoJsonPlayer"]["VSR"].values()
streams = (self._create_stream(stream, is_live) for stream in vsr)
return chain.from_iterable(streams)
def _get_vod_stream(self, movie_id):
res = http.get(VODINFO_URL.format(movie_id), headers=AJAX_HEADERS)
json = http.json(res)
json = json and json.get("data")
json = json and json.get("streams")
if not json:
raise NoStreamsError(self.url)
streams = {}
for quality in ("low", "high"):
stream = json.get(quality)
if not stream:
continue
rtmp = stream.get("url")
app = self._get_rtmp_app(rtmp)
if not app:
continue
playpath = stream.get("name")
if ".mp4" in playpath:
playpath = "mp4:" + playpath
streams[quality] = RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"playpath": playpath,
"app": app,
})
return streams
