def start(self, url, filePath, params = {}):
        '''
            Owervrite start from BaseDownloader
        '''
        self.url              = url
        self.filePath         = filePath
        self.downloaderParams = params
        self.fileExtension    = '' # should be implemented in future
        if 'ustream.tv' in url:
            self.streamSelector = strwithmeta(url).meta.get('iptv_chank_url', '')
        else:
            self.streamSelector = strwithmeta(url).meta.get('iptv_bitrate', 0)
        
        self.outData = ''
        self.contentType = 'unknown'
        
        baseWgetCmd = DMHelper.getBaseWgetCmd(self.downloaderParams) 
        
        cmd = DMHelper.GET_F4M_PATH() + (" '%s'" % baseWgetCmd) + (' "%s"' % self.url) + (' "%s"' % self.filePath) + (' %s' % self.streamSelector) + ' > /dev/null'

        printDBG("F4mDownloader::start cmd[%s]" % cmd)
        
        self.console = eConsoleAppContainer()
        self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self._cmdFinished)
        self.console_stderrAvail_conn = eConnectCallback(self.console.stderrAvail, self._dataAvail)
        self.console.execute( cmd )
        
        self.status     = DMHelper.STS.DOWNLOADING
        
        self.onStart()
        return BaseDownloader.CODE_OK
Esempio n. 2
0
 def getLinksForVideo(self, cItem):
     printDBG("NeoKinoNet.getLinksForVideo [%s]" % cItem)
     urlTab = []
     url = cItem['url']
     
     sts, data = self.cm.getPage(url)
     if not sts: return []
     sourcesData = self.cm.ph.getDataBeetwenMarkers(data, 'sources:', ']', False)[1]
     tracksData  = self.cm.ph.getDataBeetwenMarkers(data, 'tracks:', ']', False)[1]
     tracksData = re.compile('"(http[^"]+?\.srt)"').findall(tracksData)
     idx = 0
     sub_tracks = []
     for item in tracksData:
         sub_tracks.append({'title':'sub %d' % idx, 'url':item, 'lang':'defaul'})
         idx += 1
         
     sourcesData = re.compile('file:[^;]*?"([^"]+?)"[^;]*?label:[^;]*?"([^"]+?)",[^;]*?type:[^;]*?"([^"]+?)"').findall(sourcesData)
     for item in sourcesData:
         url = strwithmeta(item[0], {'external_sub_tracks':sub_tracks})
         urlTab.append({'name':item[1], 'url':url, 'type':item[2], 'need_resolve':0})
         
     url = self.cm.ph.getSearchGroups(data, '''<embed[^>]+?src=['"](http[^"^']+?)['"]''')[0]
     if url.startswith('http'):
         url = strwithmeta(url, {'external_sub_tracks':sub_tracks})
         urlTab.append({'name':'google.com', 'url':url, 'need_resolve':1})
         
     data = re.compile('''\('display'\)\.src=['"]([^'^"]+?)['"]''').findall(data)
     for url in data:
         url = strwithmeta(url, {'external_sub_tracks':sub_tracks})
         urlTab.append({'name':self.up.getHostName(url), 'url':url, 'need_resolve':1})
     
     return urlTab
def getF4MLinksWithMeta(manifestUrl, checkExt=True):
    if checkExt and not manifestUrl.split("?")[0].endswith(".f4m"):
        return []

    cm = common()
    headerParams, postData = cm.getParamsFromUrlWithMeta(manifestUrl)

    retPlaylists = []
    sts, data = cm.getPage(manifestUrl, headerParams, postData)
    if sts:
        liveStreamDetected = False
        if "live" == CParsingHelper.getDataBeetwenMarkers("<streamType>", "</streamType>", False):
            liveStreamDetected = True
        bitrates = re.compile('bitrate="([0-9]+?)"').findall(data)
        for item in bitrates:
            link = strwithmeta(manifestUrl, {"iptv_proto": "f4m", "iptv_bitrate": item})
            if liveStreamDetected:
                link.meta["iptv_livestream"] = True
            retPlaylists.append({"name": "[f4m/hds] bitrate[%s]" % item, "url": link})

        if 0 == len(retPlaylists):
            link = strwithmeta(manifestUrl, {"iptv_proto": "f4m"})
            if liveStreamDetected:
                link.meta["iptv_livestream"] = True
            retPlaylists.append({"name": "[f4m/hds]", "url": link})
    return retPlaylists
def getF4MLinksWithMeta(manifestUrl, checkExt=True):
    if checkExt and not manifestUrl.split('?')[0].endswith('.f4m'):
        return []
        
    cm = common()
    headerParams, postData = cm.getParamsFromUrlWithMeta(manifestUrl)
    
    retPlaylists = []
    sts, data = cm.getPage(manifestUrl, headerParams, postData)
    if sts:
        liveStreamDetected = False
        if 'live' == CParsingHelper.getDataBeetwenMarkers('<streamType>', '</streamType>', False):
            liveStreamDetected = True
        bitrates = re.compile('bitrate="([0-9]+?)"').findall(data)
        for item in bitrates:
            link = strwithmeta(manifestUrl, {'iptv_proto':'f4m', 'iptv_bitrate':item})
            if liveStreamDetected:
                link.meta['iptv_livestream'] = True
            retPlaylists.append({'name':'[f4m/hds] bitrate[%s]' % item, 'url':link})
        
        if 0 == len(retPlaylists):
            link = strwithmeta(manifestUrl, {'iptv_proto':'f4m'})
            if liveStreamDetected:
                link.meta['iptv_livestream'] = True
            retPlaylists.append({'name':'[f4m/hds]', 'url':link})
    return retPlaylists
Esempio n. 5
0
 def runMovePlayer(self):
     # this shoudl not happen but to make sure
     if not self.canRunMoviePlayer:
         printDBG('called runMovePlayer with canRunMoviePlayer set to False')
         return
     
     self.inMoviePlayer = True
     buffSize = self.downloader.getLocalFileSize() - self.lastSize 
     printDBG("Run MoviePlayer with buffer size [%s]" % formatBytes(float(buffSize)) )
     self.setMainTimerSts(False)
     
     exteplayerBlocked =  strwithmeta(self.url).meta.get('iptv_block_exteplayer', False)
     printDBG("runMovePlayer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exteplayerBlocked[%s]" % exteplayerBlocked)
     
     player = self.activMoviePlayer
     printDBG('IPTVPlayerBufferingWidget.runMovePlayer [%r]' % player)
     playerAdditionalParams = dict(self.playerAdditionalParams)
     playerAdditionalParams['downloader'] = self.downloader
     if strwithmeta(self.url).meta.get('iptv_proto', '') in ['f4m', 'uds', 'm3u8']:
         playerAdditionalParams['file-download-timeout'] = 90000 # 90s
     else:
         playerAdditionalParams['file-download-timeout'] = 10000 # 10s
     playerAdditionalParams['file-download-live'] = self._isInLiveMode()
     if "mini" == player:
         self.session.openWithCallback(self.leaveMoviePlayer, IPTVMiniMoviePlayer, self.filePath, self.movieTitle, self.lastPosition, 4)
     elif "exteplayer" == player:
         if not exteplayerBlocked: self.session.openWithCallback(self.leaveMoviePlayer, IPTVExtMoviePlayer, self.filePath, self.movieTitle, self.lastPosition, 'eplayer', playerAdditionalParams)
         else: self.session.openWithCallback(self.leaveMoviePlayer, IPTVExtMoviePlayer, self.filePath, self.movieTitle, self.lastPosition, 'gstplayer', playerAdditionalParams)
     elif "extgstplayer" == player: self.session.openWithCallback(self.leaveMoviePlayer, IPTVExtMoviePlayer, self.filePath, self.movieTitle, self.lastPosition, 'gstplayer', playerAdditionalParams)
     else: self.session.openWithCallback(self.leaveMoviePlayer, IPTVStandardMoviePlayer, self.filePath, self.movieTitle)
     playerAdditionalParams = None
Esempio n. 6
0
 def getVideoLinks(self, baseUrl):
     printDBG("NeoKinoNet.getVideoLinks [%s]" % baseUrl)
     urlTab = []
     videoUrl = strwithmeta(baseUrl)
     sub_tracks = videoUrl.meta['external_sub_tracks']
     if videoUrl.startswith('http'):
         urlTab = self.up.getVideoLinkExt(videoUrl)
         if len(sub_tracks):
             for idx in range(len(urlTab)):
                 urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'], {'external_sub_tracks':sub_tracks})
     return urlTab
def getDirectM3U8Playlist(M3U8Url, checkExt=True, variantCheck=True, cookieParams={}):
    if checkExt and not M3U8Url.split("?")[0].endswith(".m3u8"):
        return []

    cm = common()
    meta = strwithmeta(M3U8Url).meta
    params, postData = cm.getParamsFromUrlWithMeta(M3U8Url)
    params.update(cookieParams)

    retPlaylists = []
    try:
        finallM3U8Url = meta.get("iptv_m3u8_custom_base_link", "")
        if "" == finallM3U8Url:
            params["return_data"] = False
            sts, response = cm.getPage(M3U8Url, params, postData)
            finallM3U8Url = response.geturl()
            data = response.read().strip()
            response.close()
        else:
            sts, data = cm.getPage(M3U8Url, params, postData)
            data = data.strip()

        m3u8Obj = m3u8.inits(data, finallM3U8Url)
        if m3u8Obj.is_variant:
            for playlist in m3u8Obj.playlists:
                item = {}
                if not variantCheck or playlist.absolute_uri.split("?")[-1].endswith(".m3u8"):
                    meta.update({"iptv_proto": "m3u8", "iptv_bitrate": playlist.stream_info.bandwidth})
                    item["url"] = strwithmeta(playlist.absolute_uri, meta)
                else:
                    meta.pop("iptv_proto", None)
                    item["url"] = decorateUrl(playlist.absolute_uri, meta)

                item["bitrate"] = playlist.stream_info.bandwidth
                if None != playlist.stream_info.resolution:
                    item["with"] = playlist.stream_info.resolution[0]
                    item["heigth"] = playlist.stream_info.resolution[1]
                else:
                    item["with"] = 0
                    item["heigth"] = 0
                item["codec"] = playlist.stream_info.codecs
                item["name"] = "bitrate: %s res: %dx%d kodek: %s" % (
                    item["bitrate"],
                    item["with"],
                    item["heigth"],
                    item["codec"],
                )
                retPlaylists.append(item)
        else:
            item = {"name": "m3u8", "url": M3U8Url, "codec": "unknown", "with": 0, "heigth": 0, "bitrate": "unknown"}
            retPlaylists.append(item)
    except:
        printExc()
    return retPlaylists
def getDirectM3U8Playlist(M3U8Url, checkExt=True, variantCheck=True, cookieParams={}):
    if checkExt and not M3U8Url.split('?')[0].endswith('.m3u8'):
        return []
        
    cm = common()
    meta = strwithmeta(M3U8Url).meta
    params, postData = cm.getParamsFromUrlWithMeta(M3U8Url)
    params.update(cookieParams)
    
    retPlaylists = []
    try:
        finallM3U8Url = meta.get('iptv_m3u8_custom_base_link', '') 
        if '' == finallM3U8Url:
            params['return_data'] = False
            sts, response = cm.getPage(M3U8Url, params, postData)
            finallM3U8Url = response.geturl()
            data = response.read().strip()
            response.close()
        else:
            sts, data = cm.getPage(M3U8Url, params, postData)
            data = data.strip()
            
        m3u8Obj = m3u8.inits(data, finallM3U8Url)
        if m3u8Obj.is_variant:
            for playlist in m3u8Obj.playlists:
                item = {}
                if not variantCheck or playlist.absolute_uri.split('?')[-1].endswith('.m3u8'):
                    meta.update({'iptv_proto':'m3u8', 'iptv_bitrate':playlist.stream_info.bandwidth})
                    item['url'] = strwithmeta(playlist.absolute_uri, meta)
                else:
                    meta.pop('iptv_proto', None)
                    item['url'] = decorateUrl(playlist.absolute_uri, meta)
                
                item['bitrate'] = playlist.stream_info.bandwidth
                if None != playlist.stream_info.resolution:
                    item['with'] = playlist.stream_info.resolution[0]
                    item['heigth'] = playlist.stream_info.resolution[1]
                else:
                    item['with'] = 0
                    item['heigth'] = 0
                item['codec'] = playlist.stream_info.codecs
                item['name']  = "bitrate: %s res: %dx%d kodek: %s" % ( item['bitrate'], \
                                                                        item['with'],    \
                                                                        item['heigth'],  \
                                                                        item['codec'] )
                retPlaylists.append(item)
        else:
            item = {'name':'m3u8', 'url':M3U8Url, 'codec':'unknown', 'with':0, 'heigth':0, 'bitrate':'unknown'}
            retPlaylists.append(item)
    except:
        printExc()
    return retPlaylists
 def _viaProxy(self, url):
     if url.startswith('http'):
         baseProxy = 'http://www.proxy-german.de/'
         proxy = baseProxy + 'index.php?q={0}&hl=240'.format(urllib.quote_plus(url))
         return strwithmeta(proxy, {'Referer':baseProxy, 'Cookie':'flags=240'})
     else:
         return ''
def decorateUrl(url, metaParams={}):
    retUrl = strwithmeta( url )
    retUrl.meta.update(metaParams)
    urlLower = url.lower()
    if 'iptv_proto' not in retUrl.meta:
        if urlLower.startswith('merge://'):
            retUrl.meta['iptv_proto'] = 'merge'
        elif urlLower.split('?')[0].endswith('.m3u8'):
            retUrl.meta['iptv_proto'] = 'm3u8'
        elif urlLower.split('?')[0].endswith('.f4m'):
            retUrl.meta['iptv_proto'] = 'f4m'
        elif urlLower.startswith('rtmp'):
            retUrl.meta['iptv_proto'] = 'rtmp'
        elif urlLower.startswith('https'):
            retUrl.meta['iptv_proto'] = 'https'
        elif urlLower.startswith('http'):
            retUrl.meta['iptv_proto'] = 'http'
        elif urlLower.startswith('file'):
            retUrl.meta['iptv_proto'] = 'file'
        elif urlLower.startswith('rtsp'):
            retUrl.meta['iptv_proto'] = 'rtsp'
        elif urlLower.startswith('mms'):
            retUrl.meta['iptv_proto'] = 'mms'
        elif urlLower.startswith('mmsh'):
            retUrl.meta['iptv_proto'] = 'mmsh'
        elif 'protocol=hls' in url.lower():
            retUrl.meta['iptv_proto'] = 'm3u8'
    return retUrl
    def getLinksForVideo(self, Index = 0, selItem = None):
        listLen = len(self.onet.currList)
        if listLen < Index and listLen > 0:
            printDBG( "ERROR getLinksForVideo - current list is to short len: %d, Index: %d" % (listLen, Index) )
            return RetHost(RetHost.ERROR, value = [])
            
        if self.onet.currList[Index].name != 'playSelectedMovie':
            printDBG( "ERROR getLinksForVideo - current item has wrong type" )
            return RetHost(RetHost.ERROR, value = [])
            
        retlist = []
        videoID = self.onet.currList[Index].category
        
        subTrackTab, tab = self.onet.api.getVideoTab(self.onet.currList[Index].category, True)
        if config.plugins.iptvplayer.onetvodUseDF.value:
            maxRes = int(config.plugins.iptvplayer.onetvodDefaultformat.value) * 1.1
            tab = CSelOneLink( tab, _getLinkQuality, maxRes ).getOneLink()

        for item in tab:
            if item[0] == vodonet.FORMAT:
                nameLink = "type: %s \t bitrate: %s" % (item[0], item[2])
                url = item[1].encode('utf-8')
                url = strwithmeta(url, {'external_sub_tracks':subTrackTab})
                retlist.append(CUrlItem(nameLink.encode('utf-8'), url, 0))
            
        return RetHost(RetHost.OK, value = retlist)
 def onStart(self):
     self.onLayoutFinish.remove(self.onStart)
     self['progressBar'].value = 0
     self['bufferingBar'].range = (0, 100000)
     self['bufferingBar'].value = 0
     self.initGuiComponentsPos()
     if 'gstplayer' == self.player:
         gstplayerPath = config.plugins.iptvplayer.gstplayerpath.value
         #'export GST_DEBUG="*:6" &&' + 
         cmd = gstplayerPath  + ' "%s"' % self.fileSRC
         if "://" in self.fileSRC: 
             cmd += ' "%s" "%s"  "%s"  "%s" ' % (self.gstAdditionalParams['download-buffer-path'], self.gstAdditionalParams['ring-buffer-max-size'], self.gstAdditionalParams['buffer-duration'], self.gstAdditionalParams['buffer-size'])
             tmp = strwithmeta(self.fileSRC)
             url,httpParams = DMHelper.getDownloaderParamFromUrl(tmp)
             for key in httpParams: cmd += (' "%s=%s" ' % (key, httpParams[key]) )
             if 'http_proxy' in tmp.meta:
                 tmp = tmp.meta['http_proxy']
                 if '://' in tmp:
                     if '@' in tmp:
                         tmp = re.search('([^:]+?://)([^:]+?):([^@]+?)@(.+?)$', tmp)
                         if tmp: cmd += (' "proxy=%s" "proxy-id=%s" "proxy-pw=%s" ' % (tmp.group(1)+tmp.group(4), tmp.group(2), tmp.group(3)) )
                     else: cmd += (' "proxy=%s" ' % tmp)
     else:
         cmd = 'exteplayer3 "%s"' % self.fileSRC + " > /dev/null"
     
     self.console = eConsoleAppContainer()
     self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self.eplayer3Finished)
     self.console_stderrAvail_conn = eConnectCallback(self.console.stderrAvail, self.eplayer3DataAvailable)
     #if 'gstplayer' == self.player: 
     #    self.console_stdoutAvail_conn = eConnectCallback(self.console.stdoutAvail, self.eplayer3DataAvailable2 ) # work around to catch EOF event after seeking, pause .etc
     printDBG("onStart cmd[%s]" % cmd)
     self.console.execute( cmd )
     self['statusIcon'].setPixmap( self.playback['statusIcons']['Play'] ) # sulge for test
Esempio n. 13
0
 def getVideoLink(self, cItem):
     printDBG("GoldVodTVApi.getVideoLink")
     if self.loggedIn:
         url = strwithmeta(cItem['url'], {'params':{'load_cookie': True}})
     else:
         url = cItem['url']
     return self.up.getVideoLinkExt(url)
