def playF4mLink(url, name):
print "URL: " + url
listitem = xbmcgui.ListItem("myfile")
downloader = F4MDownloader()
runningthread = thread.start_new_thread(downloader.download, (
'myfile.flv',
url,
stopPlaying,
))
progress = xbmcgui.DialogProgress()
progress.create('Starting Stream')
stream_delay = 10
xbmc.sleep(stream_delay * 1000)
mplayer = MyPlayer()
filename = downloader.outputfile
#DIR_USERDATA + "/myfile.flv"
progress.close()
mplayer.play(filename, listitem)
while True:
xbmc.log('Sleeping...')
xbmc.sleep(1000)
if stopPlaying.isSet():
break
#if not mplayer.isPlaying():
# break
#runningthread.event.set()
print 'Job done'
#xbmc.sleep(3)
#while xbmc.Player().isPlaying():
# print "Playing"
# xbmc.sleep(100)
try:
os.remove(filename)
except:
pass
return
def answer_request(self, sendData):
global g_stopEvent
global g_downloader
try:
#Pull apart request path
request_path = self.path[1:]
request_path = re.sub(r"\?.*", "", request_path)
#If a request to stop is sent, shut down the proxy
if request_path.lower(
) == "stop": # all special web interfaces here
sys.exit()
return
if request_path.lower() == "favicon.ico":
#print 'dont have no icone here, may be in future'
self.wfile.close()
return
(url, proxy, use_proxy_for_chunks, maxbitrate, simpledownloader,
auth, streamtype) = self.decode_url(request_path)
#print 'simpledownloaderxxxxxxxxxxxxxxx',simpledownloader
if streamtype == '' or streamtype == None or streamtype == 'none':
streamtype = 'HDS'
if streamtype == 'HDS':
#print 'Url received at proxy',url,proxy,use_proxy_for_chunks,maxbitrate
#Send file request
#self.handle_send_request(download_id,file_url, file_name, requested_range,download_mode ,keep_file,connections)
downloader = None
#downloader=g_downloader
if not downloader or downloader.live == True or not (
downloader.init_done and downloader.init_url == url):
downloader = F4MDownloader()
if not downloader.init(self.wfile, url, proxy,
use_proxy_for_chunks, g_stopEvent,
maxbitrate, auth):
#print 'cannot init'
return
g_downloader = downloader
#print 'init...'
enableSeek = False
requested_range = self.headers.getheader("Range")
if requested_range == None: requested_range = ""
srange, erange = (None, None)
if downloader.live == False and len(
requested_range
) > 0 and not requested_range == "bytes=0-0": #we have to stream?
enableSeek = True
(srange,
erange) = self.get_range_request(requested_range,
downloader.total_frags)
#print 'PROXY DATA',downloader.live,enableSeek,requested_range,downloader.total_frags,srange, erange
enableSeek = False ##disabled for time being, couldn't find better way to handle
framgementToSend = 0
inflate = 1815002 #(6526684-466/3)#*373/downloader.total_frags# 4142*1024*243/8/40 #1#1024*1024
if enableSeek:
#rtype="video/x-flv" #just as default
self.send_response(206)
rtype = "flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
self.send_header("Accept-Ranges", "bytes")
#print 'not LIVE,enable seek',downloader.total_frags
totalsize = downloader.total_frags * inflate
framgementToSend = 1 #downloader.total_frags
erange = srange + framgementToSend * inflate
if erange >= totalsize:
erange = totalsize - 1
# crange="bytes "+str(srange)+"-" +str(int(downloader.total_frags-1))+"/"+str(downloader.total_frags)#recalculate crange based on srange, portionLen and content_size
# crange="bytes "+str(srange)+"-" +str(int(totalsize-1))+"/"+str(totalsize)#recalculate crange based on srange, portionLen and content_size
crange = "bytes " + str(srange) + "-" + str(
int(erange)
) + "/*" #+str(totalsize)#recalculate crange based on srange, portionLen and content_size
#print srange/inflate,erange/inflate,totalsize/inflate
self.send_header("Content-Length", str(totalsize))
self.send_header("Content-Range", crange)
etag = self.generate_ETag(url)
self.send_header("ETag", etag)
#print crange
self.send_header("Last-Modified",
"Wed, 21 Feb 2000 08:43:39 GMT")
self.send_header("Cache-Control",
"public, must-revalidate")
self.send_header("Cache-Control", "no-cache")
self.send_header("Pragma", "no-cache")
self.send_header("features", "seekable,stridable")
self.send_header("client-id", "12345")
self.send_header("Connection", 'close')
else:
self.send_response(200)
rtype = "flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange = None
elif streamtype == 'SIMPLE' or simpledownloader:
downloader = interalSimpleDownloader()
if not downloader.init(self.wfile, url, proxy, g_stopEvent,
maxbitrate):
#print 'cannot init'
return
srange, framgementToSend = (None, None)
self.send_response(200)
rtype = "flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange = None
elif streamtype == 'HLS' or simpledownloader:
downloader = HLSDownloader()
if not downloader.init(self.wfile, url, proxy,
use_proxy_for_chunks, g_stopEvent,
maxbitrate, auth):
#print 'cannot init'
return
srange, framgementToSend = (None, None)
self.send_response(200)
rtype = "flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange = None
#rtype="flv-application/octet-stream" #default type could have gone to the server to get it.
#self.send_header("Content-Type", rtype)
self.end_headers()
if not srange == None:
srange = srange / inflate
if sendData:
downloader.keep_sending_video(self.wfile, srange,
framgementToSend)
#runningthread=thread.start_new_thread(downloader.download,(self.wfile,url,proxy,use_proxy_for_chunks,))
#print 'srange,framgementToSend',srange,framgementToSend
#runningthread=thread.start_new_thread(downloader.keep_sending_video,(self.wfile,srange,framgementToSend,))
xbmc.sleep(500)
while not downloader.status == "finished":
xbmc.sleep(200)
except:
##print out a stack trace
traceback.print_exc()
g_stopEvent.set()
self.send_response(404)
#Close output stream file
self.wfile.close()
return
#Close output stream file
self.wfile.close()
return
def answer_request(self, sendData):
global g_stopEvent
global g_downloader
global g_currentprocessor
try:
#Pull apart request path
request_path=self.path[1:]
querystring=request_path
request_path=re.sub(r"\?.*","",request_path)
#If a request to stop is sent, shut down the proxy
if request_path.lower()=="stop":# all special web interfaces here
sys.exit()
return
if request_path.lower()=="favicon.ico":
print 'dont have no icone here, may be in future'
self.wfile.close()
return
if request_path.lower()=="sendvideopart":
print 'dont have no icone here, may be in future'
#sendvideoparthere
self.send_response(200)
rtype="video/mp2t" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
self.end_headers()
initDone=True
videourl=self.decode_videoparturl(querystring.split('?')[1])
g_currentprocessor.sendVideoPart(videourl,self.wfile)
#self.wfile.close()
return
initDone=False
(url,proxy,use_proxy_for_chunks,maxbitrate,simpledownloader, auth,streamtype,swf ,callbackpath, callbackparam)=self.decode_url(request_path)
print 'simpledownloaderxxxxxxxxxxxxxxx',simpledownloader
if streamtype=='' or streamtype==None or streamtype=='none': streamtype='HDS'
if streamtype=='HDS':
print 'Url received at proxy',url,proxy,use_proxy_for_chunks,maxbitrate
#Send file request
#self.handle_send_request(download_id,file_url, file_name, requested_range,download_mode ,keep_file,connections)
downloader=None
#downloader=g_downloader
if not downloader or downloader.live==True or not (downloader.init_done and downloader.init_url ==url):
from f4mDownloader import F4MDownloader
downloader=F4MDownloader()
if not downloader.init(self.wfile,url,proxy,use_proxy_for_chunks,g_stopEvent,maxbitrate,auth,swf):
print 'cannot init'
raise Exception('HDS.url failed to play\nServer down? check Url.')
g_downloader=downloader
print 'init...'
enableSeek=False
requested_range=self.headers.getheader("Range")
if requested_range==None: requested_range=""
srange, erange=(None,None)
if downloader.live==False and len(requested_range)>0 and not requested_range=="bytes=0-0": #we have to stream?
enableSeek=True
(srange, erange) = self.get_range_request(requested_range, downloader.total_frags)
print 'PROXY DATA',downloader.live,enableSeek,requested_range,downloader.total_frags,srange, erange
enableSeek=False ##disabled for time being, couldn't find better way to handle
framgementToSend=0
inflate=1815002#(6526684-466/3)#*373/downloader.total_frags# 4142*1024*243/8/40 #1#1024*1024
if enableSeek:
#rtype="video/x-flv" #just as default
self.send_response(206)
rtype="flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
self.send_header("Accept-Ranges","bytes")
print 'not LIVE,enable seek',downloader.total_frags
totalsize=downloader.total_frags*inflate
framgementToSend=1#downloader.total_frags
erange=srange+framgementToSend*inflate
if erange>=totalsize:
erange=totalsize-1
# crange="bytes "+str(srange)+"-" +str(int(downloader.total_frags-1))+"/"+str(downloader.total_frags)#recalculate crange based on srange, portionLen and content_size
# crange="bytes "+str(srange)+"-" +str(int(totalsize-1))+"/"+str(totalsize)#recalculate crange based on srange, portionLen and content_size
crange="bytes "+str(srange)+"-" +str(int(erange))+"/*"#+str(totalsize)#recalculate crange based on srange, portionLen and content_size
print srange/inflate,erange/inflate,totalsize/inflate
self.send_header("Content-Length", str(totalsize))
self.send_header("Content-Range",crange)
etag=self.generate_ETag(url)
self.send_header("ETag",etag)
print crange
self.send_header("Last-Modified","Wed, 21 Feb 2000 08:43:39 GMT")
self.send_header("Cache-Control","public, must-revalidate")
self.send_header("Cache-Control","no-cache")
self.send_header("Pragma","no-cache")
self.send_header("features","seekable,stridable")
self.send_header("client-id","12345")
self.send_header("Connection", 'close')
else:
self.send_response(200)
rtype="flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange=None
elif streamtype=='SIMPLE' or simpledownloader :
from interalSimpleDownloader import interalSimpleDownloader
downloader=interalSimpleDownloader();
if not downloader.init(self.wfile,url,proxy,g_stopEvent,maxbitrate):
print 'init throw error because init'#throw error because init
raise Exception('SIMPLE.url failed to play\nServer down? check Url.')
srange,framgementToSend=(None,None)
self.send_response(200)
rtype="flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange=None
elif streamtype=='TSDOWNLOADER':
from TSDownloader import TSDownloader
downloader=TSDownloader();
if not downloader.init(self.wfile,url,proxy,g_stopEvent,maxbitrate):
print 'cannot init but will continue to play'
raise Exception('TS.url failed to play\nServer down? check Url.')
#return
srange,framgementToSend=(None,None)
self.send_response(200)
rtype="video/mp2t" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange=None
elif streamtype=='HLS':
from hlsDownloader import HLSDownloader
downloader=HLSDownloader()
if not downloader.init(self.wfile,url,proxy,use_proxy_for_chunks,g_stopEvent,maxbitrate,auth):
print 'cannot init'
raise Exception('HLS.url failed to play\nServer down? check Url.')
srange,framgementToSend=(None,None)
self.send_response(200)
rtype="flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange=None
elif streamtype=='HLSRETRY':
from HLSDownloaderRetry import HLSDownloaderRetry
downloader=HLSDownloaderRetry()
if not downloader.init(self.wfile,url,proxy,use_proxy_for_chunks,g_stopEvent,maxbitrate,auth , callbackpath, callbackparam):
print 'cannot init'
raise Exception('HLSR.url failed to play\nServer down? check Url.')
srange,framgementToSend=(None,None)
self.send_response(200)
rtype="flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange=None
elif streamtype=='HLSREDIR':
from HLSRedirector import HLSRedirector
downloader=HLSRedirector()
g_currentprocessor=downloader
if not downloader.init(self.wfile,url,proxy,use_proxy_for_chunks,g_stopEvent,maxbitrate,auth , callbackpath, callbackparam):
print 'cannot init'
raise Exception('HLSR.url failed to play\nServer down? check Url.')
srange,framgementToSend=(None,None)
self.send_response(200)
rtype="application/vnd.apple.mpegurl" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange=None
#rtype="flv-application/octet-stream" #default type could have gone to the server to get it.
#self.send_header("Content-Type", rtype)
self.end_headers()
if not srange==None:
srange=srange/inflate
initDone=True
if sendData:
downloader.keep_sending_video(self.wfile,srange,framgementToSend)
#self.wfile.close()
#runningthread=thread.start_new_thread(downloader.download,(self.wfile,url,proxy,use_proxy_for_chunks,))
print 'srange,framgementToSend',srange,framgementToSend
#runningthread=thread.start_new_thread(downloader.keep_sending_video,(self.wfile,srange,framgementToSend,))
#xbmc.sleep(500)
#while not downloader.status=="finished":
# xbmc.sleep(200);
except Exception as inst:
#Print out a stack trace
traceback.print_exc()
#g_stopEvent.set()
if not initDone:
xbmc.executebuiltin("XBMC.Notification(F4mProxy,%s,4000,'')"%inst.message)
self.send_error(404)
#print 'sending 404'
#self.send_error(404)
#Close output stream file
#self.wfile.close()
print 'closed'
#Close output stream file
#self.wfile.close()
self.finish()
return
def answer_request(self, sendData):
global g_stopEvent
global g_downloader
try:
#Pull apart request path
request_path = self.path[1:]
request_path = re.sub(r"\?.*", "", request_path)
#If a request to stop is sent, shut down the proxy
if request_path.lower(
) == "stop": # all special web interfaces here
sys.exit()
return
if request_path.lower() == "favicon.ico":
print 'dont have no icone here, may be in future'
self.wfile.close()
return
(url, proxy, use_proxy_for_chunks, maxbitrate, simpledownloader,
auth, streamtype) = self.decode_url(request_path)
print 'simpledownloaderxxxxxxxxxxxxxxx', simpledownloader
if streamtype == '' or streamtype == None or streamtype == 'none':
streamtype = 'HDS'
if streamtype == 'HDS':
print 'Url received at proxy', url, proxy, use_proxy_for_chunks, maxbitrate
#Send file request
#self.handle_send_request(download_id,file_url, file_name, requested_range,download_mode ,keep_file,connections)
downloader = g_downloader
if not downloader or downloader.live == True or not (
downloader.init_done and downloader.init_url == url):
downloader = F4MDownloader()
if not downloader.init(self.wfile, url, proxy,
use_proxy_for_chunks, g_stopEvent,
maxbitrate, auth):
print 'cannot init'
return
g_downloader = downloader
print 'init...'
enableSeek = False
requested_range = self.headers.getheader("Range")
print 'requested Range', requested_range
if requested_range == None: requested_range = ""
srange, erange = (None, None)
if downloader.live == False and len(
requested_range
) > 0 and not requested_range == "bytes=0-0": #we have to stream?
enableSeek = True
(srange,
erange) = self.get_range_request(requested_range,
downloader.total_frags)
enableSeek = False
print 'PROXY DATA', downloader.live, enableSeek, requested_range, downloader.total_frags, srange, erange
framgementToSend = 1
for currentFreg in range(
len(downloader.fragments_list) - 1, -1, -1):
frag = downloader.fragments_list[currentFreg]
if (frag[4] <= srange):
framgementToSend = frag[1]
fragment_size = frag[3]
break
#enableSeek = False
downloader.statusStream = 'seeking'
if enableSeek:
self.send_response(206)
rtype = "flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
self.send_header("Last-Modified",
"Wed, 21 Feb 2014 08:43:39 GMT")
etag = self.generate_ETag(url)
self.send_header("ETag", etag)
self.send_header("Accept-Ranges", "bytes")
print 'not LIVE,enable seek', downloader.total_frags
totalsize = int(downloader.total_size)
erange = totalsize - 1
crange = "bytes " + str(srange) + "-" + str(
erange) + "/" + str(erange + 1)
self.send_header("Content-Range", crange)
self.send_header("Content-Disposition", "attachment")
print crange
self.send_header("Cache-Control",
"public, must-revalidate")
self.send_header("Cache-Control", "no-cache")
self.send_header("Pragma", "no-cache")
self.send_header("features", "seekable,stridable")
self.send_header("client-id", "12345")
self.send_header("Content-Length",
str(totalsize - int(srange)))
self.send_header("Connection", 'close')
else:
self.send_response(200)
rtype = "flv-application/octet-stream" #default type could have gone to the server to get it.
self.send_header("Content-Type", rtype)
srange = None
self.end_headers()
#if not srange==None:
# srange=srange/inflate
if sendData:
startRangeParam = 0
if (srange != None):
startRangeParam = int(srange)
#downloader.keep_sending_video(self.wfile,framgementToSend,0,startRangeParam)
#runningthread=thread.start_new_thread(downloader.download,(self.wfile,url,proxy,use_proxy_for_chunks,))
runningthread = thread.start_new_thread(
downloader.keep_sending_video(self.wfile, framgementToSend,
0, startRangeParam))
xbmc.sleep(500)
while not downloader.status == "finished":
xbmc.sleep(200)
except:
#Print out a stack trace
traceback.print_exc()
g_stopEvent.set()
self.send_response(404)
#Close output stream file
self.wfile.close()
return
#Close output stream file
self.wfile.close()
return
