def _get_streams(self):
zdf_json = http.get(self.url, schema=_api_schema)
if zdf_json is None:
return
headers = {
"Api-Auth": "Bearer {0}".format(zdf_json['apiToken']),
"Referer": self.url
}
res = http.get(zdf_json['content'], headers=headers)
document = http.json(res, schema=_documents_schema)
stream_request_url = document["mainVideoContent"][
"http://zdf.de/rels/target"]["http://zdf.de/rels/streams/ptmd"]
stream_request_url = API_URL + stream_request_url
res = http.get(stream_request_url, headers=headers)
res = http.json(res, schema=_schema)
streams = {}
for format_ in self._extract_streams(res):
streams.update(format_)
return streams
def _get_streams(self):
http.mount('https://', HTTPAdapter(max_retries=99))
http.headers.update({'user-agent': useragents.CHROME})
match = _url_re.match(self.url)
channel = match.group("channel")
res_room_id = http.get(ROOM_API.format(channel))
room_id_json = http.json(res_room_id, schema=_room_id_schema)
room_id = room_id_json['room_id']
if room_id_json['live_status'] != SHOW_STATUS_ONLINE:
return
ts = int(time.time() / 60)
sign = hashlib.md5(("{0}{1}".format(channel, API_SECRET,
ts)).encode("utf-8")).hexdigest()
res = http.get(API_URL.format(room_id, sign))
room = http.json(res)
if not room:
return
for stream_list in room["durl"]:
name = "source"
url = stream_list["url"]
stream = HTTPStream(self.session, url)
yield name, stream
def _get_streams(self):
match = _url_re.match(self.url)
title = self.url.rsplit('/', 1)[-1]
if title.endswith(".html"):
title = title[:-5]
request_url = "https://api.zdf.de/content/documents/%s.json?profile=player" % title
res = http.get(request_url,
headers={
"Api-Auth":
"Bearer d2726b6c8c655e42b68b0db26131b15b22bd1a32"
})
document = http.json(res, schema=_documents_schema)
stream_request_url = document["mainVideoContent"][
"http://zdf.de/rels/target"]["http://zdf.de/rels/streams/ptmd"]
stream_request_url = API_URL + stream_request_url
res = http.get(stream_request_url)
res = http.json(res, schema=_schema)
streams = {}
for format_ in self._extract_streams(res):
streams.update(format_)
return streams
def _get_streams(self):
match = _url_re.match(self.url)
if not match:
return
channel, media_id = match.group("channel", "media_id")
self.logger.debug("Matched URL: channel={0}, media_id={1}".format(channel, media_id))
if not media_id:
res = http.get(LIVE_API.format(channel))
livestream = http.json(res, schema=_live_schema)
if livestream.get("media_hosted_media"):
hosted = _live_schema.validate(livestream["media_hosted_media"])
self.logger.info("{0} is hosting {1}", livestream["media_user_name"], hosted["media_user_name"])
livestream = hosted
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":
return self._get_live_streams(player)
else:
return self._get_video_streams(player)
def _get_streams(self):
match = self._url_re.match(self.url)
channel = match.group('channel')
res = http.get(self.FORMATS_URL.format(channel))
streams = http.json(res, schema=self._formats_schema)['streams']
if streams == []:
self.logger.error('Channel may be geo-restricted, not directly provided by PlayTV or not freely available')
return
for language in streams:
for protocol, bitrates in list(streams[language].items()):
# - Ignore non-supported protocols (RTSP, DASH)
# - Ignore deprecated Flash (RTMPE/HDS) streams (PlayTV doesn't provide anymore a Flash player)
if protocol in ['rtsp', 'flash', 'dash', 'hds']:
continue
for bitrate in bitrates['bitrates']:
if bitrate['value'] == 0:
continue
api_url = self.API_URL.format(channel, protocol, language, bitrate['value'])
res = http.get(api_url)
video_url = http.json(res, schema=self._api_schema)['url']
bs = '{0}k'.format(bitrate['value'])
if protocol == 'hls':
for _, stream in HLSStream.parse_variant_playlist(self.session, video_url).items():
yield bs, stream
elif protocol == 'hds':
for _, stream in HDSStream.parse_manifest(self.session, video_url).items():
yield bs, stream
def _get_streams(self):
title = self.url.rsplit('/', 1)[-1]
if title.endswith(".html"):
title = title[:-5]
if title == "live-tv":
self.logger.info("Klicken Sie mit der rechten Maustaste auf dem Player (im Browser) und waehlen Sie 'Beitrags-Url kopieren', um einen gueltigen Link fuer streamlink zu erhalten.")
return
headers = {
"Api-Auth": "Bearer d2726b6c8c655e42b68b0db26131b15b22bd1a32",
"Referer": self.url
}
request_url = "https://api.zdf.de/content/documents/%s.json?profile=player" % title
res = http.get(request_url, headers=headers)
document = http.json(res, schema=_documents_schema)
stream_request_url = document["mainVideoContent"]["http://zdf.de/rels/target"]["http://zdf.de/rels/streams/ptmd"]
stream_request_url = API_URL + stream_request_url
res = http.get(stream_request_url, headers=headers)
res = http.json(res, schema=_schema)
streams = {}
for format_ in self._extract_streams(res):
streams.update(format_)
return streams
def _get_streams(self):
match = _url_re.match(self.url)
vid = match.group("vid")
if vid:
res = http.get(VOD_API_URL.format(vid))
data = http.json(res, schema=_vod_schema)
yield "source", HLSStream(
self.session, data["live_info"]["video"])
return
channel = match.group("channel")
res = http.get(API_URL.format(channel))
room = http.json(res, schema=_room_schema)
if not room:
self.logger.info("Not a valid room url.")
return
live_info = room["live_info"]
if live_info["live_status"] != STATUS_ONLINE:
self.logger.info("Stream currently unavailable.")
return
for item in live_info["stream_items"]:
quality = item["title"]
if quality == u"\u6700\u4f73": # "Best" in Chinese
quality = "source"
yield quality, HTTPStream(self.session, item["video"])
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_streams(self):
match = _url_re.match(self.url)
if not match:
return
channel, media_id = match.group("channel", "media_id")
self.logger.debug("Matched URL: channel={0}, media_id={1}".format(
channel, media_id))
if not media_id:
res = http.get(LIVE_API.format(channel))
livestream = http.json(res, schema=_live_schema)
if livestream["media_hosted_media"]:
hosted = _live_schema.validate(
livestream["media_hosted_media"])
self.logger.info("{0} is hosting {1}",
livestream["media_user_name"],
hosted["media_user_name"])
livestream = hosted
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":
return self._get_live_streams(player)
else:
return self._get_video_streams(player)
def _get_streams(self):
match = _url_re.match(self.url)
vid = match.group("vid")
if vid:
res = http.get(VOD_API_URL.format(vid))
data = http.json(res, schema=_vod_schema)
yield "source", HLSStream(self.session, data["live_info"]["video"])
return
channel = match.group("channel")
res = http.get(API_URL.format(channel))
room = http.json(res, schema=_room_schema)
if not room:
self.logger.info("Not a valid room url.")
return
live_info = room["live_info"]
if live_info["live_status"] != STATUS_ONLINE:
self.logger.info("Stream currently unavailable.")
return
for item in live_info["stream_items"]:
quality = item["title"]
if quality == u"\u6700\u4f73": # "Best" in Chinese
quality = "source"
yield quality, HTTPStream(self.session, item["video"])
def _get_streams(self):
match = _url_re.match(self.url)
page = match.group("page")
channel = match.group("channel")
http.headers.update({'User-Agent': useragents.CHROME})
if page == 'user':
res = http.get(self.url)
userid = _userid_re.search(res.text).group(1)
api = http.post(API_URL, data={"targetUserID": userid})
data = http.json(api, schema=_user_api_schema)
rid = data["liveStreamID"]
if rid == 0:
self.logger.info("Stream currently unavailable.")
return
url = ROOM_URL.format(rid)
res = http.get(url)
elif page == 'profile':
api = http.post(API_URL, data={"targetUserID": channel})
data = http.json(api, schema=_user_api_schema)
rid = data["liveStreamID"]
if rid == 0:
self.logger.info("Stream currently unavailable.")
return
url = ROOM_URL.format(rid)
res = http.get(url)
else:
res = http.get(self.url)
status = _status_re.search(res.text)
if not status:
return
if status.group(1) != 'true':
self.logger.info("Stream currently unavailable.")
return
url = _rtmp_re.search(res.text).group(1)
if 'rtmp:' in url:
stream = RTMPStream(self.session, {"rtmp": url, "live": True})
yield "live", stream
else:
yield "live", HTTPStream(self.session, url)
if '17app.co' in url:
prefix = url.replace("rtmp:",
"http:").replace(".flv", "/playlist.m3u8")
if '/playlist.m3u8' not in prefix:
url = prefix + "/playlist.m3u8"
else:
url = prefix
for stream in HLSStream.parse_variant_playlist(self.session,
url).items():
yield stream
else:
url = url.replace(".flv", ".m3u8")
yield "live", HLSStream(self.session, url)
def _get_channel_video(self, channel_id):
query = {
"channelId": channel_id,
"type": "video",
"eventType": "live",
"part": "id",
"key": self.get_option("api_key") or API_KEY
}
res = http.get(API_SEARCH_URL, params=query, raise_for_status=False)
if res.status_code == codes.ok:
videos = http.json(res, schema=_search_schema)
for video in videos:
video_id = video["id"]["videoId"]
self.logger.debug("Found video_id: {0}".format(video_id))
return video_id
else:
try:
errors = http.json(res, exception=ValueError)
self.logger.error("Cloud not resolve channel video:")
for error in errors['error']['errors']:
self.logger.error(" {message} ({reason})".format(**error))
except ValueError:
self.logger.error("Cloud not resolve channel video: {0} error".format(res.status_code))
def _get_streams(self):
# Retrieve URL page and search for new type of video ID
res = http.get(self.url)
match = _id_re.search(res.text)
# Use API if match, otherwise resort to old method
if match:
vid = match.group("id")
res = http.get(API_URL.format(vid))
videos = http.json(res, schema=_video_schema)
mapper = StreamMapper(
cmp=lambda format, video: video["format"] == format)
mapper.map("hls", self._create_streams, "HLS",
HLSStream.parse_variant_playlist)
mapper.map("hds", self._create_streams, "HDS",
HDSStream.parse_manifest)
else:
res = http.get(self.url, params=dict(output="json"))
videos = http.json(res, schema=_old_video_schema)
mapper = StreamMapper(
cmp=lambda type, video: video["playerType"] == type)
mapper.map("ios", self._create_streams, "HLS",
HLSStream.parse_variant_playlist)
mapper.map("flash", self._create_streams, "HDS",
HDSStream.parse_manifest)
return mapper(videos)
def _get_streams(self):
match = self._url_re.match(self.url)
channel = match.group('channel')
res = http.get(self.FORMATS_URL.format(channel))
streams = http.json(res, schema=self._formats_schema)['streams']
if streams == []:
self.logger.error('Channel may be geo-restricted, not directly provided by PlayTV or not freely available')
return
for language in streams:
for protocol, bitrates in list(streams[language].items()):
# - Ignore non-supported protocols (RTSP, DASH)
# - Ignore deprecated Flash (RTMPE) streams (PlayTV doesn't provide anymore a Flash player)
if protocol in ['rtsp', 'flash', 'dash']:
continue
for bitrate in bitrates['bitrates']:
if bitrate['value'] == 0:
continue
api_url = self.API_URL.format(channel, protocol, language, bitrate['value'])
res = http.get(api_url)
video_url = http.json(res, schema=self._api_schema)['url']
bs = '{0}k'.format(bitrate['value'])
if protocol == 'hls':
for _, stream in HLSStream.parse_variant_playlist(self.session, video_url).items():
yield bs, stream
elif protocol == 'hds':
for _, stream in HDSStream.parse_manifest(self.session, video_url).items():
yield bs, stream
def _get_qq_streams(self, vid):
res = http.get(QQ_STREAM_INFO_URL % (vid, 1))
info = http.json(res, schema=_qq_schema)
yield "live", HTTPStream(self.session, info)
res = http.get(QQ_STREAM_INFO_URL % (vid, 2))
info = http.json(res, schema=_qq_schema)
yield "live_http", HLSStream(self.session, info)
def _get_qq_streams(self, vid):
res = http.get(QQ_STREAM_INFO_URL % (vid, 1))
info = http.json(res, schema=_qq_schema)
yield "live", HTTPStream(self.session, info)
res = http.get(QQ_STREAM_INFO_URL % (vid, 2))
info = http.json(res, schema=_qq_schema)
yield "live_http", HLSStream(self.session, info)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
http.headers.update({'User-Agent': useragents.CHROME})
http.verify = False
http.mount('https://', HTTPAdapter(max_retries=99))
#Thanks to @ximellon for providing method.
try:
channel = int(channel)
except ValueError:
channel = http.get(self.url, schema=_room_id_schema)
if channel == 0:
channel = http.get(self.url, schema=_room_id_alt_schema)
res = http.get(MAPI_URL.format(channel))
room = http.json(res, schema=_room_schema)
if not room:
self.logger.info("Not a valid room url.")
return
if room["show_status"] != SHOW_STATUS_ONLINE:
self.logger.info("Stream currently unavailable.")
return
ts = int(time.time() / 60)
did = uuid.uuid4().hex.upper()
sign = hashlib.md5(
("{0}{1}{2}{3}".format(channel, did, LAPI_SECRET,
ts)).encode("utf-8")).hexdigest()
data = {"cdn": "ws", "rate": "0", "tt": ts, "did": did, "sign": sign}
res = http.post(LAPI_URL.format(channel), data=data)
room = http.json(res, schema=_lapi_schema)
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
stream = HTTPStream(self.session, url)
yield "source", stream
data = {"cdn": "ws", "rate": "2", "tt": ts, "did": did, "sign": sign}
res = http.post(LAPI_URL.format(channel), data=data)
room = http.json(res, schema=_lapi_schema)
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
stream = HTTPStream(self.session, url)
yield "middle", stream
data = {"cdn": "ws", "rate": "1", "tt": ts, "did": did, "sign": sign}
res = http.post(LAPI_URL.format(channel), data=data)
room = http.json(res, schema=_lapi_schema)
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
stream = HTTPStream(self.session, url)
yield "low", stream
def _get_streams(self):
match = _url_re.match(self.url)
subdomain = match.group("subdomain")
http.verify = False
http.mount('https://', HTTPAdapter(max_retries=99))
if subdomain == 'v':
vid = match.group("vid")
headers = {
"User-Agent": useragents.ANDROID,
"X-Requested-With": "XMLHttpRequest"
}
res = http.get(VAPI_URL.format(vid), headers=headers)
room = http.json(res, schema=_vapi_schema)
yield "source", HLSStream(self.session, room["video_url"])
return
#Thanks to @ximellon for providing method.
channel = match.group("channel")
http.headers.update({'User-Agent': useragents.CHROME})
try:
channel = int(channel)
except ValueError:
channel = http.get(self.url, schema=_room_id_schema)
if channel is None:
channel = http.get(self.url, schema=_room_id_alt_schema)
ts = int(time.time() / 60)
sign = hashlib.md5(
("{0}{1}{2}".format(channel, WAPI_SECRET,
ts)).encode("utf-8")).hexdigest()
res = http.get(WAPI_URL.format(channel, ts, sign))
room = http.json(res, schema=_room_schema)
if not room:
self.logger.info("Not a valid room url.")
return
if room["show_status"] != SHOW_STATUS_ONLINE:
self.logger.info("Stream currently unavailable.")
return
did = uuid.uuid4().hex.upper()
sign = stupidMD5(("{0}{1}{2}{3}".format(channel, did, LAPI_SECRET,
ts)))
rate = [0, 2, 1]
quality = ['source', 'medium', 'low']
for i in range(0, 3, 1):
room = self._get_room_json(channel, rate[i], ts, did, sign)
url = "{room[rtmp_url]}/{room[rtmp_live]}".format(room=room)
if 'rtmp:' in url:
stream = RTMPStream(self.session, {"rtmp": url, "live": True})
yield quality[i], stream
else:
yield quality[i], HTTPStream(self.session, url)
def _get_live_streams(self, subdomain):
"""
Get the live stream in a particular language
:param subdomain:
:return:
"""
res = http.get(self._live_api_url.format(subdomain))
live_res = http.json(res, schema=self._live_schema)
api_res = http.get(live_res[u"url"])
stream_data = http.json(api_res, schema=self._stream_api_schema)
return HLSStream.parse_variant_playlist(self.session, stream_data[u'primary'])
def _get_live_streams(self, subdomain):
"""
Get the live stream in a particular language
:param subdomain:
:return:
"""
res = http.get(self._live_api_url.format(subdomain))
live_res = http.json(res, schema=self._live_schema)
api_res = http.get(live_res[u"url"])
stream_data = http.json(api_res, schema=self._stream_api_schema)
return HLSStream.parse_variant_playlist(self.session,
stream_data[u'primary'])
def _get_live_streams(self, language):
"""
Get the live stream in a particular language
:param language:
:return:
"""
res = http.get(self._live_api_url)
live_res = http.json(res, schema=self._live_schema)
api_res = http.get(live_res[u"url"])
stream_data = http.json(api_res, schema=self._stream_api_schema)
# find the stream in the requested language
if language in stream_data[u'primary']:
playlist_url = stream_data[u'primary'][language][u"hls"]
return HLSStream.parse_variant_playlist(self.session, playlist_url)
def _get_streams(self):
match = _url_re.match(self.url)
subdomain = match.group("subdomain")
http.verify = False
http.mount('https://', HTTPAdapter(max_retries=99))
if subdomain == 'v':
vid = match.group("vid")
headers = {
"User-Agent": useragents.ANDROID,
"X-Requested-With": "XMLHttpRequest"
}
res = http.get(VAPI_URL.format(vid), headers=headers)
room = http.json(res, schema=_vapi_schema)
yield "source", HLSStream(self.session, room["video_url"])
return
#Thanks to @ximellon for providing method.
channel = match.group("channel")
http.headers.update({'User-Agent': useragents.CHROME})
try:
channel = int(channel)
except ValueError:
channel = http.get(self.url, schema=_room_id_schema)
if channel == 0:
channel = http.get(self.url, schema=_room_id_alt_schema)
res = http.get(MAPI_URL.format(channel))
room = http.json(res, schema=_room_schema)
if not room:
self.logger.info("Not a valid room url.")
return
if room["show_status"] != SHOW_STATUS_ONLINE:
self.logger.info("Stream currently unavailable.")
return
rate = [0, 2, 1]
quality = ['source', 'medium', 'low']
for i in range(0, 3, 1):
room = self._get_room_json(channel, rate[i])
url = room["live_url"]
if 'rtmp:' in url:
stream = RTMPStream(self.session, {"rtmp": url, "live": True})
yield quality[i], stream
else:
yield quality[i], HTTPStream(self.session, url)
yield quality[i], HLSStream(self.session, room["hls_url"])
def _get_live_streams(self, lang, path):
"""
Get the live stream in a particular language
:param lang:
:param path:
:return:
"""
res = http.get(self._live_api_url.format(lang, path))
live_res = http.json(res)['default']['uid']
post_data = '{"channel_url":"/api/channels/%s/"}' % live_res
try:
stream_data = http.json(http.post(self._stream_get_url, data=post_data))['stream_url']
except:
stream_data = http.json(http.post(self._stream_get_url, data=post_data))['channel_url']
return HLSStream.parse_variant_playlist(self.session, stream_data)
def _get_live_streams(self, lang, path):
"""
Get the live stream in a particular language
:param lang:
:param path:
:return:
"""
res = http.get(self._live_api_url.format(lang, path))
live_res = http.json(res)['default']['uid']
post_data = '{"channel_url":"/api/channels/%s/"}' % live_res
try:
stream_data = http.json(http.post(self._stream_get_url, data=post_data))['stream_url']
except BaseException:
stream_data = http.json(http.post(self._stream_get_url, data=post_data))['channel_url']
return HLSStream.parse_variant_playlist(self.session, stream_data)
def _get_streams(self):
match = self._url_re.match(self.url)
video_id = match.group('video_id')
if video_id is not None:
# VOD
res = http.get(self.VOD_API_URL.format(video_id))
stream_data = http.json(res, schema=self._vod_api_schema)
# Check whether video format is expired
current_date = datetime.strptime(stream_data['current_date'],
'%Y-%m-%dT%H:%M:%S.%f')
valid_start = datetime.strptime(
stream_data['shows']['valid_start'], '%Y-%m-%dT%H:%M:%S')
valid_end = datetime.strptime(stream_data['shows']['valid_end'],
'%Y-%m-%dT%H:%M:%S')
if current_date < valid_start or current_date > valid_end:
self.logger.error(
'Failed to access stream, may be due to expired content')
return
streams = stream_data['shows']['media:group']
else:
# Live
channel_id = match.group('channel_id')
# Get live streams for desktop
res = http.get(self.LIVE_API_URL, params={'channelid': channel_id})
streams = http.xml(res, schema=self._live_api_schema)
# Get HLS streams for Iphone
res = http.get(self.LIVE_API_URL,
params={
'channelid': channel_id,
'platform': 'iphone'
})
stream = http.json(res, schema=self._live_api_iphone_schema)
if stream != 'none':
streams.append(stream)
for stream in streams:
if '.f4m' in stream:
for s in HDSStream.parse_manifest(self.session,
stream).items():
yield s
if '.m3u8' in stream:
for s in HLSStream.parse_variant_playlist(
self.session, stream).items():
yield s
def _get_streams(self):
http.headers.update({
"User-Agent": useragents.CHROME,
"Referer": self.referer
})
fragment = dict(parse_qsl(urlparse(self.url).fragment))
link = fragment.get("link")
if not link:
link = self._get_tv_link()
if not link:
self.logger.error("Missing link fragment: stream unavailable")
return
player_url = self._api_url.format(link)
self.logger.debug("Requesting player API: {0} (referer={1})",
player_url, self.referer)
res = http.get(player_url,
params={"_": int(time.time() * 1000)},
headers={"X-Requested-With": "XMLHttpRequest"})
try:
data = http.json(res, schema=self.api_schema)
except PluginError as e:
print(e)
self.logger.error("Cannot play this stream type")
else:
if data["status"]:
if data["file"].startswith("<"):
self.logger.error("Cannot play embedded streams")
else:
return HLSStream.parse_variant_playlist(
self.session, data["file"])
else:
self.logger.error(data["text"])
def _get_streams(self):
http.headers.update({"User-Agent": useragents.CHROME,
"Referer": self.referer})
fragment = dict(parse_qsl(urlparse(self.url).fragment))
link = fragment.get("link")
if not link:
link = self._get_tv_link()
if not link:
self.logger.error("Missing link fragment: stream unavailable")
return
player_url = self._api_url.format(link)
self.logger.debug("Requesting player API: {0} (referer={1})", player_url, self.referer)
res = http.get(player_url,
params={"_": int(time.time() * 1000)},
headers={"X-Requested-With": "XMLHttpRequest"})
try:
data = http.json(res, schema=self.api_schema)
except PluginError as e:
print(e)
self.logger.error("Cannot play this stream type")
else:
if data["status"]:
if data["file"].startswith("<"):
self.logger.error("Cannot play embedded streams")
else:
return HLSStream.parse_variant_playlist(self.session, data["file"])
else:
self.logger.error(data["text"])
def _get_vod_streams(self, params):
manifest_url = params.get("autoURL")
if not manifest_url:
return
res = http.get(manifest_url)
if res.headers.get("Content-Type") == "application/f4m+xml":
streams = HDSStream.parse_manifest(self.session, res.url)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in streams.items():
yield __
elif res.headers.get("Content-Type") == "application/vnd.apple.mpegurl":
streams = HLSStream.parse_variant_playlist(self.session, res.url)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in streams.items():
yield __
else:
manifest = http.json(res, schema=_vod_manifest_schema)
for params in manifest["alternates"]:
name = "{0}p".format(params["height"])
stream = self._create_flv_playlist(params["template"])
yield name, stream
failovers = params.get("failover", [])
for failover in failovers:
stream = self._create_flv_playlist(failover)
yield name, stream
def _get_streams(self):
match = _url_re.match(self.url)
username = match.group("username")
CSRFToken = str(uuid.uuid4().hex.upper()[0:32])
headers = {
"Content-Type": "application/x-www-form-urlencoded",
"X-CSRFToken": CSRFToken,
"X-Requested-With": "XMLHttpRequest",
"Referer": self.url,
}
cookies = {
"csrftoken": CSRFToken,
}
post_data = "room_slug={0}&bandwidth=high".format(username)
res = http.post(API_HLS, headers=headers, cookies=cookies, data=post_data)
data = http.json(res, schema=_post_schema)
if data["success"] is True and data["room_status"] == "public":
for s in HLSStream.parse_variant_playlist(self.session, data["url"]).items():
yield s
def _get_stream_info(self, broadcast, quality, cdn, rmd):
params = {
"return_type": cdn,
"broad_key": "{broadcast}-flash-{quality}-hls".format(**locals())
}
res = http.get(STREAM_INFO_URLS.format(rmd=rmd), params=params)
return http.json(res, schema=_stream_schema)
def _get_streams(self):
# get the page
res = http.get(self.url, headers={"User-Agent": self._user_agent})
# find the big blob of stream info in the page
stream_data = self._stream_data_re.match(res.text)
stream_name = AdultSwim._url_re.match(
self.url).group(1) or "live-stream"
if stream_data:
# parse the stream info as json
stream_info = parse_json(stream_data.group(1),
schema=self._page_data_schema)
# get the stream ID
stream_id = stream_info[u"streams"][stream_name][u"stream"]
if stream_id:
api_url = self.API_URL.format(id=stream_id)
res = http.get(api_url,
headers={"User-Agent": self._user_agent})
stream_data = http.json(res, schema=self._api_schema)
for asset in stream_data[u'data'][u'stream'][u'assets']:
for n, s in HLSStream.parse_variant_playlist(
self.session, asset[u"url"]).items():
yield n, s
else:
self.logger.error(
"Couldn't find the stream ID for this stream: {}".format(
stream_name))
else:
self.logger.error(
"Couldn't find the stream data for this stream: {}".format(
stream_name))
def _get_streams(self):
channel = self.url_re.match(self.url).group(1)
res = http.get(self.api_url.format(channel))
data = http.json(res, schema=self.api_schema)
return HLSStream.parse_variant_playlist(self.session, data["channel_stream_url"])
def _get_streams(self):
"""
Finds the streams from tvcatchup.com.
"""
token = self.login(self.get_option("username"), self.get_option("password"))
m = self._url_re.match(self.url)
scode = m and m.group("scode") or self.get_option("station_code")
res = http.get(self._guide_url)
channels = {}
for t in itertags(res.text, "a"):
if t.attributes.get('cs'):
channels[t.attributes.get('cs').lower()] = t.attributes.get('title').replace("Watch ", "")
if not scode:
self.logger.error("Station code not provided, use --ustvnow-station-code.")
self.logger.error("Available stations are: {0}", ", ".join(channels.keys()))
return
if scode in channels:
self.logger.debug("Finding streams for: {0}", channels.get(scode))
r = http.get(self._stream_url, params={"scode": scode,
"token": token,
"br_n": "Firefox",
"br_v": "52",
"br_d": "desktop"},
headers={"User-Agent": useragents.FIREFOX})
data = http.json(r)
return HLSStream.parse_variant_playlist(self.session, data["stream"])
else:
self.logger.error("Invalid station-code: {0}", scode)
def _get_streams(self):
match = _url_re.match(self.url)
channel = match.group("channel")
roomID = http.get(self.url, schema=_roomID_schema)
res = http.get(API_URL.format(roomID=roomID))
room = http.json(res, schema=_room_schema)
if not room:
self.logger.info("Not a valid room url.")
return
if room["status"] != STATUS_ONLINE:
self.logger.info("Stream current unavailable.")
return
hls_url = "http://dlhls.cdn.zhanqi.tv/zqlive/{room[videoId]}_1024/index.m3u8?Dnion_vsnae={room[videoId]}".format(
room=room)
hls_stream = HLSStream(self.session, hls_url)
if hls_stream:
yield "hls", hls_stream
http_url = "http://wshdl.load.cdn.zhanqi.tv/zqlive/{room[videoId]}.flv?get_url=".format(
room=room)
http_stream = HTTPStream(self.session, http_url)
if http_stream:
yield "http", http_stream
def check_geolocation(cls, geoloc_flag):
if geoloc_flag == 'open':
return True
res = http.get(cls.GEO_URL)
data = http.json(res, schema=cls._geo_schema)
return data['country'] == geoloc_flag or data['zone'] == geoloc_flag
def _get_live_streams(self, slug):
res = http.get(LIVE_CHANNELS_API_URL)
res = http.json(res, schema=_channels_schema)
for channel in filter(lambda c: c["Slug"] == slug, res):
servers = channel["StreamingServers"]
return self._parse_streaming_servers(servers)
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 _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_streams(self):
asset_id = self._get_prid(self.get_option("subtitles"))
if asset_id:
self.logger.debug("Found asset id: {0}", asset_id)
streams = self.api_call(asset_id,
params=dict(adaptive="yes",
token=self.token),
schema=self.streams_schema)
for stream in streams:
if stream["format"] in ("adaptive", "hls", "mp4"):
if stream["contentType"] == "url":
stream_url = stream["url"]
else:
# using type=json removes the javascript function wrapper
info_url = stream["url"].replace("type=jsonp", "type=json")
# find the actual stream URL
stream_url = http.json(http.get(info_url),
schema=self.stream_info_schema)
if stream["format"] in ("adaptive", "hls"):
for s in HLSStream.parse_variant_playlist(self.session, stream_url).items():
yield s
elif stream["format"] in ("mp3", "mp4"):
yield "vod", HTTPStream(self.session, stream_url)
def _get_streams(self):
match = _url_re.match(self.url)
res = http.get(STREAM_INFO_URL,
params=match.groupdict(),
acceptable_status=STATUS_UNAVAILABLE)
if res.status_code in STATUS_UNAVAILABLE:
return
data = http.json(res, schema=_stream_schema)
if data.get("hls_url"):
hls_url = data["hls_url"]
hls_name = "live"
elif data.get("replay_url"):
self.logger.info("Live Stream ended, using replay instead")
hls_url = data["replay_url"]
hls_name = "replay"
else:
raise NoStreamsError(self.url)
streams = HLSStream.parse_variant_playlist(self.session, hls_url)
if not streams:
return {hls_name: HLSStream(self.session, hls_url)}
else:
return streams
def _get_live_streams(self, slug):
res = http.get(LIVE_CHANNELS_API_URL)
res = http.json(res, schema=_channels_schema)
for channel in filter(lambda c: c["Slug"] == slug, res):
servers = channel["StreamingServers"]
return self._parse_streaming_servers(servers)
def _get_streams(self):
asset_id = self._get_prid(self.get_option("subtitles"))
if asset_id:
self.logger.debug("Found asset id: {0}", asset_id)
streams = self.api_call(asset_id,
params=dict(adaptive="yes",
token=self.token),
schema=self.streams_schema)
for stream in streams:
if stream["format"] in ("adaptive", "hls", "mp4"):
if stream["contentType"] == "url":
stream_url = stream["url"]
else:
# using type=json removes the javascript function wrapper
info_url = stream["url"].replace("type=jsonp", "type=json")
# find the actual stream URL
stream_url = http.json(http.get(info_url),
schema=self.stream_info_schema)
if stream["format"] in ("adaptive", "hls"):
for s in HLSStream.parse_variant_playlist(self.session, stream_url).items():
yield s
elif stream["format"] in ("mp3", "mp4"):
yield "vod", HTTPStream(self.session, stream_url)
def _get_vod_stream(self):
vod_url = self.url
if vod_url.endswith('/'):
vod_url = vod_url[:-1]
json_url = '{0}.securevideo.json'.format(vod_url)
res = http.get(json_url)
match = _json_re.search(res.text)
if not match:
return
data = parse_json(match.group(1))
res = http.get(API_VOD.format(data['clientid'], data['mzid']))
data = http.json(res, schema=_stream_schema)
for d in data['targetUrls']:
if d['type'] == 'HDS':
hds_url = d['url']
for s in HDSStream.parse_manifest(self.session, hds_url).items():
yield s
if d['type'] == 'HLS':
hls_url = d['url']
for s in HLSStream.parse_variant_playlist(self.session, hls_url).items():
yield s
def _get_streams(self):
if self.is_live:
self.logger.debug("Loading live stream for {0}...", self.channel)
res = http.get(self.live_api_url, data={"r": random.randint(1, 100000)})
live_data = http.json(res)
# all the streams are equal for each type, so pick a random one
hls_streams = live_data.get("hls")
if hls_streams:
url = random.choice(hls_streams)
url = url + '&' + urlencode(self.hls_session()) # TODO: use update_qsd
for s in HLSStream.parse_variant_playlist(self.session, url, name_fmt="{pixels}_{bitrate}").items():
yield s
mpd_streams = live_data.get("mpd")
if mpd_streams:
url = random.choice(mpd_streams)
for s in DASHStream.parse_manifest(self.session, url).items():
yield s
elif self.channel == "1tv":
self.logger.debug("Attempting to find VOD stream...", self.channel)
vod_data = self.vod_data()
if vod_data:
self.logger.info(u"Found VOD: {0}".format(vod_data[0]['title']))
for stream in vod_data[0]['mbr']:
yield stream['name'], HTTPStream(self.session, update_scheme(self.url, stream['src']))
def _get_stream_info(self, broadcast, quality, cdn, rmd):
params = {
"return_type": cdn,
"broad_key": "{broadcast}-flash-{quality}-hls".format(**locals())
}
res = http.get(STREAM_INFO_URLS.format(rmd=rmd), params=params)
return http.json(res, schema=_stream_schema)
def _get_vod_streams(self, params):
manifest_url = params.get("autoURL")
if not manifest_url:
return
res = http.get(manifest_url)
if res.headers.get("Content-Type") == "application/f4m+xml":
streams = HDSStream.parse_manifest(self.session, res.url)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in streams.items():
yield __
elif res.headers.get("Content-Type") == "application/vnd.apple.mpegurl":
streams = HLSStream.parse_variant_playlist(self.session, res.url)
# TODO: Replace with "yield from" when dropping Python 2.
for __ in streams.items():
yield __
else:
manifest = http.json(res, schema=_vod_manifest_schema)
for params in manifest["alternates"]:
name = "{0}p".format(params["height"])
stream = self._create_flv_playlist(params["template"])
yield name, stream
failovers = params.get("failover", [])
for failover in failovers:
stream = self._create_flv_playlist(failover)
yield name, stream
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_channel_id(self, domain):
channel_info = http.get(CHANNEL_INFO_URL % str(domain))
info = http.json(channel_info, schema=_channel_schema)
if info is None:
return 0, 0
return info['channel']['vid'], info['channel']['id']
def _get_streams(self):
self.url = http.resolve_url(self.url)
match = _url_re.match(self.url)
parsed = urlparse(self.url)
if parsed.fragment:
channel_id = parsed.fragment
elif parsed.path[:3] == '/v/':
channel_id = parsed.path.split('/')[-1]
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_vod_stream(self, vod_id):
res = self._get_api_res("recordings", vod_id)
for sdata in http.json(res, schema=self._vod_schema):
if sdata["format"] == "hls":
hls_url = urljoin(sdata["url"], "manifest.m3u8")
yield "{0}p".format(sdata["height"]), HLSStream(self.session, hls_url)
def _post_api(self, api, payload, schema):
res = http.post(api, json=payload)
data = http.json(res, schema=schema)
if data["result"] == "success":
post_data = data["reply"]
return post_data
def _watch_live(self, channel, cookies):
self.logger.debug('_watch_live ... Channel: {0}'.format(channel))
watch_url = self.API_WATCH.format(self.base_url)
channels_url = self.API_CHANNELS.format(
self.base_url, self._session_attributes.get('power_guide_hash'))
res = http.get(channels_url, headers=self.headers, cookies=cookies)
data = http.json(res, schema=self._channels_schema)
c_list = []
for d in data:
for c in d['channels']:
c_list.append(c)
cid = []
zattoo_list = []
for c in c_list:
zattoo_list.append(c['display_alias'])
if c['display_alias'] == channel:
cid = c['cid']
self.logger.debug(
'Available zattoo channels in this country: {0}'.format(', '.join(
sorted(zattoo_list))))
if not cid:
cid = channel
self.logger.debug('CHANNEL ID: {0}'.format(cid))
params = {'cid': cid, 'https_watch_urls': True, 'stream_type': 'hls'}
return params, watch_url
def _watch_live(self, channel, cookies):
self.logger.debug('_watch_live ... Channel: {0}'.format(channel))
watch_url = self.API_WATCH.format(self.base_url)
channels_url = self.API_CHANNELS.format(self.base_url, self._session_attributes.get('power_guide_hash'))
res = http.get(channels_url, headers=self.headers, cookies=cookies)
data = http.json(res, schema=self._channels_schema)
c_list = []
for d in data:
for c in d['channels']:
c_list.append(c)
cid = []
zattoo_list = []
for c in c_list:
zattoo_list.append(c['display_alias'])
if c['display_alias'] == channel:
cid = c['cid']
self.logger.debug('Available zattoo channels in this country: {0}'.format(', '.join(sorted(zattoo_list))))
if not cid:
cid = channel
self.logger.debug('CHANNEL ID: {0}'.format(cid))
params = {
'cid': cid,
'https_watch_urls': True,
'stream_type': 'hls'
}
return params, watch_url
def _get_streams(self):
# Get video ID and channel from URL
match = self._url_re.match(self.url)
video_id = match.group('video_id')
if video_id is None:
# Retrieve URL page and search for video ID
res = http.get(self.url)
match = self._video_id_re.search(res.text)
if match is None:
return
video_id = match.group('video_id')
res = http.get(self.API_URL.format(video_id))
videos = http.json(res, schema=self._api_schema)
parsed = []
headers = {'User-Agent': self._user_agent}
# Some videos may be also available on Dailymotion (especially on CNews)
if videos['ID_DM'] != '':
for stream in self.session.streams('https://www.dailymotion.com/video/' + videos['ID_DM']).items():
yield stream
for quality, video_url in list(videos['MEDIA']['VIDEOS'].items()):
# Ignore empty URLs
if video_url == '':
continue
# Ignore duplicate video URLs
if video_url in parsed:
continue
parsed.append(video_url)
try:
# HDS streams don't seem to work for live videos
if '.f4m' in video_url and 'LIVE' not in videos['TYPE']:
for stream in HDSStream.parse_manifest(self.session,
video_url,
params={'hdcore': self.HDCORE_VERSION},
headers=headers).items():
yield stream
elif '.m3u8' in video_url:
for stream in HLSStream.parse_variant_playlist(self.session,
video_url,
headers=headers).items():
yield stream
elif '.mp4' in video_url:
# Get bitrate from video filename
match = self._mp4_bitrate_re.match(video_url)
if match is not None:
bitrate = match.group('bitrate')
else:
bitrate = quality
yield bitrate, HTTPStream(self.session,
video_url,
params={'secret': self.SECRET},
headers=headers)
except IOError as err:
if '403 Client Error' in str(err):
self.logger.error('Failed to access stream, may be due to geo-restriction')
def _get_quality_map(self, content_id):
res = http.get(self.video_api.format(id=content_id))
data = http.json(res, schema=self.video_schema)
qmap = {}
for item in data["qualities"]:
qname = {"MED": "Media", "HIGH": "Alta", "ORIGINAL": "Original"}.get(item["preset"], item["preset"])
qmap[qname] = u"{0}p".format(item["height"])
return qmap
def _get_streams(self):
# fetch requested url and find playlist info
response = http.get(self.url)
info = _find_playlist_info(response)
if not info:
# playlist info not found, let's try to find player url
player_url = _find_player_url(response)
if not player_url:
raise PluginError('Cannot find playlist info or player url!')
# get player url and try to find playlist info in it
response = http.get(player_url)
info = _find_playlist_info(response)
if not info:
raise PluginError('Cannot find playlist info in the player url!')
data = {
'playlist[0][type]': info['type'],
'playlist[0][id]': info['id'],
'requestUrl': '/ivysilani/embed/iFramePlayerCT24.php',
'requestSource': 'iVysilani',
'type': 'html'
}
headers = {
'x-addr': '127.0.0.1',
}
# fetch playlist url
response = http.post(
'http://www.ceskatelevize.cz/ivysilani/ajax/get-client-playlist',
data=data,
headers=headers
)
json_data = http.json(response, schema=_playlist_url_schema)
if json_data['url'] == "error_region":
self.logger.error("This stream is not available in your territory")
return
# fetch playlist
response = http.post(json_data['url'])
json_data = http.json(response, schema=_playlist_schema)
playlist = json_data['playlist'][0]['streamUrls']['main']
return HLSStream.parse_variant_playlist(self.session, playlist)
def _get_stream_info(self, url):
res = http.get(url, headers=HEADERS)
match = re.search(r"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_channel_info(self, username):
data = {
"bid": username,
"mode": "landing",
"player_type": "html5"
}
res = http.post(CHANNEL_API_URL, data=data)
return http.json(res, schema=_channel_schema)
