def create_trailer(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
Logger.trace(result_set)
url = self.parentItem.url
item = MediaItem(result_set["caption"], url, "video")
item.thumb = result_set["still"].replace("nocropthumb/[format]/", "")
item.fanart = item.thumb
item.append_single_stream(result_set['filename'])
item.complete = True
item.HttpHeaders = self.httpHeaders
return item
def create_live_item(self, result_set):
""" Creates a live MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param dict[str,str|dict[str,str]] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
url = result_set["stream"]["highQualityUrl"]
title = result_set["title"] or result_set["id"].title()
item = MediaItem(title, url)
item.type = "video"
item.isLive = True
if item.url.endswith(".mp3"):
item.append_single_stream(item.url)
item.complete = True
return item
return item
def create_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
#Logger.Trace(result_set)
thumb_url = "%s%s" % (self.baseUrl, result_set[6])
url = "%s%s" % (self.baseUrl, result_set[5])
name = "%s %s %s %s" % (result_set[1], result_set[2], result_set[3],
result_set[4])
video_url = result_set[0]
video_url = video_url.replace(" ", "%20")
# convert RTMP to HTTP
#rtmp://media.omroepgelderland.nl /uitzendingen/video/2012/07/120714 338 Carrie on.mp4
#http://content.omroep.nl/omroepgelderland/uitzendingen/video/2012/07/120714 338 Carrie on.mp4
video_url = video_url.replace(
"rtmp://media.omroepgelderland.nl",
"http://content.omroep.nl/omroepgelderland")
item = MediaItem(name, url)
item.thumb = thumb_url
item.icon = self.icon
item.type = 'video'
item.append_single_stream(video_url)
# set date
month = datehelper.DateHelper.get_month_from_name(
result_set[3], "nl", False)
day = result_set[2]
year = result_set[4]
item.set_date(year, month, day)
item.complete = True
return item
def add_missing_live_streams(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]]
"""
items = []
slam = MediaItem(
"Slam! TV",
"https://hls.slam.nl/streaming/hls/SLAM!/playlist.m3u8")
slam.icon = self.icon
slam.thumb = self.noImage
slam.type = "video"
slam.isLive = True
items.append(slam)
slam_fm = MediaItem(
"Slam! FM", "https://18973.live.streamtheworld.com/SLAM_AAC.aac"
"?ttag=PLAYER%3ANOPREROLL&tdsdk=js-2.9"
"&pname=TDSdk&pversion=2.9&banners=none")
slam_fm.icon = self.icon
slam_fm.thumb = self.noImage
slam_fm.type = "audio"
slam_fm.isLive = True
slam_fm.append_single_stream(slam_fm.url)
slam_fm.complete = True
items.append(slam_fm)
data = JsonHelper(data)
for e in data.get_value("includes", "Entry"):
self.__liveData[e["sys"]["id"]] = e
for e in data.get_value("includes", "Asset"):
self.__liveData[e["sys"]["id"]] = e
return data, items
def add_live_streams_and_recent(self, data):
""" Adds the live streams for RTL-Z.
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]]
"""
items = []
# let's add the RTL-Z live stream
rtlz_live = MediaItem("RTL Z Live Stream", "")
rtlz_live.icon = self.icon
rtlz_live.thumb = self.noImage
rtlz_live.complete = True
rtlz_live.isLive = True
rtlz_live.dontGroup = True
stream_item = MediaItem(
"RTL Z: Live Stream",
"http://www.rtl.nl/(config=RTLXLV2,channel=rtlxl,progid=rtlz,zone=inlineplayer.rtl.nl/rtlz,ord=0)/system/video/wvx/components/financien/rtlz/miMedia/livestream/rtlz_livestream.xml/1500.wvx"
)
stream_item.icon = self.icon
stream_item.thumb = self.noImage
stream_item.complete = True
stream_item.type = "video"
stream_item.dontGroup = True
stream_item.append_single_stream("http://mss6.rtl7.nl/rtlzbroad", 1200)
stream_item.append_single_stream("http://mss26.rtl7.nl/rtlzbroad",
1200)
stream_item.append_single_stream("http://mss4.rtl7.nl/rtlzbroad", 1200)
stream_item.append_single_stream("http://mss5.rtl7.nl/rtlzbroad", 1200)
stream_item.append_single_stream("http://mss3.rtl7.nl/rtlzbroad", 1200)
rtlz_live.items.append(stream_item)
items.append(rtlz_live)
# Add recent items
data, recent_items = self.add_recent_items(data)
return data, recent_items
def create_video_item(self, result_set):
""" Creates a MediaItem of type 'video' using the result_set from the regex.
This method creates a new MediaItem from the Regular Expression or Json
results <result_set>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.update_video_item method is called if the item is focussed or selected
for playback.
:param list[str]|dict result_set: The result_set of the self.episodeItemRegex
:return: A new MediaItem of type 'video' or 'audio' (despite the method's name).
:rtype: MediaItem|None
"""
Logger.trace(result_set)
media_link = result_set.get("ipadLink")
title = result_set.get("title")
# it seems overkill, but not all items have a contentLink and of we set
# the url to self.baseUrl it will be a duplicate item if the titles are
# equal
url = result_set.get("contentLink") or media_link or self.baseUrl
if not url.startswith("http"):
url = parse.urljoin(self.baseUrl, url)
item = MediaItem(title, url)
if media_link:
item.append_single_stream(media_link, self.channelBitrate)
# get the thumbs from multiple locations
thumb_urls = result_set.get("images", None)
thumb_url = None
if thumb_urls:
# noinspection PyUnresolvedReferences
thumb_url = \
thumb_urls[0].get("fullScreenLink", None) or \
thumb_urls[0].get("previewLink", None) or \
result_set.get("imageLink", None)
if thumb_url and not thumb_url.startswith("http"):
thumb_url = parse.urljoin(self.baseUrl, thumb_url)
if thumb_url:
item.thumb = thumb_url
item.type = 'video'
item.description = HtmlHelper.to_text(result_set.get("text"))
posix = result_set.get("timestamp", None)
if posix:
broadcast_date = DateHelper.get_date_from_posix(int(posix))
item.set_date(broadcast_date.year, broadcast_date.month,
broadcast_date.day, broadcast_date.hour,
broadcast_date.minute, broadcast_date.second)
item.complete = True
return item
def process_live_items(self, data): # NOSONAR
""" Performs pre-process actions that either return multiple live channels that are present
in the live url or an actual list item if a single live stream is present.
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]]
"""
items = []
Logger.info("Adding Live Streams")
if self.liveUrl.endswith(".m3u8"):
# We actually have a single stream.
title = "{} - {}".format(
self.channelName,
LanguageHelper.get_localized_string(
LanguageHelper.LiveStreamTitleId))
live_item = MediaItem(title, self.liveUrl)
live_item.type = 'video'
live_item.isLive = True
if self.channelCode == "rtvdrenthe":
# RTV Drenthe actually has a buggy M3u8 without master index.
live_item.append_single_stream(live_item.url, 0)
live_item.complete = True
items.append(live_item)
return "", items
# we basically will check for live channels
json_data = JsonHelper(data, logger=Logger.instance())
live_streams = json_data.get_value()
Logger.trace(live_streams)
if "videos" in live_streams:
Logger.debug("Multiple streams found")
live_streams = live_streams["videos"]
elif not isinstance(live_streams, (list, tuple)):
Logger.debug("Single streams found")
live_streams = (live_streams, )
else:
Logger.debug("List of stream found")
live_stream_value = None
for streams in live_streams:
Logger.debug("Adding live stream")
title = streams.get(
'name') or "%s - Live TV" % (self.channelName, )
live_item = MediaItem(title, self.liveUrl)
live_item.type = 'video'
live_item.complete = True
live_item.isLive = True
part = live_item.create_new_empty_media_part()
for stream in streams:
Logger.trace(stream)
bitrate = None
# used in Omrop Fryslan
if stream == "android" or stream == "iPhone":
bitrate = 250
url = streams[stream]["videoLink"]
elif stream == "iPad":
bitrate = 1000
url = streams[stream]["videoLink"]
# used in RTV Utrecht
elif stream == "androidLink" or stream == "iphoneLink":
bitrate = 250
url = streams[stream]
elif stream == "ipadLink":
bitrate = 1000
url = streams[stream]
elif stream == "tabletLink":
bitrate = 300
url = streams[stream]
# These windows stream won't work
# elif stream == "windowsLink":
# bitrate = 1200
# url = streams[stream]
# elif stream == "wpLink":
# bitrate = 1200
# url = streams[stream]
elif stream == "name":
Logger.trace("Ignoring stream '%s'", stream)
else:
Logger.warning("No url found for type '%s'", stream)
# noinspection PyUnboundLocalVariable
if "livestreams.omroep.nl/live/" in url and url.endswith(
"m3u8"):
Logger.info("Found NPO Stream, adding ?protection=url")
url = "%s?protection=url" % (url, )
if bitrate:
part.append_media_stream(url, bitrate)
if url == live_stream_value and ".m3u8" in url:
# if it was equal to the previous one, assume we have a m3u8. Reset the others.
Logger.info(
"Found same M3u8 stream for all streams for this Live channel, using that one: %s",
url)
live_item.MediaItemParts = []
live_item.url = url
live_item.complete = False
break
elif "playlist.m3u8" in url:
# if we have a playlist, use that one. Reset the others.
Logger.info(
"Found M3u8 playlist for this Live channel, using that one: %s",
url)
live_item.MediaItemParts = []
live_item.url = url
live_item.complete = False
break
else:
# add it to the possibilities
live_stream_value = url
items.append(live_item)
return "", items