Esempio n. 14
0
def decorateUrl(url, metaParams={}):
    retUrl = strwithmeta(url)
    retUrl.meta.update(metaParams)
    urlLower = url.lower()
    if "iptv_proto" not in retUrl.meta:
        if urlLower.split("?")[0].endswith(".m3u8"):
            retUrl.meta["iptv_proto"] = "m3u8"
        elif urlLower.split("?")[0].endswith(".f4m"):
            retUrl.meta["iptv_proto"] = "f4m"
        elif urlLower.startswith("rtmp"):
            retUrl.meta["iptv_proto"] = "rtmp"
        elif urlLower.startswith("https"):
            retUrl.meta["iptv_proto"] = "https"
        elif urlLower.startswith("http"):
            retUrl.meta["iptv_proto"] = "http"
        elif urlLower.startswith("file"):
            retUrl.meta["iptv_proto"] = "file"
        elif urlLower.startswith("rtsp"):
            retUrl.meta["iptv_proto"] = "rtsp"
        elif urlLower.startswith("mms"):
            retUrl.meta["iptv_proto"] = "mms"
        elif urlLower.startswith("mmsh"):
            retUrl.meta["iptv_proto"] = "mmsh"
        elif "protocol=hls" in url.lower():
            retUrl.meta["iptv_proto"] = "m3u8"
    return retUrl
 def start(self, uri, mode='loop'):
     self.uri = uri
     self.playMode = mode
     
     gstplayerPath = config.plugins.iptvplayer.gstplayerpath.value
     #'export GST_DEBUG="*:6" &&' + 
     cmd = gstplayerPath  + ' "%s"' % self.uri
     if "://" in self.uri: 
         cmd += ' "%s" "%s"  "%s"  "%s" ' % (self.gstAdditionalParams['download-buffer-path'], self.gstAdditionalParams['ring-buffer-max-size'], self.gstAdditionalParams['buffer-duration'], self.gstAdditionalParams['buffer-size'])
         tmp = strwithmeta(self.uri)
         url,httpParams = DMHelper.getDownloaderParamFromUrl(tmp)
         for key in httpParams: cmd += (' "%s=%s" ' % (key, httpParams[key]) )
         if 'http_proxy' in tmp.meta:
             tmp = tmp.meta['http_proxy']
             if '://' in tmp:
                 if '@' in tmp:
                     tmp = re.search('([^:]+?://)([^:]+?):([^@]+?)@(.+?)$', tmp)
                     if tmp: cmd += (' "proxy=%s" "proxy-id=%s" "proxy-pw=%s" ' % (tmp.group(1)+tmp.group(4), tmp.group(2), tmp.group(3)) )
                 else: cmd += (' "proxy=%s" ' % tmp)
     else:
         cmd = 'exteplayer3 "%s"' % self.uri + " > /dev/null"
     self.console = eConsoleAppContainer()
     self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self._playerFinished)
     printDBG("IPTVSimpleAudioPlayer.start cmd[%s]" % cmd)
     self.console.execute( cmd )
     self.stopped = False
Esempio n. 16
0
    def getLinksForVideo(self, cItem):
        printDBG("FuufPL.getLinksForVideo [%s]" % cItem)
        urlTab = []
        http_params = {"use_cookie": True, "save_cookie": True, "load_cookie": False, "cookiefile": self.COOKIE_FILE}
        sts, data = self.cm.getPage(self.MAIN_URL, http_params)
        if not sts:
            return urlTab

        http_params.update({"load_cookie": True})
        sts, data = self.cm.getPage(cItem["url"], http_params)
        if not sts:
            return urlTab

        try:
            PHPSESSID = self.cm.getCookieItem(self.COOKIE_FILE, "PHPSESSID")
        except:
            printExc()
            SetIPTVPlayerLastHostError(_("Not valid cookie: [%s]") % self.COOKIE_FILE)
            return urlTab

        url = self.cm.ph.getSearchGroups(data, 'file: "(http[^"]+?)"')[0]
        if "" == url:
            return urlTab
        printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> url[%s]" % url)

        retUrl = strwithmeta(url)
        retUrl.meta["Referer"] = "http://static.fuuf.pl/player/jwplayer.flash.swf"
        retUrl.meta["Cookie"] = "PHPSESSID={0}".format(PHPSESSID)

        urlTab.append({"name": "fuuf.pl", "url": retUrl})

        return urlTab
 def getLinksForVideo(self, cItem):
     printDBG("Watchwrestling.getLinksForVideo [%s]" % cItem)
     urlTab = []
     url = cItem['url']
     Referer =  cItem['Referer']
     if 1 != self.up.checkHostSupport(url):  
         tries = 0
         while tries < 3:
             sts, data = self.cm.getPage(url, {'header':{'Referer':Referer, 'User-Agent':'Mozilla/5.0'}})
             if not sts: return urlTab
             data = data.replace('// -->', '')
             data = self._clearData(data)
             #printDBG(data)
             if 'eval(unescape' in data:
                 data = urllib.unquote(self.cm.ph.getSearchGroups(data, '''eval\(unescape\(['"]([^"^']+?)['"]''')[0])
             url = self.cm.ph.getSearchGroups(data, '''<iframe[^>]*?src=['"]([^"^']+?)['"]''', 1, True)[0]
             if 'protect.cgi' in url:
                 Referer = cItem['url']
             else:
                 break
             tries += 1
     url = strwithmeta(url)
     url.meta['Referer'] = Referer
     url.meta['live'] = cItem.get('live', False)
     
     urlTab.append({'name':cItem['title'], 'url':url, 'need_resolve':1})
     return urlTab
    def __init__(self, session, url, pathForRecordings, pictureTitle):
        self.session = session
        Screen.__init__(self, session)
        self.onStartCalled = False
        
        self.recordingPath = pathForRecordings
        try:
            self.filePath = os.path.join(pathForRecordings, '.iptv_buffering.jpg')
        except:
            self.filePath = ''
            printExc()
            
        self.url           = url
        self.pictureTitle  = pictureTitle
        self.audioUrl      = strwithmeta(url).meta.get("iptv_audio_url", '')
       
        self["actions"] = ActionMap(['IPTVAlternateVideoPlayer', 'MoviePlayerActions', 'MediaPlayerActions', 'WizardActions', 'DirectionActions'],
        {
            'leavePlayer'  : self.key_exit,
            'play'         : self.key_play,
            'pause'        : self.key_pause,
            'exit'         : self.key_exit,
            'back'         : self.key_exit,
            'ok'           : self.key_ok,
        }, -1)     

        self["status"]  = Label()
        self["console"] = Label()
        self["icon"]    = SimpleAnimatedCover()
        self["picture"] = Cover()

        # prepare icon frames path
        frames = []
        for idx in range(1,self.NUM_OF_ICON_FRAMES+1): frames.append( GetIconDir('/buffering/buffering_%d.png' % idx) )
        self["icon"].loadFrames(frames) 
        
        #main Timer
        self.mainTimer = eTimer()
        self.mainTimerEnabled = False
        self.mainTimer_conn = eConnectCallback(self.mainTimer.timeout, self.updateDisplay)
        self.mainTimerInterval = 100 # by default 0,1s
        # download
        self.downloader = DownloaderCreator(self.url)
        
        self.onClose.append(self.__onClose)
        self.onShow.append(self.doStart)
        #self.onLayoutFinish.append(self.doStart)
        
        self.autoRefresh = False
        self.refreshPostfixes = ['_0', '_1']
        self.refreshCount = 0
        self.refreshing = False
        
        if len(self.audioUrl) and len(config.plugins.iptvplayer.gstplayerpath.value):
            self.audioPlayer = IPTVSimpleAudioPlayer()
        else: self.audioPlayer  = None
Esempio n. 19
0
 def _getIconUrl(self, url):
     url = self._getFullUrl(url)
     if 'hdfilme.tv' in url and self.isNeedProxy():
         proxy = 'http://www.proxy-german.de/index.php?q={0}&hl=240'.format(urllib.quote(url, ''))
         params = {}
         params['User-Agent'] = self.HEADER['User-Agent'],
         params['Referer'] = proxy
         params['Cookie'] = 'flags=2e5;'
         url = strwithmeta(proxy, params) 
     return url
 def getVideoLinks(self, baseUrl):
     printDBG("Watchwrestling.getVideoLinks [%s]" % baseUrl)
     urlTab = []
     
     url = strwithmeta(baseUrl)
     if url.meta.get('live'):
         urlTab = self.up.getAutoDetectedStreamLink(url)
     else:
         urlTab = self.up.getVideoLinkExt(url)
     return urlTab
Esempio n. 21
0
 def getLinksForVideo(self, cItem):
     printDBG("YifyTV.getLinksForVideo [%s]" % cItem)
     urlTab = []
     
     sts, data = self.cm.getPage(cItem['url'])
     if not sts: return urlTab
     
     #data = self.cm.ph.getSearchGroups(data, 'var[^"]*?parametros[^"]*?=[^"]*?"([^"]+?)"')[0]
     dat1 = self.cm.ph.getSearchGroups(data, '\}([^\{^\}]+?)var mouse_and_cat_playing_for_ever')[0].replace('var ', '')
     
     parametros = self.cm.ph.getDataBeetwenMarkers(data, 'var mouse_and_cat_playing_for_ever', ';', False)[1]
     data = self.cm.ph.getDataBeetwenMarkers(data, 'sourcesConfigMod', 'var mouse_and_cat_playing_for_ever', False)[1]
     
     globalTabCode, pyCode, args = self.getPyCode(data)
     
     pyCode = dat1.strip() + '\n' +  pyCode  + 'parametros ' + parametros.strip()
     pyCode = 'def retA():\n\t' + globalTabCode.replace('\n', '\n\t') + '\n' + pyCode.replace('\n', '\n\t') + '\n\treturn parametros\n' + 'param = retA()'
     #printDBG(pyCode)
     data = self.unpackJS(pyCode, 'param')
     #printDBG(pyCode)
     printDBG(data)
     
     sub_tracks = []
     subLangs = self.cm.ph.getSearchGroups(data, '&sub=([^&]+?)&')[0]
     if subLangs == '':
         tmp = re.compile("\=([^&]*?)&").findall(data)
         for it in tmp:
             for e in ['PT2', 'EN', 'FR', 'ES']:
                 if e in it:
                     subLangs = it
                     break
             if '' != subLangs:
                 break
     
     if subLangs != '':
         subID    = self.cm.ph.getSearchGroups(data, '&id=(tt[^&]+?)&')[0]
         if subID == '':
             subID    = self.cm.ph.getSearchGroups(data, '&pic=(tt[^&]+?)&')[0]
         subLangs = subLangs.split(',')
         for lang in subLangs:
             if subID != '':
                 sub_tracks.append({'title':lang, 'url':'http://yify.tv/player/bajarsub.php?%s_%s' % (subID, lang), 'lang':lang, 'format':'srt'})
     
     data = data.split('&')
     idx = 1
     for item in data:
         tmp = item.split('=')
         if len(tmp)!= 2: continue
         if tmp[1].endswith('enc'):
             url = strwithmeta(tmp[1], {'external_sub_tracks':sub_tracks})
             url.meta['Referer'] = cItem['url']
             url.meta['sou'] = tmp[0]
             urlTab.append({'name':_('Mirror') + ' %s' % idx, 'url':url, 'need_resolve':1})
             idx += 1
     return urlTab
Esempio n. 22
0
 def getLinksForVideo(self, cItem):
     printDBG("MyVideo.getLinksForVideo [%s]" % cItem['url'])
     if len(cItem.get('url_cache', [])):
         return cItem['url_cache']
     urlTab = []
     url = self._resolveUrl(cItem['url'])
     if config.plugins.iptvplayer.myvideode_proxyenabled.value and '' != config.plugins.iptvplayer.german_proxyurl.value:
         url = strwithmeta(url, {'http_proxy':config.plugins.iptvplayer.german_proxyurl.value})
     urlTab = self.up.getVideoLinkExt(url)
     if len(urlTab):
         cItem['url_cache'] = urlTab
     return urlTab
Esempio n. 23
0
 def start(self, url, filePath, params = {}):
     self.em3u8_url = strwithmeta(url)
     self.em3u8_filePath = filePath
     self.em3i8_params = params
     
     printDBG("===================EM3U8Downloader===================")
     printDBG(self.em3u8_url.meta)
     printDBG(self.em3u8_url.meta.get('iptv_refresh_cmd', ''))
     printDBG("=====================================================")
     self.EM3U8linkProv.execute( self.em3u8_url.meta.get('iptv_refresh_cmd', '') )
     
     return BaseDownloader.CODE_OK
Esempio n. 24
0
 def getVideoLinks(self, baseUrl):
     printDBG("Movie4kTO.getVideoLinks [%s]" % baseUrl)
     urlTab = []
     sub_tracks = strwithmeta(baseUrl).meta.get('external_sub_tracks', [])
     
     header = dict(self.AJAX_HEADER)
     header['Referer'] = baseUrl.meta['Referer']
     
     souTab = [baseUrl.meta.get('sou', '')]
     if souTab[0] == 'pic':
         souTab.append('adr')
     for sou in souTab:
         post_data = {'fv':'18', 'url':baseUrl, 'sou':sou}
         url = 'http://yify.tv/player/pk/pk/plugins/player_p2.php'
         sts, data = self.cm.getPage(url, {'header':header}, post_data)
         if not sts: return []
         #printDBG('>>>>>>>>>>>>>>>>>>>>>>>\n%s\n<<<<<<<<<<<<<<<' % data)
         try:
             printDBG(data)
             if 'jscode' in data:
                 data = self._evalJscode(data)
             data = byteify(json.loads(data))
             for item in data:
                 #printDBG('++++++++++++++++++++++\n%s\n++++++++++++++++++++++' % item)
                 if item.get('type', '').startswith('video/') and item.get('url', '').startswith('http'):
                     urlTab.append({'name':'{0}x{1}'.format(item.get('height', ''), item.get('width', '')), 'url':item['url'], 'need_resolve':0})
         except:
             SetIPTVPlayerLastHostError('The Mirror is broken.\nIf available you can choose other source.')
             printExc()
         if len(urlTab): break;
     
     if False: 
         videoUrl = url
         if url.startswith('//'):
             videoUrl = 'http:' + videoUrl
         urlTab = self.up.getVideoLinkExt(videoUrl)
     for idx in range(len(urlTab)):
         urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'], {'external_sub_tracks':sub_tracks})
     
     return urlTab
Esempio n. 25
0
 def getVideoLinks(self, baseUrl):
     printDBG("SemBilheteTV.getVideoLinks [%s]" % baseUrl)
     urlTab = []
     url = strwithmeta(baseUrl)
     if url.startswith('http'): 
         subTracks = url.meta.get('external_sub_tracks', [])
         tmp = self.up.getVideoLinkExt(url)
         if len(subTracks):
             for item in tmp:
                 item['url'] = urlparser.decorateUrl(item['url'], {'external_sub_tracks':subTracks})
                 urlTab.append(item)
         else:
             urlTab = tmp
     return urlTab
 def getHostingTable(self, urlItem):
     printDBG("getHostingTable url[%s]" % urlItem['url'])
     hostingTab = []
     verTab = []
     if self.loggedIn: http_params = {'header': self.HEADER, 'use_cookie': True, 'save_cookie': False, 'load_cookie': True, 'cookiefile': self.COOKIE_FILE}
     else: http_params = {'header': self.HEADER}
     
     sts, data = self.cm.getPage(urlItem['url'], http_params )
     if False == sts: return hostingTab
     
     # Get hosting table - hosting
     tmp = re.compile('<li[^<]+?data-s="([^"]+?)"[^<]+?data-hid="([^"]+?)"[^<]*?>([^<]+?)</li>').findall( self.cm.ph.getDataBeetwenMarkers(data, 'data-prop="hosting">', '</ul>', False)[1] )
     for item in tmp: 
         hostingTab.append( {'name':self.cleanHtmlStr(item[2]), 'url':strwithmeta(urlItem['url'], {'hosting':item[1]})} )
     return hostingTab
Esempio n. 27
0
 def getVideoLink(self, cItem):
     printDBG("TelewizjadaNetApi.getVideoLink")
     
     url = self.MAIN_URL + 'live.php?cid=%s' % cItem['cid']
     sts, data = self.cm.getPage(url, self.http_params)
     if not sts: return []
     
     http_params = dict(self.http_params)
     HTTP_HEADER= { 'User-Agent':'Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:21.0) Gecko/20100101 Firefox/21.0'}
     http_params.update({'header':HTTP_HEADER})
     http_params['header']['Referer'] = url
     
     url = self.MAIN_URL + 'get_mainchannel.php'
     sts, data = self.cm.getPage(url, http_params, {'cid':cItem['cid']})
     if not sts: return []
     try:
         data = byteify(json.loads(data))
         vid_url = data['url']
     except:
         printExc()
         return []
     
     url = self.MAIN_URL + 'set_cookie.php'
     sts, data = self.cm.getPage(url, http_params, {'url':vid_url})
     if not sts: return []
     
     url = self.MAIN_URL + 'get_channel_url.php'
     sts, data = self.cm.getPage(url, http_params, {'cid':cItem['cid']})
     if not sts: return []
     
     try:
         vid_url = byteify(json.loads(data))
         vid_url = vid_url['url']
     except:
         vid_url = data
     
     urlsTab = []
     vid_url = vid_url.strip()
     if vid_url.startswith('http://') and 'm3u8' in vid_url:
         try:
             sessid = self.cm.getCookieItem(self.COOKIE_FILE, 'sessid')
             msec   = self.cm.getCookieItem(self.COOKIE_FILE, 'msec')
             statid = self.cm.getCookieItem(self.COOKIE_FILE, 'statid')
             url = strwithmeta(vid_url, {'Cookie':'sessid=%s; msec=%s; statid=%s;' % (sessid, msec, statid)})
             urlsTab = getDirectM3U8Playlist(url)
         except:
             SetIPTVPlayerLastHostError("Problem z dostępem do pliku \"%\".\nSprawdź, czy masz wolne miejsce na pliki cookies." % self.COOKIE_FILE)
     return urlsTab
Esempio n. 28
0
 def _updateEM3U8DataAvail(self, data):
     if None != data and 0 < len(data):
         self.EM3U8ListData += data
         if self.EM3U8ListData.endswith('\n'):
             printDBG(self.EM3U8ListData)
             data = self.EM3U8ListData.split('\n')
             url = ''
             for item in data:
                 if item.startswith('http'):
                     url = item.strip()
             if url.startswith('http'):
                 if not self.em3u8Started:
                     url = strwithmeta(url, self.em3u8_url.meta)
                     M3U8Downloader.start(self, url, self.em3u8_filePath, self.em3i8_params)
                     self.em3u8Started = True
                 else:
                     self.m3u8Url = url
             self.EM3U8ListData = ''
 def start(self, url, filePath, params = {}):
     '''
         Owervrite start from BaseDownloader
     '''
     self.filePath             = filePath
     self.downloaderParams     = params
     self.fileExtension        = '' # should be implemented in future
     
     self.status       = DMHelper.STS.DOWNLOADING
     self.updateThread = None
     self.fragmentList = []
     self.lastMediaSequence = -1
     self.currentFragment = -1
     self.liveStream   = False
     self.skipFirstSegFromList = strwithmeta(url).meta.get('iptv_m3u8_skip_seg', 0)
     self._startM3U8(url)
     
     self.onStart()
     return BaseDownloader.CODE_OK
