def doDowanloadSubtitle(self, callback, subItem, tmpDir, subDir):
self.outerCallback = callback
self.tmpData = {'subItem':subItem, 'tmpDir':tmpDir, 'subDir':subDir}
# subItem === private_data
tmpFile = tmpDir + OpenSubOrgProvider.TMP_FILE_NAME
self.filesToRemove.append(tmpFile)
self.tmpData['tmpFile'] = tmpFile
tmpFile = " '{0}' ".format(tmpFile)
if not subItem.get('napisy_24', False):
params = {'User-Agent': OpenSubOrgProvider.USER_AGENT}
url = " '{0}' ".format(subItem['SubDownloadLink'])
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O ' + tmpFile + ' > /dev/null 2>&1 '
printDBG('doDowanloadSubtitle cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doDowanloadSubtitleCallback)
else:
tmpFileZip = self.tmpData['tmpFile'] + '.zip'
self.tmpData['tmpFileZip'] = tmpFileZip
self.filesToRemove.append(tmpFileZip)
tmpFileZip = " '{0}' ".format(tmpFileZip)
params = {'User-Agent': self.NAPISY24_USER_AGENT, 'Referer':'http://napisy24.pl/'}
url = "'http://napisy24.pl/run/pages/download.php?napisId={0}&typ=sr'".format(subItem['id'])
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O ' + tmpFileZip + ' > /dev/null 2>&1 '
printDBG('_doSearchSubtitleNapisy24Callback cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doDowanloadSubtitle24Callback)
def doDowanloadSubtitle(self, callback, subItem, tmpDir, subDir):
self.outerCallback = callback
self.tmpData = {"subItem": subItem, "tmpDir": tmpDir, "subDir": subDir}
# subItem === private_data
tmpFile = tmpDir + OpenSubOrgProvider.TMP_FILE_NAME
self.filesToRemove.append(tmpFile)
self.tmpData["tmpFile"] = tmpFile
tmpFile = " '{0}' ".format(tmpFile)
if not subItem.get("napisy_24", False):
params = {"User-Agent": OpenSubOrgProvider.USER_AGENT}
url = " '{0}' ".format(subItem["SubDownloadLink"])
cmd = DMHelper.getBaseWgetCmd(params) + url + " -O " + tmpFile + " > /dev/null 2>&1 "
printDBG("doDowanloadSubtitle cmd[%s]" % cmd)
self.iptv_sys = iptv_system(cmd, self._doDowanloadSubtitleCallback)
else:
tmpFileZip = self.tmpData["tmpFile"] + ".zip"
self.tmpData["tmpFileZip"] = tmpFileZip
self.filesToRemove.append(tmpFileZip)
tmpFileZip = " '{0}' ".format(tmpFileZip)
params = {"User-Agent": self.NAPISY24_USER_AGENT, "Referer": "http://napisy24.pl/"}
url = "'http://napisy24.pl/run/pages/download.php?napisId={0}&typ=sr'".format(subItem["id"])
cmd = DMHelper.getBaseWgetCmd(params) + url + " -O " + tmpFileZip + " > /dev/null 2>&1 "
printDBG("_doSearchSubtitleNapisy24Callback cmd[%s]" % cmd)
self.iptv_sys = iptv_system(cmd, self._doDowanloadSubtitle24Callback)
def doDowanloadSubtitle(self, callback, subItem, tmpDir, subDir):
self.outerCallback = callback
self.tmpData = {'subItem':subItem, 'tmpDir':tmpDir, 'subDir':subDir}
# subItem === private_data
tmpFile = tmpDir + OpenSubOrgProvider.TMP_FILE_NAME
self.filesToRemove.append(tmpFile)
self.tmpData['tmpFile'] = tmpFile
tmpFile = " '{0}' ".format(tmpFile)
if not subItem.get('napisy_24', False):
params = {'User-Agent': OpenSubOrgProvider.USER_AGENT}
url = " '{0}' ".format(subItem['SubDownloadLink'])
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O ' + tmpFile + ' > /dev/null 2>&1 '
printDBG('doDowanloadSubtitle cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doDowanloadSubtitleCallback)
else:
tmpFileZip = self.tmpData['tmpFile'] + '.zip'
self.tmpData['tmpFileZip'] = tmpFileZip
self.filesToRemove.append(tmpFileZip)
tmpFileZip = " '{0}' ".format(tmpFileZip)
params = {'User-Agent': self.NAPISY24_USER_AGENT, 'Referer':'http://napisy24.pl/'}
url = "'http://napisy24.pl/run/pages/download.php?napisId={0}&typ=sr'".format(subItem['id'])
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O ' + tmpFileZip + ' > /dev/null 2>&1 '
printDBG('_doSearchSubtitleNapisy24Callback cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doDowanloadSubtitle24Callback)
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(E2PrioFix(cmd))
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def goGetEpisodeType(self, privateData):
url = "'http://www.imdb.com/title/tt{0}/episodes/_ajax?season={1}'".format(privateData['id'], privateData['season'])
grep = '?ref_=ttep_ep{0}"'.format(privateData['episode'])
grep = " | grep '{0}'".format(grep)
cmd = DMHelper.getBaseWgetCmd({}) + url + ' -O - 2>/dev/null ' + grep
printDBG('doGetEpisodes cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._goGetEpisodeTypeCallback)
def doGetItemType(self, callback, privateData):
self.outerCallback = callback
self.tmpData = {}
self.itemTypeCache = {'type':'movie'}
url = "'https://api.themoviedb.org/3/find/tt{0}?api_key={1}&external_source=imdb_id'".format(privateData['id'], base64.b64decode('NjMxMWY4MmQ1MjAxNDI2NWQ3NjVkMzk4MDJhYWZhYTc='))
cmd = DMHelper.getBaseWgetCmd({}) + url + ' -O - 2> /dev/null '
self.iptv_sys = iptv_system(cmd, self._doGetItemTypeCallback)
def _doSearchMovieNapisy24(self):
params = {'User-Agent': self.NAPISY24_USER_AGENT, 'Referer':'http://napisy24.pl/'}
query = 'title={0}'.format(urllib.quote(self.tmpData['title']))
url = "'http://napisy24.pl/libs/webapi.php?{0}'".format(query)
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O - 2> /dev/null '
printDBG('_doSearchMovieNapisy24 cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doSearchMovieNapisy24Callback)
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
self.outData = ''
self.contentType = 'unknown'
# baseWgetCmd = DMHelper.getBaseWgetCmd(self.downloaderParams)
# TODO: add all HTTP parameters
addParams = ''
meta = strwithmeta(url).meta
if 'iptv_m3u8_key_uri_replace_old' in meta and 'iptv_m3u8_key_uri_replace_new' in meta:
addParams = ' -k "%s" -n "%s" ' % (meta['iptv_m3u8_key_uri_replace_old'], meta['iptv_m3u8_key_uri_replace_new'])
cmd = DMHelper.getBaseHLSDLCmd(self.downloaderParams) + (' "%s"' % self.url) + addParams + (' -o "%s"' % self.filePath) + ' > /dev/null'
printDBG("HLSDownloader::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( E2PrioFix( cmd ) )
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
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
def startDownloader(self, sts, reason):
if sts:
url,downloaderParams = DMHelper.getDownloaderParamFromUrl( self.cover['src'] )
self.cover['downloader'] .subscribeFor_Finish(self.downloaderEnd)
self.cover['downloader'] .start(url, self._getDownloadFilePath(), downloaderParams)
self.showSpinner()
else: self.session.openWithCallback(self.close, MessageBox, _("Downloading cannot be started.\n Downloader [%s] not working properly.\n Status[%s]") % (self.cover['downloader'].getName(), reason.strip()), type = MessageBox.TYPE_ERROR, timeout = 10 )
def getResolvedURL(self, url):
printDBG("LocalMedia.getResolvedURL [%s]" % url)
videoUrls = []
if url.startswith('/') and fileExists(url):
url = 'file://'+url
uri, params = DMHelper.getDownloaderParamFromUrl(url)
printDBG(params)
uri = urlparser.decorateUrl(uri, params)
if uri.meta.get('iptv_proto', '') in ['http', 'https']:
urlSupport = self.up.checkHostSupport( uri )
else:
urlSupport = 0
if 1 == urlSupport:
retTab = self.up.getVideoLinkExt( uri )
videoUrls.extend(retTab)
elif 0 == urlSupport and self._uriIsValid(uri):
if uri.split('?')[0].endswith('.m3u8'):
retTab = getDirectM3U8Playlist(uri)
videoUrls.extend(retTab)
elif uri.split('?')[0].endswith('.f4m'):
retTab = getF4MLinksWithMeta(uri)
videoUrls.extend(retTab)
else:
videoUrls.append({'name':'direct link', 'url':uri})
return videoUrls
def _getPageWget(self, url, params={}, post_data=None):
cmd = DMHelper.getBaseWgetCmd(params.get('header', {})) + (" '%s' " % url)
if post_data != None:
if params.get('raw_post_data', False):
post_data_str = post_data
else:
post_data_str = urllib.urlencode(post_data)
cmd += " --post-data '{0}' ".format(post_data_str)
if params.get('use_cookie', False):
cmd += " --keep-session-cookies "
cookieFile = str(params.get('cookiefile', ''))
if params.get('load_cookie', False) and fileExists(cookieFile):
cmd += " --load-cookies '%s' " % cookieFile
if params.get('save_cookie', False):
cmd += " --save-cookies '%s' " % cookieFile
cmd += ' -O - 2> /dev/null'
printDBG('_getPageWget request: [%s]' % cmd)
data = iptv_execute()( cmd )
if not data['sts'] or 0 != data['code']:
return False, None
else:
return True, data['data']
def getResolvedURL(self, url):
printDBG("LocalMedia.getResolvedURL [%s]" % url)
videoUrls = []
if url.startswith('/') and fileExists(url):
url = 'file://' + url
uri, params = DMHelper.getDownloaderParamFromUrl(url)
printDBG(params)
uri = urlparser.decorateUrl(uri, params)
if uri.meta.get('iptv_proto', '') in ['http', 'https']:
urlSupport = self.up.checkHostSupport(uri)
else:
urlSupport = 0
if 1 == urlSupport:
retTab = self.up.getVideoLinkExt(uri)
videoUrls.extend(retTab)
elif 0 == urlSupport and self._uriIsValid(uri):
if uri.split('?')[0].endswith('.m3u8'):
retTab = getDirectM3U8Playlist(uri)
videoUrls.extend(retTab)
elif uri.split('?')[0].endswith('.f4m'):
retTab = getF4MLinksWithMeta(uri)
videoUrls.extend(retTab)
else:
videoUrls.append({'name': 'direct link', 'url': uri})
return videoUrls
def _cmdFinished(self, code, terminated=False):
printDBG("MergeDownloader._cmdFinished code[%r] terminated[%r]" % (code, terminated))
# break circular references
if None != self.console:
self.console_appClosed_conn = None
self.console_stderrAvail_conn = None
self.console = None
if terminated:
self.status = DMHelper.STS.INTERRUPTED
self._cleanUp()
return
if self.status == DMHelper.STS.POSTPROCESSING:
self.localFileSize = DMHelper.getFileSize(self.filePath)
printDBG("POSTPROCESSING_cmdFinished localFileSize[%r] code[%r]" % (self.localFileSize, code))
if self.localFileSize > 0 and code == 0:
self.remoteFileSize = self.localFileSize
self.status = DMHelper.STS.DOWNLOADED
else:
self.status = DMHelper.STS.INTERRUPTED
elif code == 0:
if (self.currIdx + 1) < len(self.multi['urls']):
self.currIdx += 1
self.doStartDownload()
return
else:
self.status = DMHelper.STS.POSTPROCESSING
self.doStartPostProcess()
return
if not terminated:
self.onFinish()
self._cleanUp()
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
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
def _doSearchMovieNapisy24(self):
params = {'User-Agent': self.NAPISY24_USER_AGENT, 'Referer':'http://napisy24.pl/'}
query = 'title={0}'.format(urllib.quote(self.tmpData['title']))
url = "'http://napisy24.pl/libs/webapi.php?{0}'".format(query)
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O - 2> /dev/null '
printDBG('_doSearchMovieNapisy24 cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doSearchMovieNapisy24Callback)
def _startDownloader(self, sts, reason):
if sts:
self.downloader.subscribeFor_Finish(self.downloadFinished)
url,downloaderParams = DMHelper.getDownloaderParamFromUrl(self.currItem.get('url', ''))
self.downloader.start(url, GetTmpDir(self._TMP_FILE_NAME), downloaderParams)
else:
self["console"].setText(_("Download can not be started.\nDownloader %s not working correctly.\nStatus[%s]"))
def doStartDownload(self):
self.outData = ''
self.contentType = 'unknown'
filePath = self.multi['files'][self.currIdx]
url = self.multi['urls'][self.currIdx]
info = ""
retries = 0
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (
' %s -t %d ' % (info, retries)
) + '"' + url + '" -O "' + filePath + '" > /dev/null'
printDBG("doStartDownload 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(E2PrioFix(cmd))
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def _cmdFinished(self, code, terminated=False):
printDBG("MergeDownloader._cmdFinished code[%r] terminated[%r]" % (code, terminated))
# break circular references
if None != self.console:
self.console_appClosed_conn = None
self.console_stderrAvail_conn = None
self.console = None
if terminated:
self.status = DMHelper.STS.INTERRUPTED
self._cleanUp()
return
if self.status == DMHelper.STS.POSTPROCESSING:
self.localFileSize = DMHelper.getFileSize(self.filePath)
printDBG("POSTPROCESSING_cmdFinished localFileSize[%r] code[%r]" % (self.localFileSize, code))
if self.localFileSize > 0 and code == 0:
self.remoteFileSize = self.localFileSize
self.status = DMHelper.STS.DOWNLOADED
else:
self.status = DMHelper.STS.INTERRUPTED
elif code == 0:
if (self.currIdx + 1) < len(self.multi['urls']):
self.currIdx += 1
self.doStartDownload()
return
else:
self.status = DMHelper.STS.POSTPROCESSING
self.doStartPostProcess()
return
if not terminated:
self.onFinish()
self._cleanUp()
def _doSearchMovieNapisy24(self):
params = {"User-Agent": self.NAPISY24_USER_AGENT, "Referer": "http://napisy24.pl/"}
query = "title={0}".format(urllib.quote(self.tmpData["title"]))
url = "'http://napisy24.pl/libs/webapi.php?{0}'".format(query)
cmd = DMHelper.getBaseWgetCmd(params) + url + " -O - 2> /dev/null "
printDBG("_doSearchMovieNapisy24 cmd[%s]" % cmd)
self.iptv_sys = iptv_system(cmd, self._doSearchMovieNapisy24Callback)
def _startDownloader(self, sts, reason):
if sts:
self.downloader.subscribeFor_Finish(self.downloadFinished)
url,downloaderParams = DMHelper.getDownloaderParamFromUrl(self.currItem.get('url', ''))
self.downloader.start(url, GetTmpDir(self._TMP_FILE_NAME), downloaderParams)
else:
self["console"].setText(_("Download can not be started.\nDownloader %s not working correctly.\nStatus[%s]"))
def start(self, uri, mode='loop'):
self.uri = uri
self.playMode = mode
#'export GST_DEBUG="*:6" &&' +
cmd = '/usr/bin/gstplayer' + ' "%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(E2PrioFix(cmd))
self.stopped = False
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
self.outData = ''
self.contentType = 'unknown'
cmd = "python " + DMHelper.GET_PWGET_PATH(
) + ' "' + self.url + '" "' + self.filePath + '" > /dev/null'
printDBG("Download 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(E2PrioFix(cmd))
self.wgetStatus = self.WGET_STS.CONNECTING
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def _startFragment(self, tryAgain=False):
printDBG("_startFragment tryAgain[%r]" % tryAgain)
self.outData = ''
self.remoteFragmentSize = -1
self.remoteFragmentType = 'unknown'
if 0 > self.localFileSize:
self.m3u8_prevLocalFileSize = 0
else:
self.m3u8_prevLocalFileSize = self.localFileSize
##############################################################################
# frist download nextFragment conntent
##############################################################################
self.downloadType = self.DOWNLOAD_TYPE.SEGMENT
if None != self.console:
self.console_appClosed_conn = None
self.console_stderrAvail_conn = None
#self.console = eConsoleAppContainer()
self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self._cmdFinished )
self.console_stderrAvail_conn = eConnectCallback(self.console.stderrAvail, self._dataAvail )
if tryAgain and self.tries >= self.MAX_RETRIES:
if not self.liveStream:
return DMHelper.STS.INTERRUPTED
else:
# even if fragment is lost this is not big problem, download next one,
# this is a live stream this can happen :)
tryAgain = False
currentFragment = None
if False == tryAgain:
self.tries = 0
if (self.currentFragment + 1) < len(self.fragmentList):
self.currentFragment += 1
currentFragment = self.fragmentList[self.currentFragment]
else:
self.tries += 1
currentFragment = self.fragmentList[self.currentFragment]
if None != currentFragment:
self.wgetStatus = self.WGET_STS.CONNECTING
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (' --tries=1 --timeout=%d ' % self._getTimeout()) + '"' + currentFragment + '" -O - >> "' + self.filePath + '"'
printDBG("Download cmd[%s]" % cmd)
self.console.execute( E2PrioFix( cmd ) )
#with open("/home/sulge/tmp/m3u8.txt", "a") as myfile:
#with open("/hdd/dbg_m3u8.txt", "a") as myfile:
# myfile.write(currentFragment+"\n")
return DMHelper.STS.DOWNLOADING
else:
if self.liveStream:
# we are in live so wait for new fragments
printDBG("m3u8 downloader - wait for new fragments ----------------------------------------------------------------")
self.downloadType = self.DOWNLOAD_TYPE.WAITTING
self.console.execute( E2PrioFix( "sleep 2" ) )
return DMHelper.STS.DOWNLOADING
else:
return DMHelper.STS.DOWNLOADED
def start(self, url, filePath, params = {}, info_from=None, retries=0):
'''
Owervrite start from BaseDownloader
'''
self.url = url
self.filePath = filePath
self.downloaderParams = params
self.fileExtension = '' # should be implemented in future
self.outData = ''
self.contentType = 'unknown'
if None == info_from:
info_from = WgetDownloader.INFO.FROM_FILE
self.infoFrom = info_from
if self.infoFrom == WgetDownloader.INFO.FROM_DOTS:
info = "--progress=dot:default"
else: info = ""
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (' %s -t %d ' % (info, retries)) + '"' + self.url + '" -O "' + self.filePath + '" > /dev/null'
printDBG("Download 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( E2PrioFix( cmd ) )
self.wgetStatus = self.WGET_STS.CONNECTING
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def goGetEpisodeType(self, privateData):
url = "'http://www.imdb.com/title/tt{0}/episodes/_ajax?season={1}'".format(privateData['id'], privateData['season'])
grep = '?ref_=ttep_ep{0}"'.format(privateData['episode'])
grep = " | grep '{0}'".format(grep)
cmd = DMHelper.getBaseWgetCmd({}) + url + ' -O - 2>/dev/null ' + grep
printDBG('doGetEpisodes cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._goGetEpisodeTypeCallback)
def startDownloader(self, sts, reason):
if sts:
url,downloaderParams = DMHelper.getDownloaderParamFromUrl( self.cover['src'] )
self.cover['downloader'] .subscribeFor_Finish(self.downloaderEnd)
self.cover['downloader'] .start(url, self._getDownloadFilePath(), downloaderParams)
self.showSpinner()
else: self.session.openWithCallback(self.close, MessageBox, _("Downloading cannot be started.\n Downloader [%s] not working properly.\n Status[%s]") % (self.cover['downloader'].getName(), reason.strip()), type = MessageBox.TYPE_ERROR, timeout = 10 )
def start(self, url, filePath, params={}, info_from=None, retries=0):
'''
Owervrite start from BaseDownloader
'''
self.url = url
self.filePath = filePath
self.downloaderParams = params
self.fileExtension = '' # should be implemented in future
self.outData = ''
self.contentType = 'unknown'
if None == info_from:
info_from = WgetDownloader.INFO.FROM_FILE
self.infoFrom = info_from
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (
' --progress=dot:default -t %d ' % retries
) + '"' + self.url + '" -O "' + self.filePath + '" > /dev/null'
printDBG("Download 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.wgetStatus = self.WGET_STS.CONNECTING
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def _startFragment(self, tryAgain=False):
printDBG("_startFragment tryAgain[%r]" % tryAgain)
self.outData = ''
self.remoteFragmentSize = -1
self.remoteFragmentType = 'unknown'
if 0 > self.localFileSize:
self.m3u8_prevLocalFileSize = 0
else:
self.m3u8_prevLocalFileSize = self.localFileSize
##############################################################################
# frist download nextFragment conntent
##############################################################################
self.downloadType = self.DOWNLOAD_TYPE.SEGMENT
if None != self.console:
self.console_appClosed_conn = None
self.console_stderrAvail_conn = None
#self.console = eConsoleAppContainer()
self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self._cmdFinished )
self.console_stderrAvail_conn = eConnectCallback(self.console.stderrAvail, self._dataAvail )
if tryAgain and self.tries >= self.MAX_RETRIES:
if not self.liveStream:
return DMHelper.STS.INTERRUPTED
else:
# even if fragment is lost this is not big problem, download next one,
# this is a live stream this can happen :)
tryAgain = False
currentFragment = None
if False == tryAgain:
self.tries = 0
if (self.currentFragment + 1) < len(self.fragmentList):
self.currentFragment += 1
currentFragment = self.fragmentList[self.currentFragment]
else:
self.tries += 1
currentFragment = self.fragmentList[self.currentFragment]
if None != currentFragment:
self.wgetStatus = self.WGET_STS.CONNECTING
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (' --tries=1 --timeout=%d ' % self._getTimeout()) + '"' + currentFragment + '" -O - >> "' + self.filePath + '"'
printDBG("Download cmd[%s]" % cmd)
self.console.execute( cmd )
#with open("/home/sulge/tmp/m3u8.txt", "a") as myfile:
# myfile.write(currentFragment+"\n")
return DMHelper.STS.DOWNLOADING
else:
if self.liveStream:
# we are in live so wait for new fragments
printDBG("m3u8 downloader - wait for new fragments ----------------------------------------------------------------")
self.downloadType = self.DOWNLOAD_TYPE.WAITTING
self.console.execute( "sleep 2" )
return DMHelper.STS.DOWNLOADING
else:
return DMHelper.STS.DOWNLOADED
def doGetItemType(self, callback, privateData):
self.outerCallback = callback
self.tmpData = {'imdbid':privateData['id'], 'title':privateData['title']}
self.itemTypeCache = {'type':'movie'}
url = "'https://api.themoviedb.org/3/find/tt{0}?api_key={1}&external_source=imdb_id'".format(privateData['id'], base64.b64decode('NjMxMWY4MmQ1MjAxNDI2NWQ3NjVkMzk4MDJhYWZhYTc='))
#printDBG(url)
cmd = DMHelper.getBaseWgetCmd({}) + url + ' -O - 2> /dev/null '
self.iptv_sys = iptv_system(cmd, self._doGetItemTypeCallback)
def runCMD(self, item):
printDBG("runCMD for downloadIdx[%d]" % item.downloadIdx)
if DMHelper.DOWNLOAD_TYPE.INITIAL == item.tries:
item.fileName = DMHelper.makeUnikalFileName(item.fileName, False, False)
printDBG("Downloading started downloadIdx[%s] File[%s] URL[%s]" % (item.downloadIdx, item.fileName, item.url) )
listUDIdx = self.findIdxInQueueUD(item.downloadIdx)
self.queueUD[listUDIdx].status = DMHelper.STS.DOWNLOADING
self.queueUD[listUDIdx].fileName = item.fileName
url, downloaderParams = DMHelper.getDownloaderParamFromUrl(item.url)
self.queueUD[listUDIdx].downloader = DownloaderCreator(url)
self.queueUD[listUDIdx].callback = boundFunction(self.cmdFinished, item.downloadIdx)
self.queueUD[listUDIdx].downloader.subscribeFor_Finish( self.queueUD[listUDIdx].callback )
self.queueUD[listUDIdx].downloader.start(url, item.fileName, downloaderParams)
def doGetItemTypeOLD(self, callback, privateData):
self.outerCallback = callback
self.tmpData = {}
self.itemTypeCache = {'type':'movie'}
url = "'http://www.omdbapi.com/?i=tt{0}&plot=short&r=json'".format(privateData['id'])
cmd = DMHelper.getBaseWgetCmd({}) + url + ' -O - 2> /dev/null '
printDBG('doGetItemType cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doGetItemTypeCallback)
def runCMD(self, item):
printDBG("runCMD for downloadIdx[%d]" % item.downloadIdx)
if DMHelper.DOWNLOAD_TYPE.INITIAL == item.tries:
item.fileName = DMHelper.makeUnikalFileName(item.fileName, False, False)
printDBG("Downloading started downloadIdx[%s] File[%s] URL[%s]" % (item.downloadIdx, item.fileName, item.url) )
listUDIdx = self.findIdxInQueueUD(item.downloadIdx)
self.queueUD[listUDIdx].status = DMHelper.STS.DOWNLOADING
self.queueUD[listUDIdx].fileName = item.fileName
url, downloaderParams = DMHelper.getDownloaderParamFromUrl(item.url)
self.queueUD[listUDIdx].downloader = DownloaderCreator(url)
self.queueUD[listUDIdx].callback = boundFunction(self.cmdFinished, item.downloadIdx)
self.queueUD[listUDIdx].downloader.subscribeFor_Finish( self.queueUD[listUDIdx].callback )
self.queueUD[listUDIdx].downloader.start(url, item.fileName, downloaderParams)
def _startDownloader(self, sts, reason):
if sts:
self.downloader.subscribeFor_Finish(self.downloadFinished)
url, downloaderParams = DMHelper.getDownloaderParamFromUrl(self.uri)
self.downloader.start(url, self.outFile, downloaderParams)
else:
error, desc = self.downloader.getLastError()
self["console"].setText(_("Download can not be started.\nDownloader %s not working correctly.\nLast error \"%s (%s)\".") % (self.downloader.getName(), desc, error))
def doGetItemTypeOLD(self, callback, privateData):
self.outerCallback = callback
self.tmpData = {}
self.itemTypeCache = {"type": "movie"}
url = "'http://www.omdbapi.com/?i=tt{0}&plot=short&r=json'".format(privateData["id"])
cmd = DMHelper.getBaseWgetCmd({}) + url + " -O - 2> /dev/null "
printDBG("doGetItemType cmd[%s]" % cmd)
self.iptv_sys = iptv_system(cmd, self._doGetItemTypeCallback)
def doStartPostProcess(self):
cmd = DMHelper.GET_FFMPEG_PATH() + ' '
for item in self.multi['files']:
cmd += ' -i "{0}" '.format(item)
cmd += ' -map 0:0 -map 1:0 -vcodec copy -acodec copy "{0}" >/dev/null 2>&1 '.format(self.filePath)
printDBG("doStartPostProcess cmd[%s]" % cmd)
self.console = eConsoleAppContainer()
self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self._cmdFinished)
self.console.execute( E2PrioFix( cmd ) )
def doGetItemType(self, callback, privateData):
self.outerCallback = callback
self.tmpData = {}
self.itemTypeCache = {"type": "movie"}
url = "'https://api.themoviedb.org/3/find/tt{0}?api_key={1}&external_source=imdb_id'".format(
privateData["id"], base64.b64decode("NjMxMWY4MmQ1MjAxNDI2NWQ3NjVkMzk4MDJhYWZhYTc=")
)
cmd = DMHelper.getBaseWgetCmd({}) + url + " -O - 2> /dev/null "
self.iptv_sys = iptv_system(cmd, self._doGetItemTypeCallback)
def _doStart(self, force=False):
if self.autoRefresh or force:
self.refreshing = True
self.downloader = DownloaderCreator(self.url)
url,downloaderParams = DMHelper.getDownloaderParamFromUrl(self.url)
self.downloader.subscribeFor_Finish(self.downloaderEnd)
self.downloader.start(url, self._getDownloadFilePath(), downloaderParams)
self.setMainTimerSts(True)
else: self.refreshing = False
def _startDownloader(self, sts, reason):
if sts:
url,downloaderParams = DMHelper.getDownloaderParamFromUrl(self.url)
if self._isFlvInfiniteFile(self.url):
ret = touch(self.GST_FLV_DEMUX_IS_DEMUXING_INFINITE_FILE) # TODO: check returns value, and display message in case of False
self.downloader.start(url, self.filePath, downloaderParams)
self.setMainTimerSts(True)
self.canRunMoviePlayer = True
else:
self.session.openWithCallback(self.close, MessageBox, _("Pobieranie nie może zostać rozpoczęte.\n Downloader %s nie działa prawidłowo.\nStatus[%s]") % (self.downloader.getName(), reason.strip()), type = MessageBox.TYPE_ERROR, timeout = 10 )
def _startDownloader(self, sts, reason):
if sts:
url,downloaderParams = DMHelper.getDownloaderParamFromUrl(self.url)
if url.split('?', 1)[0].lower().endswith('.mp4'):
self.clouldBeMP4 = True
self.downloader.start(url, self.filePath, downloaderParams)
self.setMainTimerSts(True)
self.canRunMoviePlayer = True
else:
self.session.openWithCallback(self.iptvDoClose, MessageBox, _("Downloading can not be started.\n Downloader %s does not work properly.\nStatus[%s]") % (self.downloader.getName(), reason.strip()), type = MessageBox.TYPE_ERROR, timeout = 10 )
def start(self, url, filePath, params={}, info_from=None, retries=0):
'''
Owervrite start from BaseDownloader
'''
self.url = url
self.filePath = filePath
self.downloaderParams = params
self.fileExtension = '' # should be implemented in future
rtmpdump_url = self._getCMD(url)
if 0:
#rtmpdump -r rtmp://5.79.71.195/stream/ --playpath=3001_goldvod --swfUrl=http://goldvod.tv:81/j/jwplayer/jwplayer.flash.swf --pageUrl=http://goldvod.tv/tv-online/tvp1.html -o tvp1.flv
tmpTab = url.split(' ')
rtmpdump_url = '"' + tmpTab[0].strip() + '"'
del tmpTab[0]
prevflashVer = ''
for item in tmpTab:
item = item.strip()
# ignore empty and live params
if '' != prevflashVer:
rtmpdump_url += ' --' + prevflashVer[
0:-1] + ' ' + item + '"'
prevflashVer = ''
continue
idx = item.find('=')
if -1 == idx:
continue
argName = item[:idx]
argValue = item[idx + 1:]
if 'live' in argName:
item = 'live'
else:
item = '%s="%s"' % (argName, argValue)
if 'flashVer' == argName:
prevflashVer = item
continue
rtmpdump_url += ' --' + item
cmd = DMHelper.GET_RTMPDUMP_PATH(
) + " " + rtmpdump_url + ' --realtime -o "' + self.filePath + '" > /dev/null 2>&1'
printDBG("rtmpdump cmd[%s]" % cmd)
self.console = eConsoleAppContainer()
self.console_appClosed_conn = eConnectCallback(self.console.appClosed,
self._cmdFinished)
#self.console.stderrAvail.append( self._dataAvail )
self.console.execute(E2PrioFix(cmd))
self.rtmpStatus = self.RTMP_STS.CONNECTING
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def _getPage(self, callback, url, params={}, post_data=None):
if 'User-Agent' not in params: params['User-Agent'] =OpenSubOrgProvider.USER_AGENT
if None != post_data:
post_data = " --post-data '{0}' ".format(post_data)
else: post_data = ''
url = " '{0}' ".format(url)
cmd = DMHelper.getBaseWgetCmd(params) + post_data + url + ' -O - 2> /dev/null'
self.iptv_sys = iptv_system(cmd, callback)
def _checkWorkingCallBack(self, callBackFun, code, data):
reason = ''
sts = True
if code != 0:
ffmpegBinaryName = DMHelper.GET_FFMPEG_PATH()
if ffmpegBinaryName == '': ffmpegBinaryName = 'ffmpeg'
sts = False
if code == 127: reason = _('Utility "%s" can not be found.' % ffmpegBinaryName)
else: reason = data
self.iptv_sys = None
callBackFun(sts, reason)
def _getPage(self, callback, url, params={}, post_data=None):
if 'User-Agent' not in params: params['User-Agent'] =OpenSubOrgProvider.USER_AGENT
if None != post_data:
post_data = " --post-data '{0}' ".format(post_data)
else: post_data = ''
url = " '{0}' ".format(url)
cmd = DMHelper.getBaseWgetCmd(params) + post_data + url + ' -O - 2> /dev/null'
self.iptv_sys = iptv_system(cmd, callback)
def UpdateDownloaderCreator(url):
printDBG("UpdateDownloaderCreator url[%s]" % url)
if url.startswith('https'):
if IsExecutable(DMHelper.GET_WGET_PATH()):
printDBG("UpdateDownloaderCreator WgetDownloader")
return WgetDownloader()
elif IsExecutable('python'):
printDBG("UpdateDownloaderCreator PwgetDownloader")
return PwgetDownloader()
else:
if IsExecutable('wget'):
printDBG("UpdateDownloaderCreator BuxyboxWgetDownloader")
return BuxyboxWgetDownloader()
elif IsExecutable(DMHelper.GET_WGET_PATH()):
printDBG("UpdateDownloaderCreator WgetDownloader")
return WgetDownloader()
elif IsExecutable('python'):
printDBG("UpdateDownloaderCreator PwgetDownloader")
return PwgetDownloader()
printDBG("UpdateDownloaderCreator downloader not available")
return PwgetDownloader()
def _doSearchSubtitleNapisy24(self, type='imdb'):
self.tmpData['type'] = type
params = {'User-Agent': self.NAPISY24_USER_AGENT, 'Referer':'http://napisy24.pl/'}
if type == 'imdb':
query = 'imdb=tt{0}'.format(self.tmpData['imdbid'])
else:
query = 'title={0}'.format(urllib.quote(self.tmpData['title']))
url = "'http://napisy24.pl/libs/webapi.php?{0}'".format(query)
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O - 2> /dev/null '
printDBG('_doSearchSubtitleNapisy24Callback cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doSearchSubtitleNapisy24Callback)
def _doSearchSubtitleNapisy24(self, type='imdb'):
self.tmpData['type'] = type
params = {'User-Agent': self.NAPISY24_USER_AGENT, 'Referer':'http://napisy24.pl/'}
if type == 'imdb':
query = 'imdb=tt{0}'.format(self.tmpData['imdbid'])
else:
query = 'title={0}'.format(urllib.quote(self.tmpData['title']))
url = "'http://napisy24.pl/libs/webapi.php?{0}'".format(query)
cmd = DMHelper.getBaseWgetCmd(params) + url + ' -O - 2> /dev/null '
printDBG('_doSearchSubtitleNapisy24Callback cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doSearchSubtitleNapisy24Callback)
def _localFileSize(self, update=True):
printDBG(">>>>>>>>>>>>>>>>>>>>> _localFileSize [%r] loacalSize[%r] = %r" % (self.localFileSize, self.currIdx, self.multi['local_size']))
if self.localFileSize > 0:
return self.localFileSize
else:
if update:
self.multi['local_size'][self.currIdx] = DMHelper.getFileSize(self.multi['files'][self.currIdx])
localFileSize = 0
for item in self.multi['local_size']:
if item > 0:
localFileSize += item
return localFileSize
return 0
def _localFileSize(self, update=True):
printDBG(">>>>>>>>>>>>>>>>>>>>> _localFileSize [%r] loacalSize[%r] = %r" % (self.localFileSize, self.currIdx, self.multi['local_size']))
if self.localFileSize > 0:
return self.localFileSize
else:
if update:
self.multi['local_size'][self.currIdx] = DMHelper.getFileSize(self.multi['files'][self.currIdx])
localFileSize = 0
for item in self.multi['local_size']:
if item > 0:
localFileSize += item
return localFileSize
return 0
def _startM3U8(self, m3u8Url):
self.m3u8Url = m3u8Url
self.outData = ''
##############################################################################
# frist download m3u8 conntent
##############################################################################
self.downloadType = self.DOWNLOAD_TYPE.M3U8
m3u8Url = self._addTimeStampToUrl( self.m3u8Url )
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (' --tries=0 --timeout=%d ' % self._getTimeout()) + '"' + m3u8Url + '" -O - 2> /dev/null'
printDBG("Download cmd[%s]" % cmd)
self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self._cmdFinished )
self.console_stdoutAvail_conn = eConnectCallback(self.console.stdoutAvail, self._dataAvail )
self.console.execute( E2PrioFix( cmd ) )
def _doSearchSubtitleNapisy24(self, type="imdb"):
self.tmpData["type"] = type
params = {"User-Agent": self.NAPISY24_USER_AGENT, "Referer": "http://napisy24.pl/"}
if type == "imdb":
query = "imdb=tt{0}".format(self.tmpData["imdbid"])
else:
query = "title={0}".format(urllib.quote(self.tmpData["title"]))
url = "'http://napisy24.pl/libs/webapi.php?{0}'".format(query)
cmd = DMHelper.getBaseWgetCmd(params) + url + " -O - 2> /dev/null "
printDBG("_doSearchSubtitleNapisy24Callback cmd[%s]" % cmd)
self.iptv_sys = iptv_system(cmd, self._doSearchSubtitleNapisy24Callback)
def _updateM3U8Finished(self, code=0):
printDBG('m3u8 _updateM3U8Finished update code[%d]--- ' % (code))
if self.liveStream and self.M3U8Updater:
if 0 < len(self.M3U8ListData) and 0 == code:
try:
m3u8Obj = m3u8.inits(self.M3U8ListData, self.m3u8Url)
if self.liveStream and not m3u8Obj.is_variant:
self.refreshDelay = int(m3u8Obj.target_duration)
if self.refreshDelay < 5:
self.refreshDelay = 5
if 0 < len(m3u8Obj.segments):
newFragments = [
self._segUri(seg.absolute_uri)
for seg in m3u8Obj.segments
]
#self.mergeFragmentsList(newFragments)
self.mergeFragmentsListWithChecking(
newFragments,
m3u8Obj.media_sequence + len(m3u8Obj.segments))
printDBG(
'm3u8 _updateM3U8Finished list updated ---')
except Exception:
printDBG(
"m3u8 _updateM3U8Finished exception url[%s] data[%s]" %
(self.m3u8Url, self.M3U8ListData))
else:
printDBG('m3u8 _updateM3U8Finished no data ---')
# hardcode
self.M3U8UpdaterRefreshDelay += 1
if self.refreshDelay < self.M3U8UpdaterRefreshDelay or 0 != code:
self.M3U8UpdaterRefreshDelay = 0
self.M3U8ListData = ''
m3u8Url = self._addTimeStampToUrl(self.m3u8Url)
printDBG(
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [%s]"
% m3u8Url)
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (
' --tries=0 --timeout=%d ' %
self._getTimeout()) + '"' + m3u8Url + '" -O - 2> /dev/null'
printDBG("m3u8 _updateM3U8Finished download cmd[%s]" % cmd)
self.M3U8Updater.execute(E2PrioFix(cmd))
return
else:
self.M3U8Updater.execute(E2PrioFix("sleep 1"))
return
printDBG(
"|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||")
printDBG(
"||||||||||||| m3u8 _updateM3U8Finished FINISHED |||||||||||||")
printDBG(
"|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||")
def _startM3U8(self, wait=0):
self.outData = ''
##############################################################################
# frist download m3u8 conntent
##############################################################################
self.downloadType = self.DOWNLOAD_TYPE.M3U8
m3u8Url = self._addTimeStampToUrl( self.m3u8Url )
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (' --tries=0 --timeout=%d ' % self._getTimeout()) + '"' + m3u8Url + '" -O '
if wait > 0:
cmd = (' sleep %s && ' % wait) + cmd
printDBG("Download cmd[%s]" % cmd)
self.console_appClosed_conn = eConnectCallback(self.console.appClosed, self._cmdFinished )
self.console_stdoutAvail_conn = eConnectCallback(self.console.stdoutAvail, self._dataAvail )
self.console.execute( E2PrioFix( cmd ) )
def doGetEpisodesOld(self, callback, privateData, episodeData):
self.outerCallback = callback
self.tmpData = {'private_data':privateData, 'episode_data':episodeData}
year = self.itemTypeCache.get('year', '')
if year != '':
year = '&year=%s' % year
else:
year = ''
url = "'http://imdbapi.poromenos.org/js/?name={0}{1}'".format(urllib.quote(self.itemTypeCache.get('title', '')), year)
cmd = DMHelper.getBaseWgetCmd({}) + url + ' -O - 2> /dev/null '
printDBG('doGetEpisodes cmd[%s]' % cmd)
self.iptv_sys = iptv_system(cmd, self._doGetEpisodesCallback)
def doGetEpisodes(self, callback, privateData, episodeData):
self.outerCallback = callback
self.tmpData = {"private_data": privateData, "episode_data": episodeData}
year = self.itemTypeCache.get("year", "")
if year != "":
year = "&year=%s" % year
else:
year = ""
url = "'http://imdbapi.poromenos.org/js/?name={0}{1}'".format(
urllib.quote(self.itemTypeCache.get("title", "")), year
)
cmd = DMHelper.getBaseWgetCmd({}) + url + " -O - 2> /dev/null "
printDBG("doGetEpisodes cmd[%s]" % cmd)
self.iptv_sys = iptv_system(cmd, self._doGetEpisodesCallback)
def start(self, url, filePath, params = {}):
self.url = url
self.filePath = filePath
self.downloaderParams = params
self.fileExtension = '' # should be implemented in future
sts,remoteInfo = DMHelper.getRemoteContentInfoByUrllib(url, params)
if False == sts:
return BaseDownloader.CODE_WRONG_LINK
else:
self.remoteFileSize = int(remoteInfo.get('Content-Length', '-1'))
sts = self._start()
if sts == BaseDownloader.CODE_OK:
self.onStart()
return sts
def doStartDownload(self):
self.outData = ''
self.contentType = 'unknown'
filePath = self.multi['files'][self.currIdx]
url = self.multi['urls'][self.currIdx]
info = ""
retries = 0
cmd = DMHelper.getBaseWgetCmd(self.downloaderParams) + (' %s -t %d ' % (info, retries)) + '"' + url + '" -O "' + filePath + '" > /dev/null'
printDBG("doStartDownload 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( E2PrioFix( cmd ) )
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def getLinksForVideo(self, cItem):
printDBG("Urllist.getLinksForVideo url[%s]" % cItem['url'])
videoUrls = []
uri, params = DMHelper.getDownloaderParamFromUrl(cItem['url'])
printDBG(params)
uri = urlparser.decorateUrl(uri, params)
urlSupport = self.up.checkHostSupport( uri )
if 1 == urlSupport:
retTab = self.up.getVideoLinkExt( uri )
videoUrls.extend(retTab)
elif 0 == urlSupport and self._uriIsValid(uri):
if uri.split('?')[0].endswith('.m3u8'):
retTab = getDirectM3U8Playlist(uri)
videoUrls.extend(retTab)
elif uri.split('?')[0].endswith('.f4m'):
retTab = getF4MLinksWithMeta(uri)
videoUrls.extend(retTab)
else:
videoUrls.append({'name':'direct link', 'url':uri})
return videoUrls
