Darba versija

ContentSources.py

             fname = os.path.split(fname)[1]
             if fname == "__init__": continue
             if ext == '.py':
+                print "Importing %s"%fname
                 mod = __import__(fname)
                 reload(mod)
                 if "Source" in dir(mod):
             print s #.encode(sys.stdout.encoding,"replace")
 
         while True:
-            a = raw_input("Enter numeber, q for exit: ")
+            a = raw_input("Enter number, (-) for download, q for exit: ")
             if a in ("q","Q","x","X"):
                 exit_loop = True
                 print "Exiting"
             except:
                 print "Not number!"
         if exit_loop: break
+        download = False
+        if n<0:
+            n = abs(n)
+            download = True
         cur2 = content[n]
-
         data0 = cur2[1].split("::")[1] if "::" in cur2[1] else cur2[1]
         if not data0:
             pass
-
         elif cur2[1] == "back":
             cur = history.pop()
         elif sources.is_video(cur2[1]):
                     traceback.print_exc()
                     streams = []
             if streams:
-                util.play_video(streams)
+                if not download:
+                    util.play_video(streams)
+                else:
+                    Downloader.download_video(streams)
             else:
                 print "**No stream to play - %s "%(
                     cur2[1])

Downloader.py

-from boxbranding import getMachineBrand, getMachineName
-
+#from boxbranding import getMachineBrand, getMachineName
+import sys,os, os.path, re
+import urlparse, requests
 from twisted.web import client
 from twisted.internet import reactor, defer, ssl
 
+USER_AGENT = "Enigma2 HbbTV/1.1.1 (+PVR+RTSP+DL;OpenATV;;;)"
 
+#####################################################################################################
 class HTTPProgressDownloader(client.HTTPDownloader):
-	def __init__(self, url, outfile, headers=None):
-		client.HTTPDownloader.__init__(self, url, outfile, headers=headers, agent="Enigma2 HbbTV/1.1.1 (+PVR+RTSP+DL;OpenATV;;;)")
-		self.status = None
-		self.progress_callback = None
-		self.deferred = defer.Deferred()
-
-	def noPage(self, reason):
-		if self.status == "304":
-			print reason.getErrorMessage()
-			client.HTTPDownloader.page(self, "")
-		else:
-			client.HTTPDownloader.noPage(self, reason)
-
-	def gotHeaders(self, headers):
-		if self.status == "200":
-			if headers.has_key("content-length"):
-				self.totalbytes = int(headers["content-length"][0])
-			else:
-				self.totalbytes = 0
-			self.currentbytes = 0.0
-		return client.HTTPDownloader.gotHeaders(self, headers)
-
-	def pagePart(self, packet):
-		if self.status == "200":
-			self.currentbytes += len(packet)
-		if self.totalbytes and self.progress_callback:
-			self.progress_callback(self.currentbytes, self.totalbytes)
-		return client.HTTPDownloader.pagePart(self, packet)
-
-	def pageEnd(self):
-		return client.HTTPDownloader.pageEnd(self)
-
-class downloadWithProgress:
-	def __init__(self, url, outputfile, contextFactory=None, *args, **kwargs):
-		if hasattr(client, '_parse'):
-			scheme, host, port, path = client._parse(url)
-		else:
-			from twisted.web.client import _URI
-			uri = _URI.fromBytes(url)
-			scheme = uri.scheme
-			host = uri.host
-			port = uri.port
-			path = uri.path
-
-		self.factory = HTTPProgressDownloader(url, outputfile, *args, **kwargs)
-		if scheme == "https":
-			self.connection = reactor.connectSSL(host, port, self.factory, ssl.ClientContextFactory())
-		else:
-			self.connection = reactor.connectTCP(host, port, self.factory)
-
-	def start(self):
-		return self.factory.deferred
-
-	def stop(self):
-		if self.connection:
-			print "[stop]"
-			self.connection.disconnect()
-
-	def addProgress(self, progress_callback):
-		print "[addProgress]"
-		self.factory.progress_callback = progress_callback
+    def __init__(self, url, outfile, headers=None):
+        agent = USER_AGENT
+        if headers and "user-agent" in headers:
+            agent = headers["user-agent"]
+        if headers and "User-Agent" in headers:
+            agent = headers["User-Agent"]
+        client.HTTPDownloader.__init__(self, url, outfile, headers=headers, agent=agent)
+        self.status = None
+        self.progress_callback = None
+        self.deferred = defer.Deferred()
+
+    def noPage(self, reason):
+        if self.status == "304":
+            print reason.getErrorMessage()
+            client.HTTPDownloader.page(self, "")
+        else:
+            client.HTTPDownloader.noPage(self, reason)
+
+    def gotHeaders(self, headers):
+        if self.status == "200":
+            if headers.has_key("content-length"):
+                self.totalbytes = int(headers["content-length"][0])
+            else:
+                self.totalbytes = 0
+            self.currentbytes = 0.0
+        return client.HTTPDownloader.gotHeaders(self, headers)
+
+    def pagePart(self, packet):
+        if self.status == "200":
+            self.currentbytes += len(packet)
+        if self.totalbytes and self.progress_callback:
+            self.progress_callback(self.currentbytes, self.totalbytes)
+        return client.HTTPDownloader.pagePart(self, packet)
+
+    def pageEnd(self):
+        return client.HTTPDownloader.pageEnd(self)
+
+class DownloadWithProgress:
+    def __init__(self, url, outputfile, headers=None, limit=0, contextFactory=None, *args, **kwargs):
+        self.limit = limit
+        uri = urlparse.urlparse(url)
+        scheme = uri.scheme
+        host = uri.hostname
+        port = uri.port if uri.port else 80
+        path = uri.path
+        if not headers:
+            headers = {"user-agent":USER_AGENT}
+        self.factory = HTTPProgressDownloader(url, outputfile, headers, *args, **kwargs)
+        if scheme == "https":
+            self.connection = reactor.connectSSL(host, port, self.factory, ssl.ClientContextFactory())
+        else:
+            self.connection = reactor.connectTCP(host, port, self.factory)
+
+    def start(self):
+        return self.factory.deferred
+
+    def stop(self):
+        if self.connection:
+            print "[stop]"
+            self.connection.disconnect()
+
+    def addProgress(self, progress_callback):
+        print "[addProgress]"
+        self.factory.progress_callback = progress_callback
+
+#####################################################################################################
+class DownloadWithProgressFragmented:
+    def __init__(self, url, outputfile, headers = None, limit = 0, contextFactory=None, *args, **kwargs):
+        self.url = url
+        self.outputfile = outputfile
+        self.base_url = "/".join(url.split("/")[:-1])+"/"
+        self.headers = headers if headers else  {"user-agent":"Enigma2"}
+        self.limit = limit
+        self.agent = kwargs["agent"] if "agent" in kwargs else None
+        self.cookie = kwargs["cookie"] if "cookie" in kwargs else None
+        self.deferred = defer.Deferred()
+        #self.deferred.addCallback(self.start_download)
+
+    def start_download(self):
+        print "Start download"
+        try:
+            r = requests.get(self.url,headers=self.headers)
+        except Exception as e:
+            #self.deferred.errback("Cannot open manifsest file - %s"%url)
+            self.deferred.errback(e)
+        if not r.content.startswith("#EXTM3U"):
+            self.deferred.errback(Exception("Not valid manifest file - %s"%self.url))
+        streams = re.findall(r"#EXT-X-STREAM-INF:.*?BANDWIDTH=(\d+).*?\n(.+?)$", r.content, re.IGNORECASE | re.MULTILINE)
+        if streams:
+            sorted(streams, key=lambda item: int(item[0]), reverse=True)
+            url = streams[0][1]
+            if not url.startswith("http"):
+                url = self.base_url + url
+            try:
+                r = requests.get(url, headers=self.headers)
+            except Exception as e:
+                self.deferred.errback(Exception("Cannot open manifsest file - %s"%url))
+        self.ts_list = re.findall(r"#EXTINF:([\d\.]+),.*?\n(.+?)$", r.content, re.IGNORECASE | re.MULTILINE)
+        if not len(self.ts_list):
+            self.deferred.errback(Exception("Cannot read fragment list in  manifsest file - %s"%url))
+        self.ts_num = 0
+        self.type = "vod" if "#EXT-X-ENDLIST" in r.content else "live"
+        self.currentbytes = 0.0
+        self.totalbytes = -1
+        self.currenttime = 0.0
+        self.totaltime = sum(map(float,zip(*self.ts_list)[0]))
+        self.ts_file = open(self.outputfile, "wb")
+        self.download_fragment()
+
+    def download_fragment(self):
+        if self.ts_num>=len(self.ts_list):
+            pass
+            print "Call later"
+            reactor.callLater(10,self.update_manifest)
+            reactor.callLater(10, self.download_fragment)
+        else:
+            print "Start fragment download"
+            url = self.ts_list[self.ts_num][1]
+            if not "://" in url:
+                url = self.base_url+url
+            self.d = client.getPage(url,headers = self.headers)
+            self.d.addCallbacks(self.download_ok,self.download_err)
+
+
+    def download_ok(self,content):
+        content_length = len(content)
+        self.currentbytes += content_length
+        self.currenttime += float(self.ts_list[self.ts_num][0])
+        self.totalbytes = self.currentbytes * self.totaltime / self.currenttime
+        self.ts_num += 1
+        #print "Fragment %s downloaded (%s)"%(self.ts_num,len(content))
+        self.ts_file.write(content)
+        self.progress_callback(self.currentbytes, self.totalbytes)
+        if self.type == "vod":
+            if self.ts_num >= len(self.ts_list) or (self.limit and self.currenttime>self.limit):
+                self.ts_file.close()
+                self.download_finished()
+            else:
+                self.download_fragment()
+        else:
+            if self.limit and self.currenttime>self.limit: # TODO
+                self.ts_file.close()
+                self.download_finished()
+            else:
+                self.download_fragment()
+
+    def update_manifest(self):
+        self.d2 = client.getPage(self.url, headers=self.headers)
+        self.d2.addCallbacks(self.update_manifest_ok, self.update_manifest_err)
+
+    def update_manifest_ok(self,content):
+        print "Update manifest"
+        ts_list = re.findall(r"#EXTINF:([\d\.]+),\n(.+?)$", content, re.IGNORECASE | re.MULTILINE)
+        last_ts = self.ts_list[-1]
+        found = False
+        for ts in ts_list:
+            if ts == last_ts:
+                found = True
+            elif found:
+                print "Append %s"%ts[1]
+                self.ts_list.append(ts)
+        #reactor.callLater(5,self.download_fragment)
+
+    def update_manifest_err(self,content):
+        return
+
+    def download_err(self,content):
+        self.deferred.errback("Error while downloading %s"%self.ts_list[self.ts_num][1])
+
+    def download_finished(self):
+        self.totalbytes = self.currentbytes
+        self.deferred.callback("Done")
+
+    def start(self):
+        reactor.callLater(1,self.start_download)
+        return self.deferred
+
+    def stop(self):
+        self.deferred.errback() # TODO
+
+    def addProgress(self, progress_callback):
+        print "[addProgress]"
+        self.progress_callback = progress_callback
+
+#####################################################################################################
+def get_header(url,headers=None):
+    headers = {"user-agent":USER_AGENT}
+    r = requests.head(url,headers=headers)
+    return r.headers
+
+def get_ext(mtype):
+    stype = "http"
+    if mtype in ("vnd.apple.mpegURL","application/x-mpegURL",'application/x-mpegurl',"application/vnd.apple.mpegurl"):
+        return ".ts","hls"
+    elif mtype in ("application/dash+xml"):
+        return ".ts","dash" # TODO dash stream type  could be different !
+    elif mtype in ("video/mp4"):
+        return ".mp4","http"
+    elif mtype in ("video/MP2T","video/mp2t"):
+        return ".ts","http"
+    elif mtype in ("video/x-flv"):
+        return ".flv","http"
+    elif mtype in ("video/quicktime"):
+        return ".mov","http"
+    elif mtype in ("video/x-msvideo"):
+        return ".avi","http"
+    elif mtype in ("video/x-ms-wmv"):
+        return ".wmv","http"
+    elif mtype in ("video/x-matroska"):
+        return ".mkv","http"
+    else:
+        return ".mp4","http"
+
+
+
+##############################################
+def print_progress(currentbytes, totalbytes):
+    progress = float(currentbytes)/float(totalbytes)*100
+    print "%s (%i/%i)"%(progress,currentbytes,totalbytes)
+
+def download_ok(*args):
+    print "Download OK"
+    reactor.stop()
+
+def download_err(e):
+    print "Download Error %s"%e.getBriefTraceback()
+    pass
+def stop():
+    reactor.stop()
+###############################################
+
+def download_vide(stream):
+    stream = stream[0]
+    url = stream["url"]
+    headers = stream["headers"]
+    output = stream["name"].replace("\\"," ").replace(":"," ").replace("|"," ")
+    try:
+        h = get_header(url,headers={"user-agent":"Enigma2"})
+        mtype = h.get("content-type")
+        ext,stream_type = get_ext(mtype)
+    except:
+        ext,stream_type = (".ts","hls")
+    #output = urlparse.urlparse(url)[2].split('/')[-1] + ext
+    output = output+ext
+    output = os.path.join("downloads", output)
+    if stream_type == "hls":
+        d = DownloadWithProgressFragmented(url,output,headers={"user-agent":"Enigma2"})
+    else:
+        d = DownloadWithProgress(url,output,headers={"user-agent":"Enigma2"})
+    d.addProgress(print_progress)
+    d.start().addCallback(download_ok).addErrback(download_err)
+    reactor.run()
+
+
+if __name__ == "__main__":
+    if len(sys.argv)>2:
+        url= sys.argv[1]
+        output = sys.argv[1]
+    else:
+        url = "http://walterebert.com/playground/video/hls/ts/480x270.m3u8"
+        url = "https://r3---sn-bavc5ajvh-gpme.googlevideo.com/videoplayback?key=yt6&mime=video%2Fmp4&sparams=clen%2Cdur%2Cei%2Cgir%2Cid%2Cinitcwndbps%2Cip%2Cipbits%2Citag%2Clmt%2Cmime%2Cmm%2Cmn%2Cms%2Cmv%2Cpl%2Cratebypass%2Crequiressl%2Csource%2Cupn%2Cexpire&expire=1490986184&lmt=1490940183963773&dur=1302.639&itag=18&ratebypass=yes&mm=31&requiressl=yes&ipbits=0&upn=azFGj8gY02w&ip=85.254.87.15&pl=23&ei=aFDeWLzqDcn-dLC_gdAM&signature=083F353AC09CD98A70AD7D9438DD3C91C781166B.715456B9C35F040BDC4728CA76A0D1779B684A90&source=youtube&mv=m&mt=1490964451&ms=au&mn=sn-bavc5ajvh-gpme&gir=yes&clen=73596250&id=o-AGH9y-hWn1MtW1VzCyI_8XYYEWODsTDBZbfagQH3BrfQ&initcwndbps=4493750"
+        #url = "http://techslides.com/demos/sample-videos/small.mp4"
+        #url = "http://wx17.poiuytrew.pw/s/c507282042b1bf25e0b72c34a68426f3/hd_30/Jackie.2016.D.iTunes.BDRip.1080p_720.mp4"
+        #url = "http://player.tvnet.lv/live/amlst:11/chunklist_w361981294_b528000.m3u8"
+        #url = "http://vod-hls-uk-live.akamaized.net/usp/auth/vod/piff_abr_full_hd/a3e90e-b08ktytr/vf_b08ktytr_f9d55583-afc7-49bb-9bf4-d8f1ac99f56f.ism.hlsv2.ism/vf_b08ktytr_f9d55583-afc7-49bb-9bf4-d8f1ac99f56f.ism.hlsv2-audio=128000-video=5070000.m3u8"
+        #url = "https://58174450afee9.streamlock.net/vod/mp4:_definst_/f/e/8e49fc32.mp4/playlist.m3u8?safwerwfasendtime=1490877870&safwerwfasstarttime=1490859339&safwerwfashash=hS2FfVZysQVazBQ6RJn1IhUevBkKxIF09Ly3BjfT43U="
+    try:
+        h = get_header(url,headers={"user-agent":"Enigma2"})
+        mtype = h.get("content-type")
+        ext,stream_type = get_ext(mtype)
+    except:
+        ext,stream_type = (".ts","hls")
+    output = urlparse.urlparse(url)[2].split('/')[-1] + ext
+    output = os.path.join("downloads", output)
+    if stream_type == "hls":
+        d = DownloadWithProgressFragmented(url,output,headers={"user-agent":"Enigma2"})
+    else:
+        d = DownloadWithProgress(url,output,headers={"user-agent":"Enigma2"})
+    d.addProgress(print_progress)
+    d.start().addCallback(download_ok).addErrback(download_err)
+    reactor.run()
+
+