Esempio n. 30
0
 def getLinksForVideo(self, cItem):
     printDBG("Vumoo.getLinksForVideo [%s]" % cItem)
     urlTab = []
     url = cItem['url']
     
     if 'episode_url' in cItem:
         eUrl = cItem['episode_url']
         if eUrl.startswith('http'):
             eUrl = strwithmeta(eUrl, {'Referer':url})
             urlTab.append({'name':'episode', 'url':eUrl, 'need_resolve':0})
     else:
         sts, data = self.cm.getPage(url)
         if not sts: return
         
         data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="video">', '</div>', False)[1]
         data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<iframe', '</iframe>', False)
         for item in data:
             vidUrl = self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"')[0]
             if 1 != self.up.checkHostSupport(vidUrl): continue 
             urlTab.append({'name':self.up.getHostName(vidUrl), 'url':vidUrl, 'need_resolve':1})
     return urlTab
Esempio n. 31
0
    def getVideoLinks(self, baseUrl):
        printDBG("3filmy.getVideoLinks [%s]" % baseUrl)
        baseUrl = strwithmeta(baseUrl)

        return self.up.getVideoLinkExt(baseUrl)
Esempio n. 32
0
    def exploreItem(self, cItem):
        printDBG("Altadefinizione.exploreItem")

        sts, data = self.getPage(cItem['url'])
        if not sts:
            return
        self.setMainUrl(self.cm.meta['url'])

        cItem = dict(cItem)
        cItem['prev_url'] = cItem['url']

        trailer = self.cm.ph.getDataBeetwenNodes(data,
                                                 ('<div', '>', 'btn_trailer'),
                                                 ('</div', '>'), False)[1]
        url = self.getFullUrl(
            self.cm.ph.getSearchGroups(trailer, '''href=['"]([^"^']+?)['"]''',
                                       1, True)[0])
        if self.cm.isValidUrl(url):
            title = self.cleanHtmlStr(trailer)
            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'url': url,
                'title': '%s %s' % (title, cItem['title'])
            })
            self.addVideo(params)

        urlTab = []
        tmp = self.cm.ph.getAllItemsBeetwenMarkers(data, '<iframe',
                                                   '</iframe>')
        data = self.cm.ph.getAllItemsBeetwenNodes(data,
                                                  ('<a', '>', 'data-link'),
                                                  ('</a', '>'))
        for item in tmp:
            url = self.getFullUrl(
                self.cm.ph.getSearchGroups(item, '''src=['"]([^"^']+?)['"]''',
                                           1, True)[0])
            if 'http' not in url:
                continue
            sts, data = self.getPage(url)
            if not sts:
                return
            data = self.cm.ph.getAllItemsBeetwenNodes(
                data, ('<li', '>', 'data-link'), ('</li', '>'))

        for item in data:
            printDBG("Altadefinizione.exploreItem item [%s]" % item)
            url = self.getFullUrl(
                self.cm.ph.getSearchGroups(
                    item, '''data\-link=['"]([^"^']+?)['"]''', 1, True)[0])
            if url.startswith('//'):
                url = 'https:' + url
            if 1 == self.up.checkHostSupport(url):
                name = self.cleanHtmlStr(item)
                url = strwithmeta(url, {'Referer': cItem['url']})
                urlTab.append({'name': name, 'url': url, 'need_resolve': 1})

        if len(urlTab):
            params = dict(cItem)
            params.update({'good_for_fav': False, 'urls_tab': urlTab})
            self.addVideo(params)
Esempio n. 33
0
    def getLinksForVideo(self, cItem):
        printDBG("3filmy.getLinksForVideo [%s]" % cItem)

        def _link(link):
            idx = 0
            st = ''
            while idx < len(link):
                st += chr(ord(link[idx]) ^ 0x5d)
                idx += 1
            return st

        params = dict(self.ajaxParams)
        params['header'] = dict(params['header'])

        cUrl = cItem['url']

        params['header']['Referer'] = cUrl
        if 'data-hash' not in cItem:
            sts, data = self.getPage(cUrl, params)
            if not sts: return []
            tmp = self.cm.ph.getDataBeetwenNodes(data,
                                                 ('<div', '>', 'player-ajax'),
                                                 ('</div', '>'))[1]
            #            printDBG("3filmy.getLinksForVideo tmp [%s]" % tmp)
            hash = self.cm.ph.getSearchGroups(
                tmp, '''data\-hash=['"]([^"^']+?)['"]''')[0]
            id = self.cm.ph.getSearchGroups(
                tmp, '''data\-id=['"]([^"^']+?)['"]''')[0]
            post_data = {
                'id': id,
                'hash': hash,
                'd': '-1',
                'q': '-1',
                'w': '-1'
            }
        else:
            post_data = {
                'id': cItem['data-id'],
                'hash': cItem['data-hash'],
                'd': '-1',
                'q': '-1',
                'w': '-1',
                'ep': 'true'
            }

        sts, data = self.getPage('https://3filmy.com/ajax/video.details',
                                 params, post_data)
        if not sts: return []
        #        printDBG("3filmy.getLinksForVideo data[%s]" % data)

        retTab = []

        try:
            data = json_loads(data)
            qual = data['q_avb']
            opts = [data['ch']]
            opts.extend(data['opts'])
            #            printDBG("3filmy.getLinksForVideo qual: %s opts: %s" % (qual, opts))
            for qitem in qual:
                post_data.update({'q': qitem})
                for oitem in opts:
                    #                    printDBG("3filmy.getLinksForVideo oitem %s" % oitem)
                    post_data.update({'d': oitem[0]})
                    sts, data = self.getPage(
                        'https://3filmy.com/ajax/video.details', params,
                        post_data)
                    if not sts: return []
                    data = json_loads(data)
                    link = urllib.unquote(data['link'])
                    url = _link(link)
                    retTab.append({
                        'name': str(qitem) + ' - ' + oitem[1],
                        'url': strwithmeta(url, {'Referer': url}),
                        'need_resolve': 0
                    })
        except Exception:
            printExc()

        return retTab
Esempio n. 34
0
    def getLinksForVideo(self, cItem):
        printDBG("HDPopcornsCom.getLinksForVideo [%s]" % cItem)
        if 'urls' in cItem:
            return cItem.get('urls', [])
        elif 1 == self.up.checkHostSupport(cItem.get('url', '')):
            return self.up.getVideoLinkExt(cItem['url'])

        urlTab = []

        sts, data = self.getPage(cItem['url'], self.defaultParams)
        if not sts:
            return []

        data = self.cm.ph.getDataBeetwenMarkers(data, '<form action',
                                                '</form>')[1]
        try:
            url = self.getFullUrl(
                self.cm.ph.getSearchGroups(data,
                                           '''action=['"]([^'^"]+?)['"]''')[0])
            post_data = dict(
                re.findall(
                    r'<input[^>]*name="([^"]*)"[^>]*value="([^"]*)"[^>]*>',
                    data))

            params = dict(self.defaultParams)
            params['header'] = dict(params['header'])
            params['header']['Referer'] = cItem['url']

            sts, data = self.getPage(url, params, post_data)
            if not sts:
                return []

            printDBG("+++++++++++++++++++++++++++++++++++++++")
            tmp = self.cm.ph.getDataBeetwenMarkers(data,
                                                   '<div id="subtitles">',
                                                   '</form>')[1]
            popcornsubtitlesUrl = self.getFullUrl(
                self.cm.ph.getSearchGroups(tmp,
                                           '''action=['"]([^'^"]+?)['"]''')[0])
            printDBG("+++++++++++++++++++++++++++++++++++++++")

            data = self.cm.ph.getAllItemsBeetwenMarkers(data,
                                                        '<div id="btn',
                                                        '</a>',
                                                        withMarkers=True)
            for item in data:
                url = self.getFullUrl(
                    self.cm.ph.getSearchGroups(
                        item, '''href=['"]([^'^"]+?)['"]''')[0])
                if '///downloads/' in url:
                    continue
                if not self.cm.isValidUrl(url):
                    continue
                name = self.cleanHtmlStr(item)
                url = strwithmeta(
                    url.replace('&#038;', '&'),
                    {'popcornsubtitles_url': popcornsubtitlesUrl})
                urlTab.append({'name': name, 'url': url, 'need_resolve': 0})
        except Exception:
            printExc()

        return urlTab
Esempio n. 35
0
    def getVideoLinks(self, videoUrl):
        printDBG("MoovieCC.getVideoLinks [%s]" % videoUrl)
        videoUrl = strwithmeta(videoUrl)
        urlTab = []
        
        # mark requested link as used one
        if len(self.cacheLinks.keys()):
            for key in self.cacheLinks:
                for idx in range(len(self.cacheLinks[key])):
                    if videoUrl in self.cacheLinks[key][idx]['url']:
                        if not self.cacheLinks[key][idx]['name'].startswith('*'):
                            self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
                        break
        
        orginUrl = str(videoUrl)
        url = videoUrl
        post_data = None
        while True:
            try:
                httpParams = dict(self.defaultParams)
                httpParams['return_data'] = False
                
                sts, response = self.cm.getPage(url, httpParams, post_data)
                videoUrl = response.geturl()
                response.close()
            except Exception:
                printExc()
                return []
            
            if self.up.getDomain(self.getMainUrl()) in videoUrl or self.up.getDomain(videoUrl) == self.up.getDomain(orginUrl):
                sts, data = self.getPage(videoUrl)
                if not sts: return []
                
                if 'captcha' in data: data = re.sub("<!--[\s\S]*?-->", "", data)
                
                if 'google.com/recaptcha/' in data and 'sitekey' in data:
                    message = _('Link protected with google recaptcha v2.')
                    SetIPTVPlayerLastHostError(message)
                    break
                elif '<input name="captcha"' in data:
                    tmp = self.cm.ph.getDataBeetwenMarkers(data, '<content', '</form>')[1]
                    captchaTitle = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(tmp, '<h1', '</h1>')[1])
                    captchaDesc  = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(tmp, '<p', '</p>')[1])
                    
                    # parse form data
                    data = self.cm.ph.getDataBeetwenMarkers(data, '<form', '</form>')[1]
                    
                    imgUrl = self.cm.ph.getSearchGroups(data, 'src="([^"]+?)"')[0]
                    if imgUrl != '' and not imgUrl.startswith('/'): imgUrl = '/' + imgUrl
                    if imgUrl.startswith('/'): imgUrl = urlparse.urljoin(videoUrl, imgUrl)
                    
                    printDBG("img URL [%s]" % imgUrl)
                        
                    actionUrl = self.cm.ph.getSearchGroups(data, 'action="([^"]+?)"')[0]
                    if actionUrl != '': actionUrl = '/' + actionUrl
                    if actionUrl.startswith('/'): actionUrl = urlparse.urljoin(videoUrl, actionUrl)
                    elif actionUrl == '': actionUrl = videoUrl
                        
                    captcha_post_data = dict(re.findall(r'''<input[^>]+?name=["']([^"^']*)["'][^>]+?value=["']([^"^']*)["'][^>]*>''', data))
                    
                    if self.cm.isValidUrl(imgUrl):
                        params = dict(self.defaultParams)
                        params['header'] = dict(params['header'] )
                        params['header']['Accept'] = 'image/png,image/*;q=0.8,*/*;q=0.5'
                        params = dict(self.defaultParams)
                        params.update( {'maintype': 'image', 'subtypes':['jpeg', 'png'], 'check_first_bytes':['\xFF\xD8','\xFF\xD9','\x89\x50\x4E\x47'], 'header':params['header']} )
                        filePath = GetTmpDir('.iptvplayer_captcha.jpg')
                        ret = self.cm.saveWebFile(filePath, imgUrl.replace('&amp;', '&'), params)
                        if not ret.get('sts'):
                            SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
                            return urlTab

                        params = deepcopy(IPTVMultipleInputBox.DEF_PARAMS)
                        params['accep_label'] = _('Send')
                        params['title'] = captchaTitle
                        params['status_text'] = captchaDesc
                        params['with_accept_button'] = True
                        params['list'] = []
                        item = deepcopy(IPTVMultipleInputBox.DEF_INPUT_PARAMS)
                        item['label_size'] = (160,75)
                        item['input_size'] = (480,25)
                        item['icon_path'] = filePath
                        item['title'] = _('Answer')
                        item['input']['text'] = ''
                        params['list'].append(item)
            
                        ret = 0
                        retArg = self.sessionEx.waitForFinishOpen(IPTVMultipleInputBox, params)
                        printDBG(retArg)
                        if retArg and len(retArg) and retArg[0]:
                            printDBG(retArg[0])
                            captcha_post_data['captcha'] = retArg[0][0]
                            post_data = captcha_post_data
                            url = actionUrl
                        
                        if not sts:
                            return urlTab
                        else:
                            continue
                
                found = False
                printDBG(data)
                tmp = re.compile('''<iframe[^>]+?src=['"]([^"^']+?)['"]''', re.IGNORECASE).findall(data)
                for url in tmp:
                    if 1 == self.up.checkHostSupport(url):
                        videoUrl = url
                        found = True
                        break
                if not found or 'flashx' in videoUrl:
                    tmp = self.cm.ph.getAllItemsBeetwenMarkers(data, 'embedFrame', '</a>')
                    tmp.extend(self.cm.ph.getAllItemsBeetwenMarkers(data, '<a', '</a>'))
                    for urlItem in tmp:
                        url = self.cm.ph.getSearchGroups(urlItem, '''href=['"](https?://[^'^"]+?)['"]''')[0]
                        if 1 == self.up.checkHostSupport(url):
                            videoUrl = url
                            found = True
                            break
            break
        
        if self.cm.isValidUrl(videoUrl):
            urlTab = self.up.getVideoLinkExt(videoUrl)
        
        return urlTab
    def getVideoLinks(self, videoUrl):
        printDBG("Altadefinizione.getVideoLinks [%s]" % videoUrl)
        videoUrl = strwithmeta(videoUrl)
        urlTab = []

        # mark requested link as used one
        if len(self.cacheLinks.keys()):
            for key in self.cacheLinks:
                for idx in range(len(self.cacheLinks[key])):
                    if videoUrl in self.cacheLinks[key][idx]['url']:
                        if not self.cacheLinks[key][idx]['name'].startswith(
                                '*'):
                            self.cacheLinks[key][idx][
                                'name'] = '*' + self.cacheLinks[key][idx][
                                    'name']
                        break

        urlParams = dict(self.defaultParams)
        urlParams['header'] = dict(urlParams['header'])
        urlParams['header']['Referer'] = str(
            videoUrl.meta.get('Referer', self.getMainUrl()))

        sts, data = self.getPage(videoUrl, urlParams)
        if not sts:
            return urlTab
        cUrl = data.meta['url']

        playerData = self.cm.ph.getDataBeetwenNodes(
            data, ('<input', '>', 'urlEmbed'), ('<iframe', '>'))[1]
        if playerData == '':
            printDBG('Missig player data')
            return urlTab
        playerData = self.cm.ph.getSearchGroups(
            playerData, '''value=['"]([^'^"]+?)['"]''')[0]
        printDBG('PLAYER_DATA: %s\n' % playerData)

        if self.cacheJSCode == '':
            jsUrl = ''
            data = re.compile('''<script[^>]+?src=['"]([^'^"]+?)['"]''',
                              re.I).findall(data)
            for item in data:
                if 'filmlive' not in item:
                    continue
                jsUrl = self.cm.getFullUrl(item, self.cm.getBaseUrl(cUrl))
                break

            sts, data = self.getPage(jsUrl, urlParams)
            if not sts:
                return urlTab
            try:
                idxS = data.find('function clearify')
                num = 1
                idx = data.find('{', idxS)
                for idx in range(idx + 1, len(data), 1):
                    if data[idx] == '{':
                        num += 1
                    if data[idx] == '}':
                        num -= 1
                    if num == 0:
                        printDBG("JS_CODE_IDX: [%s:%s]" % (idxS, idx))
                        break

                jscode = data[idxS:idx + 1]
                printDBG('JS_CODE: %s\n' % jscode)
                self.cacheJSCode = jscode
            except Exception:
                printExc()

        jscode = [
            'var $={base64:function(not_used,e){e.length%4==3&&(e+="="),e.length%4==2&&(e+="=="),e=Duktape.dec("base64",e),decText="";for(var t=0;t<e.byteLength;t++)decText+=String.fromCharCode(e[t]);return decText},trim:function(e){return null==e?"":(e+"").replace(n,"")}};',
            self.cacheJSCode,
            'print(clearify("%s"))' % playerData
        ]
        ret = js_execute('\n'.join(jscode))
        if ret['sts'] and 0 == ret['code']:
            printDBG(ret['data'])
            urlTab = self.up.getVideoLinkExt(ret['data'])
        return urlTab
