def _get_live_streams(self): stream_id = _id_map[self.channel_path] if stream_id == "ruv": qualities_rtmp = ["720p", "480p", "360p", "240p"] for i, quality in enumerate(qualities_rtmp): yield quality, RTMPStream( self.session, { "rtmp": RTMP_LIVE_URL.format(stream_id, i + 1), "pageUrl": self.url, "live": True }) qualities_hls = ["240p", "360p", "480p", "720p"] for i, quality_hls in enumerate(qualities_hls): yield quality_hls, HLSStream(self.session, HLS_RUV_LIVE_URL.format(i + 1)) else: yield "audio", RTMPStream( self.session, { "rtmp": RTMP_LIVE_URL.format(stream_id, 1), "pageUrl": self.url, "live": True }) yield "audio", HLSStream(self.session, HLS_RADIO_LIVE_URL.format(stream_id))
def _get_streams(self): """ Find the streams for web.tv :return: """ headers = {} res = http.get(self.url, headers=headers) headers["Referer"] = self.url sources = self._sources_re.findall(res.text) if len(sources): sdata = parse_json(sources[0], schema=self._sources_schema) for source in sdata: self.logger.debug("Found stream of type: {}", source[u'type']) if source[u'type'] == u"application/vnd.apple.mpegurl": # if the url has no protocol, assume it is http url = source[u"src"] if url.startswith("//"): url = "http:" + url try: # try to parse the stream as a variant playlist variant = HLSStream.parse_variant_playlist(self.session, url, headers=headers) if variant: for q, s in variant.items(): yield q, s else: # and if that fails, try it as a plain HLS stream yield 'live', HLSStream(self.session, url, headers=headers) except IOError: self.logger.warning("Could not open the stream, perhaps the channel is offline")
def _create_hls_streams(self, bitrate): url = bitrate["url"] quality = self._get_quality(bitrate["label"]) if not url.startswith("http"): url = HLS_PLAYLIST_BASE.format(url) if bitrate["label"] == "Auto": try: streams = HLSStream.parse_variant_playlist(self.session, url) return streams.items() except IOError as err: self.logger.warning("Failed to extract HLS streams: {0}", err) else: return quality, HLSStream(self.session, url)
def _get_streams(self): page = http.get(self.url) try: channel, _, _, _, online, visibility, is_flash = self._get_stream_arguments( page) except ValueError: return if not online: self.logger.error("This stream is currently offline") return channel_server_res = http.post(API_CHANNEL_INFO, data={"loadbalancinginfo": channel}) if is_flash: return { "live": RTMPStream( self.session, { "rtmp": RTMP_URL.format(channel_server_res.text), "playpath": RTMP_PLAYPATH.format(channel, visibility), "pageUrl": self.url, "live": True }) } else: return HLSStream.parse_variant_playlist( self.session, HLS_URL.format(channel_server_res.text, channel, visibility), verify=False)
def _get_streams(self): match = _url_re.match(self.url) videoid = match.group('id') streams = {} # Set header data for user-agent hdr = {'User-Agent': USER_AGENT} # Parse video ID from data received from supplied URL res = http.get(VK_VIDEO_URL + videoid.strip(), headers=hdr) for match in re.findall(SINGLE_VIDEO_URL, res.text): url = match[0].replace("\\/", "/") streams[match[2]] = HTTPStream(self.session, url) if not streams: # try to check is live match = VK_LIVE_HASH.search(res.text) params = videoid.split('_') if match and match.group('hash'): url = VK_EXT_URL.format(params[0].replace('video', "").replace('-', ""), params[1], match.group('hash')) res = http.get(url, headers=hdr) match = SINGLE_HLS_URL.search(res.text) if match and match.group('playlist'): hls_streams = HLSStream.parse_variant_playlist(self.session, match.group('playlist').replace("\\/", "/"), namekey="pixels") streams.update(hls_streams) return streams
def _get_streams(self): # get the HLS xml from the same sub domain as the main url, defaulting to www sdomain = _url_re.match(self.url).group(1) or "www" res = http.get(API_URL.format(sdomain)) stream_url = http.xml(res, schema=_schema) return HLSStream.parse_variant_playlist(self.session, stream_url)
def _create_stream(self, stream, is_live): stream_name = "{0}p".format(stream["height"]) stream_type = stream["mediaType"] stream_url = stream["url"] if stream_type in ("hls", "mp4"): if urlparse(stream_url).path.endswith("m3u8"): try: streams = HLSStream.parse_variant_playlist( self.session, stream_url) # TODO: Replace with "yield from" when dropping Python 2. for stream in streams.items(): yield stream except IOError as err: self.logger.error("Failed to extract HLS streams: {0}", err) else: yield stream_name, HTTPStream(self.session, stream_url) elif stream_type == "rtmp": params = { "rtmp": stream["streamer"], "playpath": stream["url"], "swfVfy": SWF_URL, "pageUrl": self.url, } if is_live: params["live"] = True else: params["playpath"] = "mp4:{0}".format(params["playpath"]) stream = RTMPStream(self.session, params) yield stream_name, stream
def _get_streams(self): match = _url_re.match(self.url) videoid = match.group('id') # Set header data for user-agent hdr = {'User-Agent': USER_AGENT} # Parse video ID from data received from supplied URL res = http.get(self.url, headers=hdr) if not res: return {} for match in re.findall(_player_params, res.text): try: params = json.loads(base64.b64decode(match)) video_url = params.get("url") res = http.get(video_url, headers=hdr) video_url = res.text.split('=')[1] return HLSStream.parse_variant_playlist( self.session, video_url) except Exception as e: self.logger.error("Failed to decode player params: {0}", e) return {}
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_star_streams(self, desktop_url, mobile_url, token=""): if token: self.logger.debug("Opening stream with token: {}", token) if mobile_url: for _, s in HLSStream.parse_variant_playlist(self.session, mobile_url + token, headers={ "Referer": self.url }).items(): yield "live", s if desktop_url: # get the HDS stream URL res = http.get(desktop_url + token) stream_data = http.json(res, schema=self.hds_schema) for _, s in HDSStream.parse_manifest( self.session, stream_data["url"], pvswf=self.SWF_URL, is_akamai=stream_data["use_akamai"], headers={ "Referer": self.url }).items(): yield "live", s
def _get_streams(self): res = http.get(self.url) data_m = self.data_re.search(res.text) if data_m: stream_url = data_m.group(1) self.logger.debug("Found stream: {}", stream_url) yield "live", HLSStream(self.session, stream_url)
def _get_streams(self): match = _url_re.match(self.url) video = match.group("video_id") playlist = _playlist_url.format(video) return HLSStream.parse_variant_playlist(self.session, playlist)
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): res = http.get(self.url) match = _info_re.search(res.text) if not match: return info = parse_json(match.group(1), schema=_schema) stream_name = info["mode"] mp4_url = info.get("mp4_url") ios_url = info.get("ios_url") swf_url = info.get("swf_url") if mp4_url: stream = HTTPStream(self.session, mp4_url) yield stream_name, stream if ios_url: if urlparse(ios_url).path.endswith(".m3u8"): streams = HLSStream.parse_variant_playlist( self.session, ios_url) # TODO: Replace with "yield from" when dropping Python 2. for stream in streams.items(): yield stream if swf_url: stream = self._get_rtmp_stream(swf_url) if stream: yield stream_name, stream
def _get_streams(self): streams = {} # streaming.media.ccc.de match = _url_streaming_media_re.match(self.url) if match: query_url = API_URL_STREAMING_MEDIA live_streams = parse_streaming_media_json(get_json(query_url),\ match.group('room')) for stream_name, stream_url in live_streams.items(): if re.search(r"m3u8", live_streams[stream_name]): streams[stream_name] = HLSStream(self.session,\ stream_url) else: streams[stream_name] = HTTPStream(self.session,\ stream_url) # media.ccc.de elif _url_media_re.search(self.url): event_id = get_event_id(self.url) query_url = "%s/public/events/%i" % (API_URL_MEDIA, event_id) recordings = parse_media_json(get_json(query_url)) for name, stream_url in recordings.items(): streams[name] = HTTPStream(self.session, stream_url) if not streams: raise PluginError("This plugin does not support your " "selected video.") return streams
def _get_streams(self): res = http.get(self.url) text = res.text cdn = _RE_CDN.search(text).group(1) playlist_url = _RE_PLAYLIST.search(text).group(1) url = 'http://{}{}'.format(cdn, playlist_url) return dict(source=HLSStream(self.session, url))
def _get_sarpurinn_streams(self): res = http.get(self.url) match = _rtmp_url_re.search(res.text) if not match: yield token = match.group("id") status = match.group("status") extension = match.group("ext") date = match.group("date") if not date: date = "" if extension == "mp3": key = "audio" else: key = "576p" # HLS on Sarpurinn is currently only available on videos yield key, HLSStream( self.session, HLS_SARPURINN_URL.format(status, date, token, extension)) yield key, RTMPStream( self.session, { "rtmp": RTMP_SARPURINN_URL.format(status, date, token, extension), "pageUrl": self.url, "live": True })
def _get_streams(self): if _stream_url_re.match(self.url): mode = MODE_STREAM else: mode = MODE_VOD res = http.get(self.url) match = _json_re.search(res.text) if match: data = json.loads( _json_re.search(res.text).group('json').replace('"', '"')) else: raise PluginError("Could not extract JSON metadata") streams = {} try: if mode == MODE_STREAM: sources = data['playlist']['videos'][0]['sources'] elif mode == MODE_VOD: sources = data['selected_video']['sources'] except (KeyError, IndexError): raise PluginError("Could not extract sources") for source in sources: try: if source['delivery'] != 'hls': continue url = source['src'].replace('\/', '/') except KeyError: continue stream = HLSStream.parse_variant_playlist(self.session, url) streams.update(stream) return streams
def _get_streams(self): res = http.get(self.url, schema=_live_schema) if not res: return if res["type"] == "hls" and urlparse(res["url"]).path.endswith("m3u8"): stream = HLSStream(self.session, res["url"]) return dict(hls=stream)
def _get_streams(self): clips = http.get(self.url, schema=_schema) if not clips: return for clip in clips: for source in clip["sources"]: return HLSStream.parse_variant_playlist(self.session, source["file"])
def _parse_vod_streams(self, vod): for name, stream in vod["streams"].items(): scheme = urlparse(stream["url"]).scheme if scheme == "http": yield name, HLSStream(self.session, stream["url"]) elif scheme == "rtmp": yield name, self._create_rtmp_stream(stream, live=False)
def _get_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): 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): content_id = self._get_content_id() if content_id: self.logger.debug(u"Loading content: {}", content_id) hls_url = self._get_hls_url(content_id) return HLSStream.parse_variant_playlist(self.session, hls_url) else: self.logger.error(u"Could not find the contentId for this stream")
def _get_streams(self): """ Finds the streams from tvcatchup.com. """ http.headers.update({"User-Agent": USER_AGENT}) res = http.get(self.url) match = _stream_re.search(res.text, re.IGNORECASE | re.MULTILINE) if match: stream_url = match.group("stream_url") if stream_url: if "_adp" in stream_url: return HLSStream.parse_variant_playlist( self.session, stream_url) else: return {'576p': HLSStream(self.session, stream_url)}
def _get_streams(self): username = _RE_URL.match(self.url).group(1) url = 'https://www.stream.me/api-user/v1/{}/channel'.format(username) data = http.get(url).json() try: m3u8 = data['_embedded']['streams'][0]['_links']['hlsmp4']['href'] return HLSStream.parse_variant_playlist(self.session, m3u8) except KeyError: return {}
def _get_streams(self): match = _url_re.match(self.url) channel = match.group("channel") channel = channel.replace("_", "-") playlist_url = PLAYLIST_URL.format(channel) return HLSStream.parse_variant_playlist(self.session, playlist_url, check_streams=True)
def _get_streams(self): res = http.get(self.url) match = (_stream_hls_re.search(res.text) or _stream_data_re.search(res.text)) if not match: return stream_url = parse_json(match.group(1)) return HLSStream.parse_variant_playlist(self.session, stream_url)
def _get_hls_stream(self, broadcast, username): keyjson = self._get_hls_key(broadcast, username) if keyjson["result"] != CHANNEL_RESULT_OK: return key = keyjson["data"]["hls_authentication_key"] info = self._get_stream_info(broadcast, "hls") if "view_url" in info: return HLSStream(self.session, info["view_url"], params=dict(aid=key))
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 playlist_url = http.json(res, schema=_stream_schema) if "hls_url" in playlist_url: return dict( replay=HLSStream(self.session, playlist_url["hls_url"])) elif "replay_url" in playlist_url: self.logger.info("Live Stream ended, using replay instead") return dict( replay=HLSStream(self.session, playlist_url["replay_url"])) else: return