PlayStream.py

 # Used fragments of code from enigma2-plugin-tv3play by Taapat (https://github.com/Taapat/enigma2-plugin-tv3play)
 #
 
-__version__ = "0.6l"
+__version__ = "0.6r"
 __id__ = "playstream"
 __title__ = "PlayStream"
 __author__ = "ivars777@gmail.com"
 __desc__ = "Play online video streams from various sources"
 
 import os,time,sys,os,os.path
-import datetime,re
+import datetime,re, traceback
 import urllib2
 
 from Plugins.Plugin import PluginDescriptor
 from plugin_locale import _
 import ContentSources
 import util
-from VideoDownload import downloadJob, HLSDownloadJob,VideoDownloadList
+from VideoDownload import DownloadJob, HLSDownloadJob,VideoDownloadList
+from Downloader import get_header, get_ext
 #import enigma2_api
 
 e2 = None
         #print self.content
         self["list"].setList(self.content)
         self["cur"].setText(self.content[0][3])
-        self.setTitle2(self.cur_menu[0])
+        self.setTitle2(self.cur_menu[0] + " (" + self.cur_menu[1].split("::")[0]+")")
         self.show_picture(self.content[0][2])
         reactor.callLater(1,self.check_update)
 
             return
 
         elif self.sources.is_video(current[1]):
-            if self.sources.stream_type(current[1]):
+            if ContentSources.stream_type(current[1]):
                 stream = util.item()
                 stream["url"] = current[1]
                 stream["name"] = current[0]
                     streams = self.sources.get_streams(current[1])
                 except Exception,e:
                     print str(e)
+                    traceback.print_exc()
                     self.session. open(MessageBox, "Error - %s"%str(e) , MessageBox.TYPE_INFO)
                     return
             if streams:
                 try:
                     self.session.open(PSPlayer, streams)
                 except Exception as e:
+                    traceback.print_exc()
                     self.msg("Error launching player - " + str(e))
                     return
             else:
                 index = zip(*new_content)[1].index(cur_menu_old[1])
             except:
                 index = 0
-            self.setTitle2(self.cur_menu[0])
+            self.setTitle2(self.cur_menu[0]+ " (" + self.cur_menu[1].split("::")[0]+")")
             self.show_content(new_content,index)
 
         else:
                 nfo = self.sources.get_info(self.current[1])
             except Exception, e:
                 print str(e)
+                traceback.print_exc()
                 self.session.open(MessageBox, "Error - %s" % str(e), MessageBox.TYPE_INFO)
                 return
         else:
                 new_content = self.sources.get_content(self.cur_menu[1])
             except Exception,e:
                 self.cur_menu = self.history.pop()
+                traceback.print_exc()
                 self.session. open(MessageBox, "Error - %s"%str(e) , MessageBox.TYPE_INFO)
                 return
-            self.setTitle2(self.cur_menu[0])
+            self.setTitle2(self.cur_menu[0] + " (" + self.cur_menu[1].split("::")[0]+")")
             self.show_content(new_content)
 
     def back(self):
         self.session.open(VideoDownloadList)
 
     def download_video(self,current, download_dir=""):
-        if self.sources.stream_type(current[1]):
+        if ContentSources.stream_type(current[1]):
             stream = util.item()
             stream["url"] = current[1]
             stream["name"] = current[0]
                 streams = self.sources.get_streams(current[1])
             except Exception,e:
                 print "Error - %s"%str(e)
+                traceback.print_exc()
                 self.session. open(MessageBox, "Error - %s"%str(e) , MessageBox.TYPE_INFO)
                 return
         if not streams:
         print "download stream",stream
         #self.msg("Start downloading..")
         self.stream = stream
-        stream_type = self.stream["type"] #self.sources.stream_type(stream["url"])
+        url = stream["url"]
+        headers = stream["headers"] if "headers" in stream else {}
+        stream_type = ContentSources.stream_type(url) #self.sources.stream_type(stream["url"])
         if not stream_type: #
             print "Not supported stream type found to download - %s"%(self.current[1])
             self.msg("Not supported stream type found to download - %s"%(self.current[1]))
             return
 
         title = self.stream["name"].strip()
-        url = self.stream["url"]
-        stream_type = self.stream["type"] #self.sources.stream_type(stream["url"])
         downloadDir = config.plugins.playstream.download_dir.value if not download_dir else download_dir
         if not os.path.exists(downloadDir):
             try:
                 os.mkdir(downloadDir)
             except Exception as e:
+                traceback.print_exc()
                 print 'Error creating download directory "%s"!\nPlease specify in the settings existing directory\n%s'%(downloadDir,str(e))
                 self.msg('Error creating download directory "%s"!\nPlease specify in the settings existing directory\n%s'%(downloadDir,str(e)))
                 return
         fname0 = util.make_fname(title)
-        fname = fname0 +".mp4"
-        outputfile = os.path.join(downloadDir, fname)
         #print "Trying to download - ", current
         if self.stream["img"]:
             try:
             nfofile = subfile = os.path.join(downloadDir,fname0+".nfo")
             with open(nfofile,"w") as f:
                 nfo_txt = util.nfo2xml(self.stream["nfo"])
-                f.write()
+                f.write(nfo_txt)
+        try:
+            h = get_header(url,headers)
+        except:
+            h = None
+        if not h:
+            self.session.open(MessageBox, "Can non get headers - %s" % url)
+            return False
+
+        mtype = h.get("content-type")
+        if not mtype:
+            mtype = "videp/mp4" # TODO default mtype if not content-type in header?
+
+        fext,stream_type = get_ext(mtype)
+        fname = fname0 + fext
+        outputfile = os.path.join(downloadDir, fname)
         overwrite = config.plugins.playstream.overwrite_download.value
         if not overwrite and os.path.exists(outputfile):
             self.msg( _('Sorry, this file already exists:\n%s') % outputfile)
             return False
             #os.remove(outputfile)
 
-        if stream_type in ("http","https"):
+        if stream_type in ("http","https", "hls"):
             print "\n**Download %s - %s"%(title,url)
-            #reload(downloadJob)
-            job_manager.AddJob(downloadJob(url, outputfile, title[:20], self.video_download_stop))
+            #reload(DownloadJob)
+            try:
+                job_manager.AddJob(DownloadJob(url, outputfile, title[:20], self.video_download_stop, headers, stream_type))
+            except Exception as e:
+                print str(e)
+                traceback.print_exc()
+                self.session.open(MessageBox, "Error - %s" % str(e), MessageBox.TYPE_INFO)
+                return  False
+
             self.active_downloads += 1
             #self.msg(_('Video download started!'))
             return True
             self.msg("RSTP stream download not yet implemented!")
             return False
         else:
-            self.msg("Unkown stream type!")
+            self.msg("Unkown stream type - %s!"%stream_type)
             return False
 
 
             self.session.open(OptionsScreen,self)
 
     def video_download_stop(self,title):
-        #self.activeDownloads -= 1
-        #self.msg("Download '%s'finished!"%title)
+        self.active_downloads -= 1
+        self.msg2(title)
         print "video_download_stop ", title
 
     def msg2(self,msg,timeout=10,mtype = None):

VideoDownload.py

 import os
+from os import path
 
 from enigma import eTimer, getDesktop
 from Components.ActionMap import ActionMap
 from Components.Sources.StaticText import StaticText
 from Components.Task import Task, Job, job_manager
 from Screens.Screen import Screen