Esempio n. 37
0
    def getDirectLinks(self,
                       url,
                       formats='flv, mp4',
                       dash=True,
                       dashSepareteList=False,
                       allowVP9=None,
                       allowAgeGate=None):
        printDBG('YouTubeParser.getDirectLinks')
        list = []
        try:
            if self.cm.isValidUrl(url) and '/channel/' in url and url.endswith(
                    '/live'):
                sts, data = self.cm.getPage(url)
                if sts:
                    videoId = self.cm.ph.getSearchGroups(
                        data,
                        '''<meta[^>]+?itemprop=['"]videoId['"][^>]+?content=['"]([^'^"]+?)['"]'''
                    )[0]
                    if videoId == '':
                        videoId = self.cm.ph.getSearchGroups(
                            data,
                            '''['"]REDIRECT_TO_VIDEO['"]\s*\,\s*['"]([^'^"]+?)['"]'''
                        )[0]
                    if videoId != '':
                        url = 'https://www.youtube.com/watch?v=' + videoId
            list = YoutubeIE()._real_extract(url,
                                             allowVP9=allowVP9,
                                             allowAgeGate=allowAgeGate)
        except Exception:
            printExc()
            if dashSepareteList:
                return [], []
            else:
                return []

        reNum = re.compile('([0-9]+)')
        retHLSList = []
        retList = []
        dashList = []
        # filter dash
        dashAudioLists = []
        dashVideoLists = []
        if dash:
            # separete audio and video links
            for item in list:
                if 'mp4a' == item['ext']:
                    dashAudioLists.append(item)
                elif item['ext'] in ('mp4v', 'webmv'):
                    dashVideoLists.append(item)
                elif 'mpd' == item['ext']:
                    tmpList = getMPDLinksWithMeta(item['url'], checkExt=False)
                    printDBG(tmpList)
                    for idx in range(len(tmpList)):
                        tmpList[idx]['format'] = "%sx%s" % (tmpList[idx].get(
                            'height', 0), tmpList[idx].get('width', 0))
                        tmpList[idx]['ext'] = "mpd"
                        tmpList[idx]['dash'] = True
                    dashList.extend(tmpList)
            # sort by quality -> format
            def _key(x):
                if x['format'].startswith('>'):
                    int(x['format'][1:-1])
                else:
                    int(ph.search(x['format'], reNum)[0])

            dashAudioLists = sorted(dashAudioLists, key=_key, reverse=True)
            dashVideoLists = sorted(dashVideoLists, key=_key, reverse=True)

        for item in list:
            printDBG(">>>>>>>>>>>>>>>>>>>>>")
            printDBG(item)
            printDBG("<<<<<<<<<<<<<<<<<<<<<")
            if -1 < formats.find(item['ext']):
                if 'yes' == item['m3u8']:
                    format = re.search('([0-9]+?)p$', item['format'])
                    if format != None:
                        item['format'] = format.group(1) + "x"
                        item['ext'] = item['ext'] + "_M3U8"
                        item['url'] = decorateUrl(item['url'],
                                                  {"iptv_proto": "m3u8"})
                        retHLSList.append(item)
                else:
                    format = re.search('([0-9]+?x[0-9]+?$)', item['format'])
                    if format != None:
                        item['format'] = format.group(1)
                        item['url'] = decorateUrl(item['url'])
                        retList.append(item)

        if len(dashAudioLists):
            # use best audio
            for item in dashVideoLists:
                item = dict(item)
                item["url"] = decorateUrl(
                    "merge://audio_url|video_url", {
                        'audio_url': dashAudioLists[0]['url'],
                        'video_url': item['url']
                    })
                dashList.append(item)

        # try to get hls format with alternative method
        if 0 == len(retList):
            try:
                video_id = YoutubeIE()._extract_id(url)
                url = 'http://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1' % video_id
                sts, data = self.cm.getPage(
                    url, {
                        'header': {
                            'User-agent':
                            'Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B334b Safari/531.21.10'
                        }
                    })
                if sts:
                    data = data.replace('\\"', '"').replace('\\\\\\/', '/')
                    hlsUrl = self.cm.ph.getSearchGroups(
                        data, '''"hlsvp"\s*:\s*"(https?://[^"]+?)"''')[0]
                    hlsUrl = json_loads('"%s"' % hlsUrl)
                    if self.cm.isValidUrl(hlsUrl):
                        hlsList = getDirectM3U8Playlist(hlsUrl)
                        if len(hlsList):
                            dashList = []
                            for item in hlsList:
                                item['format'] = "%sx%s" % (item.get(
                                    'with', 0), item.get('heigth', 0))
                                item['ext'] = "m3u8"
                                item['m3u8'] = True
                                retList.append(item)
            except Exception:
                printExc()
            if 0 == len(retList):
                retList = retHLSList

            if dash:
                try:
                    sts, data = self.cm.getPage(
                        url, {
                            'header': {
                                'User-agent':
                                'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36'
                            }
                        })
                    data = data.replace('\\"',
                                        '"').replace('\\\\\\/',
                                                     '/').replace('\\/', '/')
                    dashUrl = self.cm.ph.getSearchGroups(
                        data, '''"dashmpd"\s*:\s*"(https?://[^"]+?)"''')[0]
                    dashUrl = json_loads('"%s"' % dashUrl)
                    if '?' not in dashUrl: dashUrl += '?mpd_version=5'
                    else: dashUrl += '&mpd_version=5'
                    printDBG("DASH URL >> [%s]" % dashUrl)
                    if self.cm.isValidUrl(dashUrl):
                        dashList = getMPDLinksWithMeta(dashUrl, checkExt=False)
                        printDBG(dashList)
                        for idx in range(len(dashList)):
                            dashList[idx]['format'] = "%sx%s" % (
                                dashList[idx].get('height', 0),
                                dashList[idx].get('width', 0))
                            dashList[idx]['ext'] = "mpd"
                            dashList[idx]['dash'] = True
                except Exception:
                    printExc()

        for idx in range(len(retList)):
            if retList[idx].get('m3u8', False):
                retList[idx]['url'] = strwithmeta(
                    retList[idx]['url'], {'iptv_m3u8_live_start_index': -30})

        if dashSepareteList:
            return retList, dashList
        else:
            retList.extend(dashList)
            return retList
Esempio n. 38
0
    def getVideoLinks(self, videoUrl):
        printDBG("BSTO.getVideoLinks [%s]" % videoUrl)
        urlTab = []
        
        key = strwithmeta(videoUrl).meta.get('links_key', '')
        if key in self.cacheLinks:
            for idx in range(len(self.cacheLinks[key])):
                if self.cacheLinks[key][idx]['url'] == videoUrl and not self.cacheLinks[key][idx]['name'].startswith('*'):
                    self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
        
        sts, data = self.getPage(videoUrl)
        if not sts: 
            return []
        
        #printDBG("---------------------------")
        #printDBG(data)
        #printDBG("---------------------------")
        
        errorMsgTab = []
        
        # LID
        #<div class="hoster-player" data-lid="4778534">
        # token
        #<meta name="security_token" content="edfafd7a9fa9a7d005f88c96" />
        # ticket <- token from recaptcha
        # recaptcha sitekey
        #series.init (1, 1, '6LeiZSYUAAAAAI3JZXrRnrsBzAdrZ40PmD57v_fs')
        
        lid = self.cm.ph.getSearchGroups(data, "data-lid=['\"]([^'^\"]+?)['\"]")[0]
        printDBG("Data LID : %s " % lid)
        
        token = self.cm.ph.getSearchGroups(data, "<meta.*security_token.*content=\"(.*?)\"")[0]
        printDBG("Security token : %s " % token)
        
        if not lid or not token:
            return []
        
        sitekey = self.cm.ph.getSearchGroups(data, "'([0-9a-zA-Z_]{38,}?)'\)")[0]
        
        if sitekey != '':
            ticket, errorMsgTab = self.processCaptcha(sitekey,  self.cm.meta['url'], bypassCaptchaService=config.plugins.iptvplayer.bsto_bypassrecaptcha.value)
            if not ticket :
                SetIPTVPlayerLastHostError(errorMsgTab)
                return []
        
        printDBG("ticket: %s" % ticket)
                
        # post data
        postData = {'token': token, 'LID': lid, 'ticket': ticket}
        ajaxUrl = self.MAIN_URL + "ajax/embed.php"
        ajaxParams = self.defaultParams
        ajaxParams['header']= self.AJAX_HEADER
        ajaxParams['header']['Referer'] = videoUrl
         
        sts, ajaxData = self.cm.getPage(ajaxUrl, ajaxParams, post_data=postData)
        if not sts: 
            return []

        printDBG("----------- ajax data ----------")
        printDBG(ajaxData)
        printDBG("--------------------------------")
        # {"success":true,"link":"https:\/\/vivo.sx\/2eaf981402","embed":"0"}
        
        jsonData = json_loads(ajaxData) 
        
        hostUrl = jsonData.get('link','')
        
        if hostUrl:
            if 1 != self.up.checkHostSupport(hostUrl):
                SetIPTVPlayerLastHostError('\n'.join(errorMsgTab)) 
            elif self.cm.isValidUrl(hostUrl):
                BSTO.LINKS_CACHE[lid] = hostUrl
                if config.plugins.iptvplayer.bsto_linkcache.value:
                    WriteTextFile(GetCacheSubDir('bs.to', lid), hostUrl)
                urlTab = self.up.getVideoLinkExt(hostUrl)
        
        return urlTab
Esempio n. 39
0
 def getLinksForVideo(self, cItem):
     printDBG("YifyTV.getLinksForVideo [%s]" % cItem)
     
     urlTab = self.cacheLinks.get(cItem['url'], [])
     if len(urlTab): return urlTab
     
     url = cItem['url']
     if not url.endswith('/'): url += '/'
     sts, data = self.getPage(url + 'watching/?playermode=')
     if not sts: return urlTab
     
     printDBG("+++++++++++++++++++++++  data  ++++++++++++++++++++++++")
     printDBG(data)
     printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
     
     trailer = self.cm.ph.getDataBeetwenReMarkers(data, re.compile('''<a[^>]+?class=['"]video'''), re.compile('''</a>'''))[1]
     trailerUrl  = self.cm.ph.getSearchGroups(trailer, '''href=['"](https?://[^'^"]+?)['"]''')[0]
     
     imdbid = self.cm.ph.getSearchGroups(data, '''var\s+imdbid\s*=\s*['"]([^'^"]+?)['"]''')[0]
     
     jscode = '$ = function(){return {ready:function(){}}};\n' + self.cm.ph.getDataBeetwenMarkers(data, 'function autoPlay()', '</script>')[1][:-9]
     try:
         jscode = base64.b64decode('''dmFyIGRvY3VtZW50ID0ge307DQp2YXIgd2luZG93ID0gdGhpczsNCnZhciBsb2NhdGlvbiA9IHt9Ow0KbG9jYXRpb24uaG9zdG5hbWUgPSAiJXMiOw0KbG9jYXRpb24udG9TdHJpbmcgPSBmdW5jdGlvbigpew0KICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAiJXMiOw0KICAgICAgICAgICAgICAgICAgICB9Ow0KJXM7DQoNCnByaW50KHdpbmRvdy5wYXJhbWV0cm9zKQ==''') % (self.up.getDomain(self.getMainUrl()), self.getMainUrl(), jscode)
         printDBG("+++++++++++++++++++++++  CODE  ++++++++++++++++++++++++")
         printDBG(jscode)
         printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
         ret = iptv_js_execute( jscode )
         if ret['sts'] and 0 == ret['code']:
             decoded = ret['data'].strip()
             printDBG('DECODED DATA -> [%s]' % decoded)
         data = decoded
     except Exception:
         printExc()
     
     sub_tracks = []
     subLangs = self.cm.ph.getSearchGroups(data, '&sub=([^&]+?)&')[0]
     if subLangs == '':
         tmp = re.compile("\=([^&]*?)&").findall(data)
         for it in tmp:
             for e in ['PT2', 'EN', 'FR', 'ES']:
                 if e in it:
                     subLangs = it
                     break
             if '' != subLangs:
                 break
     
     if subLangs != '':
         subID    = self.cm.ph.getSearchGroups(data, '&id=(tt[^&]+?)&')[0]
         if subID == '':
             subID    = self.cm.ph.getSearchGroups(data, '&pic=(tt[^&]+?)&')[0]
         subLangs = subLangs.split(',')
         for lang in subLangs:
             if subID != '':
                 sub_tracks.append({'title':lang, 'url':'https://ymovies.tv/player/bajarsub.php?%s_%s' % (subID, lang), 'lang':lang, 'format':'srt'})
     
     data = data.split('&')
     idx = 1
     for item in data:
         tmp = item.split('=')
         if len(tmp)!= 2: continue
         if tmp[1].endswith('enc'):
             url = strwithmeta(tmp[1], {'Referer': cItem['url'], 'sou':tmp[0], 'imdbid':imdbid, 'external_sub_tracks':sub_tracks})
             urlTab.append({'name':_('Mirror') + ' %s' % idx, 'url':url, 'need_resolve':1})
         elif '' != self.VIDEO_HOSTINGS_MAP.get(tmp[0], ''):
             url = self.VIDEO_HOSTINGS_MAP[tmp[0]].format(tmp[1])
             url = strwithmeta(url, {'Referer': cItem['url'], 'imdbid':imdbid, 'external_sub_tracks':sub_tracks})
             urlTab.append({'name':_('Mirror') + ' %s [%s]' % (idx, self.up.getHostName(url)), 'url':url, 'need_resolve':1})
         idx += 1
     
     if len(urlTab):
         self.cacheLinks[cItem['url']] = urlTab
     
     if self.cm.isValidUrl(trailerUrl) and 1 == self.up.checkHostSupport(trailerUrl):
         urlTab.insert(0, {'name':self.cleanHtmlStr(trailer), 'url':trailerUrl, 'need_resolve':1})
     
     return urlTab
    def getVideoLinks(self, baseUrl):
        printDBG("YifyTV.getVideoLinks [%s]" % baseUrl)
        
        # mark requested link as used one
        if len(self.cacheLinks.keys()):
            for key in self.cacheLinks:
                for idx in range(len(self.cacheLinks[key])):
                    if baseUrl in self.cacheLinks[key][idx]['url']:
                        if not self.cacheLinks[key][idx]['name'].startswith('*'):
                            self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
                        break
        
        urlTab = []
        
        baseUrl = strwithmeta(baseUrl)
        imdbid  = baseUrl.meta.get('imdbid', '')
        sub_tracks = baseUrl.meta.get('external_sub_tracks', [])
        
        header = dict(self.AJAX_HEADER)
        #header['Referer'] = baseUrl.meta['Referer']
        
        if 'sou' in baseUrl.meta:
            souTab = [baseUrl.meta['sou']]
            if souTab[0] == 'pic':
                souTab.append('adr')
            if souTab[0] == 'adr':
                souTab.append('pic')
            
            for sou in souTab:
                post_data = {'fv':'27', 'url':baseUrl, 'sou':sou}
                url = 'https://ymovies.se/playerlite/pk/pk/plugins/player_p2.php'
                sts, data = self.getPage(url, {'header':header}, post_data)
                if not sts: 
                    return []
                
                printDBG("+++++++++++    player_p2.php javascript code  +++++++++")
                printDBG(data)
                printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
                
                if 'jscode' in data:
                        data = byteify(json_loads(data))[0]['jscode'][1:-1] 
                        if 'eval(' in data:
                            evalCode = self.cm.ph.getSearchGroups(data, "(eval\(.*?\));")[0]
                            evalCode2 = evalCode[5:-1]
                            evalCodeSub = "print(" + evalCode2 + ");\n" + evalCode
                            printDBG("eval code: %s, %s ----> %s" % (evalCode, evalCode2, evalCodeSub));
                            data = data.replace(evalCode,evalCodeSub)

                        jsTab = ['']
                        jsTab.append('''var iptv_href="%s"; var iptv_domain="%s"; var iptv_video_id="%s"; var iptv_jwpath="%s";\n''' % (self.getMainUrl(), self.up.getDomain(self.getMainUrl()), imdbid, url))
                        jsTab.append(base64.b64decode('''ZnVuY3Rpb24gU2hvd0Rpdigpe31mdW5jdGlvbiBzaG93aUZyYW1lKCl7cHJpbnQoYXJndW1lbnRzWzBdKX1mdW5jdGlvbiBnZXRKd1BhdGgoKXtyZXR1cm4gaXB0dl9qd3BhdGh9ZnVuY3Rpb24gZ2V0X3BhcmFtc19ub19zb3JjZXMoKXtyZXR1cm4gaXB0dl92aWRlb19pZH1mdW5jdGlvbiBzZXRUaW1lb3V0KHQsbil7aWYoaXB0dl9kaXJlY3QpdHJ5e3QoKX1jYXRjaChlKXtwcmludCgiXG4iKX1lbHNlIHRoaXMudHJ5dXAoKX12YXIgZG9jdW1lbnQ9e30sd2luZG93PXRoaXMsbG9jYXRpb249e307bG9jYXRpb24uaHJlZj1pcHR2X2hyZWYsbG9jYXRpb24uaG9zdG5hbWU9aXB0dl9kb21haW4sbG9jYXRpb24udG9TdHJpbmc9ZnVuY3Rpb24oKXtyZXR1cm4gaXB0dl9ocmVmfSxkb2N1bWVudC5sb2NhdGlvbj1sb2NhdGlvbjt2YXIgZWxlbWVudD1mdW5jdGlvbih0KXt0aGlzLnRleHQ9ZnVuY3Rpb24oKXtyZXR1cm4ibm9uZSJ9LHRoaXMuZmlyc3Q9ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IGVsZW1lbnR9fSwkPWZ1bmN0aW9uKHQpe3JldHVybiBuZXcgZWxlbWVudCh0KX0scGxheWVybW9kZT0iIixzb3VyY2VTZWxlY3RlZD0wLHNvdXJjZXM9W3tzdWJfZGVsYXk6MCxzdWJfZmFjdG9yOjF9XTskLmdldD1mdW5jdGlvbigpe3JldHVybiBwcmludChhcmd1bWVudHNbMF0pLHtkb25lOlNob3dEaXYsZXJyb3I6U2hvd0Rpdn19LCQucG9zdD1mdW5jdGlvbigpe3ByaW50KCJcbklQVFZfUE9TVF9TVEFSVFxuIikscHJpbnQoSlNPTi5zdHJpbmdpZnkoe3VybDphcmd1bWVudHNbMF0scGFyYW1zOmFyZ3VtZW50c1sxXX0pKSxwcmludCgiXG5JUFRWX1BPU1RfRU5EXG4iKX07'''))

                        jsTab.append('var iptv_fun = %s; iptv_fun();' % data)

                        for iptv_direct in ["false", "true"]:
                            jsTab[0] = 'var iptv_direct = %s;' % iptv_direct
                            jscode = '\n'.join(jsTab)
                            printDBG("+++++++++++++ code after replaces ++++++++++++++++++++++++")
                            printDBG(jscode)
                            printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
                            ret = js_execute( jscode )

                            if ret['sts']: #and 0 == ret['code']:
                                decoded = ret['data'].strip()
                                printDBG('DECODED DATA -> [%s]' % decoded)

                                # various forms of data answer

                                try_url = decoded.split('\n')[-1]
                                if self.cm.isValidUrl(try_url):
                                    urlTab.extend(self.up.getVideoLinkExt(try_url))

                                    break

                                elif 'parseRes2' in decoded:
                                    printDBG("Search for ParseRes2 argument")
                                    prData = self.cm.ph.getSearchGroups(decoded, "parseRes2\(\"(.*?)\"\)")[0]    
                                    printDBG("ParseRes2 function argument : %s" % prData)

                                    #decoded2 = json_loads(prData.replace('\"','"'))

                                    decoded2 = json_loads(eval('"'+ prData + '"'))
                                    printDBG("------------decoded2-------------")
                                    printDBG(str(decoded2))

                                    for l in decoded2:
                                        if 'url' in l: 
                                            if l['url'].endswith('.m3u8'):
                                                params = getDirectM3U8Playlist(self.getFullUrl(l['url']), checkExt=False, variantCheck=True, checkContent=True, sortWithMaxBitrate=99999999)
                                                printDBG(str(params))
                                                urlTab.extend(params)  
                                            else:
                                                if not 'image' in l.get('type',''):
                                                    params = {'name': l.get('type','link'), 'url': self.getFullUrl(l['url']) }
                                                    printDBG(str(params))
                                                    urlTab.append(params)
                                    break
                                    
                                elif 'showiFrame' in decoded:
                                    arg = self.cm.ph.getSearchGroups(decoded, "showiFrame\(['\"](.*?)['\"]\)")[0]
                                    printDBG("Search for showiFrame argument: %s " % arg)

                                    if 'emb=' in decoded:
                                        url = urllib.unquote(self.cm.ph.getDataBeetwenMarkers(decoded, "emb='+'", "*", False)[1])
                                        if not url:
                                            url = urllib.unquote(self.cm.ph.getDataBeetwenMarkers(decoded, "emb='+'", "'", False)[1])

                                        printDBG("---> found url: %s " % url)
                                        if 'sub.file' in url:
                                            tmp = url.split('sub.file')
                                            url = tmp[0]
                                            subTrack = urllib.unquote(tmp[1])
                                            if url.startswith('//'):
                                                url = 'http:' + url
                                            if subTrack.startswith('//'):
                                                subTrack = 'http:' + subTrack
                                            tmpUrlTab = self.up.getVideoLinkExt(url)
                                            if self.cm.isValidUrl(subTrack):
                                                format = subTrack[-3:]
                                                for idx in range(len(tmpUrlTab)):
                                                    tmpUrlTab[idx]['url'] = strwithmeta(tmpUrlTab[idx]['url'], {'external_sub_tracks':[{'title':'', 'url':subTrack, 'lang':'en', 'format':format}]})
                                            urlTab.extend(tmpUrlTab)
                                            printDBG(urlTab)
                                        else:
                                            urlTab.extend(self.up.getVideoLinkExt(url))
                                        
                                    else:    
                                        if self.cm.isValidUrl(arg):
                                            urlTab = self.up.getVideoLinkExt(arg)
                                    
                                    break
                                    
                                elif 'sources[sourceSelected]["paramId"]' in decoded:
                                    data = data.replace('"+"', '').replace(' ', '')
                                    paramSite = self.cm.ph.getSearchGroups(data, 'sources\[sourceSelected\]\["paramSite"\]="([^"]+?)"')[0]
                                    data = self.cm.ph.getSearchGroups(data, 'sources\[sourceSelected\]\["paramId"\]="([^"]+?)"')[0]
                                    printDBG('data ------------------------- [%s]' % data)
                                    if data.startswith('enc'):
                                        encrypted = base64.b64decode(data[3:])
                                        key = unhexlify(base64.b64decode('MzAzOTM4NzMzOTM3MzU0MTMxMzIzMzczMzEzMzM1NjQ2NDY2Njc3NzQ4MzczODM0MzczNTMzMzQzNjcyNjQ3Nw=='))
                                        iv = unhexlify(base64.b64decode('NWE0MTRlMzEzNjMzNjk2NDZhNGM1MzUxMzU0YzY0MzU='))
                                        cipher = AES_CBC(key=key, padding=noPadding(), keySize=32)
                                        data = cipher.decrypt(encrypted, iv).split('\x00')[0]
                                        if 'ucl' == paramSite:
                                            params = self.up.getVideoLinkExt("https://userscloud.com/embed-" + data + "-1280x534.html")
                                            printDBG(str(params))
                                            urlTab.extend(params)
                                        elif 'tus' == paramSite:
                                            params = self.up.getVideoLinkExt("https://tusfiles.net/embed-" + data + "-1280x534.html?v=34")
                                            printDBG(str(params))
                                            urlTab.extend(params)
                                        elif 'up' == paramSite:
                                            params = self.up.getVideoLinkExt("http://uptobox.com/" + data)
                                            printDBG(str(params))
                                            urlTab.extend(params)
                                        break

                                elif 'IPTV_POST_START' in decoded:
                                    data = self.cm.ph.getDataBeetwenMarkers(data, 'IPTV_POST_START', 'IPTV_POST_END', 0)[1]
                                    try:
                                        tmp = byteify(json_loads(data.strip()))
                                        sts, data = self.getPage(tmp['url'], {'header':header, 'raw_post_data':True}, tmp['params'])
                                        if not sts: return []
                                        tmp = byteify(json_loads(data))
                                        for hostDomain in tmp['hosts']:
                                            params = {'name':hostDomain, 'url':'http://%s%s' % (hostDomain, tmp['path'])}
                                            printDBG(str(params))
                                            urlTab.append(params)
                                        if len(urlTab): break
                                    except Exception:
                                        printExc()

                                else:
                                    data = json_loads(decoded)
            
        elif self.cm.isValidUrl(baseUrl):
            urlTab = self.up.getVideoLinkExt(baseUrl)
        
        printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
        printDBG(urlTab)
        
        for idx in range(len(urlTab)):
            subs = list(strwithmeta(urlTab[idx]['url']).meta.get('external_sub_tracks', []))
            subs.extend(sub_tracks)
            urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'], {'external_sub_tracks':subs})
        
        printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
        printDBG(urlTab)
        return urlTab
    def getLinksForVideo(self, cItem):
        printDBG("YifyTV.getLinksForVideo [%s]" % cItem)
        
        urlTab = self.cacheLinks.get(cItem['url'], [])
        if len(urlTab): 
            return urlTab

        url = cItem['url']
        if not url.endswith('/'): 
            url += '/'

        sts, data = self.getPage(url + 'watching/?playermode=')
        if not sts: 
            return urlTab
        
        #printDBG("+++++++++++++++++++++++  data  ++++++++++++++++++++++++")
        #printDBG(data)
        #printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
        
        trailer = self.cm.ph.getDataBeetwenReMarkers(data, re.compile('''<a[^>]+?class=['"]video'''), re.compile('''</a>'''))[1]
        trailerUrl  = self.cm.ph.getSearchGroups(trailer, '''href=['"](https?://[^'^"]+?)['"]''')[0]
        
        imdbid = self.cm.ph.getSearchGroups(data, '''var\s+imdbid\s*=\s*['"]([^'^"]+?)['"]''')[0]
        
        videoTable = self.cm.ph.getDataBeetwenMarkers(data, ("<table", ">","videos-table"), "</table>")[1]
        mirrors= self.cm.ph.getAllItemsBeetwenMarkers(videoTable, "<tr><td data-label", "</tr>")
        
        for mirror in mirrors:

            name = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(mirror, ("<h6",">"), "</h6>", False)[1])
        
            quality = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(mirror, ("<td",">","Quality"), "</td>", False)[1])
            if quality:
                name = name + " " + quality
            
            lang = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(mirror, ("<td",">","Language"), "</td>", False)[1])
            if lang:
                name = name + " " + lang
                
            subtitle = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(mirror, ("<td",">","Subtitle"), "</td>", False)[1])

            if len(subtitle)>0 and (not "n/d" in subtitle.lower()):
                name = name + " " + subtitle
            
            printDBG("mirror name : %s" % name)

            jscode = self.cm.ph.getDataBeetwenMarkers(mirror, ("<script",">"), "</script>", False)[1]
            
            if jscode:
                jscode = "var window={ eval: function(t){ console.log(t); } }; \n\n " + jscode
                
                #printDBG("+++++++++++++++++++++++  CODE  ++++++++++++++++++++++++")
                #printDBG(jscode)
                #printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
                ret = js_execute( jscode )

                if ret['sts'] and 0 == ret['code']:
                    action_params = self.cm.ph.getSearchGroups(ret['data'], "ajaxActionGet\(([^\)]+?)\)")[0]
                    sec = "play"
                    ajax_url = self.AJAX_URL + eval(action_params)
            
                    printDBG("ajax url: %s" % ajax_url)
            
                    params = {'header':self.AJAX_HEADER, 'use_cookie': True, 'load_cookie': True, 'save_cookie': True, 'cookiefile': self.COOKIE_FILE}
                    params['header']['Referer'] = url
        
                    sts, ajaxData = self.cm.getPage(ajax_url, params)  
            
                    if sts:
                        #printDBG("-------------")
                        #printDBG( ajaxData)
                        #printDBG("-------------")

                        try:
                            response = json_loads(ajaxData)
                        
                            htmlcode = response["htmlcode"]
                            #printDBG(htmlcode)
                        
                            objs = re.findall("(\{[^\}]+?\})", htmlcode)
                        
                            for obj in objs:
                                if "linkTo" in obj:
                                    printDBG("-------------------")
                                    printDBG(obj)
                                    printDBG("-------------------")
                        
                                    try:
                                        videoData=json_loads(obj)
                                        videoUrl = videoData["linkTo"]
                                        #printDBG("mirror video url : %s" % videoUrl)
                                        
                                        videoUrl = strwithmeta(videoUrl, {'Referer': cItem['url'], 'imdbid':imdbid}) #'external_sub_tracks':sub_tracks})
                                        params = {'name': name, 'url': videoUrl, 'need_resolve':1}
                                        printDBG(str(params))
                                        urlTab.append(params)
                                        
                                    except:
                                        printExc()
                        
                                    break
                        except:
                            printExc()

        if len(urlTab):
            self.cacheLinks[cItem['url']] = urlTab

        if self.cm.isValidUrl(trailerUrl) and 1 == self.up.checkHostSupport(trailerUrl):
            if not 'listType'in trailerUrl:
                params = {'name':self.cleanHtmlStr(trailer), 'url':trailerUrl, 'need_resolve':1}
                printDBG(str(params))
                urlTab.insert(0, params)

        return urlTab
