def _get_streams(self):
channelname = urlparse(self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {"Referer": self.url, "Accept-Encoding": "deflate"}
options = dict(channel=channelname, vw="580", vh="390", domain="www.cast3d.tv")
res = http.get(self.PlayerURL, headers=headers, params=options)
match = re.search(".+?'streamer':'(.+?)'", res.text)
if not match:
raise NoStreamsError(self.url)
streams = {}
url = urlparse(match.group(1))
if url.scheme.startswith("rtmp"):
redirect = False
rtmp = match.group(1)
if "redirect" in rtmp:
redirect = True
streams["live"] = RTMPStream(
self.session,
{"rtmp": rtmp, "pageUrl": self.url, "swfVfy": self.SWFURL, "playpath": channelname, "live": True},
redirect=redirect,
)
elif url.scheme.startswith("http"):
streams["live"] = HTTPStream(self.session, match.group(1))
else:
raise PluginError(("Invalid stream type: {0}").format(url.scheme))
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):
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)
streams = defaultdict(list)
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)
streams[stream_name].append(stream)
if ios_url:
if urlparse(ios_url).path.endswith(".m3u8"):
hls_streams = HLSStream.parse_variant_playlist(
self.session, ios_url
)
for name, stream in hls_streams.items():
streams[name].append(stream)
if swf_url:
stream = self._get_rtmp_streams(swf_url)
if stream:
streams[stream_name].append(stream)
return streams
def _create_flv_playlist(self, template):
res = http.get(template)
json = http.json(res)
if not isinstance(json, dict):
raise PluginError("Invalid JSON response")
parsed = urlparse(template)
try:
url_template = '{0}://{1}{2}'.format(parsed.scheme, parsed.netloc,
json['template'])
segment_max = reduce(lambda i, j: i + j[0], json['fragments'], 0)
duration = json['duration']
except KeyError:
raise PluginError('Unexpected JSON response')
substreams = [
HTTPStream(self.session,
url_template.replace('$fragment$', str(i)))
for i in range(1, segment_max + 1)
]
return FLVPlaylist(self.session,
streams=substreams,
duration=duration,
skip_header=True,
flatten_timestamps=True)
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):
self.logger.debug("Fetching stream info")
res = urlget(self.url)
match = re.search("flashplayer: \"(.+.swf)\".+streamer: \"(.+)\""
".+file: \"(.+).flv\"", res.text, re.DOTALL)
if not match:
raise NoStreamsError(self.url)
rtmpurl = match.group(2).replace("\\/", "/")
parsed = urlparse(rtmpurl)
params = {
"rtmp": rtmpurl,
"app": "{0}?{1}".format(parsed.path[1:], parsed.query),
"pageUrl": self.url,
"swfVfy": match.group(1),
"playpath" : match.group(3),
"live": True
}
match = re.search("(http(s)?://.+/server.php\?id=\d+)",
res.text)
if match:
token_url = match.group(1)
res = res_json(urlget(token_url, headers=dict(Referer=self.url)))
token = res.get("token")
if token:
params["token"] = token
streams = {}
streams["live"] = RTMPStream(self.session, params)
return streams
def _get_streams(self):
channelid = urlparse(
self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {"Referer": self.url}
options = dict(id=channelid)
res = urlget(self.StreamInfoURL, headers=headers, params=options)
json = res_json(res, "stream info JSON")
if not isinstance(json, dict):
raise PluginError("Invalid JSON response")
if not ("rtmp" in json and "streamname" in json):
raise NoStreamsError(self.url)
if not RTMPStream.is_usable(self.session):
raise PluginError(
"rtmpdump is not usable and required by Owncast plugin")
rtmp = json["rtmp"]
playpath = json["streamname"]
streams = {}
streams["live"] = RTMPStream(
self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfUrl": self.SWFURL,
"playpath": playpath,
"live": True
})
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)
streams = defaultdict(list)
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)
streams[stream_name].append(stream)
if ios_url:
if urlparse(ios_url).path.endswith(".m3u8"):
hls_streams = HLSStream.parse_variant_playlist(
self.session, ios_url)
for name, stream in hls_streams.items():
streams[name].append(stream)
if swf_url:
stream = self._get_rtmp_streams(swf_url)
if stream:
streams[stream_name].append(stream)
return streams
def _create_rtmp_stream(self, cdn, stream_name):
parsed = urlparse(cdn)
options = dict(rtmp=cdn, app=parsed.path[1:],
playpath=stream_name, pageUrl=self.url,
swfUrl=SWF_URL, live=True)
return RTMPStream(self.session, options)
def _get_streams(self):
parsed = urlparse(self.url)
if parsed.fragment:
channelid = parsed.fragment
else:
channelid = parsed.path.rpartition("view/")[-1]
if not channelid:
raise NoStreamsError(self.url)
channelid = channelid.lower().replace("/", "_")
self.logger.debug("Fetching stream info")
res = urlget(self.APIURL.format(channelid))
json = res_json(res)
if not isinstance(json, dict):
raise PluginError("Invalid JSON response")
elif not ("success" in json and "payload" in json):
raise PluginError("Invalid JSON response")
elif json["success"] == False:
raise NoStreamsError(self.url)
streams = {}
streams["live"] = HTTPStream(self.session, json["payload"])
return streams
def _get_streams(self):
parsed = urlparse(self.url)
cls = PROTOCOL_MAP.get(parsed.scheme)
if not cls:
return
split = self.url.split(" ")
url = split[0]
urlnoproto = re.match("^\w+://(.+)", url).group(1)
# Prepend http:// if needed.
if cls != RTMPStream and not re.match("^http(s)?://", urlnoproto):
urlnoproto = "http://{0}".format(urlnoproto)
params = (" ").join(split[1:])
params = self._parse_params(params)
if cls == RTMPStream:
params["rtmp"] = url
for boolkey in ("live", "realtime", "quiet", "verbose", "debug"):
if boolkey in params:
params[boolkey] = bool(params[boolkey])
stream = cls(self.session, params)
elif cls == HLSStream.parse_variant_playlist or cls == HDSStream.parse_manifest:
return cls(self.session, urlnoproto, **params)
else:
stream = cls(self.session, urlnoproto, **params)
return dict(live=stream)
def _get_streams(self):
channelid = urlparse(self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {"Referer": self.url}
options = dict(id=channelid)
res = urlget(self.StreamInfoURL, headers=headers, params=options)
json = res_json(res, "stream info JSON")
if not isinstance(json, dict):
raise PluginError("Invalid JSON response")
if not ("rtmp" in json and "streamname" in json):
raise NoStreamsError(self.url)
if not RTMPStream.is_usable(self.session):
raise PluginError("rtmpdump is not usable and required by Owncast plugin")
rtmp = json["rtmp"]
playpath = json["streamname"]
streams = {}
streams["live"] = RTMPStream(
self.session, {"rtmp": rtmp, "pageUrl": self.url, "swfUrl": self.SWFURL, "playpath": playpath, "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):
channelname = urlparse(self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {
"Referer": self.url
}
res = urlget(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 = urlget(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_stream(self, channel_id, quality):
params = dict(channel_id=channel_id, quality=quality)
res = urlopen(CHINFO_URL, data=params, headers=AJAX_HEADERS,
session=self.rsession)
json = res_json(res)
if not json:
raise NoStreamsError(self.url)
elif not isinstance(json, list):
raise PluginError("Invalid JSON response")
info = json[0]
rtmp = info.get("serverURL")
playpath = info.get("streamName")
if not (rtmp and playpath):
raise NoStreamsError(self.url)
parsed = urlparse(rtmp)
if not parsed.scheme.startswith("rtmp"):
raise NoStreamsError(self.url)
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
return RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"playpath": playpath,
"app": app,
"live": True
})
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_rtmp_stream(self, cdn, stream_name):
parsed = urlparse(cdn)
options = dict(rtmp=cdn, app=parsed.path[1:],
playpath=stream_name, pageUrl=self.url,
swfUrl=SWF_URL, live=True)
return RTMPStream(self.session, options)
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)
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_streams(self):
parsed = urlparse(self.url)
if not parsed.scheme in self.ProtocolMap:
raise NoStreamsError(self.url)
cls = self.ProtocolMap[parsed.scheme]
split = self.url.split(" ")
url = split[0]
urlnoproto = re.match("^\w+://(.+)", url).group(1)
params = (" ").join(split[1:])
params = self._parse_params(params)
if cls == RTMPStream:
params["rtmp"] = url
for boolkey in ("live", "realtime", "quiet", "verbose", "debug"):
if boolkey in params:
params[boolkey] = bool(params[boolkey])
stream = cls(self.session, params)
elif cls == HLSStream.parse_variant_playlist or cls == HDSStream.parse_manifest:
return cls(self.session, urlnoproto, **params)
else:
stream = cls(self.session, urlnoproto, **params)
return dict(live=stream)
def get_alt_live_streams(self):
res = self._get_live_page(self.res)
match = re.search('jQuery.post\("/live/ajaxGetUrl.gom", ({.+?}),',
res.text)
if not match:
raise NoStreamsError(self.url)
ajaxparams = match.group(1)
ajaxparams = dict(re.findall("(\w+):(\d+)", ajaxparams))
levels = re.findall("setFlashLevel\((\d+)\);.+?<span class=\"qtype\">(\w+)</span>", res.text)
streams = {}
for level, quality in levels:
params = ajaxparams.copy()
params["level"] = level
quality = quality.lower()
res = urlopen(self.GetStreamURL, data=params, session=self.rsession)
url = unquote(res.text)
if not urlparse(url).path.endswith(".f4m"):
continue
try:
s = HDSStream.parse_manifest(self.session, url)
if len(s) > 0:
bitrate, stream = list(s.items())[0]
streams[quality] = stream
except IOError:
self.logger.warning("Unable to parse manifest")
return streams
def _get_stream_live(self):
self.logger.debug("Fetching room_id")
res = http.get(self.url)
match = re.search("room/id/(\d+)", res.text)
if not match:
return
room_id = match.group(1)
self.logger.debug("Comparing channel name with URL")
match = re.search("<meta property=\"og:url\" content=\"http://www.filmon.us/(\w+)", res.text)
if not match:
return
channel_name = match.group(1)
base_name = self.url.rstrip("/").rpartition("/")[2]
if (channel_name != base_name):
return
playpath = "mp4:bc_" + room_id
if not playpath:
raise NoStreamsError(self.url)
rtmp = RTMP_URL
parsed = urlparse(rtmp)
app = parsed.path[1:]
return RTMPStream(self.session, {
"rtmp": RTMP_URL,
"pageUrl": self.url,
"swfUrl": SWF_URL,
"playpath": playpath,
"app": app,
"live": True
})
def _get_streams(self):
parsed = urlparse(self.url)
if not parsed.scheme in self.ProtocolMap:
raise NoStreamsError(self.url)
cls = self.ProtocolMap[parsed.scheme]
split = self.url.split(" ")
url = split[0]
urlnoproto = re.match("^\w+://(.+)", url).group(1)
params = (" ").join(split[1:])
params = self._parse_params(params)
if cls == RTMPStream:
params["rtmp"] = url
for boolkey in ("live", "realtime", "quiet", "verbose", "debug"):
if boolkey in params:
params[boolkey] = bool(params[boolkey])
stream = cls(self.session, params)
elif cls == HLSStream.parse_variant_playlist or cls == HDSStream.parse_manifest:
return cls(self.session, urlnoproto, **params)
else:
stream = cls(self.session, urlnoproto, **params)
return dict(live=stream)
def _get_streams(self):
channelname = urlparse(
self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {"Referer": self.url}
res = urlget(self.PlayerURL.format(channelname), headers=headers)
match = re.search("'FlashVars', '(id=\d+)&", res.text)
if not match:
raise NoStreamsError(self.url)
channelname += "?" + match.group(1)
res = urlget(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):
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):
res = http.get(self.url, schema=_live_schema)
if not res:
return
if res["type"] == "hls" and urlparse(res["url"]).path.endswith("m3u8"):
stream = HLSStream(self.session, res["url"])
return dict(hls=stream)
def __init__(self, url):
parsed = urlparse(url)
# Attempt to resolve current live URL if main page is passed
if len(parsed.path) <= 1:
url = self.LiveURL
Plugin.__init__(self, url)
def _parse_vod_streams(self, vod):
for name, stream in vod["streams"].items():
scheme = urlparse(stream["url"]).scheme
if scheme == "http":
yield name, HLSStream(self.session, stream["url"])
elif scheme == "rtmp":
yield name, self._create_rtmp_stream(stream, live=False)
def _get_rtmp_app(self, rtmp):
parsed = urlparse(rtmp)
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
return app
def __init__(self, url):
parsed = urlparse(url)
# Attempt to resolve current live URL if main page is passed
if len(parsed.path) <= 1:
url = self.LiveURL
Plugin.__init__(self, url)
def _get_streams(self):
res = http.get(self.url, schema=_live_schema)
if not res:
return
if res["type"] == "hls" and urlparse(res["url"]).path.endswith("m3u8"):
stream = HLSStream(self.session, res["url"])
return dict(hls=stream)
def _get_rtmp_app(self, rtmp):
parsed = urlparse(rtmp)
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
return app
def _get_video_streams(self, player):
base_url = player["clip"]["baseUrl"] or VOD_BASE_URL
mapper = StreamMapper(cmp=lambda ext, bitrate: urlparse(bitrate["url"])
.path.endswith(ext))
mapper.map(".m3u8", self._create_video_stream, HLSStream, base_url)
mapper.map(".mp4", self._create_video_stream, HTTPStream, base_url)
mapper.map(".flv", self._create_video_stream, HTTPStream, base_url)
return mapper(player["clip"]["bitrates"])
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if not res:
return
if res["type"] == "channel" and urlparse(res["url"]).path.endswith("m3u8"):
return HLSStream.parse_variant_playlist(self.session, res["url"])
elif res["type"] == "video":
stream = HTTPStream(self.session, res["url"])
return dict(video=stream)
def _get_video_streams(self, player):
base_url = player["clip"]["baseUrl"] or VOD_BASE_URL
mapper = StreamMapper(
cmp=lambda ext, bitrate: urlparse(bitrate["url"]).path.endswith(ext)
)
mapper.map(".m3u8", self._create_video_stream, HLSStream, base_url)
mapper.map(".mp4", self._create_video_stream, HTTPStream, base_url)
mapper.map(".flv", self._create_video_stream, HTTPStream, base_url)
return mapper(player["clip"]["bitrates"])
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)
# looking for the <MediaFiles> tag
xmldoc = http.xml(res)
mediafiles = xmldoc.find(".//VideoEntries//MediaFiles")
# No mediafiles, no streams
if not mediafiles:
return None
rtmp = mediafiles.attrib['base']
streams = {}
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}k".format(bitrate)
streams[quality] = RTMPStream(self.session, params)
return streams
def _get_streams(self):
channelname = urlparse(
self.url).path.rstrip("/").rpartition("/")[-1].lower()
self.logger.debug("Fetching stream info")
headers = {"Referer": self.url, "Accept-Encoding": "deflate"}
options = dict(channel=channelname,
vw="580",
vh="390",
domain="www.cast3d.tv")
res = http.get(self.PlayerURL, headers=headers, params=options)
match = re.search(".+?'streamer':'(.+?)'", res.text)
if not match:
raise NoStreamsError(self.url)
streams = {}
url = urlparse(match.group(1))
if url.scheme.startswith("rtmp"):
redirect = False
rtmp = match.group(1)
if "redirect" in rtmp:
redirect = True
streams["live"] = RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfVfy": self.SWFURL,
"playpath": channelname,
"live": True
},
redirect=redirect)
elif url.scheme.startswith("http"):
streams["live"] = HTTPStream(self.session, match.group(1))
else:
raise PluginError(("Invalid stream type: {0}").format(url.scheme))
return streams
def _get_streams(self):
res = http.get(self.url, schema=_schema)
if not res:
return
if res["type"] == "channel" and urlparse(
res["url"]).path.endswith("m3u8"):
return HLSStream.parse_variant_playlist(self.session, res["url"])
elif res["type"] == "video":
stream = HTTPStream(self.session, res["url"])
return dict(video=stream)
def _get_streams(self):
channelname = urlparse(self.url).path.rstrip("/").rpartition("/")[-1].lower()
channelname = channelname.replace("_", "-")
try:
streams = HLSStream.parse_variant_playlist(self.session,
self.PlaylistURL.format(channelname))
except IOError:
return
return streams
def _get_rtmp_app(self, rtmp):
parsed = urlparse(rtmp)
if not parsed.scheme.startswith("rtmp"):
return
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
return app
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 resolve_url(url):
parsed = urlparse(url)
if len(parsed.scheme) == 0:
url = "http://" + url
for name, plugin in plugins.get_plugins().items():
if plugin.can_handle_url(url):
obj = plugin(url)
return obj
return None
def _get_stream_upload(self):
video = urlparse(self.url).path
if http.resolve_url(prepend_www(self.url)) == 'http://www.filmon.us/channels':
raise PluginError(video + " don't exist")
playpath = "mp4:resources" + video + '/v_3.mp4'
rtmp = RTMP_UPLOAD_URL
parsed = urlparse(rtmp)
app = parsed.path[1:]
return RTMPStream(self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfUrl": SWF_UPLOAD_URL,
"playpath": playpath,
"app": app,
"live": True
})
def _get_rtmp_app(self, rtmp):
parsed = urlparse(rtmp)
if not parsed.scheme.startswith("rtmp"):
return
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
return app
def _get_streams(self):
self.logger.debug("Fetching stream info")
res = urlget(self.url)
match = re.search("var current_channel = (.*);", res.text)
if match:
json = parse_json(match.group(1))
else:
raise NoStreamsError(self.url)
if not isinstance(json, dict):
raise PluginError("Invalid JSON response")
elif not "streams" in json:
raise NoStreamsError(self.url)
if not RTMPStream.is_usable(self.session):
raise PluginError(
"rtmpdump is not usable and required by Filmon plugin")
match = re.search("var flash_config = (.*);", res.text)
if match:
config = parse_json(match.group(1))
if "streamer" in config:
self.SWFURL = urljoin(self.SWFURL, config["streamer"])
streams = {}
for stream in json["streams"]:
if not ("url" in stream and "name" in stream):
continue
parsed = urlparse(stream["url"])
if not parsed.scheme.startswith("rtmp"):
continue
if parsed.query:
app = "{0}?{1}".format(parsed.path[1:], parsed.query)
else:
app = parsed.path[1:]
name = stream["quality"]
streams[name] = RTMPStream(
self.session, {
"rtmp": stream["url"],
"pageUrl": self.url,
"swfUrl": self.SWFURL,
"playpath": stream["name"],
"app": app,
"live": True
})
return streams
def _create_stream(self, source):
url = source["file"]
if urlparse(url).path.endswith("m3u8"):
streams = HLSStream.parse_variant_playlist(self.session, url)
# TODO: Replace with "yield from" when dropping Python 2.
for stream in streams.items():
yield stream
else:
name = source.get("label", "vod")
yield name, HTTPStream(self.session, url)
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):
channelname = urlparse(
self.url).path.rstrip("/").rpartition("/")[-1].lower()
channelname = channelname.replace("_", "-")
try:
streams = HLSStream.parse_variant_playlist(
self.session, self.PlaylistURL.format(channelname))
except IOError:
raise NoStreamsError(self.url)
return streams
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):
"""
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)
# looking for the <MediaFiles> tag
xmldoc = http.xml(res)
mediafiles = xmldoc.find(".//VideoEntries//MediaFiles")
# No mediafiles, no streams
if not mediafiles:
return None
rtmp = mediafiles.attrib["base"]
streams = {}
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}k".format(bitrate)
streams[quality] = RTMPStream(self.session, params)
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_stream_upload(self):
video = urlparse(self.url).path
if http.resolve_url(prepend_www(
self.url)) == 'http://www.filmon.us/channels':
raise PluginError(video + " don't exist")
playpath = "mp4:resources" + video + '/v_3.mp4'
rtmp = RTMP_UPLOAD_URL
parsed = urlparse(rtmp)
app = parsed.path[1:]
return RTMPStream(
self.session, {
"rtmp": rtmp,
"pageUrl": self.url,
"swfUrl": SWF_UPLOAD_URL,
"playpath": playpath,
"app": app,
"live": True
})
def _get_channel_name(self, url):
name = None
if ("dailymotion.com" in url) or ("dai.ly" in url):
rpart = urlparse(url).path.rstrip("/").rpartition("/")[-1].lower()
name = re.sub("_.*", "", rpart)
elif ("video.gamecreds.com" in url):
res = urlget(url)
# The HTML is broken (unclosed meta tags) and minidom fails to parse.
# Since we are not manipulating the DOM, we get away with a simple grep instead of fixing it.
match = re.search("<meta property=\"og:video\" content=\"http://www.dailymotion.com/swf/video/([a-z0-9]{6})", res.text)
if match: name = match.group(1)
return name
def _get_streams(self):
country_code = urlparse(self.url).netloc.split(".")[0]
self.logger.debug("Fetching stream info")
res = urlget(self.APIURL)
json = res_json(res)
if not isinstance(json, dict):
raise PluginError("Invalid JSON response")
elif not ("primary" in json or "secondary" in json):
raise PluginError("Invalid JSON response")
if not RTMPStream.is_usable(self.session):
raise PluginError(
"rtmpdump is not usable and required by Euronews plugin")
streams = {}
self.logger.debug("Euronews Countries:{0}",
" ".join(json["primary"].keys()))
if not (country_code in json["primary"]
or country_code in json["secondary"]):
res = urlget(self.GEOIPURL)
geo = res_json(res)
if isinstance(json, dict) and "country_code" in geo:
country_code = geo["country_code"].lower()
if not (country_code in json["primary"]
or country_code in json["secondary"]):
country_code = "en"
else:
country_code = "en"
for site in ("primary", "secondary"):
for quality in json[site][country_code]["rtmp_flash"]:
stream = json[site][country_code]["rtmp_flash"][quality]
name = quality + "k"
if site == "secondary":
name += "_alt"
streams[name] = RTMPStream(
self.session, {
"rtmp": stream["server"],
"playpath": stream["name"],
"swfUrl": self.SWFURL,
"live": True
})
if len(streams) == 0:
raise NoStreamsError(self.url)
return streams
def __init__(self, url):
Plugin.__init__(self, url)
match = _url_re.match(url).groupdict()
self.channel = match.get("channel").lower()
self.subdomain = match.get("subdomain")
self.video_type = match.get("video_type")
self.video_id = match.get("video_id")
parsed = urlparse(url)
self.params = parse_query(parsed.query)
self.api = TwitchAPI(beta=self.subdomain == "beta")
self.usher = UsherService()