-from Tools.Downloader import downloadWithProgress
 from Tools.Directories import fileExists
-from os import path
+
+from Downloader import DownloadWithProgress, DownloadWithProgressFragmented,get_header
+
+
+def timer_callback(timer,callback):
+    if "callback" in dir(timer):
+        timer.callback.append(callback)
+    else:
+        timer_conn = timer.timeout.connect(callback)
+
+###########################################################################################
+class DownloadJob(Job):
+    def __init__(self, url, outputfile, title, downloadStop,headers=None,stream_type="http"):
+        Job.__init__(self, title)
+        DownloadTask(self, url, outputfile, title, downloadStop,headers,stream_type)
+
+
+class DownloadTask(Task):
+    def __init__(self, job, url, outputfile, title, downloadStop,headers={},stream_type="http"):
+        Task.__init__(self, job, _('Downloading'))
+        self.job = job
+        self.title = title
+        self.url = url
+        self.outputfile = outputfile
+        self.headers = headers
+        self.stream_type = stream_type
+        self.downloadStop = downloadStop
+        self.job.currentbytes = 0
+        self.job.totalbytes = -1
+
+    def run(self, callback):
+        self.callback = callback
+        if self.stream_type == "hls":
+            self.download = DownloadWithProgressFragmented(self.url, self.outputfile,self.headers)
+        else:
+            self.download = DownloadWithProgress(self.url, self.outputfile, self.headers)
+        self.download.addProgress(self.downloadProgress)
+        self.download.start().addCallback(self.downloadFinished).addErrback(self.downloadFailed)
+
+    def downloadProgress(self, currentbytes, totalbytes):
+        self.job.currentbytes = currentbytes
+        self.job.totalbytes = totalbytes
+        progress = self.job.currentbytes/float(self.job.totalbytes) * 100
+        self.setProgress(progress)
+
+    def downloadFinished(self, result):
+        Task.processFinished(self, 0)
+        self.setProgress(self.end)
+        self.downloadStop("Success - " + self.title)
+
+    def downloadFailed(self, failure_instance=None, error_message=''):
+        print '[PlayStream] Video download failed'
+        if error_message == '' and failure_instance is not None:
+            error_message = failure_instance.getErrorMessage()
+            print '[PlayStream]', str(error_message)
+        Task.processFinished(self, 1)
+        self.downloadStop("Failed - "+ self.title)
 
 class HLSDownloadJob(Job):
-	def __init__(self, url, destfile, title,downloadStop):
-		Job.__init__(self, title)
-		AddHLSProcessTask(self, url, destfile, title, downloadStop)
+    def __init__(self, url, destfile, title,downloadStop,headers=None):
+        Job.__init__(self, title)
+        AddHLSProcessTask(self, url, destfile, title, downloadStop,headers)
 
+
+######################################################################################################
 class AddHLSProcessTask(Task):
-	def __init__(self, job, url, destfile, title,downloadStop):
-		Task.__init__(self, job, title)
-		self.job = job
-		self.title = title
-		cmdline = '/usr/bin/gst-launch-1.0 "%s" !  hlsdemux ! filesink location="%s"'%(url,destfile)	
-		self.setCmdline(cmdline)
-		self.url = url
-		self.destfile = destfile
-		self.downloadStop = downloadStop
-		self.job.currentbytes = 0
-		self.job.totalbytes = 0
-		#self.setProgress(100)
-		self.ProgressTimer = eTimer()
-		self.ProgressTimer.callback.append(self.ProgressUpdate)
-
-	def ProgressUpdate(self):
-		if not fileExists(self.destfile, 'r'):
-			return
-		self.job.currentbytes = path.getsize(self.destfile)
-		progress = self.job.currentbytes/float(self.job.totalbytes) * 100 if self.job.totalbytes else 0
-		self.setProgress(progress)
-		#self.setProgress(int((path.getsize(self.destfile)/float(self.totalbytes))*100))
-		self.ProgressTimer.start(5000, True)
-
-	def prepare(self):
-		self.job.totalbytes = -1 # TODO getsize(self.url)
-		self.ProgressTimer.start(5000, True)
-
-	def afterRun(self):
-		#self.setProgress(100)
-		self.ProgressTimer.stop()
-		self.downloadStop(self.title)
-
-class downloadJob(Job):
-	def __init__(self, url, outputfile, title, downloadStop):
-		Job.__init__(self, title)
-		downloadTask(self, url, outputfile, title, downloadStop)
-
-
-class downloadTask(Task):
-	def __init__(self, job, url, outputfile, title, downloadStop):
-		Task.__init__(self, job, _('Downloading'))
-		self.job = job
-		self.title = title
-		self.url = url
-		self.outputfile = outputfile
-		self.downloadStop = downloadStop
-		self.job.currentbytes = 0
-		self.job.totalbytes = -1		
-
-	def run(self, callback):
-		self.callback = callback
-		self.download = downloadWithProgress(self.url, self.outputfile)
-		self.download.addProgress(self.downloadProgress)
-		self.download.start().addCallback(self.downloadFinished)\
-			.addErrback(self.downloadFailed)
-
-	def downloadProgress(self, currentbytes, totalbytes):
-		self.job.currentbytes = currentbytes
-		self.job.totalbytes = totalbytes
-		progress = self.job.currentbytes/float(self.job.totalbytes) * 100
-		self.setProgress(progress)
-
-	def downloadFinished(self, result):
-		Task.processFinished(self, 0)
-		self.setProgress(self.end)
-		self.downloadStop(self.title)
-
-	def downloadFailed(self, failure_instance=None, error_message=''):
-		print '[PlayStream] Video download failed'
-		if error_message == '' and failure_instance is not None:
-			error_message = failure_instance.getErrorMessage()
-			print '[PlayStream]', str(error_message)
-		Task.processFinished(self, 1)
-		self.downloadStop("")
+    def __init__(self, job, url, destfile, title,downloadStop,headers=None):
+        Task.__init__(self, job, title)
+        self.job = job
+        self.title = title
+        cmdline = '/usr/bin/gst-launch-1.0 "%s" !  hlsdemux ! filesink location="%s"'%(url,destfile)
+        self.setCmdline(cmdline)
+        self.url = url
+        self.destfile = destfile
+        self.downloadStop = downloadStop
+        self.job.currentbytes = 0
+        self.job.totalbytes = 0
+        #self.setProgress(100)
+        self.ProgressTimer = eTimer()
+        timer_callback(self.ProgressTimer, self.ProgressUpdate)
+
+    def ProgressUpdate(self):
+        if not fileExists(self.destfile, 'r'):
+            return
+        self.job.currentbytes = path.getsize(self.destfile)
+        progress = self.job.currentbytes/float(self.job.totalbytes) * 100 if self.job.totalbytes else 0
+        self.setProgress(progress)
+        #self.setProgress(int((path.getsize(self.destfile)/float(self.totalbytes))*100))
+        self.ProgressTimer.start(5000, True)
+
+    def prepare(self):
+        self.job.totalbytes = -1 # TODO getsize(self.url)
+        self.ProgressTimer.start(5000, True)
+
+    def afterRun(self):
+        #self.setProgress(100)
+        self.ProgressTimer.stop()
+        self.downloadStop(self.title)
 
 
 class VideoDownloadList(Screen):
-	screenWidth = getDesktop(0).size().width()
-	if screenWidth and screenWidth == 1920:
-		skin = """<screen position="center,center" size="945,555">
-				<widget source="list" render="Listbox" position="center,45" size="900,405" \
-					scrollbarMode="showOnDemand" >
-					<convert type="TemplatedMultiContent" >
-						{"template": [
-							MultiContentEntryText(pos=(15,1), size=(465,33), \
-								font=0, flags=RT_HALIGN_LEFT, text=1), # Title
-							MultiContentEntryText(pos=(345,1), size=(225,33), \
-								font=0, flags=RT_HALIGN_RIGHT, text=2), # State
-							MultiContentEntryProgress(pos=(585,6), size=(150,33), \
-								percent=-3), # Progress
-							MultiContentEntryText(pos=(750,1), size=(120,33), \
-								font=0, flags=RT_HALIGN_LEFT, text=4), # Percentage
-							],
-						"fonts": [gFont("Regular",30)],
-						"itemHeight": 45}
-					</convert>
-				</widget>
-				<ePixmap position="center,484" size="210,60" pixmap="skin_default/buttons/red.png" \
-					transparent="1" alphatest="on" />
-				<widget source="key_red" render="Label" position="center,485" zPosition="2" \
-					size="210,60" valign="center" halign="center" font="Regular;33" transparent="1" />
-				</screen>"""
-	else:
-		skin = """<screen position="center,center" size="630,370">
-				<widget source="list" render="Listbox" position="center,30" size="600,270" \
-					scrollbarMode="showOnDemand" >
-					<convert type="TemplatedMultiContent" >
-						{"template": [
-							MultiContentEntryText(pos=(10,1), size=(210,22), \
-								font=0, flags=RT_HALIGN_LEFT, text=1), # Title
-							MultiContentEntryText(pos=(230,1), size=(150,22), \
-								font=0, flags=RT_HALIGN_RIGHT, text=2), # State
-							MultiContentEntryProgress(pos=(390,4), size=(100,22), \
-								percent=-3), # Progress
-							MultiContentEntryText(pos=(500,1), size=(80,22), \
-								font=0, flags=RT_HALIGN_LEFT, text=4), # Percentage
-							],
-						"fonts": [gFont("Regular",20)],
-						"itemHeight": 30}
-					</convert>
-				</widget>
-				<ePixmap position="center,323" size="140,40" pixmap="skin_default/buttons/red.png" \
-					transparent="1" alphatest="on" />
-				<widget source="key_red" render="Label" position="center,328" zPosition="2" \
-					size="140,30" valign="center" halign="center" font="Regular;22" transparent="1" />
-				</screen>"""
-
-	def __init__(self, session):
-		Screen.__init__(self, session)
-		self['key_red'] = StaticText(_('Exit'))
-		self['list'] = List([])
-		self['actions'] = ActionMap(['SetupActions', 'ColorActions'],
-			{
-				'cancel': self.close,
-				'ok': self.ok,
-				'red': self.close,
-		                'blue': self.abort
-			}, -2)
-		self.onLayoutFinish.append(self.layoutFinished)
-		self.onClose.append(self.cleanVariables)
-		self.progressTimer = eTimer()
-		self.progressTimer.callback.append(self.updateDownloadList)
-
-	def layoutFinished(self):
-		self.setTitle(_('Active video downloads'))
-		self.updateDownloadList()
-
-	def cleanVariables(self):
-		del self.progressTimer
-
-	def updateDownloadList(self):
-		self.progressTimer.stop()
-		downloadList = []
-		for job in job_manager.getPendingJobs():
-			progress = job.progress / float(job.end) * 100
-			currentbytes = job.currentbytes if "currentbytes" in dir(job) else 0
-			downloadList.append((job, job.name, job.getStatustext(),
-				int(progress), "%.1fM"%(currentbytes/1024.0/1024.0) ))
-		self['list'].updateList(downloadList)
-		if downloadList:
-			self.progressTimer.startLongTimer(2)
-
-	def ok(self):
-		current = self['list'].getCurrent()
-		if current:
-			from Screens.TaskView import JobView
-			self.session.open(JobView, current[0])
-			
-	def abort(self):
-		current = self['list'].getCurrent()
-		job = current[0]
-		if job.status == job.NOT_STARTED:
-			job_manager.active_jobs.remove(job)
-			self.close(False)
-		elif job.status == job.IN_PROGRESS:
-			job.cancel()
-		else:
-			self.close(False)
-	
+    screenWidth = getDesktop(0).size().width()
+    if screenWidth and screenWidth == 1920:
+        skin = """<screen position="center,center" size="945,555">
+                <widget source="list" render="Listbox" position="center,45" size="900,405" \
+                    scrollbarMode="showOnDemand" >
+                    <convert type="TemplatedMultiContent" >
+                        {"template": [
+                            MultiContentEntryText(pos=(15,1), size=(465,33), \
+                                font=0, flags=RT_HALIGN_LEFT, text=1), # Title
+                            MultiContentEntryText(pos=(345,1), size=(225,33), \
+                                font=0, flags=RT_HALIGN_RIGHT, text=2), # State
+                            MultiContentEntryProgress(pos=(585,6), size=(150,33), \
+                                percent=-3), # Progress
+                            MultiContentEntryText(pos=(750,1), size=(120,33), \
+                                font=0, flags=RT_HALIGN_LEFT, text=4), # Percentage
+                            ],
+                        "fonts": [gFont("Regular",30)],
+                        "itemHeight": 45}
+                    </convert>
+                </widget>
+                <ePixmap position="center,484" size="210,60" pixmap="skin_default/buttons/red.png" \
+                    transparent="1" alphatest="on" />
+                <widget source="key_red" render="Label" position="center,485" zPosition="2" \
+                    size="210,60" valign="center" halign="center" font="Regular;33" transparent="1" />
+                </screen>"""
+    else:
+        skin = """<screen position="center,center" size="630,370">
+                <widget source="list" render="Listbox" position="center,30" size="600,270" \
+                    scrollbarMode="showOnDemand" >
+                    <convert type="TemplatedMultiContent" >
+                        {"template": [
+                            MultiContentEntryText(pos=(10,1), size=(210,22), \
+                                font=0, flags=RT_HALIGN_LEFT, text=1), # Title
+                            MultiContentEntryText(pos=(230,1), size=(150,22), \
+                                font=0, flags=RT_HALIGN_RIGHT, text=2), # State
+                            MultiContentEntryProgress(pos=(390,4), size=(100,22), \
+                                percent=-3), # Progress
+                            MultiContentEntryText(pos=(500,1), size=(80,22), \
+                                font=0, flags=RT_HALIGN_LEFT, text=4), # Percentage
+                            ],
+                        "fonts": [gFont("Regular",20)],
+                        "itemHeight": 30}
+                    </convert>
+                </widget>
+                <ePixmap position="center,323" size="140,40" pixmap="skin_default/buttons/red.png" \
+                    transparent="1" alphatest="on" />
+                <widget source="key_red" render="Label" position="center,328" zPosition="2" \
+                    size="140,30" valign="center" halign="center" font="Regular;22" transparent="1" />
+                </screen>"""
+
+    def __init__(self, session):
+        Screen.__init__(self, session)
+        self['key_red'] = StaticText(_('Exit'))
+        self['list'] = List([])
+        self['actions'] = ActionMap(['SetupActions', 'ColorActions'],
+            {
+                'cancel': self.close,
+                'ok': self.ok,
+                'red': self.close,
+                        'blue': self.abort
+            }, -2)
+        self.onLayoutFinish.append(self.layoutFinished)
+        self.onClose.append(self.cleanVariables)
+        self.progressTimer = eTimer()
+        timer_callback(self.progressTimer,self.updateDownloadList)
+
+    def layoutFinished(self):
+        self.setTitle(_('Active video downloads'))
+        self.updateDownloadList()
+
+    def cleanVariables(self):
+        del self.progressTimer
+
+    def updateDownloadList(self):
+        self.progressTimer.stop()
+        downloadList = []
+        for job in job_manager.getPendingJobs():
+            progress = job.progress / float(job.end) * 100
+            currentbytes = job.currentbytes if "currentbytes" in dir(job) else 0
+            downloadList.append((job, job.name, job.getStatustext(),
+                int(progress), "%.1fM"%(currentbytes/1024.0/1024.0) ))
+        self['list'].updateList(downloadList)
+        if downloadList:
+            self.progressTimer.startLongTimer(2)
+
+    def ok(self):
+        current = self['list'].getCurrent()
+        if current:
+            from Screens.TaskView import JobView
+            self.session.open(JobView, current[0])
+
+    def abort(self):
+        current = self['list'].getCurrent()
+        job = current[0]
+        if job.status == job.NOT_STARTED:
+            job_manager.active_jobs.remove(job)
+            self.close(False)
+        elif job.status == job.IN_PROGRESS:
+            job.cancel()
+        else:
+            self.close(False)
+
 
 class VideoDirBrowser(Screen):
