def update_json_video_item(self, item):
""" Updates an existing MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
headers = {}
if self.localIP:
headers.update(self.localIP)
data = UriHandler.open(item.url,
proxy=self.proxy,
additional_headers=headers)
video_data = JsonHelper(data)
stream_data = video_data.get_value("mediaAssetsOnDemand")
if not stream_data:
return item
use_adaptive = AddonSettings.use_adaptive_stream_add_on()
stream_data = stream_data[0]
part = item.create_new_empty_media_part()
if "hlsUrl" in stream_data:
hls_url = stream_data["hlsUrl"]
if use_adaptive:
stream = part.append_media_stream(hls_url, 0)
M3u8.set_input_stream_addon_input(stream,
self.proxy,
headers=headers)
item.complete = True
else:
for s, b in M3u8.get_streams_from_m3u8(hls_url,
self.proxy,
headers=headers):
item.complete = True
part.append_media_stream(s, b)
if "timedTextSubtitlesUrl" in stream_data and stream_data[
"timedTextSubtitlesUrl"]:
sub_url = stream_data["timedTextSubtitlesUrl"].replace(
".ttml", ".vtt")
sub_url = HtmlEntityHelper.url_decode(sub_url)
part.Subtitle = SubtitleHelper.download_subtitle(sub_url,
format="webvtt")
return item
def update_live_item(self, item):
""" Updates an existing live MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
part = item.create_new_empty_media_part()
if AddonSettings.use_adaptive_stream_add_on():
stream = part.append_media_stream(item.url, 0)
M3u8.set_input_stream_addon_input(stream, self.proxy)
item.complete = True
else:
for s, b in M3u8.get_streams_from_m3u8(item.url, self.proxy):
item.complete = True
part.append_media_stream(s, b)
return item
def __update_m3u8(self, url, part, headers, use_kodi_hls):
""" Update a video that has M3u8 streams.
:param str url: The URL for the stream.
:param MediaItemPart part: The new part that needs updating.
:param dict[str,str] headers: The URL headers to use.
:param bool use_kodi_hls: Should we use the InputStream Adaptive add-on?
"""
# first see if there are streams in this file, else check the second location.
for s, b in M3u8.get_streams_from_m3u8(url,
self.proxy,
headers=headers):
if use_kodi_hls:
strm = part.append_media_stream(url, 0)
M3u8.set_input_stream_addon_input(strm, headers=headers)
# Only the main M3u8 is needed
break
else:
part.append_media_stream(s, b)
if not part.MediaStreams and "manifest.m3u8" in url:
Logger.warning(
"No streams found in %s, trying alternative with 'master.m3u8'",
url)
url = url.replace("manifest.m3u8", "master.m3u8")
for s, b in M3u8.get_streams_from_m3u8(url,
self.proxy,
headers=headers):
if use_kodi_hls:
strm = part.append_media_stream(url, 0)
M3u8.set_input_stream_addon_input(strm, headers=headers)
# Only the main M3u8 is needed
break
else:
part.append_media_stream(s, b)
# check for subs
# https://mtgxse01-vh.akamaihd.net/i/201703/13/DCjOLN_1489416462884_427ff3d3_,48,260,460,900,1800,2800,.mp4.csmil/master.m3u8?__b__=300&hdnts=st=1489687185~exp=3637170832~acl=/*~hmac=d0e12e62c219d96798e5b5ef31b11fa848724516b255897efe9808c8a499308b&cc1=name=Svenska%20f%C3%B6r%20h%C3%B6rselskadade~default=no~forced=no~lang=sv~uri=https%3A%2F%2Fsubstitch.play.mtgx.tv%2Fsubtitle%2Fconvert%2Fxml%3Fsource%3Dhttps%3A%2F%2Fcdn-subtitles-mtgx-tv.akamaized.net%2Fpitcher%2F20xxxxxx%2F2039xxxx%2F203969xx%2F20396967%2F20396967-swt.xml%26output%3Dm3u8
# https://cdn-subtitles-mtgx-tv.akamaized.net/pitcher/20xxxxxx/2039xxxx/203969xx/20396967/20396967-swt.xml&output=m3u8
if "uri=" in url and not part.Subtitle:
Logger.debug("Extracting subs from M3u8")
sub_url = url.rsplit("uri=")[-1]
sub_url = HtmlEntityHelper.url_decode(sub_url)
sub_data = UriHandler.open(sub_url, proxy=self.proxy)
subs = [
line for line in sub_data.split("\n")
if line.startswith("http")
]
if subs:
part.Subtitle = SubtitleHelper.download_subtitle(
subs[0], format='webvtt', proxy=self.proxy)
return
def update_video_item(self, item):
""" Updates an existing MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
headers = {}
if self.localIP:
headers.update(self.localIP)
data = UriHandler.open(item.url,
proxy=self.proxy,
additional_headers=headers)
m3u8_url = Regexer.do_regex('data-file="([^"]+)"', data)[0]
part = item.create_new_empty_media_part()
if AddonSettings.use_adaptive_stream_add_on(with_encryption=False):
stream = part.append_media_stream(m3u8_url, 0)
M3u8.set_input_stream_addon_input(stream,
proxy=self.proxy,
headers=headers)
item.complete = True
else:
for s, b, a in M3u8.get_streams_from_m3u8(m3u8_url,
self.proxy,
headers=headers,
map_audio=True):
if a and "-audio" not in s:
video_part = s.rsplit("-", 1)[-1]
video_part = "-%s" % (video_part, )
s = a.replace(".m3u8", video_part)
part.append_media_stream(s, b)
item.complete = True
return item
def update_live_video(self, item):
""" Updates an existing live stream MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
if "m3u8" not in item.url:
Logger.error("Cannot update live stream that is not an M3u8: %s",
item.url)
part = item.create_new_empty_media_part()
adaptive_available = AddonSettings.use_adaptive_stream_add_on(
with_encryption=False)
if adaptive_available:
stream = part.append_media_stream(item.url, 0)
M3u8.set_input_stream_addon_input(stream, self.proxy)
return item
for s, b in M3u8.get_streams_from_m3u8(item.url, self.proxy):
item.complete = True
# apparently they split up M3u8 streams and audio streams, so we need to fix that here
# this is an ugly fix, but it will work!
if "-audio_" not in s:
s = s.replace(".m3u8", "-audio_track=96000.m3u8")
part.append_media_stream(s, b)
return item
def __update_live_video(self, item, manifest, headers):
video_info = manifest.get_value("playable", "assets", 0)
url = video_info["url"]
encrypted = video_info["encrypted"]
part = item.create_new_empty_media_part()
if encrypted:
use_adaptive = AddonSettings.use_adaptive_stream_add_on(
with_encryption=True)
if not use_adaptive:
Logger.error(
"Cannot playback encrypted item without inputstream.adaptive with encryption support"
)
return item
stream = part.append_media_stream(url, 0)
key = M3u8.get_license_key("", key_headers=headers, key_type="R")
M3u8.set_input_stream_addon_input(stream,
proxy=self.proxy,
headers=headers,
license_key=key)
item.complete = True
else:
use_adaptive = AddonSettings.use_adaptive_stream_add_on(
with_encryption=False)
if use_adaptive:
stream = part.append_media_stream(url, 0)
M3u8.set_input_stream_addon_input(stream,
self.proxy,
headers=headers)
item.complete = True
else:
for s, b in M3u8.get_streams_from_m3u8(url,
self.proxy,
headers=headers):
item.complete = True
part.append_media_stream(s, b)
return item
def update_video_item(self, item): # NOSONAR
""" Updates an existing MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
Logger.debug('Starting update_video_item for %s (%s)', item.name,
self.channelName)
# we need to fetch the actual url as it might differ for single video items
data, secure_url = UriHandler.header(item.url, proxy=self.proxy)
# Get the MZID
secure_url = secure_url.rstrip("/")
secure_url = "%s.mssecurevideo.json" % (secure_url, )
data = UriHandler.open(secure_url,
proxy=self.proxy,
additional_headers=item.HttpHeaders)
secure_data = JsonHelper(data, logger=Logger.instance())
mzid = secure_data.get_value(
list(secure_data.json.keys())[0], "videoid")
# region New URL retrieval with DRM protection
# We need a player token
token_data = UriHandler.open(
"https://media-services-public.vrt.be/"
"vualto-video-aggregator-web/rest/external/v1/tokens",
data="",
additional_headers={"Content-Type": "application/json"})
token = JsonHelper(token_data).get_value("vrtPlayerToken")
asset_url = "https://media-services-public.vrt.be/vualto-video-aggregator-web/rest/" \
"external/v1/videos/{0}?vrtPlayerToken={1}&client=vrtvideo"\
.format(HtmlEntityHelper.url_encode(mzid), HtmlEntityHelper.url_encode(token))
asset_data = UriHandler.open(asset_url,
proxy=self.proxy,
no_cache=True)
asset_data = JsonHelper(asset_data)
drm_key = asset_data.get_value("drm")
drm_protected = drm_key is not None
adaptive_available = AddonSettings.use_adaptive_stream_add_on(
with_encryption=drm_protected)
part = item.create_new_empty_media_part()
srt = None
# see if we prefer hls over dash
hls_prio = 2 if self._get_setting("hls_over_dash", False) else 0
for target_url in asset_data.get_value("targetUrls"):
video_type = target_url["type"]
video_url = target_url["url"]
if video_type == "hls_aes" and drm_protected and adaptive_available:
# no difference in encrypted or not.
Logger.debug("Found HLS AES encrypted stream and a DRM key")
stream = part.append_media_stream(video_url, 0)
M3u8.set_input_stream_addon_input(stream, self.proxy)
elif video_type == "hls" and not drm_protected:
# no difference in encrypted or not.
if adaptive_available:
Logger.debug(
"Found standard HLS stream and without DRM protection")
stream = part.append_media_stream(video_url, hls_prio)
M3u8.set_input_stream_addon_input(stream, self.proxy)
else:
m3u8_data = UriHandler.open(video_url, self.proxy)
for s, b, a in M3u8.get_streams_from_m3u8(
video_url,
self.proxy,
play_list_data=m3u8_data,
map_audio=True):
item.complete = True
if a:
audio_part = a.rsplit("-", 1)[-1]
audio_part = "-%s" % (audio_part, )
s = s.replace(".m3u8", audio_part)
part.append_media_stream(s, b)
srt = M3u8.get_subtitle(video_url,
play_list_data=m3u8_data,
proxy=self.proxy)
if not srt:
continue
srt = srt.replace(".m3u8", ".vtt")
part.Subtitle = SubtitleHelper.download_subtitle(
srt, format="webvtt")
elif video_type == "mpeg_dash" and adaptive_available:
if not drm_protected:
Logger.debug(
"Found standard MPD stream and without DRM protection")
stream = part.append_media_stream(video_url, 1)
Mpd.set_input_stream_addon_input(stream, self.proxy)
else:
stream = part.append_media_stream(video_url, 1)
encryption_json = '{{"token":"{0}","drm_info":[D{{SSM}}],"kid":"{{KID}}"}}'\
.format(drm_key)
encryption_key = Mpd.get_license_key(
key_url="https://widevine-proxy.drm.technology/proxy",
key_type="D",
key_value=encryption_json,
key_headers={
"Content-Type": "text/plain;charset=UTF-8"
})
Mpd.set_input_stream_addon_input(
stream, self.proxy, license_key=encryption_key)
if video_type.startswith("hls") and srt is None:
srt = M3u8.get_subtitle(video_url, proxy=self.proxy)
if srt:
srt = srt.replace(".m3u8", ".vtt")
part.Subtitle = SubtitleHelper.download_subtitle(
srt, format="webvtt")
item.complete = True
# endregion
return item
def update_video_item(self, item):
""" Updates an existing MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
video_data = UriHandler.open(item.url,
proxy=self.proxy,
additional_headers=self.localIP)
if not video_data:
return item
video_data = JsonHelper(video_data)
video_info = video_data.get_value("data", "attributes")
part = item.create_new_empty_media_part()
m3u8url = video_info["streaming"]["hls"]["url"]
m3u8data = UriHandler.open(m3u8url, self.proxy)
if AddonSettings.use_adaptive_stream_add_on():
stream = part.append_media_stream(m3u8url, 0)
item.complete = True
M3u8.set_input_stream_addon_input(stream, self.proxy)
else:
# user agent for all sub m3u8 and ts requests needs to be the same
part.HttpHeaders[
"user-agent"] = "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-GB; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13 (.NET CLR 3.5.30729)"
for s, b, a in M3u8.get_streams_from_m3u8(
m3u8url,
self.proxy,
append_query_string=False,
map_audio=True,
play_list_data=m3u8data):
item.complete = True
if a:
audio_part = a.split("-prog_index.m3u8", 1)[0]
audio_id = audio_part.rsplit("/", 1)[-1]
s = s.replace("-prog_index.m3u8",
"-{0}-prog_index.m3u8".format(audio_id))
part.append_media_stream(s, b)
if self.language == "se":
vtt_url = M3u8.get_subtitle(m3u8url,
self.proxy,
m3u8data,
language="sv")
elif self.language == "dk":
vtt_url = M3u8.get_subtitle(m3u8url,
self.proxy,
m3u8data,
language="da")
else:
vtt_url = M3u8.get_subtitle(m3u8url, self.proxy, m3u8data)
# https://dplaynordics-vod-80.akamaized.net/dplaydni/259/0/hls/243241001/1112635959-prog_index.m3u8?version_hash=bb753129&hdnts=st=1518218118~exp=1518304518~acl=/*~hmac=bdeefe0ec880f8614e14af4d4a5ca4d3260bf2eaa8559e1eb8ba788645f2087a
vtt_url = vtt_url.replace("-prog_index.m3u8", "-0.vtt")
part.Subtitle = SubtitleHelper.download_subtitle(vtt_url,
format='srt',
proxy=self.proxy)
return item
def update_video_item(self, item):
""" Updates an existing MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
Logger.debug('Starting update_video_item for %s (%s)', item.name,
self.channelName)
# noinspection PyStatementEffect
"""
C:\temp\rtmpdump-2.3>rtmpdump.exe -z -o test.flv -n "cp70051.edgefcs.net" -a "tv
4ondemand" -y "mp4:/mp4root/2010-06-02/pid2780626_1019976_T3MP48_.mp4?token=c3Rh
cnRfdGltZT0yMDEwMDcyNjE2NDYyNiZlbmRfdGltZT0yMDEwMDcyNjE2NDgyNiZkaWdlc3Q9ZjFjN2U1
NTRiY2U5ODMxMDMwYWQxZWEwNzNhZmUxNjI=" -l 2
C:\temp\rtmpdump-2.3>rtmpdump.exe -z -o test.flv -r rtmpe://cp70051.edgefcs.net/
tv4ondemand/mp4root/2010-06-02/pid2780626_1019976_T3MP48_.mp4?token=c3RhcnRfdGlt
ZT0yMDEwMDcyNjE2NDYyNiZlbmRfdGltZT0yMDEwMDcyNjE2NDgyNiZkaWdlc3Q9ZjFjN2U1NTRiY2U5
ODMxMDMwYWQxZWEwNzNhZmUxNjI=
"""
# retrieve the mediaurl
data = UriHandler.open(item.url,
proxy=self.proxy,
additional_headers=self.localIP)
stream_info = JsonHelper(data)
m3u8_url = stream_info.get_value("playbackItem", "manifestUrl")
if m3u8_url is None:
return item
part = item.create_new_empty_media_part()
if AddonSettings.use_adaptive_stream_add_on() and False:
subtitle = M3u8.get_subtitle(m3u8_url, proxy=self.proxy)
stream = part.append_media_stream(m3u8_url, 0)
M3u8.set_input_stream_addon_input(stream, self.proxy)
item.complete = True
else:
m3u8_data = UriHandler.open(m3u8_url,
proxy=self.proxy,
additional_headers=self.localIP)
subtitle = M3u8.get_subtitle(m3u8_url,
proxy=self.proxy,
play_list_data=m3u8_data)
for s, b, a in M3u8.get_streams_from_m3u8(m3u8_url,
self.proxy,
play_list_data=m3u8_data,
map_audio=True):
item.complete = True
if not item.isLive and "-video" not in s:
continue
if a and "-audio" not in s:
# remove any query parameters
video_part = s.rsplit("?", 1)[0]
video_part = video_part.rsplit("-", 1)[-1]
video_part = "-%s" % (video_part, )
s = a.replace(".m3u8", video_part)
part.append_media_stream(s, b)
if subtitle:
subtitle = subtitle.replace(".m3u8", ".webvtt")
part.Subtitle = SubtitleHelper.download_subtitle(subtitle,
format="m3u8srt",
proxy=self.proxy)
return item
def update_video_for_mzid(self, item, mzid, live=False): # NOSONAR
""" Updates a video item based on the MZID
:param MediaItem item: the parent item
:param str mzid: the MZID
"""
# region New URL retrieval with DRM protection
# We need a player token
token_data = UriHandler.open(
"https://media-services-public.vrt.be/"
"vualto-video-aggregator-web/rest/external/v1/tokens",
data="",
additional_headers={"Content-Type": "application/json"})
token = JsonHelper(token_data).get_value("vrtPlayerToken")
asset_url = "https://media-services-public.vrt.be/vualto-video-aggregator-web/rest/" \
"external/v1/videos/{0}?vrtPlayerToken={1}&client=vrtvideo"\
.format(HtmlEntityHelper.url_encode(mzid), HtmlEntityHelper.url_encode(token))
asset_data = UriHandler.open(asset_url,
proxy=self.proxy,
no_cache=True)
asset_data = JsonHelper(asset_data)
drm_key = asset_data.get_value("drm")
drm_protected = drm_key is not None
adaptive_available = AddonSettings.use_adaptive_stream_add_on(
with_encryption=drm_protected, channel=self)
part = item.create_new_empty_media_part()
srt = None
# see if we prefer hls over dash
hls_prio = 2 if self._get_setting("hls_over_dash",
'false') == 'true' else 0
for target_url in asset_data.get_value("targetUrls"):
video_type = target_url["type"]
video_url = target_url["url"]
if video_type == "hls_aes" and drm_protected and adaptive_available:
# no difference in encrypted or not.
Logger.debug("Found HLS AES encrypted stream and a DRM key")
stream = part.append_media_stream(video_url, hls_prio)
M3u8.set_input_stream_addon_input(stream, self.proxy)
elif video_type == "hls" and not drm_protected:
# no difference in encrypted or not.
if adaptive_available:
Logger.debug(
"Found standard HLS stream and without DRM protection")
stream = part.append_media_stream(video_url, hls_prio)
M3u8.set_input_stream_addon_input(stream, self.proxy)
else:
m3u8_data = UriHandler.open(video_url, self.proxy)
for s, b, a in M3u8.get_streams_from_m3u8(
video_url,
self.proxy,
play_list_data=m3u8_data,
map_audio=True):
item.complete = True
if a:
audio_part = a.rsplit("-", 1)[-1]
audio_part = "-%s" % (audio_part, )
s = s.replace(".m3u8", audio_part)
part.append_media_stream(s, b)
srt = M3u8.get_subtitle(video_url,
play_list_data=m3u8_data,
proxy=self.proxy)
if not srt or live:
# If there is not SRT don't download it. If it a live stream with subs,
# don't use it as it is not supported by Kodi
continue
srt = srt.replace(".m3u8", ".vtt")
part.Subtitle = SubtitleHelper.download_subtitle(
srt, format="webvtt")
elif video_type == "mpeg_dash" and adaptive_available:
if not drm_protected:
Logger.debug(
"Found standard MPD stream and without DRM protection")
stream = part.append_media_stream(video_url, 1)
Mpd.set_input_stream_addon_input(stream, self.proxy)
else:
stream = part.append_media_stream(video_url, 1)
encryption_json = '{{"token":"{0}","drm_info":[D{{SSM}}],"kid":"{{KID}}"}}'\
.format(drm_key)
encryption_key = Mpd.get_license_key(
key_url="https://widevine-proxy.drm.technology/proxy",
key_type="D",
key_value=encryption_json,
key_headers={
"Content-Type": "text/plain;charset=UTF-8"
})
Mpd.set_input_stream_addon_input(
stream, self.proxy, license_key=encryption_key)
if video_type.startswith("hls") and srt is None:
srt = M3u8.get_subtitle(video_url, proxy=self.proxy)
if not srt or live:
# If there is not SRT don't download it. If it a live stream with subs,
# don't use it as it is not supported by Kodi
continue
srt = srt.replace(".m3u8", ".vtt")
part.Subtitle = SubtitleHelper.download_subtitle(
srt, format="webvtt")
item.complete = True
# endregion
return item
def update_json_video_item(self, item):
""" Updates an existing MediaItem with more data.
Used to update none complete MediaItems (self.complete = False). This
could include opening the item's URL to fetch more data and then process that
data or retrieve it's real media-URL.
The method should at least:
* cache the thumbnail to disk (use self.noImage if no thumb is available).
* set at least one MediaItemPart with a single MediaStream.
* set self.complete = True.
if the returned item does not have a MediaItemPart then the self.complete flag
will automatically be set back to False.
:param MediaItem item: the original MediaItem that needs updating.
:return: The original item with more data added to it's properties.
:rtype: MediaItem
"""
headers = {"accept": "application/vnd.sbs.ovp+json; version=2.0"}
data = UriHandler.open(item.url,
proxy=self.proxy,
additional_headers=headers)
if UriHandler.instance().status.code == 404:
Logger.warning("No normal stream found. Trying newer method")
new_url = item.url.replace("https://embed.kijk.nl/api/",
"https://embed.kijk.nl/")
item.url = new_url[:new_url.index("?")]
return self.__update_embedded_video(item)
json = JsonHelper(data)
embed_url = json.get_value("metadata", "embedURL")
if embed_url:
Logger.warning(
"Embed URL found. Using that to determine the streams.")
item.url = embed_url
try:
return self.__update_embedded_video(item)
except:
Logger.warning("Failed to update embedded item:",
exc_info=True)
use_adaptive_with_encryption = AddonSettings.use_adaptive_stream_add_on(
with_encryption=True, channel=self)
mpd_info = json.get_value("entitlements", "play")
# is there MPD information in the API response?
if mpd_info is not None:
return self.__update_video_from_mpd(item, mpd_info,
use_adaptive_with_encryption)
# Try the plain M3u8 streams
part = item.create_new_empty_media_part()
m3u8_url = json.get_value("playlist")
use_adaptive = AddonSettings.use_adaptive_stream_add_on(channel=self)
# with the Accept: application/vnd.sbs.ovp+json; version=2.0 header, the m3u8 streams that
# are brightcove based have an url paramter instead of an empty m3u8 file
Logger.debug("Trying standard M3u8 streams.")
if m3u8_url != "https://embed.kijk.nl/api/playlist/.m3u8" \
and "hostingervice=brightcove" not in m3u8_url:
for s, b in M3u8.get_streams_from_m3u8(m3u8_url,
self.proxy,
append_query_string=True):
if "_enc_" in s:
continue
if use_adaptive:
# we have at least 1 none encrypted streams
Logger.info("Using HLS InputStreamAddon")
strm = part.append_media_stream(m3u8_url, 0)
M3u8.set_input_stream_addon_input(strm, proxy=self.proxy)
item.complete = True
return item
part.append_media_stream(s, b)
item.complete = True
return item
Logger.warning("No M3u8 data found. Falling back to BrightCove")
video_id = json.get_value("vpakey")
# videoId = json.get_value("videoId") -> Not all items have a videoId
mpd_manifest_url = "https://embed.kijk.nl/video/%s?width=868&height=491" % (
video_id, )
referer = "https://embed.kijk.nl/video/%s" % (video_id, )
data = UriHandler.open(mpd_manifest_url,
proxy=self.proxy,
referer=referer)
# First try to find an M3u8
m3u8_urls = Regexer.do_regex('https:[^"]+.m3u8', data)
for m3u8_url in m3u8_urls:
m3u8_url = m3u8_url.replace("\\", "")
# We need the actual URI to make this work, so fetch it.
m3u8_url = UriHandler.header(m3u8_url, proxy=self.proxy)[-1]
Logger.debug("Found direct M3u8 in brightcove data.")
if use_adaptive:
# we have at least 1 none encrypted streams
Logger.info("Using HLS InputStreamAddon")
strm = part.append_media_stream(m3u8_url, 0)
M3u8.set_input_stream_addon_input(strm, proxy=self.proxy)
item.complete = True
return item
for s, b in M3u8.get_streams_from_m3u8(m3u8_url,
self.proxy,
append_query_string=True):
item.complete = True
part.append_media_stream(s, b)
return item
return self.__update_video_from_brightcove(
item, data, use_adaptive_with_encryption)
def add_others(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list method, BEFORE the items are
processed. Allows setting of parameters (like title etc) for the channel.
Inside this method the <data> could be changed and additional items can
be created.
The return values should always be instantiated in at least ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
others = MediaItem(
"\b.: Populair :.",
"https://api.kijk.nl/v2/default/sections/popular_PopularVODs?offset=0"
)
items.append(others)
days = MediaItem("\b.: Deze week :.", "#lastweek")
items.append(days)
search = MediaItem("\b.: Zoeken :.", "searchSite")
search.complete = True
search.icon = self.icon
search.thumb = self.noImage
search.dontGroup = True
search.HttpHeaders = {"X-Requested-With": "XMLHttpRequest"}
items.append(search)
if self.channelCode == "veronica":
live = LanguageHelper.get_localized_string(
LanguageHelper.LiveStreamTitleId)
live_radio = MediaItem("Radio Veronica {}".format(live), "")
live_radio.type = "video"
live_radio.icon = self.icon
live_radio.thumb = self.noImage
live_radio.dontGroup = True
part = live_radio.create_new_empty_media_part()
live_stream = "https://talparadiohls-i.akamaihd.net/hls/live/585615/VR-Veronica-1/playlist.m3u8"
if AddonSettings.use_adaptive_stream_add_on(with_encryption=False,
channel=self):
stream = part.append_media_stream(live_stream, 0)
M3u8.set_input_stream_addon_input(stream, self.proxy)
live_radio.complete = True
else:
for s, b in M3u8.get_streams_from_m3u8(live_stream,
self.proxy):
live_radio.complete = True
part.append_media_stream(s, b)
items.append(live_radio)
Logger.debug("Pre-Processing finished")
return data, items