Esempio n. 42
0
    def exploreItem(self, cItem):
        printDBG("HDSTo.exploreItem")
        self.cacheLinks = {}

        sts, data = self.getPage(cItem['url'])
        if not sts: return
        cUrl = self.getFullUrl(self.cm.meta['url'])
        self.setMainUrl(cUrl)

        sTtile = self.cleanHtmlStr(
            self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'title-holder'),
                                           ('</h', '>'), False)[1])
        desc = ''

        tmp = self.cm.ph.getAllItemsBeetwenNodes(data, ('<a', '>', 'iframe'),
                                                 ('</a', '>'))
        for item in tmp:
            if 'file-video-o' not in item: continue
            title = self.cleanHtmlStr(item)
            url = self.getFullUrl(
                self.cm.ph.getSearchGroups(item, '''href=['"]([^"^']+?)["']''',
                                           1, True)[0], cUrl)
            if url == '': continue
            self.cacheLinks[url] = [{
                'name': '',
                'url': strwithmeta(url, {'Referer': cUrl}),
                'need_resolve': 1
            }]

            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'title': sTtile + '- ' + title,
                'url': strwithmeta(url, {'Referer': cUrl}),
                'desc': desc,
                'prev_url': cUrl
            })
            self.addVideo(params)

        sts, tmp = self.cm.ph.getDataBeetwenNodes(
            data, ('<a', '</a>', 'fa-language'), ('<', '>'))
        if sts:
            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'title': sTtile,
                'url': strwithmeta(cUrl, {'Referer': cUrl}),
                'desc': desc,
                'prev_url': cUrl
            })
            self.addVideo(params)
            self.cacheLinks[cUrl] = [{
                'name':
                '',
                'url':
                strwithmeta(cUrl, {'Referer': cUrl}),
                'need_resolve':
                1
            }]

            url = self.getFullUrl(
                self.cm.ph.getSearchGroups(tmp, '''href=['"]([^"^']+?)["']''',
                                           1, True)[0], cUrl)
            title = self.cleanHtmlStr(tmp)
            if url != '':
                params = dict(cItem)
                params.update({
                    'good_for_fav': False,
                    'title': sTtile + '- ' + title,
                    'url': strwithmeta(url, {'Referer': cUrl}),
                    'desc': desc,
                    'prev_url': cUrl
                })
                self.addVideo(params)
                self.cacheLinks[url] = [{
                    'name':
                    '',
                    'url':
                    strwithmeta(url, {'Referer': cUrl}),
                    'need_resolve':
                    1
                }]

        tmp = self.cm.ph.getDataBeetwenNodes(data, ('<ul', '>', 'collapsible'),
                                             ('</ul', '>'), False)[1]
        tmp = self.cm.ph.getAllItemsBeetwenMarkers(tmp, '<li', '</li>')
        for item in tmp:
            title = self.cleanHtmlStr(
                self.cm.ph.getDataBeetwenMarkers(item, '</i>', '<script>')[1])
            desc = self.cleanHtmlStr(
                self.cm.ph.getDataBeetwenMarkers(item, '<p', '</p>')[1])
            urls = []
            item = self.cm.ph.getAllItemsBeetwenMarkers(item, '<a', '</a>')
            for it in item:
                linkName = self.cleanHtmlStr(it)
                linkUrl = self.getFullUrl(
                    self.cm.ph.getSearchGroups(it,
                                               '''href=['"]([^"^']+?)["']''',
                                               1, True)[0], cUrl)
                if linkUrl == '': continue
                urls.append({
                    'name': linkName,
                    'url': strwithmeta(linkUrl, {'Referer': cUrl}),
                    'need_resolve': 1
                })

            if len(urls):
                url = cUrl + '#' + title
                self.cacheLinks[url] = urls
                params = dict(cItem)
                params.update({
                    'good_for_fav': False,
                    'title': sTtile + ' ' + title,
                    'url': strwithmeta(url, {'Referer': cUrl}),
                    'desc': desc,
                    'prev_url': cUrl
                })
                self.addVideo(params)
Esempio n. 43
0
    def getVideoLinks(self, videoUrl):
        printDBG("AnimeTo.getVideoLinks [%s]" % videoUrl)
        baseUrl = str(videoUrl)
        videoUrl = strwithmeta(videoUrl)
        urlTab = []

        # mark requested link as used one
        if len(self.cacheLinks.keys()):
            for key in self.cacheLinks:
                for idx in range(len(self.cacheLinks[key])):
                    if videoUrl in self.cacheLinks[key][idx]['url']:
                        if not self.cacheLinks[key][idx]['name'].startswith(
                                '*'):
                            self.cacheLinks[key][idx][
                                'name'] = '*' + self.cacheLinks[key][idx][
                                    'name']
                        break

        #sts, data = self.getPage(self.getFullUrl('token'))
        #if not sts: return []
        #cookieItem = self.uncensored(data)

        id = videoUrl.meta.get('id', '')
        params = dict(self.defaultParams)
        params['header'] = dict(self.AJAX_HEADER)
        params['header']['Referer'] = str(videoUrl)
        #params['cookie_items'] = cookieItem

        #sts, data = self.getPage('https://9anime.to/ajax/episode/info?id=%s&update=0' % id, params)
        #if not sts: return []

        sts, data = self.getPage(videoUrl[:videoUrl.rfind('/')], params)
        if sts:
            timestamp = self.cm.ph.getSearchGroups(
                data, '''data-ts=['"]([^"^']+?)['"]''')[0]
        else:
            timestamp = ''

        if timestamp == '':
            sts, data = self.getPage(videoUrl, params)
            if not sts: return []
            timestamp = self.cm.ph.getSearchGroups(
                data, '''data-ts=['"]([^"^']+?)['"]''')[0]

        getParams = {
            'ts': timestamp,
            'id': videoUrl.meta.get('id', ''),
            'Q': '1'
        }
        getParams = self._updateParams(getParams)
        url = self.getFullUrl('/ajax/film/update-views?' +
                              urllib.urlencode(getParams))
        sts, data = self.getPage(url, params)
        if not sts: return []

        m = "++++++++++++++++++++++++++++++++"
        printDBG('%s\n%s\n%s' % (m, data, m))

        getParams = {
            'ts': timestamp,
            'id': videoUrl.meta.get('id', ''),
            'update': '0'
        }
        getParams = self._updateParams(getParams)
        printDBG(
            ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> timestamp[%s]"
            % timestamp)
        url = self.getFullUrl('/ajax/episode/info?' +
                              urllib.urlencode(getParams))
        sts, data = self.getPage(url, params)
        if not sts: return []

        videoUrl = ''
        subTrack = ''
        try:
            data = byteify(json.loads(data))
            printDBG(data)
            subTrack = data.get('subtitle', '')
            if data['type'] == 'iframe':
                videoUrl = self._updateParams({'url': data['target']},
                                              False)['url']
                if videoUrl.startswith('//'): videoUrl = 'http:' + videoUrl
            elif data['type'] == 'direct':
                printDBG("----------------------------------------------")
                printDBG(data)
                printDBG("----------------------------------------------")
                query = self._updateParams(dict(data['params']), False)
                query.update({'mobile': '0'})
                url = data['grabber']
                if '?' in url: url += '&'
                else: url += '?'
                url += urllib.urlencode(query)
                sts, data = self.getPage(url, params)
                if not sts: return []
                data = byteify(json.loads(data))
                for item in data['data']:
                    if item['type'] != 'mp4': continue
                    if not self.cm.isValidUrl(item['file']): continue
                    urlTab.append({'name': item['label'], 'url': item['file']})
                urlTab = urlTab[::-1]
            else:
                printDBG('Unknown url type!')
                printDBG(">>>>>>>>>>>>>>>>>>>>>")
                printDBG(data)
                printDBG("<<<<<<<<<<<<<<<<<<<<<")
        except Exception:
            printExc()

        if self.cm.isValidUrl(videoUrl) and 0 == len(urlTab):
            urlTab = self.up.getVideoLinkExt(
                strwithmeta(videoUrl, {'Referer': baseUrl}))

        if self.cm.isValidUrl(subTrack):
            format = subTrack[-3:]
            for idx in range(len(urlTab)):
                urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'])
                if 'external_sub_tracks' not in urlTab[idx]['url'].meta:
                    urlTab[idx]['url'].meta['external_sub_tracks'] = []
                urlTab[idx]['url'].meta['external_sub_tracks'].append({
                    'title':
                    '',
                    'url':
                    subTrack,
                    'lang':
                    'pt',
                    'format':
                    format
                })

        return urlTab
Esempio n. 44
0
    def exploreItem(self, cItem, nextCategory):
        printDBG("AnimeTo.exploreItem")

        sts, data = self.getPage(cItem['url'])
        if not sts: return

        desc = self.cleanHtmlStr(
            self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'desc'),
                                           ('</div', '>'))[1])

        serverNamesMap = {}
        tmp = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'servers'),
                                             ('</div', '>'))[1]
        tmp = self.cm.ph.getAllItemsBeetwenNodes(data,
                                                 ('<span', '>', 'data-name'),
                                                 ('</span', '>'))
        for item in tmp:
            serverName = self.cleanHtmlStr(item)
            serverKey = self.cm.ph.getSearchGroups(
                item, '''\sdata\-name=['"]([^'^"]+?)['"]''')[0]
            serverNamesMap[serverKey] = serverName

        rangesTab = []
        self.cacheEpisodes = {}
        self.cacheLinks = {}
        data = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'data-name'),
                                              ('<script', '>'))[1]
        data = re.compile('''(<div[^>]+?server[^>]+?>)''').split(data)
        for idx in range(1, len(data), 2):
            if 'episodes' not in data[idx + 1]: continue
            serverKey = self.cm.ph.getSearchGroups(
                data[idx], '''\sdata\-name=['"]([^'^"]+?)['"]''')[0]
            serverName = serverNamesMap.get(serverKey, serverKey)

            rangeNameMap = {}
            tmp = self.cm.ph.getAllItemsBeetwenNodes(
                data[idx + 1], ('<span', '>', 'data-range-id'),
                ('</span', '>'))
            for item in tmp:
                rangeName = self.cleanHtmlStr(item)
                rangeKey = self.cm.ph.getSearchGroups(
                    item, '''\sdata\-range\-id=['"]([^'^"]+?)['"]''')[0]
                rangeNameMap[rangeKey] = rangeName

            tmp = self.cm.ph.getAllItemsBeetwenMarkers(data[idx + 1], '<ul',
                                                       '</ul>')
            for rangeSection in tmp:
                rangeKey = self.cm.ph.getSearchGroups(
                    rangeSection,
                    '''\sdata\-range\-id=['"]([^'^"]+?)['"]''')[0]
                rangeName = rangeNameMap.get(rangeKey, rangeKey)

                if rangeName not in rangesTab:
                    rangesTab.append(rangeName)
                    self.cacheEpisodes[rangeName] = []

                rangeSection = self.cm.ph.getAllItemsBeetwenMarkers(
                    rangeSection, '<li', '</li>')
                for item in rangeSection:
                    title = self.cleanHtmlStr(item)
                    id = self.cm.ph.getSearchGroups(
                        item, '''data-id=['"]([^'^"]+?)['"]''')[0]
                    url = self.getFullUrl(
                        self.cm.ph.getSearchGroups(
                            item, '''href=['"]([^'^"]+?)['"]''')[0])
                    if id == '' or url == '': continue
                    if title not in self.cacheEpisodes[rangeName]:
                        self.cacheEpisodes[rangeName].append(title)
                        self.cacheLinks[title] = []
                    url = strwithmeta(url, {'id': id})
                    self.cacheLinks[title].append({
                        'name': serverName,
                        'url': url,
                        'need_resolve': 1
                    })

        for item in rangesTab:
            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'category': nextCategory,
                'series_title': cItem['title'],
                'title': item,
                'desc': desc,
                'range_key': item
            })
            if 1 == len(rangesTab):
                self.listEpisodes(params)
                break
            self.addDir(params)