-	def __init__(self, session, downloadDir):
-		Screen.__init__(self, session)
-		self.skinName = ['VideoDirBrowser', 'FileBrowser']
-		self['key_red'] = StaticText(_('Cancel'))
-		self['key_green'] = StaticText(_('Use'))
-		if not os.path.exists(downloadDir):
-			downloadDir = '/'
-		self.filelist = FileList(downloadDir, showFiles = False)
-		self['filelist'] = self.filelist
-		self['FilelistActions'] = ActionMap(['SetupActions', 'ColorActions'],
-			{
-				'cancel': self.cancel,
-				'red': self.cancel,
-				'ok': self.ok,
-				'green': self.use
-			}, -2)
-		self.onLayoutFinish.append(self.layoutFinished)
-
-	def layoutFinished(self):
-		self.setTitle(_('Please select the download directory'))
-
-	def ok(self):
-		if self.filelist.canDescent():
-			self.filelist.descent()
-
-	def use(self):
-		currentDir = self['filelist'].getCurrentDirectory()
-		dirName = self['filelist'].getFilename()
-		if currentDir is None or \
-			(self.filelist.canDescent() and dirName and len(dirName) > len(currentDir)):
-			self.close(dirName)
-
-	def cancel(self):
-		self.close(False)
+    def __init__(self, session, downloadDir):
+        Screen.__init__(self, session)
+        self.skinName = ['VideoDirBrowser', 'FileBrowser']
+        self['key_red'] = StaticText(_('Cancel'))
+        self['key_green'] = StaticText(_('Use'))
+        if not os.path.exists(downloadDir):
+            downloadDir = '/'
+        self.filelist = FileList(downloadDir, showFiles = False)
+        self['filelist'] = self.filelist
+        self['FilelistActions'] = ActionMap(['SetupActions', 'ColorActions'],
+            {
+                'cancel': self.cancel,
+                'red': self.cancel,
+                'ok': self.ok,
+                'green': self.use
+            }, -2)
+        self.onLayoutFinish.append(self.layoutFinished)
+
+    def layoutFinished(self):
+        self.setTitle(_('Please select the download directory'))
+
+    def ok(self):
+        if self.filelist.canDescent():
+            self.filelist.descent()
+
+    def use(self):
+        currentDir = self['filelist'].getCurrentDirectory()
+        dirName = self['filelist'].getFilename()
+        if currentDir is None or \
+            (self.filelist.canDescent() and dirName and len(dirName) > len(currentDir)):
+            self.close(dirName)
+
+    def cancel(self):
+        self.close(False)

changelog.md

+**0.6r** (01.04.2017)
+- [feature] LMT Straume video (bez TV, kas strādā tikai LMT tīklā)
+
+**0.6p** (31.03.2017)
+- [bugfix] filmix sērijas
+- [bugfix] daļa failu download kļūdu novērstas (bet līdz galam vēl nestrādā)
+
+**0.6n** (29.03.2017)
+- [bugfix][feature] failu download pārtaisīts nezimantojot gstreamer
+
+**0.6m** (28.03.2017)
+- [bugfix] viaplay login un playback
+- [feature] tekošais source nosaukums loga titlē
+
 **0.6j** (22.03.2017)
 - salabota InsecureRequestWaening importa kļūda
 

deploy.bat

 PlayStream.png
 ContentSources.py
 VideoDownload.py
+Downloader.py
 enigma2_api.py
 resolver.py
 util.py

imake.bat

 @echo off
 :=== Parameters ===
 
-if ()==(%1%) (
-    python get_version.py PlayStream.py >version.txt
-    cat version.txt
-    pause
-    set /p ver=<version.txt
-    echo Version: %ver%
-) else (
-    set ver=%1
-)
+python get_version.py PlayStream.py >version.txt
+cat version.txt
+pause
+set /p ver=<version.txt
+echo Version: %ver%
+
 pause
 set prog=PlayStream
 set pack_name=enigma2-plugin-extensions-playstream
 set script_dir=usr\script\
 set ipk_dir=ipkg\
 set release_dir=release\
-set feed_dir=w:\feed\
+set feed_dir=q:\web\feed\
 
 set AR=\MinGW\bin\ar.exe
 set TAR=\MinGW\msys\1.0\bin\tar.exe
 %prog%.png
 ContentSources.py
 VideoDownload.py
+Downloader.py
 enigma2_api.py
 resolver.py
 util.py
 sources\mtgplay.py
 sources\play24.py
 sources\replay.py
+sources\lmt.py
 sources\serialguru.py
 sources\tvdom.py
 sources\ustvnow.py
 %AR% -r %release_dir%%pack_name%_%ver% ipkg\debian-binary ipkg\data.tar.gz ipkg\control.tar.gz
 @echo on
 mv %release_dir%%pack_name%_%ver% %release_dir%%pack_name%_%ver%.ipk
+
 git add %release_dir%%pack_name%_%ver%.ipk
+if not ()==(%1%) (
+git commit -m %ver%
+git tag %ver%
+git push
+)
 
 copy %release_dir%%pack_name%_%ver%.ipk %feed_dir%%pack_name%_%ver%.ipk
 pushd  %feed_dir%

playstreamproxy.py

 
 HOST_NAME = ""
 PORT_NUMBER = 88
-DEBUG = False
+DEBUG = True
+DEBUG2 = False
 
