def update_live_stream(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 """ part = item.create_new_empty_media_part() if item.url == "#livetv": url = "https://d34pj260kw1xmk.cloudfront.net/live/l1/tv/index.m3u8" M3u8.update_part_with_m3u8_streams(part, url, encrypted=True) else: # the audio won't play with the InputStream Adaptive add-on. url = "https://d34pj260kw1xmk.cloudfront.net/live/l1/radio/index.m3u8" for s, b in M3u8.get_streams_from_m3u8(url): part.append_media_stream(s, b) item.complete = True return item
def update_live_stream(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("Updating the live stream") url = "https://rrr.sz.xlcdn.com/?account=atvijf" \ "&file=live&type=live&service=wowza&protocol=https&output=playlist.m3u8" part = item.create_new_empty_media_part() item.complete = \ M3u8.update_part_with_m3u8_streams(part, url, proxy=self.proxy, channel=self) 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) part = item.create_new_empty_media_part() item.complete = M3u8.update_part_with_m3u8_streams(part, item.url, channel=self) return item
def __update_video(self, item, data): if not item.url.startswith("https://api.viervijfzes.be/content/"): regex = 'data-video-*id="([^"]+)' m3u8_url = Regexer.do_regex(regex, data)[-1] # we either have an URL now or an uuid else: m3u8_url = item.url.rsplit("/", 1)[-1] if ".m3u8" not in m3u8_url: Logger.info("Not a direct M3u8 file. Need to log in") url = "https://api.viervijfzes.be/content/%s" % (m3u8_url, ) # We need to log in if not self.loggedOn: self.log_on() # add authorization header authentication_header = { "authorization": self.__idToken, "content-type": "application/json" } data = UriHandler.open(url, additional_headers=authentication_header) json_data = JsonHelper(data) m3u8_url = json_data.get_value("video", "S") # Geo Locked? if "/geo/" in m3u8_url.lower(): # set it for the error statistics item.isGeoLocked = True part = item.create_new_empty_media_part() item.complete = M3u8.update_part_with_m3u8_streams( part, m3u8_url, channel=self, encrypted=False) return item
def create_video_item_json(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 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) image_data = result_set.get("media", []) thumb = None url = None for image in image_data: thumb = image.get("imageHigh", image["image"]) url = image.get("url") item = MediaItem(result_set["title"], url) item.type = "video" item.icon = self.icon item.thumb = thumb or self.noImage item.complete = True item.description = result_set.get("text") part = item.create_new_empty_media_part() M3u8.update_part_with_m3u8_streams(part, url, proxy=self.proxy, channel=self) # Let's not do the time now time_stamp = result_set["created"] date_time = DateHelper.get_date_from_posix(time_stamp) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) return item
def update_video_item(self, item): """Updates an existing MediaItem with more data. Arguments: item : MediaItem - the MediaItem that needs to be updated Returns: The original item with more data added to it's properties. 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. """ Logger.debug('Starting update_video_item for %s (%s)', item.name, self.channelName) from resources.lib.streams.m3u8 import M3u8 data = UriHandler.open(item.url, proxy=self.proxy) video_id = Regexer.do_regex(r'{"video":{"config":{"uri":"([^"]+)', data)[0] url = "http://media.mtvnservices.com/pmt/e1/access/index.html?uri={}&configtype=edge".format( video_id) meta_data = UriHandler.open(url, proxy=self.proxy, referer=self.baseUrl) meta = JsonHelper(meta_data) stream_parts = meta.get_value("feed", "items") for stream_part in stream_parts: stream_url = stream_part["group"]["content"] stream_url = stream_url.replace("&device={device}", "") stream_url = "%s&format=json&acceptMethods=hls" % (stream_url, ) stream_data = UriHandler.open(stream_url, proxy=self.proxy) stream = JsonHelper(stream_data) # subUrls = stream.get_value("package", "video", "item", 0, "transcript", 0, "typographic") # NOSONAR part = item.create_new_empty_media_part() hls_streams = stream.get_value("package", "video", "item", 0, "rendition") for hls_stream in hls_streams: hls_url = hls_stream["src"] item.complete |= M3u8.update_part_with_m3u8_streams( part, hls_url, proxy=self.proxy) item.complete = True Logger.trace("Media url: %s", item) 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 """ data = UriHandler.open(item.url) video_data = JsonHelper(data) stream_data = video_data.get_value("playable") if not stream_data: return item part = item.create_new_empty_media_part() for stream_info in stream_data["assets"]: url = stream_info["url"] stream_type = stream_info["format"] if stream_type == "HLS": item.complete = M3u8.update_part_with_m3u8_streams(part, url) else: Logger.warning("Found unknow stream type: %s", stream_type) if "subtitles" not in stream_data or not stream_data["subtitles"]: return item for sub in stream_data["subtitles"]: sub_url = None sub_type = sub["type"] default_sub = sub["defaultOn"] if default_sub: sub_url = sub["webVtt"] sub_type = "webvtt" # set Retrospect type if sub_url: part.Subtitle = SubtitleHelper.download_subtitle( sub_url, format=sub_type) break return item
def update_video_item(self, item): """Updates an existing MediaItem with more data. Arguments: item : MediaItem - the MediaItem that needs to be updated Returns: The original item with more data added to it's properties. 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. """ Logger.debug('Starting update_video_item for %s (%s)', item.name, self.channelName) data = UriHandler.open(item.url, proxy=self.proxy) # get the playlist GUID playlist_guids = Regexer.do_regex( "<div[^>]+data-playlist-id='([^']+)'[^>]+></div>", data) if not playlist_guids: # let's try the alternative then (for the new channels) playlist_guids = Regexer.do_regex( 'local_playlist[", -]+([a-f0-9]{20})"', data) playlist_guid = playlist_guids[0] play_list_url = "http://api.mtvnn.com/v2/nl/NL/local_playlists/{}.json?video_format=m3u8".format( playlist_guid) data = UriHandler.open(play_list_url, proxy=self.proxy) from resources.lib.helpers.jsonhelper import JsonHelper from resources.lib.streams.m3u8 import M3u8 json_data = JsonHelper(data) m3u8_url = json_data.get_value("local_playlist_videos", 0, "url") part = item.create_new_empty_media_part() item.complete = M3u8.update_part_with_m3u8_streams(part, m3u8_url, proxy=self.proxy, channel=self, encrypted=True) 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) xml_data = UriHandler.open(item.url, proxy=self.proxy) # <ref type='adaptive' device='pc' host='http://manifest.us.rtl.nl' href='/rtlxl/network/pc/adaptive/components/videorecorder/27/278629/278630/d009c025-6e8c-3d11-8aba-dc8579373134.ssm/d009c025-6e8c-3d11-8aba-dc8579373134.m3u8' /> m3u8_urls = Regexer.do_regex( "<ref type='adaptive' device='pc' host='([^']+)' href='/([^']+)' />", xml_data) if not m3u8_urls: Logger.warning("No m3u8 data found for: %s", item) return item m3u8_url = "%s/%s" % (m3u8_urls[0][0], m3u8_urls[0][1]) part = item.create_new_empty_media_part() # prevent the "418 I'm a teapot" error part.HttpHeaders[ "user-agent"] = "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0" # Remove the Range header to make all streams start at the beginning. # Logger.debug("Setting an empty 'Range' http header to force playback at the start of a stream") # part.HttpHeaders["Range"] = '' item.complete = M3u8.update_part_with_m3u8_streams( part, m3u8_url, proxy=self.proxy, headers=part.HttpHeaders, channel=self) 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 """ from resources.lib.streams.m3u8 import M3u8 Logger.debug('Starting update_video_item for %s (%s)', item.name, self.channelName) meta_data = UriHandler.open(item.url, referer=self.baseUrl) meta = JsonHelper(meta_data) stream_parts = meta.get_value("feed", "items") for stream_part in stream_parts: stream_url = stream_part["group"]["content"] stream_url = stream_url.replace("&device={device}", "") stream_url = "%s&format=json&acceptMethods=hls" % (stream_url, ) stream_data = UriHandler.open(stream_url) stream = JsonHelper(stream_data) # subUrls = stream.get_value("package", "video", "item", 0, "transcript", 0, "typographic") # NOSONAR part = item.create_new_empty_media_part() hls_streams = stream.get_value("package", "video", "item", 0, "rendition") for hls_stream in hls_streams: hls_url = hls_stream["src"] item.complete |= M3u8.update_part_with_m3u8_streams(part, hls_url) item.complete = True Logger.trace("Media url: %s", item) 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("Updating a (Live) video item") if item.type == "audio": item.append_single_stream(item.url, 0) item.complete = True elif ".m3u8" in item.url: part = item.create_new_empty_media_part() item.complete = M3u8.update_part_with_m3u8_streams(part, item.url, channel=self, encrypted=False) elif item.url.endswith(".mp4"): item.append_single_stream(item.url, self.channelBitrate) item.complete = True return item
def update_json_video(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: %s', item.name) data = UriHandler.open(item.url, proxy=self.proxy, additional_headers=self.httpHeaders) json_data = JsonHelper(data) streams = json_data.get_value("formats") if not streams: return item qualities = { "720p": 1600, "480p": 1200, "360p": 500, "other": 0 } # , "http-hls": 1500, "3gp-mob01": 300, "flv-web01": 500} part = item.create_new_empty_media_part() urls = [] for stream in streams: url = stream["url"].values()[-1] if url in urls: # duplicate url, ignore continue urls.append(url) # actually process the url if ".m3u8" not in url: part.append_media_stream(url=url, bitrate=qualities.get( stream.get("name", "other"), 0)) item.complete = True # elif AddonSettings.use_adaptive_stream_add_on(): # content_type, url = UriHandler.header(url, self.proxy) # stream = part.append_media_stream(url, 0) # M3u8.SetInputStreamAddonInput(stream, self.proxy) # item.complete = True else: M3u8.update_part_with_m3u8_streams(part, url, proxy=self.proxy, channel=self) 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) data = UriHandler.open(item.url, proxy=self.proxy) json_data, _ = self.extract_json(data) video_id = json_data.get_value("versions", 0, "id") stream_data_url = "http://open.live.bbc.co.uk/mediaselector/5/select/version/2.0/mediaset/iptv-all/vpid/{}".format(video_id) # this URL is one from the webbrowser but requires a security part. So NOT: # streamDataUrl = "http://open.live.bbc.co.uk/mediaselector/5/select/version # /2.0/mediaset/pc/vpid/%s" % (vid,) # # but: # streamDataUrl = "http://open.live.bbc.co.uk/mediaselector/5/select/version # /2.0/mediaset/pc/vpid/%s/atk/2214e42b5729dcdd012dfb61a3054d39309ccd31/asn/1/ # And I don't know where that one comes from part = item.create_new_empty_media_part() stream_data = UriHandler.open(stream_data_url, proxy=self.proxy) # Reroute for debugging # from debug.router import Router # streamData = Router.get_via("uk", streamDataUrl, self.proxy) connection_datas = Regexer.do_regex( r'<media bitrate="(\d+)"[^>]+>\W*' r'(<connection[^>]+>\W*)' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?' r'(<connection[^>]+>\W*)?</media>', stream_data) for connection_data in connection_datas: # first the bitrate bitrate = int(connection_data[0]) Logger.trace("Found Media: %s", connection_data) # go through the available connections for connection in connection_data[1:]: if not connection: continue connection_xml = XmlHelper(connection) stream_bitrate = bitrate Logger.trace("Analyzing Connection: %s", connection) supplier = connection_xml.get_tag_attribute("connection", {"supplier": None}) protocol = connection_xml.get_tag_attribute("connection", {"protocol": None}) transfer_format = connection_xml.get_tag_attribute("connection", {"transferFormat": None}) Logger.debug("Found connection information:\n" "Protocol: %s\n" "TransferFormat: %s\n" "Supplier: %s\n" "Bitrate: %s", protocol, transfer_format, supplier, bitrate) if protocol.startswith("http"): if transfer_format != "hls": # and transfer_format != "dash": Logger.debug("Ignoring TransferFormat: %s", transfer_format) continue if "lime" in supplier or "mf_akamai_uk" in supplier: # Prefer others stream_bitrate -= 1 # Logger.debug("Ignoring Supplier: %s", supplier) # continue url = connection_xml.get_tag_attribute("connection", {"href": None}) elif protocol.startswith("rtmp"): Logger.warning("Ignoring RTMP for now") continue else: Logger.warning("Unknown protocol: %s", protocol) continue if transfer_format == "hls": item.complete = M3u8.update_part_with_m3u8_streams(part, url, proxy=self.proxy, bitrate=stream_bitrate) elif transfer_format == "dash": strm = part.append_media_stream(url, bitrate) Mpd.set_input_stream_addon_input(strm, self.proxy) # get the subtitle subtitles = Regexer.do_regex( '<connection href="(http://www.bbc.co.uk/iplayer/subtitles/[^"]+/)([^/]+.xml)"', stream_data) if len(subtitles) > 0: subtitle = subtitles[0] subtitle_url = "%s%s" % (subtitle[0], subtitle[1]) part.Subtitle = subtitlehelper.SubtitleHelper.download_subtitle( subtitle_url, subtitle[1], "ttml", proxy=self.proxy) item.complete = True Logger.trace('finishing update_video_item: %s.', item) 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) data = UriHandler.open(item.url, proxy=self.proxy) json = JsonHelper(data, Logger.instance()) video_data = json.get_value("video") if video_data: part = item.create_new_empty_media_part() if self.localIP: part.HttpHeaders.update(self.localIP) # Get the videos video_infos = video_data.get("videoReferences") # Similar to SVT supported_formats = { "dash": 2, "dash-avc-51": 3, "hls": 0, "hls-ts-avc-51": 1, "ios": 0 } for video_info in video_infos: video_type = video_info["playerType"] video_url = video_info['url'] if video_type not in supported_formats: Logger.debug("Ignoring %s: %s", video_type, video_url) continue if "hls" in video_type or "ios" in video_type: M3u8.update_part_with_m3u8_streams(part, video_url) elif "dash" in video_type: stream = part.append_media_stream(video_url, supported_formats[video_type]) Mpd.set_input_stream_addon_input(stream, self.proxy) else: continue # stream_info = video_info['url'] # if "manifest.f4m" in stream_info: # continue # elif "master.m3u8" in stream_info: # for s, b in M3u8.get_streams_from_m3u8(stream_info, self.proxy, headers=part.HttpHeaders): # item.complete = True # part.append_media_stream(s, b) # subtitles subtitles = video_data.get("subtitleReferences") if subtitles and subtitles[0]["url"]: Logger.trace(subtitles) sub_url = subtitles[0]["url"] file_name = "%s.srt" % (EncodingHelper.encode_md5(sub_url),) sub_data = UriHandler.open(sub_url, proxy=self.proxy) # correct the subs regex = re.compile(r"^1(\d:)", re.MULTILINE) sub_data = re.sub(regex, r"0\g<1>", sub_data) sub_data = re.sub(r"--> 1(\d):", r"--> 0\g<1>:", sub_data) local_complete_path = os.path.join(Config.cacheDir, file_name) Logger.debug("Saving subtitle to: %s", local_complete_path) with open(local_complete_path, 'w') as f: f.write(sub_data) part.Subtitle = local_complete_path item.complete = True return item
def __update_embedded_video(self, item): """ Updates video items that are encrypted. This could be the default for Krypton! :param MediaItem item: The item to update. :return: An updated item. :rtype: MediaItem """ data = UriHandler.open(item.url, proxy=self.proxy) if UriHandler.instance().status.code == 404: title, message = Regexer.do_regex( r'<h1>([^<]+)</h1>\W+<p>([^<]+)<', data)[0] XbmcWrapper.show_dialog(title, message) return item start_needle = "var playerConfig =" start_data = data.index(start_needle) + len(start_needle) end_data = data.index("var talpaPlayer") data = data[start_data:end_data].strip().rstrip(";") json = JsonHelper(data) has_drm_only = True adaptive_available = AddonSettings.use_adaptive_stream_add_on( with_encryption=False, channel=self) adaptive_available_encrypted = AddonSettings.use_adaptive_stream_add_on( with_encryption=True, channel=self) for play_list_entry in json.get_value("playlist"): part = item.create_new_empty_media_part() for source in play_list_entry["sources"]: stream_type = source["type"] stream_url = source["file"] stream_drm = source.get("drm") if not stream_drm: has_drm_only = False if stream_type == "m3u8": Logger.debug("Found non-encrypted M3u8 stream: %s", stream_url) M3u8.update_part_with_m3u8_streams(part, stream_url, proxy=self.proxy, channel=self) item.complete = True elif stream_type == "dash" and adaptive_available: Logger.debug("Found non-encrypted Dash stream: %s", stream_url) stream = part.append_media_stream(stream_url, 1) Mpd.set_input_stream_addon_input(stream, proxy=self.proxy) item.complete = True else: Logger.debug("Unknown stream source: %s", source) else: compatible_drm = "widevine" if compatible_drm not in stream_drm or stream_type != "dash": Logger.debug("Found encrypted %s stream: %s", stream_type, stream_url) continue Logger.debug("Found Widevine encrypted Dash stream: %s", stream_url) license_url = stream_drm[compatible_drm]["url"] pid = stream_drm[compatible_drm]["releasePid"] encryption_json = '{"getRawWidevineLicense":' \ '{"releasePid":"%s", "widevineChallenge":"b{SSM}"}' \ '}' % (pid,) headers = { "Content-Type": "application/json", "Origin": "https://embed.kijk.nl", "Referer": stream_url } encryption_key = Mpd.get_license_key( license_url, key_type=None, key_value=encryption_json, key_headers=headers) stream = part.append_media_stream(stream_url, 0) Mpd.set_input_stream_addon_input( stream, proxy=self.proxy, license_key=encryption_key) item.complete = True subs = [ s['file'] for s in play_list_entry.get("tracks", []) if s.get('kind') == "captions" ] if subs: subtitle = SubtitleHelper.download_subtitle(subs[0], format="webvtt") part.Subtitle = subtitle if has_drm_only and not adaptive_available_encrypted: XbmcWrapper.show_dialog( LanguageHelper.get_localized_string(LanguageHelper.DrmTitle), LanguageHelper.get_localized_string( LanguageHelper.WidevineLeiaRequired)) return item
def update_graphql_item(self, item): """ Updates video items that are encrypted. This could be the default for Krypton! :param MediaItem item: The item to update. :return: An updated item. :rtype: MediaItem """ sources = item.metaData["sources"] part = item.create_new_empty_media_part() hls_over_dash = self._get_setting("hls_over_dash") == "true" for src in sources: stream_type = src["type"] url = src["file"] drm = src["drm"] if "?filter=" in url: url = url[:url.index("?filter=")] if stream_type == "dash" and not drm: bitrate = 0 if hls_over_dash else 2 stream = part.append_media_stream(url, bitrate) item.complete = Mpd.set_input_stream_addon_input( stream, self.proxy) elif stream_type == "dash" and drm and "widevine" in drm: bitrate = 0 if hls_over_dash else 1 stream = part.append_media_stream(url, bitrate) # fetch the authentication token: # url = self.__get_api_persisted_url("drmToken", "634c83ae7588a877e2bb67d078dda618cfcfc70ac073aef5e134e622686c0bb6", variables={}) url = self.__get_api_query_url("drmToken", "{token,expiration}") token_data = UriHandler.open(url, proxy=self.proxy, no_cache=True) token_json = JsonHelper(token_data) token = token_json.get_value("data", "drmToken", "token") # we need to POST to this url using this wrapper: key_url = drm["widevine"]["url"] release_pid = drm["widevine"]["releasePid"] encryption_json = '{{"getRawWidevineLicense":{{"releasePid":"{}","widevineChallenge":"b{{SSM}}"}}}}'.format( release_pid) encryption_key = Mpd.get_license_key( key_url=key_url, key_type="b", key_value=encryption_json, key_headers={ "Content-Type": "application/json", "authorization": "Basic {}".format(token) }) Mpd.set_input_stream_addon_input(stream, license_key=encryption_key) item.complete = True elif stream_type == "m3u8" and not drm: bitrate = 2 if hls_over_dash else 0 item.complete = M3u8.update_part_with_m3u8_streams( part, url, proxy=self.proxy, channel=self, bitrate=bitrate) else: Logger.debug("Found incompatible stream: %s", src) subtitle = None for sub in item.metaData.get("subtitles", []): subtitle = sub["file"] part.Subtitle = subtitle # If we are here, we can playback. item.isDrmProtected = False return item
def __update_item_from_video_references(self, item, videos, subtitles=None): # NOSONAR """ :param MediaItem item: The original MediaItem that needs updating. :param list[any] videos: Videos to add. :param dict subtitles: Subtitle information. :return: Updated MediaItem :rtype: MediaItem """ item.MediaItemParts = [] part = item.create_new_empty_media_part() if self.localIP: part.HttpHeaders.update(self.localIP) use_input_stream = AddonSettings.use_adaptive_stream_add_on( channel=self) for video in videos: video_format = video.get("format", "") if not video_format: video_format = video.get("playerType", "") video_format = video_format.lower() if ("dash" in video_format and not video_format == "dash") or "hds" in video_format: Logger.debug("Skipping video format: %s", video_format) continue Logger.debug("Found video item for format: %s", video_format) url = video['url'] if any(filter(lambda s: s.Url == url, part.MediaStreams)): Logger.debug("Skippping duplicate Stream url: %s", url) continue if video_format == "dash" and use_input_stream: stream = part.append_media_stream(video['url'], 1) Mpd.set_input_stream_addon_input(stream, self.proxy) elif "m3u8" in url: alt_index = url.find("m3u8?") if alt_index > 0: url = url[0:alt_index + 4] if "-fmp4.m3u8" in url or "-lowbw.m3u8" in url: Logger.trace("Ignoring: %s", url) continue M3u8.update_part_with_m3u8_streams(part, url, encrypted=False, proxy=self.proxy, headers=part.HttpHeaders, channel=self) elif video["url"].startswith("rtmp"): # just replace some data in the URL part.append_media_stream( self.get_verifiable_video_url(video["url"]).replace( "_definst_", "?slist="), video[1]) else: part.append_media_stream(url, 0) if subtitles: Logger.info("Found subtitles to play") for sub in subtitles: sub_format = sub["format"].lower() url = sub["url"] if sub_format == "websrt": sub_url = url # elif subFormat == "webvtt": # Logger.Info("Found M3u8 subtitle, replacing with WSRT") # start, name, index = sub[-1].rsplit("/", 2) # subUrl = "%s/%s/%s.wsrt" % (start, name, name) else: # look for more continue part.Subtitle = subtitlehelper.SubtitleHelper.download_subtitle( sub_url, format="srt", proxy=self.proxy, replace={"&": "&"}) # stop when finding one break item.complete = True return item