Esempio n. 45
0
    def _unshorten_iivpl(self, baseUri):
        baseUri = strwithmeta(baseUri)
        ref = baseUri.meta.get('Referer', baseUri)
        USER_AGENT = 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.0'
        HTTP_HEADER = {
            'User-Agent': USER_AGENT,
            'Accept': '*/*',
            'Accept-Encoding': 'gzip, deflate',
            'Referer': ref
        }
        HTTP_HEADER_AJAX = {
            'User-Agent': USER_AGENT,
            'Accept': '*/*',
            'Accept-Encoding': 'gzip, deflate',
            'Referer': baseUri,
            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
            'X-Requested-With': 'XMLHttpRequest'
        }

        COOKIE_FILE = GetCookieDir('iit.pl')
        tries = 0
        retUri, retSts = '', 'KO'
        while tries < 2 and retSts != 'OK':
            tries += 1
            rm(COOKIE_FILE)
            try:
                params = {
                    'header': HTTP_HEADER,
                    'use_cookie': True,
                    'load_cookie': True,
                    'save_cookie': True,
                    'cookiefile': COOKIE_FILE
                }

                sts, data = self.cm.getPage(baseUri, params)

                sts, headers = self.cm.getPage(
                    'http://iiv.pl/modules/system/assets/js/framework.js',
                    params)

                headers = self.cm.ph.getDataBeetwenMarkers(
                    headers, 'headers', '}')[1]
                headers = re.compile('''['"]([^'^"]+?)['"]''').findall(headers)
                salt = self.cm.ph.getSearchGroups(
                    data, '''data\-salt="([^"]+?)"''')[0]
                time = self.cm.ph.getSearchGroups(
                    data, '''data\-time="([^"]+?)"''')[0]
                action = self.cm.ph.getSearchGroups(
                    data, '''data\-action="([^"]+?)"''')[0]
                banner = self.cm.ph.getSearchGroups(
                    data, '''data\-banner="([^"]+?)"''')[0]
                component = self.cm.ph.getSearchGroups(
                    data, '''data\-component="([^"]+?)"''')[0]
                if tries > 1:
                    GetIPTVSleep().Sleep(int(time))

                sts, partials = self.cm.getPage(
                    'http://iiv.pl/themes/cutso/assets/javascript/shortcut/shortcut.js',
                    params)
                partials = self.cm.ph.getDataBeetwenMarkers(
                    partials, 'update:', '}')[1]
                partials = self.cm.ph.getSearchGroups(
                    partials, '''['"]([^'^"]+?)['"]''')[0]
                if partials == '':
                    partials = 'shortcut/link_show'
                for header in headers:
                    if 'HANDLER' in header:
                        HTTP_HEADER_AJAX[header] = action
                    elif 'PARTIALS' in header:
                        HTTP_HEADER_AJAX[header] = partials

                post_data = {'salt': salt, 'banner': banner, 'blocker': 0}
                params['header'] = HTTP_HEADER_AJAX
                sts, data = self.cm.getPage(baseUri, params, post_data)
                data = json_loads(data)
                printDBG(">>>%s<<<" % data)
                uri = self.cm.ph.getSearchGroups(
                    data[partials], '''href="(https?://[^"]+?)"''')[0]
                retUri, retSts = uri, 'OK'

            except Exception as e:
                retUri, retSts = baseUri, str(e)
                printExc()

        return retUri, retSts
Esempio n. 46
0
    def getVideoLinks(self, videoUrl):
        videoUrl = strwithmeta(videoUrl)
        urlTab = []
        
        # mark requested link as used one
        if len(self.cacheLinks.keys()):
            for key in self.cacheLinks:
                for idx in range(len(self.cacheLinks[key])):
                    if videoUrl in self.cacheLinks[key][idx]['url']:
                        if not self.cacheLinks[key][idx]['name'].startswith('*'):
                            self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
                        break
                        
        url = videoUrl
        post_data = None
        while True:
            httpParams = dict(self.defaultParams)
            httpParams['max_data_size'] = 0
            self.cm.getPage(url, httpParams, post_data)
            if 'url' in self.cm.meta: videoUrl = self.cm.meta['url']
            else: return []
            
            if self.up.getDomain(self.getMainUrl()) in videoUrl:
                sts, data = self.getPage(videoUrl)
                if not sts: return []
                
                if 'captcha' in data: data = re.sub("<!--[\s\S]*?-->", "", data)
                
                if 'google.com/recaptcha/' in data and 'sitekey' in data:
                    message = _('Link protected with google recaptcha v2.')
                    if True != self.loggedIn:
                        message += '\n' + _('Please fill your login and password in the host configuration (available under blue button) and try again.')
                    SetIPTVPlayerLastHostError(message)
                    break
                elif '<input name="captcha"' in data:
                    data = self.cm.ph.getDataBeetwenMarkers(data, '<div align="center">', '</form>')[1]
                    captchaTitle = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(data, '<h3', '</h3>')[1])
                    captchaDesc = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(data, '</h3>', '</span>')[1])
                    
                    # parse form data
                    data = self.cm.ph.getDataBeetwenMarkers(data, '<form', '</form>')[1]
                    
                    imgUrl = self.cm.ph.getSearchGroups(data, 'src="([^"]+?)"')[0]
                    if imgUrl != '': imgUrl = '/' + imgUrl
                    if imgUrl.startswith('/'): imgUrl = urlparse.urljoin(videoUrl, imgUrl)
                    
                    printDBG("img URL [%s]" % imgUrl)
                        
                    actionUrl = self.cm.ph.getSearchGroups(data, 'action="([^"]+?)"')[0]
                    if actionUrl != '': actionUrl = '/' + actionUrl
                    if actionUrl.startswith('/'): actionUrl = urlparse.urljoin(videoUrl, actionUrl)
                    elif actionUrl == '': actionUrl = videoUrl
                        
                    captcha_post_data = dict(re.findall(r'''<input[^>]+?name=["']([^"^']*)["'][^>]+?value=["']([^"^']*)["'][^>]*>''', data))
                    
                    if self.cm.isValidUrl(imgUrl):
                        params = dict(self.defaultParams)
                        params['header'] = dict(params['header'] )
                        params['header']['Accept'] = 'image/png,image/*;q=0.8,*/*;q=0.5'
                        params = dict(self.defaultParams)
                        params.update( {'maintype': 'image', 'subtypes':['jpeg', 'png'], 'check_first_bytes':['\xFF\xD8','\xFF\xD9','\x89\x50\x4E\x47'], 'header':params['header']} )
                        filePath = GetTmpDir('.iptvplayer_captcha.jpg')
                        ret = self.cm.saveWebFile(filePath, imgUrl.replace('&amp;', '&'), params)
                        if not ret.get('sts'):
                            SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
                            return urlTab

                        params = deepcopy(IPTVMultipleInputBox.DEF_PARAMS)
                        params['accep_label'] = _('Send')
                        params['title'] = captchaTitle
                        params['status_text'] = captchaDesc
                        params['with_accept_button'] = True
                        params['list'] = []
                        item = deepcopy(IPTVMultipleInputBox.DEF_INPUT_PARAMS)
                        item['label_size'] = (160,75)
                        item['input_size'] = (480,25)
                        item['icon_path'] = filePath
                        item['title'] = _('Answer')
                        item['input']['text'] = ''
                        params['list'].append(item)
            
                        ret = 0
                        retArg = self.sessionEx.waitForFinishOpen(IPTVMultipleInputBox, params)
                        printDBG(retArg)
                        if retArg and len(retArg) and retArg[0]:
                            printDBG(retArg[0])
                            captcha_post_data['captcha'] = retArg[0][0]
                            post_data = captcha_post_data
                            url = actionUrl
                        
                        if not sts:
                            return urlTab
                        else:
                            continue
                
                tmp = ph.IFRAME.findall(data)
                for urlItem in tmp:
                    url = self.cm.getFullUrl(urlItem[1])
                    if 1 == self.up.checkHostSupport(url):
                        videoUrl = url
                        break
            break

        if not self.up.checkHostSupport(videoUrl):
            sts, data = self.getPage(videoUrl)
            if not sts: return []
            tmp = ph.IFRAME.findall(data)
            tmp.extend(ph.A.findall(data))
            for item in tmp:
                url = self.cm.getFullUrl(item[1])
                if 1 == self.up.checkHostSupport(url):
                    videoUrl = url
                    break

        if self.up.checkHostSupport(videoUrl):
            return self.up.getVideoLinkExt(videoUrl)

        return urlTab
    def exploreItem(self, cItem):
        printDBG("Altadefinizione.exploreItem")
        self.cacheLinks = {}

        sts, data = self.getPage(cItem['url'])
        if not sts:
            return
        cUrl = data.meta['url']

        descObj = self.getArticleContent(cItem, data)[0]
        desc = []
        for t in ['quality', 'imdb_rating', 'year', 'genres']:
            if t in descObj['other_info']:
                desc.append(descObj['other_info'][t])
        desc = ' | '.join(desc) + '[/br]' + descObj['text']

        # trailer
        trailerUrl = self.cm.ph.getDataBeetwenNodes(
            data, ('<div', '>', 'showTrailer'), ('</div', '>'), False)[1]
        trailerUrl = self.getFullUrl(
            self.cm.ph.getSearchGroups(
                trailerUrl,
                '''<iframe[^>]+?src=['"]([^"^']+?)['"]''',
                1,
                ignoreCase=True)[0])
        if trailerUrl != '':
            trailerUrl = strwithmeta(trailerUrl, {'Referer': cItem['url']})
            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'title': '%s - %s' % (cItem['title'], _('trailer')),
                'url': trailerUrl,
                'desc': desc,
                'prev_url': cItem['url']
            })
            self.addVideo(params)

        data = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'player'),
                                              ('</div', '>'), False)[1]
        playerUrl = self.getFullUrl(
            self.cm.ph.getSearchGroups(
                data,
                '''<iframe[^>]+?src=['"]([^"^']+?)['"]''',
                1,
                ignoreCase=True)[0])
        if playerUrl == '':
            return

        urlParams = dict(self.defaultParams)
        urlParams['header'] = dict(urlParams)
        urlParams['header']['Referer'] = cUrl
        sts, data = self.getPage(playerUrl, urlParams)
        if not sts:
            return

        data = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'listRes'),
                                              ('</div', '>'), False)[1]
        data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<a', '</a>')
        for item in data:
            url = self.getFullUrl(
                self.cm.ph.getSearchGroups(item,
                                           '''href=['"]([^"^']+?)['"]''')[0])
            if url == '':
                continue
            title = self.cleanHtmlStr(item)
            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'title': '%s - %s' % (cItem['title'], title),
                'url': url,
                'desc': desc,
                'prev_url': cItem['url']
            })
            self.addVideo(params)
Esempio n. 48
0
    def exploreItem(self, cItem):
        printDBG("cb01uno.exploreItem [%s] " % cItem['title'])

        sts, data = self.getPage(cItem['url'])
        if not sts:
            return

        data = self.cleanHtmlFromCR(data)

        self.setMainUrl(self.cm.meta['url'])
        cItem['prev_url'] = cItem['url']

        #trailer
        trailer = self.cm.ph.getDataBeetwenNodes(data, 'Guarda il Trailer:',
                                                 ('</div', '>'), False)[1]
        if trailer:
            url = re.findall("src=['\"]?([^ >'\"]+?)['\"]?[ >]", trailer)
            if url:
                if self.cm.isValidUrl(url[0]):
                    title = "Trailer"
                    params = dict(cItem)
                    params.update({
                        'good_for_fav': False,
                        'url': url[0],
                        'title': '%s %s' % (title, cItem['title'])
                    })
                    self.addVideo(params)

        #video links
        urlTab = []

        #links = re.findall("href=['\"]?([^ '\"]+?)['\"]? target=\"?_blank\"? rel=\"[^\"]+\">(.*?)</a>", data)
        #example: <a href="http://swzz.xyz/link/479Pq/" target="_blank" rel="noopener noreferrer">Akvideo</a>
        links = re.findall(
            "href=['\"]?([^ '\"]+?)['\"]? target=\"?_blank\"? rel=\"[^\"]+\">(.*?)</a>|<strong>(.*?)</strong>",
            data)
        categ = ''

        for l in links:
            if not l[0]:
                if 'streaming hd' in l[2].lower():
                    categ = 'HD'
                elif 'streaming' in l[2].lower():
                    categ = 'SD'
                elif 'download hd' in l[2].lower():
                    categ = 'download HD'
                elif 'download' in l[2].lower():
                    categ = 'download SD'

            else:
                url = l[0]
                if url.startswith('"'):
                    url = url[1:]
                if url.endswith('"'):
                    url = url[:-1]
                if self.cm.isValidUrl(url) and not (('feeds' in url) or
                                                    ('cb01' in url) or
                                                    ('feedburner' in url)):
                    url = strwithmeta(url, {'Referer': cItem['url']})
                    if l[1]:
                        urlTab.append({
                            'name': "%s [%s]" % (l[1], categ),
                            'url': url,
                            'need_resolve': 1
                        })
                    else:
                        urlTab.append({
                            'name':
                            "%s [%s]" % (self.cm.getBaseUrl(url, True), categ),
                            'url':
                            url,
                            'need_resolve':
                            1
                        })

        if len(urlTab):
            params = dict(cItem)
            params.update({'good_for_fav': False, 'urls_tab': urlTab})
            printDBG(str(params))
            self.addVideo(params)
Esempio n. 49
0
 def getVideoLinks(self, url):
     printDBG("SVTPlaySE.getVideoLinks [%s]" % url)
     retTab = []
     url = strwithmeta(url)
     return retTab
Esempio n. 50
0
 def getLinksForVideo(self, cItem):
     printDBG("SVTPlaySE.getLinksForVideo [%s]" % cItem)
     videoUrls = []
     
     hlsUrl  = cItem.get('hls_url')
     dashUrl = cItem.get('dash_url')
     
     subtitlesTab = []
     
     if hlsUrl == None or dashUrl == None:
         if 'api' not in self.up.getDomain(cItem['url']):
             url = self.getFullUrl(cItem['url'])
             sts, data = self.cm.getPage(url, self.defaultParams)
             if not sts: return []
             videoId = self.cm.ph.getSearchGroups(data, '<video\s+?data-video-id="([^"]+?)"')[0]
             url = 'https://api.svt.se/video/' + videoId
         else:
             url = cItem['url']
         
         sts, data = self.cm.getPage(url, self.defaultParams)
         if not sts: return []
         
         printDBG(data)
         
         try:
             data = byteify(json.loads(data))
             
             videoItem = data.get('video', None)
             if videoItem  == None: videoItem = data
             for item in videoItem['videoReferences']:
                 if self.cm.isValidUrl(item['url']):
                     if 'dashhbbtv' in item['format']:
                         dashUrl = item['url']
                     elif 'hls' in item['format']:
                         hlsUrl = item['url']
             
             for item in videoItem['subtitleReferences']:
                 format = item['url'][-3:]
                 if format in ['srt', 'vtt']:
                     subtitlesTab.append({'title':format, 'url':self.getFullIconUrl(item['url']), 'lang':'n/a', 'format':format})
         except Exception: 
             printExc()
     
     tmpTab = []
     if config.plugins.iptvplayer.svt_prefered_format.value == 'hls':
         tmpTab.append(hlsUrl)
         tmpTab.append(dashUrl)
     else:
         tmpTab.append(dashUrl)
         tmpTab.append(hlsUrl)
     
     max_bitrate = int(config.plugins.iptvplayer.svt_default_quality.value)
     for item in tmpTab:
         if item == '': continue
         if item == dashUrl:
             item = getMPDLinksWithMeta(item, False)
         elif item == hlsUrl:
             vidTab = []
             # item = strwithmeta(item, {'X-Forwarded-For':'83.172.75.170'})
             try:
                 tmp = urlparse.urlparse(item)
                 tmp = urlparse.parse_qs(tmp.query)['alt'][0]
                 vidTab = getDirectM3U8Playlist(tmp, False, checkContent=True)
             except Exception:
                 printExc()
             if 0 == len(vidTab):
                 item = getDirectM3U8Playlist(item, False, checkContent=True)
             else:
                 item = vidTab
         else: continue
         
         if len(item):
             def __getLinkQuality( itemLink ):
                 try: return int(itemLink['height'])
                 except Exception: return 0
             item = CSelOneLink(item, __getLinkQuality, max_bitrate).getSortedLinks()
             if config.plugins.iptvplayer.svt_use_default_quality.value:
                 videoUrls.append(item[0])
                 break
             videoUrls.extend(item)
     
     if len(subtitlesTab):
         for idx in range(len(videoUrls)):
             videoUrls[idx]['url'] = strwithmeta(videoUrls[idx]['url'], {'external_sub_tracks':subtitlesTab})
             videoUrls[idx]['need_resolve'] = 0
     
     return videoUrls