+SPLIT_CHAR = "~"
+SPLIT_CODE = "%7E"
+EQ_CODE = "%3D"
+COL_CODE = "%3A"
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+icy-metadata: 1
+Cache-Control: max-age=0
+Accept-Encoding: gzip, deflate
+User-Agent: GStreamer souphttpsrc libsoup/2.52.2
+Connection: Keep-Alive
+""")
 sessions = {}
 
 class StreamHandler(BaseHTTPRequestHandler):
 
     def do_HEAD(self):
+        print "**head"
         self.send_response(200)
-        self.send_header("Server", "StreamProxy")
-        self.send_header("Content-type", "text/html")
+        self.send_header("Server", "playstreamproxy")
+        if ".m3u8" in self.path.lower():
+            ct = "application/vnd.apple.mpegurl"
+        elif ".ts" in self.path.lower():
+            ct = "video/MP2T"
+        elif ".mp4" in ".ts" in self.path.lower():
+            ct = "video/mp4"
+        else:
+            ct = "text/html"
+        self.send_header("Content-type", ct)
         self.end_headers()
 
     def do_GET(self):
-        """Respond to a GET request."""
-        SPLIT_CHAR = "~"
-        SPLIT_CODE = "%7E"
-        EQ_CODE = "%3D"
-        COL_CODE = "%3A"
-        self.log_message("get_url: \n%s", self.path)
+        """Respond to a GET request"""
+        self.log_message("\n\n"+40*"#"+"\nget_url: \n%s", self.path)
         p = self.path.split("~")
-        url = urllib.unquote(p[0][1:])
+        #url = urllib.unquote(p[0][1:])
+        url = p[0][1:]
         url = url.replace(COL_CODE, ":")
-        headers = headers2dict("""
-        User-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 8_0_2 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12A366 Safari/600.1.4
-        """)
+        headers = self.headers.dict
+        headers = {} # TODO
+        headers["host"] = urlparse.urlparse(url).hostname
         if len(p)>1:
             for h in p[1:]:
-                headers[h.split("=")[0]]=urllib.unquote(h.split("=")[1])
-        #self.fetch_offline(self.wfile)
+                k = h.split("=")[0].lower()
+                v = urllib.unquote(h.split("=")[1])
+                headers[k]=v
+        if DEBUG:
+            print "url=%s"%url
+            print "Original request headers + url headers:"
+            print_headers(headers)
+
+        self.protocol_version = 'HTTP/1.1'
+
+        # TODO fetch selection
         try:
-            self.fetch_url2(self.wfile, url, headers)
+            if ".lattelecom.tv/" in url: # lattelecom.tv hack
+                self.fetch_ltc(self.wfile, url, headers)
+            elif "filmas.lv" in url or "viaplay" in url: #  HLS session/decode filmas.lv in url:
+                self.fetch_url2(self.wfile, url, headers)
+            else: # plain fetch
+                self.fetch_url(self.wfile, url, headers)
         except Exception as e:
             print "Got Exception: ", str(e)
+            import traceback
+            traceback.print_exc()
+
+    ### Remote server request procedures ###
 
     def fetch_offline(self,wfile):
+        print "** Fetch offline"
         self.send_response(200)
-        self.send_header("Server", "StreamProxy")
+        self.send_header("Server", "playstreamproxy")
         self.send_header("Content-type", "video/mp4")
         self.end_headers()
         self.wfile.write(open("offline.mp4", "rb").read())
-        self.wfile.close()
+        #self.wfile.close()
+
+    def fetch_url(self,wfile,url,headers):
+        if DEBUG:
+            print "\n***********************************************************"
+            print "fetch_url: \n%s"%url
+            print "**Server request headers: "
+            print_headers(headers)
+        #if ".lattelecom.tv/" in url and EQ_CODE in url:
+        #    url = url.replace(EQ_CODE,"=")
+        r = requests.get(url,headers = headers)
+        code = r.status_code
+        if DEBUG:
+            print "** Server/proxy response, code = %s"%code
+            print_headers(r.headers)
+        if not code in (200,206):
+            print "***Error, code=%s",code
+            self.send_response(code)
+            self.send_headers(r.headers)
+            wfile.close()
+            return
+        self.send_response(code)
+        self.send_headers(r.headers)
+        CHUNK_SIZE = 1024*4
+        for chunk in r.iter_content(CHUNK_SIZE):
+            try:
+                wfile.write(chunk)
+            except Exception as e:
+                print "Exception: ", str(e)
+                wfile.close()
+                return
+        if DEBUG: print "**File downloaded"
+        wfile.close()
+        # time.sleep(1)
+        return
+
+    def fetch_ltc(self, wfile, url, headers):
+        if DEBUG:
+            print "\n***********************************************************"
+            print "fetch_url2: \n%s"%url
+        #self.log_message("fetch_filmas: \n%s", url)
+        #self.log_message("headers: %s", headers)
+        base_url = hls_base(url)
+        if DEBUG: print "base_url=",base_url
+        if base_url not in sessions:
+            if DEBUG: print "New session"
+            sessions[base_url] = {}
+            sessions[base_url]["session"] = requests.Session()
+            #sessions[base_url]["session"].headers = {}
+            sessions[base_url]["key"] = binascii.a2b_hex(headers["key"]) if "key" in headers and headers["key"] else None
+        ses = sessions[base_url]["session"]
+        key = sessions[base_url]["key"]
+        ses.headers.clear()
+        ses.headers.update(headers0)
+        ses.headers.update(headers)
+        ses.headers["Connection"]="Keep-Alive"
+        if DEBUG:
+            print "**Server request headers: "
+            print_headers(ses.headers)
+        for t in range(3):
+            r = ses.get(url, stream=True, verify=False)
+            code = r.status_code #r.status_code
+            if DEBUG:
+                print "\n\n=====================================\n**Server response:", code #r.status_code
+                print "**Server response headers: "
+                print_headers(r.headers)
+            if code in (200,2016): break
+        if not (code in (200,206)):
+            print "***Error, code=%s"%code
+            self.send_response(code)
+            self.send_headers(r.headers)
+            wfile.close()
+            #self.fetch_offline(wfile)
+            return
+
+        ### Start of return formin and sending
+        self.send_response(200)
+        #headers2 = del_headers(r.headers,["Content-Encoding",'Transfer-Encoding',"Connection",'content-range',"range"])
+        headers2  = {"server":"playstreamproxy", "content-type":"text/html"}
+
+        # Content-Type: application/vnd.apple.mpegurl (encrypted)
+        if r.headers["content-type"] == "application/vnd.apple.mpegurl":
+            content = r.content
+            content = r.content.replace(base_url,"")
+            content = re.sub("#EXT-X-KEY:METHOD=AES-128.+\n", "", content, 0, re.IGNORECASE | re.MULTILINE)
+            headers2["content-type"] = "application/vnd.apple.mpegurl"
+            headers2["content-length"] = "%s"%len(content)
+            r.headers["content-length"] = "%s"%len(content)
+            #headers2['content-range'] = 'bytes 0-%s/%s'%(len(content)-1,len(content))
+            #self.send_headers(headers2)
+            self.send_headers(r.headers)
+            wfile.write(content)
+            wfile.close()
+
+        # Content-Type: video/MP2T (encrypted)
+        elif r.headers["content-type"] == "video/MP2T" and key:
+            print "Decode video/MP2T"
+            content = r.content
+            from Crypto.Cipher import AES
+            iv = content[:16]
+            d = AES.new(key, AES.MODE_CBC, iv)
+            content = d.decrypt(content[16:])
+            headers2["content-type"] = "video/MP2T"
+            headers2["content-length"] = "%s"% (len(content))
+            #headers2['content-range'] = 'bytes 0-%s/%s' % (len(content) - 1, len(content))
+            print content[0:16]
+            print "Finish decode"
+            self.send_headers(headers2)
+            wfile.write(content)
+            wfile.close()
+
+        else:
+            print "Return regular content"
+            headers2["content-type"]  = r.headers["content-type"]
+            if "content-length" in r.headers:
+                headers2["content-length"] = r.headers["content-length"]
+            self.send_headers(r.headers)
+            CHUNK_SIZE = 4 * 1024
+            for chunk in r.iter_content(CHUNK_SIZE):
+                try:
+                    #print "#",
+                    wfile.write(chunk)
+                except Exception as e:
+                    print "Exception: ", str(e)
+                    return
+            if DEBUG: print "File downloaded = "
+            wfile.close()
+            #time.sleep(1)
+            return
 
 
     def fetch_url2(self, wfile, url, headers):
-        if DEBUG: print "\n***********************************************************"
-        self.log_message("fetch_url: \n%s", url)
+        if DEBUG:
+            print "\n***********************************************************"
+            print "fetch_url2: \n%s"%url
+        #self.log_message("fetch_filmas: \n%s", url)
         #self.log_message("headers: %s", headers)
-
-        base_url = "/".join(url.split("/")[0:-1])
+        base_url = hls_base(url)
+        if DEBUG: print "base_url=",base_url
         if base_url not in sessions:
-            sessions[base_url]={}
+            if DEBUG: print "New session"
+            sessions[base_url] = {}
             sessions[base_url]["session"] = requests.Session()
+            #sessions[base_url]["session"].headers = {}
             sessions[base_url]["key"] = binascii.a2b_hex(headers["key"]) if "key" in headers and headers["key"] else None
-            #cj = cookielib.CookieJar()
-            #sessions[base_url] = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
-        else:
-            if "key" in headers and headers["key"]: sessions[base_url]["key"] = binascii.a2b_hex(headers["key"])
         ses = sessions[base_url]["session"]
         key = sessions[base_url]["key"]
-
-        if DEBUG: print "**Request headers: "
+        ses.headers.clear()
+        ses.headers.update(headers0)
         ses.headers.update(headers)
-        #ses.addheaders=[]
-        for h in ses.headers:
-            #ses.addheaders.append((h,headers[h]))
-            if DEBUG: print h,"=",ses.headers[h]
-        r = ses.get(url, stream=True,verify=False)
-        #r = ses.open(url)
-        code = r.status_code #r.status_code
-        if DEBUG: print "**Response:", code #r.status_code
-        if DEBUG: print "**Response headers: "
-        for h in r.headers:
-            if DEBUG: print h,"=",r.headers[h]
-        self.send_response(code)
-
-        print code
-        if code <> 200:
-            self.fetch_offline(wfile)
+        ses.headers["Connection"]="Keep-Alive"
+        if DEBUG:
+            print "**Server request headers: "
+            print_headers(ses.headers)
+        for t in range(3):
+            r = ses.get(url, stream=True, verify=False)
+            code = r.status_code #r.status_code
+            if DEBUG:
+                print "\n\n=====================================\n**Server response:", code #r.status_code
+                print "**Server response headers: "
+                print_headers(r.headers)
+            if code in (200,2016): break
+        if not (code in (200,206)):
+            print "***Error, code=%s"%code
+            self.send_response(code)
+            self.send_headers(r.headers)
+            wfile.close()
+            #self.fetch_offline(wfile)
             return
 
-        if DEBUG: print "**Return headers:"
-        headers2 = {}
-        for h in r.headers:
-            if h.lower() in ("user-agent","server","transfer-encoding","content-encoding","connection"):
-                if DEBUG: print h," - skipped"
-                continue
-            else:
-                headers2[h] = r.headers[h]
-                if DEBUG:print h,"=",r.headers[h]
+        ### Start of return formin and sending
+        self.send_response(200)
+        #headers2 = del_headers(r.headers,["Content-Encoding",'Transfer-Encoding',"Connection",'content-range',"range"])
+        headers2  = {"server":"playstreamproxy", "content-type":"text/html"}
 
-        # Content-Type: application/vnd.apple.mpegurl
-        if r.headers["Content-Type"] == "application/vnd.apple.mpegurl" and key:
+        # Content-Type: application/vnd.apple.mpegurl (encrypted)
+        if r.headers["content-type"] == "application/vnd.apple.mpegurl":
             content = r.content
-            content = r.content.replace(base_url+"/","")
+            content = r.content.replace(base_url,"")
             content = re.sub("#EXT-X-KEY:METHOD=AES-128.+\n", "", content, 0, re.IGNORECASE | re.MULTILINE)
-            headers2["Content-Length"] = "%s"%len(content)
-            self.send_headers(headers2)
+            headers2["content-type"] = "application/vnd.apple.mpegurl"
+            headers2["content-length"] = "%s"%len(content)
+            r.headers["content-length"] = "%s"%len(content)
+            #headers2['content-range'] = 'bytes 0-%s/%s'%(len(content)-1,len(content))
+            #self.send_headers(headers2)
+            self.send_headers(r.headers)
             wfile.write(content)
+            wfile.close()
 
-        # Content-Type: video/MP2T
-        elif r.headers["Content-Type"] == "video/MP2T" and key:
+        # Content-Type: video/MP2T (encrypted)
+        elif r.headers["content-type"] == "video/MP2T" and key:
+            print "Decode video/MP2T"
             content = r.content
             from Crypto.Cipher import AES
             iv = content[:16]
             d = AES.new(key, AES.MODE_CBC, iv)
             content = d.decrypt(content[16:])
-            headers2["Content-Length"] = "%s"%len(content)
+            headers2["content-type"] = "video/MP2T"
+            headers2["content-length"] = "%s"% (len(content))
+            #headers2['content-range'] = 'bytes 0-%s/%s' % (len(content) - 1, len(content))
+            print content[0:16]
+            print "Finish decode"
             self.send_headers(headers2)
             wfile.write(content)
+            wfile.close()
 
         else:
-            self.send_headers(headers2)
+            print "Return regular content"
+            headers2["content-type"]  = r.headers["content-type"]
+            if "content-length" in r.headers:
+                headers2["content-length"] = r.headers["content-length"]
+            self.send_headers(r.headers)
             CHUNK_SIZE = 4 * 1024
-            if code == 200:
-                #while True:
-                    #chunk = r.read(CHUNK_SIZE)
-                    #if not chunk:
-                        #break
-                    #wfile.write(chunk)
-                #pass
-                #wfile.close()
-                for chunk in r.iter_content(1024):
-                    try:
-                        #print "#",
-                        wfile.write(chunk)
-                    except Exception as e:
-                        print "Exception: ", str(e)
-                        return
-                if DEBUG: print "  = file downloaded = "
-                time.sleep(1)
-        self.wfile.close()
+            for chunk in r.iter_content(CHUNK_SIZE):
+                try:
+                    #print "#",
+                    wfile.write(chunk)
+                except Exception as e:
+                    print "Exception: ", str(e)
+                    return
+            if DEBUG: print "File downloaded = "
+            wfile.close()
+            #time.sleep(1)
+            return
 
     def send_headers(self,headers):
+        #if DEBUG:
+            #print "**Return headers: "
+            #print_headers(headers)
         for h in headers:
             self.send_header(h, headers[h])
         self.end_headers()
 class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
     """Handle requests in a separate thread."""
 
-def start():
-    httpd = ThreadedHTTPServer((HOST_NAME, PORT_NUMBER), StreamHandler)
+def start(host = HOST_NAME, port = PORT_NUMBER):
+    httpd = ThreadedHTTPServer((host, port), StreamHandler)
     print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, PORT_NUMBER)
     try:
         httpd.serve_forever()
     def run(self):
         start()
 
+def print_headers(headers):
+    for h in headers:
+        print "%s: %s"%(h,headers[h])
+
+def del_headers(headers0,tags):
+    headers = headers0.copy()
+    for t in tags:
+        if t in headers:
+            del headers[t]
+        if t.lower() in headers:
+            del headers[t.lower()]
+    return headers
+
+def hls_base(url):
+    url2 = url.split("?")[0]
+    url2 = "/".join(url2.split("/")[0:-1])+ "/"
+    return url2
+
 if __name__ == "__main__":
     daemon = ProxyDaemon("/var/run/playstreamproxy.pid")
     if len(sys.argv) == 2:

readme.md

 Enigma2 plugin to to play various online streams (mostly Latvian).  
 Stream sources are in  subfolder "sources", and can be added/customized
 Currently implemented:
-- Main menu and manual stream definition in streams.cfg file
-- **replay.lsm.lv** media portal content (Latvian TV)
-- **skaties.lv** media portal content (MTG media portal Latvian version), other countries MTG contents are available through customizing main menu (country=xx) 
-- **lattelecom.tv(shortcut.lv)** media portal content
-- **play24.lv** media portal content
-- **viaplay.lv**
-- **cinemalive.tv**
-- **kinofilmnet.lv**
-- **dom.tv**
-- **BBC iPlayer**
-- **Euronews**
-- **filmon.tv** media portal content
-- **ustvnow.tv**
-- **serialguru.ru**
-- **filmix.net**
+- Main menu and manual stream definition in sources/streams.cfg file
+- **replay.lsm.lv** - Latvian TV live streams and archive (Latvian)
+- **skaties.lv** - skaties.lv streams (Latvian LNT, TV3, TV3+, TV6, TV2)
+- **lattelecom.tv(shortcut.lv)** - live, archive and video (Latvian, English, Russian), account required
+- **play24.lv** - RigaTV24 live and archive (Latvian)
+- **viaplay.lv** - video streams (partly working, only non-DRM - Latvian, Russian)
+- **LMT straume** - LMT video streams (Latvian)
+- **cinemalive.tv** - movies and series in Latvian (partly working)
+- **movieplace.lv** - movies and series in Latvian (partly working)
+- **dom.tv** - live and archive of Latvian and Russion TV channels, registration required
+- **BBC iPlayer** - BBC live and archive, UK IP address (VPN) required
+- **Euronews** - Euronews live and archive
+- **filmon.tv** - media portal content
+- **ustvnow.tv** - USA live TV (only SD), registration required
+- **filmix.net** - movies and series in Russian
+- **serialguru.ru** - movies and series in Russian (partly working)
 
 ---
 Copyright (c) 2016 ivars777 (ivars777@gmail.com)  

resolver.py

     url = "https://goo.gl/yMTzqf"
     url = "http://cdn.kapnob.ru/video/5e67c8b1ad018ffa/iframe"
     url = "http://kodik.cc/video/10830/4269a802d1a9d9bdc53fe38488d53a52/720p"
+    url = "https://www.youtube.com/embed/RUyQ_JJ6A84?rel=0&fs=1&wmode=transparent"
     streams = resolve(url)
     if not streams:
         print "No streams found"

sources/SourceBase.py

         return source,data,path,plist,clist,params,qs
 
 def stream_type(data):
-    if "::" in data:
-        data = data.split("::")[1]
     data = data.lower()
     m = re.search(r"^(\w+)://", data)
     prefix = m.group(1) if m else ""
-    if prefix in ("http","https") and ".m3u8" in data:
-        return "hls"
-    elif prefix == "http":
-        return "http"
+    if prefix in ("http","https"):
+        if ".m3u8" in data:
+            return "hls"
+        elif ".mpd" in data:
+            return "dash"
+        else:
+            return "http"
     else:
         return prefix
 

sources/cinemalive.py

     
 class Source(SourceBase):
     
-    def __init__(self,country=""):
+    def __init__(self,country="",cfg_path=None):
         self.name = "cinemalive"
         self.title = "cinemalive.tv"
         self.img = "picons/cinemalive.png" #"https://cinemalive.tv/assets/img/logo.png"

sources/config.py

 os.path.dirname(os.path.abspath(__file__))
 class Source(SourceBase):
 
-    def __init__(self,country="lv"):
+    def __init__(self,country="lv",cfg_path=None):
         self.name = "config"
         self.country=country
         cur_directory = os.path.dirname(os.path.abspath(__file__))
-        self.streams_file = os.path.join(cur_directory,"streams.cfg")
+        if not cfg_path: cfg_path = cur_directory
+        self.streams_file = os.path.join(cfg_path,"streams.cfg")
         self.lists = collections.OrderedDict()
         self.titles = {}
         self.read_streams()
                 self.lists[name] = []
             else:
                 if line[0] in ("#"): continue
-                items = tuple(line.strip().split("|"))
+                items = line.strip().split("|")
                 if not items[0]: continue
                 if len(items)==1:
                     self.titles[name] = items[0]
                 else:
+                    if len(items) == 4:
+                        items[3] = items[3].replace("\\n","\n")
                     self.lists[name].append(items)
 
     def write_streams(self):
         f = open(self.streams_file,"w")
         for l in self.lists.keys():
             f.write("[%s]\n"%l)
+            t = self.get_title(l)
+            if t<>l:
+                f.write("%s\n"%t)
             for item in self.lists[l]:
-                f.write("%s|%s|%s|%s\n"%(item[0],item[1],item[2],item[3]))
+                f.write("%s|%s|%s|%s\n"%(item[0].replace("\n",""),item[1],item[2],item[3].replace("\n","\\n")))
             f.write("\n")
         f.close()
 

sources/euronews.py

 
 class Source(SourceBase):
 
-    def __init__(self,language="en"):
+    def __init__(self,language="en",cfg_path=None):
         self.name = "euronews"
         self.title = "Euronews"
         self.img = "http://pbs.twimg.com/profile_images/732665354242150400/tZsCnjuh_400x400.jpg"
         """)
         #self.language=language
         cur_directory = os.path.dirname(os.path.abspath(__file__))
-        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
         self.options = OrderedDict([("language","en")])
         self.options_read()
         self.vid={"1": "News", "2": "European Affairs", "3": "Lifestyle", "4": "Knowledge"}

sources/filmix.py

 
 class Source(SourceBase):
 
-    def __init__(self,country=""):
+    def __init__(self,country="",cfg_path=None):
         self.name = "filmix"
         self.title = "filmix.me"
         self.img = "http://cs5324.vk.me/g33668783/a_903fcc63.jpg"
             m = re.search('<p itemprop="description"[^>]+>([^<]+)<', r, re.DOTALL)
             desc = desc0 =  util.unescape(m.group(1).strip()) if m else ""
             vid = plist[-1]
-            js = self.get_movie_info(vid)
+            m = re.search(r"meta_key = \['(\w+)', '(\w+)', '(\w+)'\]", r, re.IGNORECASE)
+            key = m.group(3) if m else ""
+            js = self.get_movie_info(vid,key)
             translations = js["message"]["translations"]["flash"]
             for pl  in translations:
                 if translations[pl].startswith("http"):
         video_link = m.group(1)
         series = True if video_link == '{video-link}' else False
         vid = plist[1]
-        js = self.get_movie_info(vid)
+        m = re.search(r"meta_key = \['(\w+)', '(\w+)', '(\w+)'\]", r, re.IGNORECASE)
+        key = m.group(3) if m else ""
+        js = self.get_movie_info(vid,key)
         translations = js["message"]["translations"]["flash"]
         for pl in translations:
             if translations[pl].startswith("http"):
         result = self._http_request(url,params,headers=headers)
         return result
 
-    def get_movie_info(self,vid):
+    def get_movie_info(self,vid,key=""):
         headers = headers2dict("""
     User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
     Accept: application/json, text/javascript, */*; q=0.01
     Content-Type: application/x-www-form-urlencoded; charset=UTF-8
     X-Requested-With: XMLHttpRequest
     Referer: https://filmix.me/play/%s
+    Cookie: ad_win12=1;
     """%vid )
-        post_data = {"post_id":vid}
+        post_data = {"post_id":vid,"key=":key}
         r = util.post("https://filmix.me/api/movies/player_data", data=post_data, headers = headers)
         if not r:
             raise Exception("Can not get movie info")

sources/filmon.py

 
 class Source(SourceBase):
 
-    def __init__(self,country="lv"):
+    def __init__(self,country="lv",cfg_path=None):
         self.name = "filmon"
         self.title = "FilmOn"
         self.img = "http://behindthegloves.com/wp-content/uploads/2016/01/FilmOn-logo1.jpg"

sources/iplayer.py

 
 class Source(SourceBase):
 
-    def __init__(self):
+    def __init__(self,cfg_path=None):
         self.name = "iplayer"
         self.title = "BBC iPlayer"
         self.img = "http://www.userlogos.org/files/logos/inductiveload/BBC_iPlayer_logo.png"
             "s4cpbs":"http://www.lyngsat-logo.com/hires/ss/s4c_uk.png"
         }
         cur_directory = os.path.dirname(os.path.abspath(__file__))
-        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
         self.options = OrderedDict([("user","lietotajs"),("password","parole")])
         self.options_read()
 

sources/lmt.py

     import json
 except:
     import simplejson as json
-import urllib2, urllib
+import requests
 import datetime, re, sys,os
 import ConfigParser
 from collections import OrderedDict
 except:
     sys.path.insert(0,'..')
     import util