Esempio n. 51
0
    def getLinksForVideo(self, cItem):
        printDBG("watchMovies.getLinksForVideo [%s]" % cItem)

        cacheKey = cItem['url']
        cacheTab = self.cacheLinks.get(cacheKey, [])
        if len(cacheTab): return cacheTab

        self.cacheLinks = {}

        params = dict(self.defaultParams)
        params['header'] = dict(params['header'])

        cUrl = cItem['url']
        url = cItem['url']

        retTab = []

        params['header']['Referer'] = cUrl
        sts, data = self.getPage(url, params)
        if not sts: return []

        #        sts, jscode = self.getPage('https://watch-movies.pl/js/bootstrap.php', params)
        #        if not sts: return []

        cUrl = data.meta['url']
        self.setMainUrl(cUrl)

        data = self.cm.ph.getDataBeetwenNodes(data,
                                              ('<ul', '>', 'playeroptionsul'),
                                              ('</ul', '>'))[1]
        data = self.cm.ph.getAllItemsBeetwenNodes(data, ('<li', '>'),
                                                  ('</li', '>'))

        for item in data:
            printDBG("watchMovies.getLinksForVideo item[%s]" % item)
            data_type = self.cm.ph.getSearchGroups(
                item, '''data-type=['"]([^"^']+?)['"]''', 1, True)[0]
            data_post = self.cm.ph.getSearchGroups(
                item, '''data-post=['"]([^"^']+?)['"]''', 1, True)[0]
            data_nume = self.cm.ph.getSearchGroups(
                item, '''data-nume=['"]([^"^']+?)['"]''', 1, True)[0]
            post_data = {
                'action': 'doo_player_ajax',
                'post': data_post,
                'nume': data_nume,
                'type': data_type
            }
            sts, data = self.getPage(
                'https://watch-movies.pl/wp-admin/admin-ajax.php', params,
                post_data)
            if not sts: return []
            printDBG("watchMovies.getLinksForVideo data ajax[%s]" % item)
            playerUrl = self.cm.ph.getSearchGroups(
                data, '''src=['"]([^"^']+?)['"]''', 1, True)[0]
            retTab.append({
                'name': self.up.getHostName(playerUrl),
                'url': strwithmeta(playerUrl, {'Referer': url}),
                'need_resolve': 1
            })

        if len(retTab):
            self.cacheLinks[cacheKey] = retTab
        return retTab
Esempio n. 52
0
 def _urlWithCookie(self, url):
     url = self._getFullUrl(url)
     if url == '': return ''
     cookieHeader = self.cm.getCookieHeader(self.COOKIE_FILE)
     return strwithmeta(url, {'Cookie':cookieHeader, 'User-Agent':self.USER_AGENT})
Esempio n. 53
0
 def getVideoLinks(self, baseUrl):
     printDBG("YifyTV.getVideoLinks [%s]" % baseUrl)
     
     # mark requested link as used one
     if len(self.cacheLinks.keys()):
         for key in self.cacheLinks:
             for idx in range(len(self.cacheLinks[key])):
                 if baseUrl in self.cacheLinks[key][idx]['url']:
                     if not self.cacheLinks[key][idx]['name'].startswith('*'):
                         self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
                     break
     
     urlTab = []
     
     baseUrl = strwithmeta(baseUrl)
     imdbid  = baseUrl.meta.get('imdbid', '')
     sub_tracks = baseUrl.meta.get('external_sub_tracks', [])
     
     header = dict(self.AJAX_HEADER)
     #header['Referer'] = baseUrl.meta['Referer']
     
     if 'sou' in baseUrl.meta:
         souTab = [baseUrl.meta['sou']]
         if souTab[0] == 'pic':
             souTab.append('adr')
         if souTab[0] == 'adr':
             souTab.append('pic')
         
         for sou in souTab:
             post_data = {'fv':'27', 'url':baseUrl, 'sou':sou}
             url = 'https://ymovies.tv/playerlite/pk/pk/plugins/player_p2.php'
             sts, data = self.getPage(url, {'header':header}, post_data)
             if not sts: return []
             
             printDBG("+++++++++++++++++++++++  data  ++++++++++++++++++++++++")
             printDBG(data)
             printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
             
             try:
                 attempt = 0
                 while attempt < 3:
                     attempt += 1
                     printDBG(data)
                     if 'jscode' in data:
                         try:
                             data = byteify(json.loads(data))[0]['jscode'][1:-1]#.replace('eval(', 'print(')
                             jsTab = [''] 
                             jsTab.append('''var iptv_href="%s"; var iptv_domain="%s"; var iptv_video_id="%s"; var iptv_jwpath="%s";\n''' % (self.getMainUrl(), self.up.getDomain(self.getMainUrl()), imdbid, url))
                             jsTab.append(base64.b64decode('''ZnVuY3Rpb24gU2hvd0Rpdigpe31mdW5jdGlvbiBzaG93aUZyYW1lKCl7cHJpbnQoYXJndW1lbnRzWzBdKX1mdW5jdGlvbiBnZXRKd1BhdGgoKXtyZXR1cm4gaXB0dl9qd3BhdGh9ZnVuY3Rpb24gZ2V0X3BhcmFtc19ub19zb3JjZXMoKXtyZXR1cm4gaXB0dl92aWRlb19pZH1mdW5jdGlvbiBzZXRUaW1lb3V0KHQsbil7aWYoaXB0dl9kaXJlY3QpdHJ5e3QoKX1jYXRjaChlKXtwcmludCgiXG4iKX1lbHNlIHRoaXMudHJ5dXAoKX12YXIgZG9jdW1lbnQ9e30sd2luZG93PXRoaXMsbG9jYXRpb249e307bG9jYXRpb24uaHJlZj1pcHR2X2hyZWYsbG9jYXRpb24uaG9zdG5hbWU9aXB0dl9kb21haW4sbG9jYXRpb24udG9TdHJpbmc9ZnVuY3Rpb24oKXtyZXR1cm4gaXB0dl9ocmVmfSxkb2N1bWVudC5sb2NhdGlvbj1sb2NhdGlvbjt2YXIgZWxlbWVudD1mdW5jdGlvbih0KXt0aGlzLnRleHQ9ZnVuY3Rpb24oKXtyZXR1cm4ibm9uZSJ9LHRoaXMuZmlyc3Q9ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IGVsZW1lbnR9fSwkPWZ1bmN0aW9uKHQpe3JldHVybiBuZXcgZWxlbWVudCh0KX0scGxheWVybW9kZT0iIixzb3VyY2VTZWxlY3RlZD0wLHNvdXJjZXM9W3tzdWJfZGVsYXk6MCxzdWJfZmFjdG9yOjF9XTskLmdldD1mdW5jdGlvbigpe3JldHVybiBwcmludChhcmd1bWVudHNbMF0pLHtkb25lOlNob3dEaXYsZXJyb3I6U2hvd0Rpdn19LCQucG9zdD1mdW5jdGlvbigpe3ByaW50KCJcbklQVFZfUE9TVF9TVEFSVFxuIikscHJpbnQoSlNPTi5zdHJpbmdpZnkoe3VybDphcmd1bWVudHNbMF0scGFyYW1zOmFyZ3VtZW50c1sxXX0pKSxwcmludCgiXG5JUFRWX1BPU1RfRU5EXG4iKX07'''))
                             jsTab.append('var iptv_fun = %s; iptv_fun();' % data)
                             
                             for iptv_direct in ["false", "true"]:
                                 jsTab[0] = 'var iptv_direct = %s;' % iptv_direct
                                 jscode = '\n'.join(jsTab)
                                 printDBG("+++++++++++++++++++++++  CODE  ++++++++++++++++++++++++")
                                 printDBG(jscode)
                                 printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
                                 ret = iptv_js_execute( jscode )
                                 if not ret['sts'] or  0 != ret['code']:
                                     ret = iptv_js_execute( jscode.replace('eval(', 'print(') )
                                 if ret['sts'] and 0 == ret['code']:
                                     decoded = ret['data'].strip()
                                     printDBG('DECODED DATA -> [%s]' % decoded)
                                     data = decoded
                                     break
                             if 'jscode' in data:
                                 data = data[data.find("["):data.rfind("]")+1]
                                 data = byteify(json.loads('"%s"' % data))
                                 continue
                         except Exception:
                             printExc()
                             
                         if 'IPTV_POST_START' in data:
                             data = self.cm.ph.getDataBeetwenMarkers(data, 'IPTV_POST_START', 'IPTV_POST_END', 0)[1]
                             try:
                                 tmp = byteify(json.loads(data.strip()))
                                 sts, data = self.getPage(tmp['url'], {'header':header, 'raw_post_data':True}, tmp['params'])
                                 if not sts: return []
                                 tmp = byteify(json.loads(data))
                                 for hostDomain in tmp['hosts']:
                                     urlTab.append({'name':hostDomain, 'url':'http://%s%s' % (hostDomain, tmp['path'])})
                                 if len(urlTab): break
                             except Exception:
                                 printExc()
                         
                         g3 = self.cm.ph.getSearchGroups(data+'&', '''[&\?]g3=([^&]+?)&''')[0]
                         emb = self.cm.ph.getSearchGroups(data+'&', '''[&\?]emb=([^&^\*]+?)[&\*]''')[0]
                         if emb != '': data = urllib.unquote(emb)
                         if g3 != '':
                             post_data = {'fv':'0', 'g3':urllib.unquote(g3)}
                             url = 'https://ymovies.tv/playerlite/pk/pk/plugins/player_g3.php'
                             sts, data = self.getPage(url, {'header':header}, post_data)
                             if not sts: return []
                             printDBG(data)
                         elif self.cm.isValidUrl(data) and 1 == self.up.checkHostSupport(data):
                             urlTab = self.up.getVideoLinkExt(data)
                             break                            
                         else:
                             if 'showiFrame(' in data:
                                 url = urllib.unquote(self.cm.ph.getDataBeetwenMarkers(data, "emb='+'", "'", False)[1])
                                 tmp = url.split('sub.file')
                                 url = tmp[0]
                                 subTrack = urllib.unquote(tmp[1])
                                 if url.startswith('//'):
                                     url = 'http:' + url
                                 if subTrack.startswith('//'):
                                     subTrack = 'http:' + subTrack
                                 tmpUrlTab = self.up.getVideoLinkExt(url)
                                 if self.cm.isValidUrl(subTrack):
                                     format = subTrack[-3:]
                                     for idx in range(len(tmpUrlTab)):
                                         tmpUrlTab[idx]['url'] = strwithmeta(tmpUrlTab[idx]['url'], {'external_sub_tracks':[{'title':'', 'url':subTrack, 'lang':'en', 'format':format}]})
                                 urlTab.extend(tmpUrlTab)
                                 printDBG(urlTab)
                                 break
                                 
                             if 'sources[sourceSelected]["paramId"]' in data:
                                 data = data.replace('"+"', '').replace(' ', '')
                                 paramSite = self.cm.ph.getSearchGroups(data, 'sources\[sourceSelected\]\["paramSite"\]="([^"]+?)"')[0]
                                 data = self.cm.ph.getSearchGroups(data, 'sources\[sourceSelected\]\["paramId"\]="([^"]+?)"')[0]
                                 printDBG('data ------------------------- [%s]' % data)
                                 if data.startswith('enc'):
                                     encrypted = base64.b64decode(data[3:])
                                     key = unhexlify(base64.b64decode('MzAzOTM4NzMzOTM3MzU0MTMxMzIzMzczMzEzMzM1NjQ2NDY2Njc3NzQ4MzczODM0MzczNTMzMzQzNjcyNjQ3Nw=='))
                                     iv = unhexlify(base64.b64decode('NWE0MTRlMzEzNjMzNjk2NDZhNGM1MzUxMzU0YzY0MzU='))
                                     cipher = AES_CBC(key=key, padding=noPadding(), keySize=32)
                                     data = cipher.decrypt(encrypted, iv).split('\x00')[0]
                                     if 'ucl' == paramSite:
                                         urlTab.extend( self.up.getVideoLinkExt("https://userscloud.com/embed-" + data + "-1280x534.html") )
                                     elif 'tus' == paramSite:
                                         urlTab.extend( self.up.getVideoLinkExt("https://tusfiles.net/embed-" + data + "-1280x534.html?v=34") )
                                     elif 'up' == paramSite:
                                         urlTab.extend( self.up.getVideoLinkExt("http://uptobox.com/" + data) )
                                     break
                     
                     if '("' in data: 
                         data = self.cm.ph.getDataBeetwenMarkers(data, '(', ')', False)[1]
                         data = byteify(json.loads(data))
                     if isinstance(data, basestring):
                         data = byteify(json.loads(data))
                     printDBG(data)
                     for item in data:
                         #printDBG('++++++++++++++++++++++\n%s\n++++++++++++++++++++++' % item)
                         if (item.get('type', '').startswith('video/') or item.get('type', '').startswith('application/x-shockwave-flash')) and self.cm.isValidUrl(item.get('url', '')):
                             urlTab.append({'name':'{0}x{1}'.format(item.get('height', ''), item.get('width', '')), 'url':item['url'], 'need_resolve':0})
                 break
             except Exception:
                 SetIPTVPlayerLastHostError('The Mirror is broken.\nIf available you can choose other source.')
                 printExc()
                 return []
             
             if len(urlTab): break;
         
     elif self.cm.isValidUrl(baseUrl):
         urlTab = self.up.getVideoLinkExt(baseUrl)
     
     printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
     printDBG(urlTab)
     
     for idx in range(len(urlTab)):
         subs = list(strwithmeta(urlTab[idx]['url']).meta.get('external_sub_tracks', []))
         subs.extend(sub_tracks)
         urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'], {'external_sub_tracks':subs})
     
     printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
     printDBG(urlTab)
     return urlTab
    def getLinksForVideo(self, cItem):
        printDBG("TantiFilmOrg.getLinksForVideo [%s]" % cItem)
        urlTab = []

        if len(self.cacheLinks.get(cItem['url'], [])):
            return self.cacheLinks[cItem['url']]

        type = cItem['video_type']
        if type == 'trailer':
            return self.up.getVideoLinkExt(cItem['url'])
        else:
            sts, data = self.getPage(cItem['url'])
            if not sts: return []

        urlTab = []
        if type == 'movie':
            tmp = self.cm.ph.getDataBeetwenMarkers(
                data, '<div id="wpwm-movie-links">', '<div class="film-left">',
                False)[1]
            tmp = tmp.split('</ul>')
            printDBG(tmp)
            for item in tmp:
                url = self.cm.ph.getSearchGroups(
                    item,
                    '''<iframe[^>]+?src=['"]([^'^"]+?)['"]''',
                    ignoreCase=True)[0]
                if url.startswith('//'):
                    url = "https:" + url
                if not self.cm.isValidUrl(url):
                    continue
                id = self.cm.ph.getSearchGroups(item,
                                                '''id=['"]([^'^"]+?)['"]''',
                                                ignoreCase=True)[0]
                title = self.cm.ph.getDataBeetwenReMarkers(
                    data,
                    re.compile('''<a[^>]+?href=['"]\#%s['"][^>]*?>''' %
                               re.escape(id)), re.compile('</a>'))[1]
                title = self.cleanHtmlStr(title)
                if title == '':
                    title = self.up.getDomain(url)
                url_params = {
                    'name': title,
                    'url': strwithmeta(url, {'url': cItem['url']}),
                    'need_resolve': 1
                }
                printDBG(str(url_params))
                urlTab.append(url_params)
        elif type == 'episode':
            data = self.cm.ph.getAllItemsBeetwenMarkers(
                data, '<nav class="', '</select>')
            if len(data) < 3:
                printDBG(
                    "!!!!!!!!!!!! wrong makers for links TV series -> url[%s]"
                    % cItem['url'])
                return []

            data = data[2]
            seasonName = self.cleanHtmlStr(
                self.cm.ph.getDataBeetwenMarkers(
                    data.split('<ul')[0], '<a', '</a>')[1])
            data = self.cm.ph.getAllItemsBeetwenMarkers(
                data, '<option', '</option>')
            printDBG(data)
            for item in data:
                url = self.cm.ph.getSearchGroups(
                    item, '''href=['"]([^'^"]+?)['"]''')[0]
                if not self.cm.isValidUrl(url): continue
                title = self.cleanHtmlStr(item)
                if title == '':
                    continue
                url_params = {
                    'name': title,
                    'url': strwithmeta(url, {'url': cItem['url']}),
                    'need_resolve': 1
                }
                printDBG(str(url_params))
                urlTab.append(url_params)

        self.cacheLinks[cItem['url']] = urlTab
        return urlTab
Esempio n. 55
0
    def exploreItem(self, cItem):
        printDBG('Filma24IO.exploreItem')
        self.cacheLinks = {}
        sts, data = self.getPage(cItem['url'])
        if not sts:
            return
        cUrl = self.cm.meta['url']
        self.setMainUrl(cUrl)
        desc = []
        try:
            descObj = self.getArticleContent(cItem, data)[0]
            for item in descObj['other_info']['custom_items_list']:
                desc.append(item[1])

            desc = ' | '.join(desc) + '[/br]' + descObj['text']
        except Exception:
            printExc()

        trailerUrl = ph.find(data, ('<div', '>', 'trailer-player'),
                             '</div>',
                             flags=0)[1]
        trailerUrl = self.getFullUrl(ph.search(trailerUrl, ph.IFRAME)[1])
        if trailerUrl:
            trailerUrl = strwithmeta(trailerUrl, {'Referer': cItem['url']})
            params = {
                'good_for_fav': False,
                'title': '%s - %s' % (cItem['title'], _('trailer')),
                'url': trailerUrl,
                'trailer': True,
                'desc': desc,
                'prev_url': cItem['url']
            }
            self.addVideo(MergeDicts(cItem, params))
        self.cacheLinks[cUrl] = []
        tmp = ph.findall(data, ('<ul', '>', 'w-links'), '</ul>', flags=0)
        for tmpItem in tmp:
            tmpItem = ph.findall(tmpItem, ('<a', '>'),
                                 '</a>',
                                 flags=ph.START_S)
            for idx in range(1, len(tmpItem), 2):
                name = ph.clean_html(tmpItem[idx])
                url = self.getFullUrl(ph.getattr(tmpItem[idx - 1], 'href'))
                self.cacheLinks[cUrl].append({
                    'name': name,
                    'url': url,
                    'need_resolve': 1
                })

        tmp = ph.find(data, ('<div', '>', 'movie-player'), '</div>',
                      flags=0)[1]
        url = self.getFullUrl(ph.search(tmp, ph.IFRAME)[1])
        if url:
            self.cacheLinks[cUrl].insert(
                0, {
                    'name': self.cm.getBaseUrl(url, True).upper(),
                    'url': url,
                    'need_resolve': 1
                })
        if len(self.cacheLinks[cUrl]):
            self.addVideo(
                MergeDicts(
                    cItem, {
                        'good_for_fav': False,
                        'url': cUrl,
                        'desc': desc,
                        'prev_url': cItem['url']
                    }))