+from YouTubeVideoUrl import YouTubeVideoUrl
 
 headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
 import HTMLParser
 """)
         self.url = "http://straume.lmt.lv/lv/"
 
-
     ######### Entry point ########
     def get_content(self, data):
         print "[lmt] get_content:", data
             content.extend([
                 ("Meklēt", "lmt::meklet?q={0}","","Meklēt"),
                 ("Straumes", "lmt::straumes","","Tiešraides un aktuāli video"),
-                ("TV", "lmt::tv","","TV tiešraides (tikai LMT tīklā)"),
+                #("TV", "lmt::tv","","TV tiešraides (tikai LMT tīklā)"),
                 ("Jaunākie", "lmt::video/jaunakie?videoPage=1", "", "Visu žanru jaunākie video"),
                 ("Sports", "lmt::video/sports?videoPage=1", "", "Sports"),
                 ("Kultūra un māksla", "lmt::video/kultura?videoPage=1", "", "Kultūra un māksla"),
                 ("Konferences", "lmt::video/konferences?videoPage=1", "", "Konferences"),
                 ("Raidījumi", "lmt::video/raidijumi?videoPage=1", "", "Raidījumi"),
                 ("Notikumi", "lmt::video/notikumi?videoPage=1", "", "Notikumi"),
-                ("Filmas un seriāli", "lmt::filmas?videoPage=1", "", "Filmas un seriāli"),
+                ("Filmas un seriāli", "lmt::video/filmas?videoPage=1", "", "Filmas un seriāli"),
                 ("Dažādi video", "lmt::video/dazadi?videoPage=1", "", "Dažādi video"),
+                ("Viedtelevīzija", "lmt::video/viedtelevizija?videoPage=1", "", "Viedtelevīzija"),
             ])
             return content
 
-        elif clist in ("meklet","video", "filmas"):
+        elif clist in ("meklet","video", "straumes","video-saraksts"):
             r=self.call(data)
-            result = re.findall('<a href="([^"]+)"> (.+?) </a></div>.+?> (.+?)</div>', r, re.DOTALL)
-            for item in result:
-                title = item[1].replace("<b>","").replace("</b>","")
-                data2 = item[0].replace("http://movieplace.lv/","")
-                img = self.img
-                desc = item[2].replace("<b>","").replace("</b>","")
-                content.append((title,self.name+"::"+data2,img,desc))
-            if '<span>&raquo;</span>' in r:
-                m = re.search("p=(\d+)",data)
+            result = re.findall('<a class="video-picture" (.+?)</li>', r, re.IGNORECASE | re.MULTILINE)
+            for r2 in result:
+                m = re.search('<a class="video-title" href="/lv/([^"]+)">([^<]+)<', r2)
+                title = m.group(2)
+                data2 = m.group(1)
+                m = re.search("([^ ]+) 2x", r2)
                 if m:
-                    page = int(m.group(1))+1
-                    data2 = re.sub(r"p=\d+", r"p=%s"%page, data)
-                    content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
-            return content
-
-        # Filmu saraksti ##
-        elif clist in ["load","dir"] and len(plist)<=3:
-            if clist == "jaunakas":
-                r = self.call("")
-            else:
-                r = self.call(data)
-            #r = r.decode("cp1251").encode("utf8")
-            if clist == "load":
-                result = re.findall(r' <a href="/([^"]+)" alt="([^"]+)"><img src="/([^"]+)" title="([^"]+)">.+?<div class="years">([^<]+)</div>\s+<div class="country">([^<]+)</div>', r, re.DOTALL)
-            else:
-                result = re.findall(r' <a href="/([^"]+)" alt="([^"]+)"><img src="/([^"]+)" title="[^"]+">.+?<span>([^<]+)</span>\s*<div class="country">([^<]+)</div>', r, re.IGNORECASE | re.DOTALL)
-            for item in result:
-                title = item[1]+" [%s]"%item[4] if clist=="load" else item[1]+" / %s [%s]"%(item[3],item[4])
-                img = "http://movieplace.lv/"+item[2]
-                data2 = item[0]
-                desc = "%s\n%s"%(title,item[5]) if clist=="load" else title
+                    img = m.group(1)
+                else:
+                    m = re.search('<img src="([^"]+)', r2)
+                    img = m.group(1) if m else ""
+                m = re.search('<span class="playlist-overlay">([^<]+)</span>', r2)
+                overlay = m.group(1) if m else ""
+                m = re.search('<span class="badge badge-[^>]+>([^<]+)(<[^>]+>([^<]+))*</span>', r2, re.IGNORECASE)
+                badge = ""
+                if m:
+                    badge = m.group(1)
+                    if m.group(3):
+                        badge = badge + m.group(3)
+                categories = re.findall('<span class="category-title">([^<]+)</span>', r2)
+                categories = "".join(categories)
+                if overlay:
+                    title = "%s [%s]"%(title,overlay)
+                if badge:
+                    title = "%s [%s]"%(title,badge)
+                desc = title
+                if categories:
+                    desc = desc + "\n"+ categories
                 content.append((title,self.name+"::"+data2,img,desc))
-            m = re.search('<[ab] class="swchItemA*1"( href="/([^"]+)" onclick="[^"]+")*><span>([^<]+)</span></[ab]> </span>', r, re.DOTALL)
+            m = re.search("videoPage=(\d+)",data)
             if m:
-                if m.group(1):
-                    page = int(re.search("\d+$",data).group())
-                    page = page+1
-                    data2 = re.sub("\d$","%s"%page,data)
-                    content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+                page = int(m.group(1))+1
+                data2 = re.sub(r"videoPage=\d+", r"videoPage=%s"%page, data)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            #print content
             return content
 
-        ### Seriāls ###
-        elif clist=="dir" and len(plist)==4:
-            r = self.call(path)
-            title0 = re.search('<h2 class="title" itemprop="name">(.+?)</h2>', r, re.DOTALL).group(1)
-            m = re.search(r'<span>VALODA:</span> <b><em itemprop="alternativeHeadline"><a href="[^"]*" class="entAllCats">([^<]+)</a></em></b></div>\s+?<div><span>SEZONA:</span> <b>([^<]+)</b></div>', r, re.IGNORECASE | re.DOTALL)
-            if m:
-                title0 = "%s / Season %s [%s]"%(title0,m.group(2),m.group(1))
-            desc0 = title0
-            img0 = "http://movieplace.lv" + re.search('<img src="(.+?)".+?itemprop="image">', r, re.DOTALL).group(1)
-            #TODO
-            result = re.findall(r'<summary>([^<]+)</summary><iframe src="https://openload\.co/embed/[^/]+/"', r, re.DOTALL)
-            i = 1
-            for item in result:
-                title = title0+" - " + item
-                data2 = data+"?e=%s"%i
-                img = img0
-                desc = desc0
-                content.append((title,self.name+"::"+data2,img,desc))
-                i += 1
-            return content
 
         ### kaut kas neparedzets ###
         else:
 
     def is_video(self,data):
         source,data,path,plist,clist,params,qs = self.parse_data(data)
-        if clist=="dir" and len(plist) == 4 and "e"in qs: # sērija
-            return True
-        elif clist=="load" and len(plist) == 4:
+        if not clist in ("meklet","video", "straumes","video-saraksts","home"):
             return True
-        else:
-            return False
 
     def call(self, data,params=None,headers=None,lang=""):
         if not headers: headers = self.headers
         url = self.url+data
-        result = self._http_request(url,params,headers=headers)
+        r = requests.get(url,headers = headers)
+        return r.content
+        #result = self._http_request(url,params,headers=headers)
         return result
 
     def get_streams(self,data):
-        print "[movieplace] get_streams:", data
+        print "[lmt] get_streams:", data
         if not self.is_video(data):
             return []
         source,data,path,plist,clist,params,qs = self.parse_data(data)
         r = self.call(path)
-        if clist=="load":
-            m = re.search('<h2 class="title" itemprop="name">([^<]+)</h2>', r, re.DOTALL)
-            title = re.search('<itemprop="name">(.+?)</itemprop="name">', r, re.DOTALL).group(1)
-            m = re.search(r'<div role="tabpanel" class="tab-pane fade in active" id="heading-tab4">\s*(.+?)\s*</div>', r, re.DOTALL)
-            desc = m.group(1) if m else title
-            m = re.search('<meta property="og:image" content="([^"]+)" />', r, re.DOTALL)
-            img = m.group(1) if m else ""
-            rr = []
-            for m in re.finditer("(RU|ENG|LAT|LAT SUB)<BR( /)*>.*?>?<BR( /)*>.*?<iframe", r, re.IGNORECASE | re.DOTALL):
-                if len(rr)>0:
-                    rr[-1]["end"] = m.start()
-                rr.append({"lang":m.group(1),"start":m.start(),"end":len(r)})
-            streams = []
-            for m in re.finditer(r'src="(https*://(goo\.gl|songs2dl|kodik|cdn\.kapnob|hqq|openload|sv1.servkino|vidwatch|online\.kinozz).+?)"', r, re.IGNORECASE | re.DOTALL):
-                url = m.group(1)
-                lang = "?"
-                for rrr in rr:
-                    if m.start()>rrr["start"] and m.start()<rrr["end"]:
-                        lang = rrr["lang"]
-                        break
-                for s in resolver.resolve(url):
-                    s["name"] = title
-                    s["desc"] = desc
-                    s["img"] = img
-                    s["type"] = self.stream_type(s["url"])
-                    s["lang"] = lang
-                    streams.append(s)
-            return streams
+        title = re.search("<h1>(.+?)</h1", r, re.IGNORECASE).group(1)
+        m = re.search('<a class="category-title".+?[^>]+>([^<]+)<', r, re.IGNORECASE | re.DOTALL)
+        categories = m.group(1) if m else ""
+        m = re.search('<span class="category-title">([^<]+)</span>.+?</p>', r, re.IGNORECASE | re.DOTALL)
+        if m:
+            categories = categories + m.group(1)
+        if categories:
+            tite = "%s [%s]"%(title,categories)
+        img = re.search('<meta property="twitter:image" content="([^"]+)">', r, re.IGNORECASE | re.DOTALL).group(1)
+        desc = title + "\n" + re.search('<meta property="og:description" content="([^"]+)">', r, re.IGNORECASE | re.DOTALL).group(1)
+        m = re.search('file: "([^"]+)"', r, re.IGNORECASE)
+        if m:
+            data2 = m.group(1)
+            stream = util.item()
+            stream["name"] = title
+            stream["url"] = data2
+            stream["img"] = img
+            stream["desc"] = desc
+            stream["resolver"] = "lmt"
+            return [stream]
+        elif re.search('src="http*://www.youtube.com/embed/(\w+).*"',r):
+            m = re.search('src="http*://www.youtube.com/embed/(\w+).*"',r)
+            video_id = m.group(1)
+            #http://www.youtube.com/embed/RUyQ_JJ6A84?rel=0&fs=1&wmode=transparent
+            data2 = YouTubeVideoUrl().extract(video_id)
+            s = util.item()
+            s["name"] = title
+            s["url"] = data2
+            s["desc"] = desc
+            s["img"] = img
+            s["resolver"] = "lmt"
+            return [s]
+        elif 'src="http://cdn.tiesraides.lv/lmtstraume.lv/' in r:
+            m = re.search('src="(http://cdn\.tiesraides\.lv/[^"]+)"',r)
+            url = m.group(1)
+            # src="http://cdn.tiesraides.lv/lmtstraume.lv/live-record2-ip/40?c=614127284dcd58d8a84afcf498a3ac7a&v=1405"
+            r = self._http_request(url)
+            #http://edge-telia2.tiesraides.lv/live-record2/lmtstraume.lv.40_1/manifest.f4m
+            m = re.search("'(http://.+?\.m3u8)'",r)
+            data2 = m.group(1) if m else ""
+            s = util.item()
+            s["name"] = title
+            s["url"] = data2
+            s["desc"] = desc
+            s["img"] = img
+            s["resolver"] = "lmt"
+            return [s]
+        else:
+            raise Exception("No stream found")
 
 
-        elif clist=="dir" and "e" in qs: # serialā sērija
-            #TODO
-            result = re.findall(r'<summary>([^<]+)</summary><iframe src="([^"]+)"', r, re.DOTALL)
-            i = int(qs["s"])-1
-            url0 = result[i][1]
-            title = title + " - " + result[i][0]
-        else:
-            #iframe src="https://openload.co/embed/wlw6Vl9zwL0/"
-            result = re.findall(r'<iframe src="([^"]+)"', r, re.DOTALL)
-            if not result:
-                return []
-            url0 = result[0]
-        return streams
+                # streams = resolver.resolve(url)
+            # for s in streams:
+            #     s["name"] = title
+            #     s["desc"] = desc
+            #     s["img"] = img
+            #     streams.append(s)
+            # return streams
+
 
 if __name__ == "__main__":
     country= "lv"

sources/ltc.py

 # Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
 #
 import sys, os, os.path, re, sys
-import urllib,urllib2
+import urllib,urllib2,urlparse
 from xml.sax.saxutils import unescape,escape
 from urllib import quote, unquote
 import datetime
 
 class Source(SourceBase):
 
-    def __init__(self):
+    def __init__(self,cfg_path=None):
         self.name = "ltc"
         self.title = "Shortcut.lv (lattelecom.tv)"
         self.img = "picons/shortcut.png"
         self.today2 = self.today.strftime("%d.%m.%Y")
 
         cur_directory = os.path.dirname(os.path.abspath(__file__))
-        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
         self.options = OrderedDict([("user","lietotajs"),("password","parole")])
         self.options_read()
 
         captions = sorted(captions,key=lambda item: item["order"],reverse=True)
         for s in streams_xml:
             for server in servers:
+                stream = util.item()
                 server2 = self.load_balancer(server)
                 url = "http://%s/mobile-vod/%s/playlist.m3u8?resource_id=%s&auth_token=%s"%(server2,s[0],resource_id,token)
-                stream = util.item()
+                # TODO Engima2 gstreamer vajag lai padod playlist nevis chunklist
+                # r3 = self._http_request(url)
+                # sss = re.findall(r"#EXT-X-STREAM-INF:.*?BANDWIDTH=(\d+).*?\n(.+?)$", r3, re.IGNORECASE | re.MULTILINE)
+                # if sss:
+                #     url2 = sss[0][1]
+                #     stream["headers"] = {"Referer":url}
+                #     if url2.startswith("http"):
+                #         url = url2
+                #     else:
+                #         url = util.hls_base(url)+url2
                 stream["url"]=url
                 stream["lang"]=s[1]
                 stream["quality"]=s[2]
 
     if len(sys.argv)>1 and  not "ltc::" in sys.argv[1]:
 
-        vid = sys.argv[1]
-        print "login - %s"%c.login("ivars777","xxx")
-        vid = "1069"
-        vid = "1462566072086"
-        channelid="101"
-        vid = "1350462656767"
+        vid = vid2 = sys.argv[1]
+        password = sys.argv[2]
+        print "login - %s"%c.login("ivars777",password)
+        #vid = "1069"
+        #vid = "1462566072086"
+        #channelid="101"
+        #vid = "1350462656767"
         #data = c.get_stream_url(vid,"vod")
         #call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",data["stream"]])
-        pass
+        #pass
 
-        print "login2 - %s"%c.login2("ivars777","xxx")
+        print "login2 - %s"%c.login2("ivars777",password)
         #vid2 = "animation/ultimate_avengers_ii"
         #vid2 = "animation/ice_age"
-        vid2 = "tiesraide/ltv1"
+        #vid2 = "tiesraide/ltv1"
         #vid2 = "arhivs/1456521417815"
-        data = c.get_stream_url2(vid2)
-        print data
+        streams = c.get_stream_url2(vid2)
+        stream = streams[-1]
+        print
         #for s in data:
-        call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",data["stream"]])
+        #call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",stream["url"]])
+        cmd = ["ffplay.exe",
+               "-headers","Referer:%s"%(quote(stream["headers"]["Referer"])),
+               "-headers","Connection:Keep-Alive",
+               stream["url"]]
+        print " ".join(cmd)
+        call(cmd)
         pass
 
 

sources/movieplace.py

 
 class Source(SourceBase):
 
-    def __init__(self, country=""):
+    def __init__(self, country="",cfg_path=None):
         self.name = "movieplace"
         self.title = "MoviePlace.lv"
         self.img = "http://movieplace.lv/images/logo.png"

sources/mtgplay.py

 
 class Source(SourceBase):
     
-    def __init__(self,country="lv"):
+    def __init__(self,country="lv",cfg_path=None):
         self.name = "mtgplay"
         self.title = "Skaties.lv (TV3)"
         self.img = "http://skaties.lv/touch-icon-192x192.png"

sources/play24.py

     
 class Source(SourceBase):
     
-    def __init__(self,country="lv"):
+    def __init__(self,country="lv",cfg_path=None):
         self.name = "play24"
         self.title = "Play24.lv"
         self.img = "http://play24.lv/images/play24-logo-black.png"

sources/replay.py

 
 class Source(SourceBase):
 
-    def __init__(self,country="lv"):
+    def __init__(self,country="lv",cfg_path=None):
         self.name = "replay"
         self.title = "Replay.lv (LTV)"
         self.img = "http://replay.lsm.lv/apple-touch-icon.png"

sources/serialguru.py

 
 class Source(SourceBase):
 
-    def __init__(self,country=""):
+    def __init__(self,country="",cfg_path=None):
         self.name = "serialguru"
         self.title = "SerialGURU.ru"
         self.img = "http://serialguru.ru/images/xlogo_new.png.pagespeed.ic.0sre2_2OJN.png"

sources/streams.cfg

 Shortcut (lattelecom.tv)|ltc::home|https://kursors.lv/wp-content/uploads/2016/07/Shortcut-logo.png|lattelecom TV, arhīves un video
 Play24.lv (Riga24TV)|play24::home|http://play24.lv/images/play24-logo-black.png|play24.lv (Riga24TV)tiešraide un arhīvs
 viaplay.lv|viaplay::home|https://yt3.ggpht.com/-noVdjbNR-V8/AAAAAAAAAAI/AAAAAAAAAAA/yZ9XNP5urLY/s900-c-k-no-mo-rj-c0xffffff/photo.jpg|Viaplay.lv - filmas latviešu, krievu u.c. valodās
+LMT straume|lmt::home|http://www.lob.lv/images/logo/lmt_straume_vert_rgb.png|LMT straume - dažādi video latviesu valodā
 TVDom.tv|tvdom::home|https://tvdom.tv/front/assets/images/logo.png|PBK tiešraides un arhīvs
 BBC iPlayer|iplayer::home|http://www.userlogos.org/files/logos/inductiveload/BBC_iPlayer_logo.png|BBC live streams and arhive
 Euronews|euronews::home|http://pbs.twimg.com/profile_images/732665354242150400/tZsCnjuh_400x400.jpg|Euronews live streams and archive
 MTGPlay|config::mtg|https://www.mtg.com/wp-content/uploads/2015/11/MTG-Logo-Medium-Red-PNG.png|Other countries MTG media portals content
 Filmas.lv|filmas::home|https://www.filmas.lv/wp-content/uploads/2013/06/LVfilmas-logo-jauns21.png|Filmas.lv - Latvijas filmas
 
+
 [my_tv]
 My Tv
 ..return|back|default|Atgriezties atpakaļ

sources/tvdom.py

 
 class Source(SourceBase):
 
-    def __init__(self,country="lv"):
+    def __init__(self,country="lv",cfg_path=None):
         self.name = "tvdom"
         self.title = "TVDom.tv"
         self.img = "https://tvdom.tv/front/assets/images/logo.png"
         self.token = None
 
         cur_directory = os.path.dirname(os.path.abspath(__file__))
-        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
         self.options = OrderedDict([("user","lietotajs"),("password","parole")])
         self.options_read()
 

sources/ustvnow.py

 
 class Source(SourceBase):
 
-    def __init__(self,country="lv"):
+    def __init__(self,country="lv",cfg_path=None):
         self.name = "ustvnow"
         self.title = "USTVNow"
         self.img = "http://watch.ustvnow.com/assets/ustvnow/img/ustvnow_og_image.png"
         self.country=country
         self.token = ""
         cur_directory = os.path.dirname(os.path.abspath(__file__))
-        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
         self.options = OrderedDict([("user","lietotajs"),("password","parole")])
         self.options_read()
 

sources/viaplay.cfg

 [viaplay]
 user = ivars777@gmail.com
 password = kaskade7
-device = 
+device = 14e06be92a07f9936749b560394669b7f32d3540-499b21d2-e6ec-4973-b57c-6db7cf43bdd0=c27f3554-13f4-40ca-a11a-6d97f832613a
 

sources/viaplay.py

 
 class Source(SourceBase):
 
-    def __init__(self,language="en"):
+    def __init__(self,language="en",cfg_path=None):
         self.name = "viaplay"
         self.title = "viaplay.lv"
         self.img = "https://yt3.ggpht.com/-noVdjbNR-V8/AAAAAAAAAAI/AAAAAAAAAAA/yZ9XNP5urLY/s900-c-k-no-mo-rj-c0xffffff/photo.jpg"
         """)
         #self.language=language
         cur_directory = os.path.dirname(os.path.abspath(__file__))
-        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
         self.options = OrderedDict([("user","change_user"),("password","change_password"),("device","")])
         self.options_read()
         self.device = self.options["device"]
 Upgrade-Insecure-Requests: 1
 Content-Type: application/x-www-form-urlencoded
 """)
-        url = "https://viaplay.lv/tdi/login/nav/formular?csrfToken=%s"%self.csrfToken
+        url = "https://viaplay.lv/tdi/login/nav/form?csrfToken=%s"%self.csrfToken
+        #      https://viaplay.lv/tdi/login/nav/form?_infuse=1&_ts=1490554674901&csrfToken=
         params = "nav_redirectUri=https%3A%2F%2Fviaplay.lv%2F&nav_email={}&nav_password={}".format(urllib.quote(user),urllib.quote(password))
+        #         nav_redirectUri=https%3A%2F%2Fviaplay.lv%2F&nav_email=ivars777%40gmail.com&nav_password=kaskade7&nav_remember=true
         headers["Cookie"] = "ott_cookies_confirmed=1; PLAY_SESSION=%s;"%self.play_session
         if self.device:
             headers["Cookie"] += "ott_dids=%s"%self.device
         if not "Set-Cookie" in r.headers:
             self.play_session = None
             return False
+        if not "ott_web_sac" in r.cookies:
+            self.play_session = None
+            return False
         self.ott = r.cookies["ott_web_sac"]
 
         ### Dabu iekārtas ID ###
         streams = []
         url = "https://viaplay.lv/"+data
         r = self._http_request(url)
-        if clist=="series":
+        if clist in ("series","livestream"): # TODO nerāda overtime u.c.
             m = re.search(r'<h1 class="is-bottom-sticked is-size-h2">(.+?)</h1>.*?<h2 class="is-size-h4">.*?<p class="is-size-h6 is-strong is-bottom-sticked">(.+?)<div class="toggler-content">\s+<p>(.+?)</p>', r, re.DOTALL)
             if not m:
                 raise Exception("Problem getting video information")
             stype = "DASH" if "dash" in s["type"] else "HLS"
             if "drm" in s: ###
                 # TODO, encrypted stream
+                raise Exception("Can not play DRM protected stream!\nOnly local and Russian content available without DRM")
                 continue
             url = s["src"]
             #urlp = util.streamproxy_encode(s["src"])

util.py

         #'!decodebin!autovideosink'
     ]
     cmd3 = ["ffplay.exe",url]
-    cmd = cmd1 if url.startswith("https") else cmd2
-    ret = call(cmd3)
+    cmd = cmd3 if url.startswith("https") else cmd2
+    ret = call(cmd)
     #if ret:
         #a = raw_input("*** Error, continue")
     return
     fname0 = re.sub("['""]","",fname0)
     return fname0
 
+
+def hls_base(url):
+    url2 = url.split("?")[0]
+    url2 = "/".join(url2.split("/")[0:-1])+ "/"
+    return url2
+
 def stream_change(stream):
     #return stream # TODO
     if "resolver" in stream and stream["resolver"] in ("viaplay","hqq","filmas") or \
     #url = "http://localhost:88/https://walterebert.com/playground/video/hls/ts/480x270.m3u8?token=xxxx~User-Agent=Enigma2~Cookie=xxxxx"
     url = "http://hyt4d6.vkcache.com/secip/0/UMQ3q2gNjTlOPnEVm3iTiA/ODAuMjMyLjI0MC42/1479610800/hls-vod-s3/flv/api/files/videos/2015/09/11/144197748923a22.mp4.m3u8http://hyt4d6.vkcache.com/secip/0/Y-ZA1qRm8toplc0dN_L6_w/ODAuMjMyLjI0MC42/1479654000/hls-vod-s3/flv/api/files/videos/2015/09/11/144197748923a22.mp4.m3u8"
     headers = {"User-Agent":"Mozilla/5.0 (iPhone; CPU iPhone OS 9_2 like Mac OS X) AppleWebKit/601.1 (KHTML, like Gecko) CriOS/47.0.2526.70 Mobile/13C71 Safari/601.1.46"}
+    url = "http://str1e.lattelecom.tv/mobile-vod/mp4:sf_fantastic_beasts_and_where_to_find_them_en_hd.mp4/playlist.m3u8?resource_id=fantastic_beasts_and_where_to_find_them&auth_token=6NAvMFDG+rYTAc4hb5JeL2bmsaRR7bAE23M6KDmhKYOGyXoo0gDpJUE9scYy+nQmfbgk03cWMe9MuXWSH1GqwolEk2jOQ/8Mrg7tOdbwrA8zM7nmkfCZPqQkwajZN4mfSJQVKHqXqJ8="
+    headers={}
+    print url
     urlp = streamproxy_encode(url,headers)
     print urlp
+    url2,headers2 = streamproxy_decode(urlp)
+    #print url2 - 2
     player(urlp)
-
     pass