Esempio n. 56
0
    def showelms(self, cItem):
        urlo = cItem['url']
        img_ = cItem['icon']
        desc = cItem['desc']
        sts, data = self.getPage(cItem['url'])
        if not sts: return
        cUrl = self.cm.meta['url']
        self.setMainUrl(cUrl)

        self.cacheLinks[cUrl] = []
        playerData = self.cm.ph.getDataBeetwenNodes(data,
                                                    ('<div', '>', 'player'),
                                                    ('</ul', '>'), False)[1]
        tmp = self.cm.ph.getAllItemsBeetwenMarkers(playerData, '<li', '</li>')
        for item in tmp:
            link = self.cm.ph.getSearchGroups(
                item, '''href=['"]#([^"^']+?)['"]''')[0]
            if link == '': continue
            name = self.cleanHtmlStr(item)
            link = self.cm.ph.getDataBeetwenNodes(playerData,
                                                  ('<div', '>', link),
                                                  ('</div', '>'), False)[1]
            url = self.getFullUrl(
                self.cm.ph.getSearchGroups(
                    link, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1,
                    True)[0])
            if url != '':
                self.cacheLinks[cUrl].append({
                    'name':
                    name,
                    'url':
                    strwithmeta(url, {'Referer': cUrl}),
                    'need_resolve':
                    1
                })

        if len(self.cacheLinks[cUrl]):
            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'url': cUrl,
                'desc': desc,
                'prev_url': cItem['url']
            })
            self.addVideo(params)
        else:
            playerData = self.cm.ph.rgetAllItemsBeetwenNodes(
                data, ('</iframe', '>'), ('<div', '>', 'id'),
                caseSensitive=False)
            for item in playerData:
                frameId = self.cm.ph.getSearchGroups(
                    item, '''<div[^>]+?id=['"]([^"^']+?)['"]''', 1, True)[0]
                url = self.getFullUrl(
                    self.cm.ph.getSearchGroups(
                        item, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1,
                        True)[0])
                if url == '': continue
                name = self.cleanHtmlStr(
                    self.cm.ph.getDataBeetwenNodes(data,
                                                   ('<a', '>', '#' + frameId),
                                                   ('</a', '>'), False)[1])
                self.cacheLinks[url] = [{
                    'name':
                    name,
                    'url':
                    strwithmeta(url, {'Referer': cUrl}),
                    'need_resolve':
                    1
                }]
                params = dict(cItem)
                params.update({
                    'good_for_fav': False,
                    'url': url,
                    'title': cItem['title'] + ': ' + name,
                    'desc': desc,
                    'prev_url': cItem['url']
                })
                self.addVideo(params)
Esempio n. 57
0
    def getVideoLinks(self, videoUrl):
        printDBG("HDSTo.getVideoLinks [%s]" % videoUrl)
        # mark requested link as used one
        if len(self.cacheLinks.keys()):
            for key in self.cacheLinks:
                for idx in range(len(self.cacheLinks[key])):
                    if videoUrl in self.cacheLinks[key][idx]['url']:
                        if not self.cacheLinks[key][idx]['name'].startswith(
                                '*'):
                            self.cacheLinks[key][idx][
                                'name'] = '*' + self.cacheLinks[key][idx][
                                    'name']

        linksTab = []
        if 0 == self.up.checkHostSupport(videoUrl):
            sts, data = self.getPage(videoUrl)
            if sts:
                cUrl = self.getFullUrl(self.cm.meta['url'])
                sts, tmp = self.cm.ph.getDataBeetwenMarkers(
                    data, '<video', '</video>')
                if sts:
                    tmp = self.cm.ph.getAllItemsBeetwenMarkers(
                        tmp, '<source', '>', False, False)
                    for item in tmp:
                        if 'video/mp4' in item.lower():
                            url = self.getFullUrl(
                                self.cm.ph.getSearchGroups(
                                    item, '''src=['"]([^"^']+?)['"]''')[0])
                            if url != '':
                                linksTab.append({
                                    'name':
                                    str(len(linksTab) + 1) + ' mp4',
                                    'url':
                                    url
                                })

                jwplayer = False
                jscode = []
                data = self.cm.ph.getAllItemsBeetwenNodes(
                    data, ('<script', '>'), ('</script', '>'), False)
                for item in data:
                    if '"$' in item or 'var _' in item or 'bitrates' in item:
                        jscode.append(item)
                    elif 'jwplayer' in item:
                        jwplayer = True
                        jscode.append(item)

                if not jwplayer:
                    jscode.insert(
                        0,
                        'var document={};function RadiantMP(){return document}document.getElementById=function(){return document},document.addEventListener=function(){},document.init=function(){print(JSON.stringify(arguments))};'
                    )
                else:
                    jscode.insert(
                        0,
                        'window=this; function stub() {}; function jwplayer() {return {setup:function(){print(JSON.stringify(arguments[0]))}, onTime:stub, onPlay:stub, onComplete:stub, onReady:stub, addButton:stub}}; window.jwplayer=jwplayer;'
                    )

                ret = js_execute('\n'.join(jscode))
                try:
                    data = byteify(json.loads(ret['data'].strip()))
                    if jwplayer:
                        for dat in data['playlist']:
                            subsTab = []
                            for item in dat.get('tracks', []):
                                try:
                                    if item.get('kind', '') != 'captions':
                                        continue
                                    title = self.cleanHtmlStr(item['label'])
                                    lang = item['file'].rsplit('-',
                                                               1)[-1].split(
                                                                   '.', 1)[0]
                                    if lang == '': lang = title
                                    subsTab.append({
                                        'title':
                                        title,
                                        'url':
                                        self.getFullUrl(item['file'], cUrl),
                                        'lang':
                                        lang,
                                        'format':
                                        item['file'].rsplit('.', 1)[-1]
                                    })
                                except Exception:
                                    pass

                            tmpLinksTab = []
                            for item in dat.get('sources', []):
                                name = len(tmpLinksTab)
                                if isinstance(item, dict):
                                    url = item['file']
                                    name = item.get('label', name)
                                else:
                                    url = item
                                type = url.split('.')[-1].split('?',
                                                                1)[0].lower()
                                if type == 'm3u8':
                                    tmpLinksTab.extend(
                                        getDirectM3U8Playlist(
                                            url,
                                            checkExt=False,
                                            checkContent=True))
                                elif type == 'mp4':
                                    tmpLinksTab.append({
                                        'name': name,
                                        'url': url
                                    })

                            if len(subsTab):
                                for idx in range(len(tmpLinksTab)):
                                    tmpLinksTab[idx]['url'] = strwithmeta(
                                        tmpLinksTab[idx]['url'],
                                        {'external_sub_tracks': subsTab})

                            linksTab.extend(tmpLinksTab)
                    else:
                        for key, dat in data.iteritems():
                            subsTab = []
                            for item in dat.get('ccFiles', []):
                                if len(item) < 3: continue
                                subsTab.append({
                                    'title':
                                    self.cleanHtmlStr(item[1]),
                                    'url':
                                    self.getFullUrl(item[2], cUrl),
                                    'lang':
                                    self.cleanHtmlStr(item[0]),
                                    'format':
                                    self.cleanHtmlStr(item[0]).rsplit('.',
                                                                      1)[-1]
                                })

                            tmpLinksTab = []
                            for type, item in dat.get('bitrates',
                                                      {}).iteritems():
                                if type == 'hls':
                                    tmpLinksTab.extend(
                                        getDirectM3U8Playlist(
                                            item,
                                            checkExt=False,
                                            checkContent=True))
                                elif type == 'mp4' and isinstance(item, list):
                                    for url in item:
                                        if '-' in url:
                                            name = url.rsplit('-',
                                                              1)[-1].replace(
                                                                  '.', ' ')
                                        else:
                                            name = 'mp4'
                                        tmpLinksTab.append({
                                            'name': name,
                                            'url': url
                                        })

                            if len(subsTab):
                                for idx in range(len(tmpLinksTab)):
                                    tmpLinksTab[idx]['url'] = strwithmeta(
                                        tmpLinksTab[idx]['url'],
                                        {'external_sub_tracks': subsTab})

                            linksTab.extend(tmpLinksTab)
                except Exception:
                    printExc()
        else:
            linksTab = self.up.getVideoLinkExt(videoUrl)
        return linksTab
Esempio n. 58
0
    def exploreItem(self, cItem):
        printDBG("hostszenestreamz.exploreItem")

        sts, data = self.getPage(cItem['url'])
        if not sts: return

        if '<div class="noEntry"' in data:
            return

        title = cItem.get('title', '')

        trailerurl = ''
        trailerdata = ph.findall(data, '<iframe src=', '</iframe>')
        for item in trailerdata:
            if 'youtube' in item:
                trailerurl = self.getFullUrl(
                    ph.search(item, '''src=['"]([^'^"]+?)['"]''')[0])
                if trailerurl.endswith('/embed/'): trailerurl = ''
                break

        plot = ''
        plotdata = ph.findall(data, '<p><b>', '</b></p>', flags=0)
        for item in plotdata:
            item = item.replace('\n', '')
            item = item.replace('\r', '')
            plot = item

        desc = cItem.get('desc', '')
        url = cItem.get('url', '')
        icon = cItem.get('icon', '')

        if plot != '':
            if desc != '':
                desc = desc + '[/br]'
            desc = desc + plot

        if trailerurl != '':
            trailerurl = self.getFullUrl(trailerurl)
            trailerurl = strwithmeta(trailerurl, {'Referer': url})
            params = dict(cItem)
            params.update({
                'good_for_fav': False,
                'title': '%s %s' % (title, '[Trailer]'),
                'url': trailerurl,
                'desc': desc
            })
            self.addVideo(params)

        if '/publ/' in url:
            links = ph.findall(data, '<div class="inner', '</fieldset>')

            self.cacheLinks = {}
            linksKey = cItem['url']
            self.cacheLinks[linksKey] = []
            params = dict(cItem)
            url = ''
            for item in links:
                item = item.replace('\n', '')
                item = item.replace('\r', '')
                url = ph.search(item, ph.A_HREF_URI_RE)[1]
                name = ph.search(url, '''//([^/]+)/''')[0]
                nameparts = name.split('.')
                if len(nameparts) != 2:
                    name = nameparts[-2] + '.' + nameparts[-1]
                url = self.getFullUrl(url)
                url = strwithmeta(url, {'Referer': linksKey})
                self.cacheLinks[linksKey].append({
                    'name': name,
                    'url': url,
                    'need_resolve': 1
                })

            if self.cacheLinks != {}:
                params = dict(cItem)
                params.update({
                    'good_for_fav': False,
                    'title': '%s' % title,
                    'links_key': linksKey,
                    'url': linksKey,
                    'desc': desc
                })
                self.addVideo(params)
        else:
            seasons = ph.findall(data, '<div class="spoiler', '</fieldset>')
            sKey = 0
            self.cacheSeasons = {}
            onlyEpisodes = False
            episodesList = []
            eNum = 1
            for item in seasons:
                item = item.replace('\n', '')
                item = item.replace('\r', '')
                season = ph.search(item, '''STAFFEL ([^<]+)<''')[0]
                if len(season):
                    if season.startswith('0'): season = season.replace('0', '')
                    episodesList = []
                    links = ph.findall(item, '<a href="', '</a>')
                    eNum = 1
                    for litem in links:
                        url = ph.search(litem, ph.A_HREF_URI_RE)[1]
                        url = strwithmeta(url, {'Referer': cItem['url']})
                        episode = str(eNum)
                        etitle = '%s s%se%s' % (
                            cItem['title'], season.zfill(2), episode.zfill(2))
                        params = {
                            'title': etitle,
                            'url': url,
                            'prev_url': cItem['url']
                        }
                        episodesList.append(params)
                        eNum += 1

                    if len(episodesList):
                        self.cacheSeasons[sKey] = episodesList

                    params = dict(cItem)
                    params.update({
                        'good_for_fav': False,
                        'category': 'list_episodes',
                        'title': title + ' ' + _('Season %s') % season,
                        'url': url,
                        'desc': desc,
                        'icon': icon,
                        's_key': sKey
                    })
                    self.addDir(params)
                    sKey += 1
                else:
                    onlyEpisodes = True
                    season = '1'
                    url = ph.search(item, ph.A_HREF_URI_RE)[1]
                    url = strwithmeta(url, {'Referer': cItem['url']})
                    episode = str(eNum)
                    etitle = '%s s%se%s' % (cItem['title'], season.zfill(2),
                                            episode.zfill(2))
                    params = {
                        'title': etitle,
                        'url': url,
                        'prev_url': cItem['url']
                    }
                    episodesList.append(params)
                    eNum += 1

            if onlyEpisodes:
                if len(episodesList):
                    self.cacheSeasons[sKey] = episodesList

                params = dict(cItem)
                params.update({
                    'good_for_fav': False,
                    'category': 'list_episodes',
                    'title': title + ' ' + _('Season %s') % season,
                    'url': url,
                    'desc': desc,
                    'icon': icon,
                    's_key': sKey
                })
                self.addDir(params)
Esempio n. 59
0
    def __init__(self, session, url, pathForRecordings, pictureTitle, addParams={}):
        self.session = session
        Screen.__init__(self, session)
        self.onStartCalled = False
        
        self.recordingPath = pathForRecordings
        try:
            self.filePath = os.path.join(pathForRecordings, '.iptv_buffering.jpg')
        except Exception:
            self.filePath = ''
            printExc()
        
        self.addParams = {'seq_mode':False}
        self.addParams.update(addParams)
        
        self.url           = url
        self.pictureTitle  = pictureTitle
        self.audioUrl      = strwithmeta(url).meta.get("iptv_audio_url", '')
       
        self["actions"] = ActionMap(['IPTVAlternateVideoPlayer', 'MoviePlayerActions', 'MediaPlayerActions', 'WizardActions', 'DirectionActions'],
        {
            'leavePlayer'  : self.key_exit,
            'play'         : self.key_play,
            'pause'        : self.key_pause,
            'exit'         : self.key_exit,
            'back'         : self.key_exit,
            'ok'           : self.key_ok,
        }, -1)     

        self["status"]  = Label()
        self["console"] = Label()
        self["icon"]    = SimpleAnimatedCover()
        self["picture"] = Cover()

        # prepare icon frames path
        frames = []
        for idx in range(1,self.NUM_OF_ICON_FRAMES+1): frames.append( GetIconDir('/buffering/buffering_%d.png' % idx) )
        self["icon"].loadFrames(frames) 
        
        #main Timer
        self.mainTimer = eTimer()
        self.mainTimerEnabled = False
        
        if self.addParams['seq_mode']:
            self.canAutoClose = True
            self.mainTimer_conn = eConnectCallback(self.mainTimer.timeout, self.closeAfterTimeout)
            self.mainTimerInterval = 1000 * 10 #10s
        else:
            self.mainTimer_conn = eConnectCallback(self.mainTimer.timeout, self.updateDisplay)
            self.mainTimerInterval = 100 # by default 0,1s
        # download
        self.downloader = DownloaderCreator(self.url)
        
        self.onClose.append(self.__onClose)
        self.onShow.append(self.doStart)
        #self.onLayoutFinish.append(self.doStart)
        
        self.autoRefresh = False
        self.refreshPostfixes = ['_0', '_1']
        self.refreshCount = 0
        self.refreshing = False
        
        if len(self.audioUrl) and len(config.plugins.iptvplayer.gstplayerpath.value):
            self.audioPlayer = IPTVSimpleAudioPlayer()
        else: self.audioPlayer  = None
Esempio n. 60
0
    def exploreItem(self, cItem, nextCategory):
        printDBG("Cinemaxx.exploreItem")
        self.cacheLinks = {}

        sts, data = self.getPage(cItem['url'])
        if not sts: return
        cUrl = self.cm.meta['url']
        self.setMainUrl(cUrl)

        desc = []
        descObj = self.getArticleContent(cItem, data)[0]
        icon = descObj['images'][0]['url']
        baseTitle = descObj['title']
        for item in descObj['other_info']['custom_items_list']:
            desc.append(item[1])
        desc = ' | '.join(desc) + '[/br]' + descObj['text']

        data = ph.find(data, ('<div', '>', 'dle-content'),
                       ('<div', '>', 'dle_b_iptv'),
                       flags=0)[1]
        trailer = ph.find(data, ('<', '>', '#trailer'), '</div>', flags=0)[1]
        title = self.cleanHtmlStr(trailer)
        trailer = self.getFullUrl(ph.search(trailer, ph.IFRAME_SRC_URI_RE)[1])
        if trailer:
            self.addVideo({
                'good_for_fav': True,
                'prev_url': cUrl,
                'title': '%s %s' % (title, baseTitle),
                'url': trailer,
                'icon': icon,
                'desc': desc
            })

        data = ph.find(data, ('<div', '>', 'full-video'), '</div>', flags=0)[1]
        url = self.getFullUrl(ph.search(data, ph.IFRAME_SRC_URI_RE)[1])
        if url:
            if ('/video/' in url and '/serials/' in url) or 'playlist' in url:
                url = strwithmeta(url, {'Referer': cUrl})
                seasons = self.hdgocc.getSeasonsList(url)
                for item in seasons:
                    self.addDir(
                        MergeDicts(
                            cItem, {
                                'good_for_fav': False,
                                'prev_url': cUrl,
                                'category': nextCategory,
                                'serie_title': baseTitle,
                                'title': 'Staffel %s' % item['title'],
                                'season_id': item['id'],
                                'url': item['url'],
                                'icon': icon,
                                'desc': desc
                            }))

                if 0 != len(seasons):
                    return

                seasonUrl = url
                episodes = self.hdgocc.getEpiodesList(seasonUrl, -1)
                for item in episodes:
                    title = '{0} - {1} - s01e{2} '.format(
                        baseTitle, item['title'],
                        str(item['id']).zfill(2))
                    self.addVideo({
                        'good_for_fav': False,
                        'type': 'video',
                        'prev_url': cUrl,
                        'title': title,
                        'url': item['url'],
                        'icon': icon,
                        'desc': desc
                    })

                if 0 != len(episodes):
                    return

            self.addVideo({
                'good_for_fav': False,
                'prev_url': cUrl,
                'title': baseTitle,
                'url': url,
                'icon': icon,
                'desc': desc
            })
        else:
            data = ph.find(data, 'vk.show(', ');', flags=0)[1].split(',',
                                                                     1)[-1]
            ret = js_execute('print(JSON.stringify(%s));' % data)
            if ret['sts'] and 0 == ret['code']:
                try:
                    data = json_loads(ret['data'])
                    for sNum, season in enumerate(data, 1):
                        subItems = []
                        for eNum, episode in enumerate(season, 1):
                            title = baseTitle + ' s%se%s' % (
                                str(sNum).zfill(2), str(eNum).zfill(2))
                            subItems.append({
                                'good_for_fav': False,
                                'type': 'video',
                                'prev_url': cUrl,
                                'title': title,
                                'url': episode,
                                'icon': icon,
                                'desc': desc
                            })
                        if subItems:
                            self.addDir(
                                MergeDicts(
                                    cItem, {
                                        'good_for_fav':
                                        False,
                                        'prev_url':
                                        cUrl,
                                        'title':
                                        'Staffel %s' % (str(sNum).zfill(2)),
                                        'category':
                                        'sub_items',
                                        'sub_items':
                                        subItems
                                    }))
                except Exception:
                    printExc()