Sākotnējais kommits

ChoiceBox.py

@@ -0,0 +1,235 @@
+from Screens.Screen import Screen
+from Components.ActionMap import NumberActionMap
+from Components.Label import Label
+from Components.ChoiceList import ChoiceEntryComponent, ChoiceList
+from Components.Sources.StaticText import StaticText
+from Components.Pixmap import Pixmap
+import enigma
+
+class ChoiceBox2(Screen):
+    skin =  """
+<screen name="ChoiceBox2" position="center,center" size="720,480" title="ChoiceBox" zPosition="5">
+    <widget name="text" position="0,0" size="720,0" font="Regular;30"/>
+    <widget name="list" font="Regular;22" position="10,10" size="710,460" scrollbarMode="showOnDemand" enableWrapAround="1"/>
+    <applet type="onLayoutFinish">
+            self["list"].instance.setItemHeight(25)
+    </applet>
+
+</screen>
+"""
+    #<applet type="onLayoutFinish">
+    #self.autoResize()
+    #</applet>
+    
+    def __init__(self, session, title="", list=None, keys=None, selection=0, skin_name=None, text=""):
+        Screen.__init__(self, session)        
+        #self.setTitle(_("Choice Box"))
+        if not list: list = []
+        if not skin_name: skin_name = []
+
+
+        #if isinstance(skin_name, str):
+        #	skin_name = [skin_name]
+        #self.skinName = skin_name + ["ChoiceBox"]
+        self["text"] = Label()
+        self.var = ""
+
+        if title:
+            title = _(title)
+            if len(title) < 55 and title.find('\n') == -1:
+                Screen.setTitle(self, title)
+            elif title.find('\n') != -1:
+                temptext = title.split('\n')
+                if len(temptext[0]) < 55:
+                    Screen.setTitle(self, temptext[0])
+                    count = 2
+                    labeltext = ""
+                    while len(temptext) >= count:
+                        if labeltext:
+                            labeltext += '\n'
+                        labeltext = labeltext + temptext[count-1]
+                        count += 1
+                        print 'count',count
+                    self["text"].setText(labeltext)
+                else:
+                    self["text"] = Label(title)
+            else:
+                self["text"] = Label(title)
+        elif text:
+            self["text"] = Label(_(text))
+        self.list = []
+        self.summarylist = []
+        if keys is None:
+            self.__keys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ] + (len(list) - 10) * [""]
+        else:
+            self.__keys = keys + (len(list) - len(keys)) * [""]
+
+        self.keymap = {}
+        pos = 0
+        for x in list:
+            strpos = str(self.__keys[pos])
+            self.list.append(ChoiceEntryComponent(key = strpos, text = x))
+            if self.__keys[pos] != "":
+                self.keymap[self.__keys[pos]] = list[pos]
+            self.summarylist.append((self.__keys[pos], x[0]))
+            pos += 1
+        self["list"] = ChoiceList(list = self.list, selection = selection)
+        self["summary_list"] = StaticText()
+        self["summary_selection"] = StaticText()
+        self.updateSummary(selection)
+
+        self["actions"] = NumberActionMap(["WizardActions", "InputActions", "ColorActions"],
+                                          {
+                                              "ok": self.go,
+                                              "1": self.keyNumberGlobal,
+                                              "2": self.keyNumberGlobal,
+                                              "3": self.keyNumberGlobal,
+                                              "4": self.keyNumberGlobal,
+                                              "5": self.keyNumberGlobal,
+                                              "6": self.keyNumberGlobal,
+                                              "7": self.keyNumberGlobal,
+                                              "8": self.keyNumberGlobal,
+                                              "9": self.keyNumberGlobal,
+                                              "0": self.keyNumberGlobal,
+                                              "red": self.keyRed,
+                                              "green": self.keyGreen,
+                                              "yellow": self.keyYellow,
+                                              "blue": self.keyBlue,
+                                              "up": self.up,
+                                              "down": self.down,
+                                              "left": self.left,
+                                              "right": self.right
+                                              }, -1)
+
+        self["cancelaction"] = NumberActionMap(["WizardActions", "InputActions", "ColorActions"],
+                                               {
+                                                   "back": self.cancel,
+                                                   }, -1)
+        #self.onShown.append(self.onshow)
+
+    def autoResize(self):
+        desktop_w = enigma.getDesktop(0).size().width()
+        desktop_h = enigma.getDesktop(0).size().height()
+        count = len(self.list)
+        itemheight = self["list"].getItemHeight()
+        if count > 15:
+            count = 15
+        if not self["text"].text:
+            # move list
+            textsize = (520, 0)
+            listsize = (520, itemheight*count)
+            self["list"].instance.move(enigma.ePoint(0, 0))
+            self["list"].instance.resize(enigma.eSize(*listsize))
+        else:
+            textsize = self["text"].getSize()
+            if textsize[0] < textsize[1]:
+                textsize = (textsize[1],textsize[0]+10)
+            if textsize[0] > 520:
+                textsize = (textsize[0], textsize[1]+itemheight)
+            else:
+                textsize = (520, textsize[1]+itemheight)
+            listsize = (textsize[0], itemheight*count)
+            # resize label
+            self["text"].instance.resize(enigma.eSize(*textsize))
+            self["text"].instance.move(enigma.ePoint(10, 10))
+            # move list
+            self["list"].instance.move(enigma.ePoint(0, textsize[1]))
+            self["list"].instance.resize(enigma.eSize(*listsize))
+
+        wsizex = textsize[0]
+        wsizey = textsize[1]+listsize[1]
+        wsize = (wsizex, wsizey)
+        self.instance.resize(enigma.eSize(*wsize))
+
+        # center window
+        self.instance.move(enigma.ePoint((desktop_w-wsizex)/2, (desktop_h-wsizey)/2))
+
+    def left(self):
+        if len(self["list"].list) > 0:
+            while 1:
+                self["list"].instance.moveSelection(self["list"].instance.pageUp)
+                self.updateSummary(self["list"].l.getCurrentSelectionIndex())
+                if self["list"].l.getCurrentSelection()[0][0] != "--" or self["list"].l.getCurrentSelectionIndex() == 0:
+                    break
+
+    def right(self):
+        if len(self["list"].list) > 0:
+            while 1:
+                self["list"].instance.moveSelection(self["list"].instance.pageDown)
+                self.updateSummary(self["list"].l.getCurrentSelectionIndex())
+                if self["list"].l.getCurrentSelection()[0][0] != "--" or self["list"].l.getCurrentSelectionIndex() == 0:
+                    break
+
+    def up(self):
+        if len(self["list"].list) > 0:
+            while 1:
+                self["list"].instance.moveSelection(self["list"].instance.moveUp)
+                self.updateSummary(self["list"].l.getCurrentSelectionIndex())
+                if self["list"].l.getCurrentSelection()[0][0] != "--" or self["list"].l.getCurrentSelectionIndex() == 0:
+                    break
+
+    def down(self):
+        if len(self["list"].list) > 0:
+            while 1:
+                self["list"].instance.moveSelection(self["list"].instance.moveDown)
+                self.updateSummary(self["list"].l.getCurrentSelectionIndex())
+                if self["list"].l.getCurrentSelection()[0][0] != "--" or self["list"].l.getCurrentSelectionIndex() == len(self["list"].list) - 1:
+                    break
+
+    # runs a number shortcut
+    def keyNumberGlobal(self, number):
+        self.goKey(str(number))
+
+    # runs the current selected entry
+    def go(self):
+        cursel = self["list"].l.getCurrentSelection()
+        if cursel:
+            self.goEntry(cursel[0])
+        else:
+            self.cancel()
+
+    # runs a specific entry
+    def goEntry(self, entry):
+        if entry and len(entry) > 3 and isinstance(entry[1], str) and entry[1] == "CALLFUNC":
+            arg = entry[3]
+            entry[2](arg)
+        elif entry and len(entry) > 2 and isinstance(entry[1], str) and entry[1] == "CALLFUNC":
+            entry[2](None)
+        else:
+            self.close(entry)
+
+    # lookups a key in the keymap, then runs it
+    def goKey(self, key):
+        if self.keymap.has_key(key):
+            entry = self.keymap[key]
+            self.goEntry(entry)
+
+    # runs a color shortcut
+    def keyRed(self):
+        self.goKey("red")
+
+    def keyGreen(self):
+        self.goKey("green")
+
+    def keyYellow(self):
+        self.goKey("yellow")
+
+    def keyBlue(self):
+        self.goKey("blue")
+
+    def updateSummary(self, curpos=0):
+        pos = 0
+        summarytext = ""
+        for entry in self.summarylist:
+            if curpos-2 < pos < curpos+5:
+                if pos == curpos:
+                    summarytext += ">"
+                    self["summary_selection"].setText(entry[1])
+                else:
+                    summarytext += entry[0]
+                summarytext += ' ' + entry[1] + '\n'
+            pos += 1
+        self["summary_list"].setText(summarytext)
+
+    def cancel(self):
+        self.close(None)

ContentSources.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+
+import sys,os,re
+import urllib2
+sys.path.insert(0,os.path.dirname(os.path.abspath(__file__)))
+from  sources.SourceBase import stream_type
+import util
+stream0 = {'name': '', 'url': '', 'quality': '???', 'surl': '', 'subs': '', 'headers': {},"desc":"","img":"","lang":"","type":""}                   
+
+class ContentSources(object):
+    """Wrapper for content sources plugin"""
+
+    #----------------------------------------------------------------------
+    def __init__(self,plugin_path):
+        self.plugins = {}
+        self.error_content = [("..atpakaļ","back",None,"Kļūda, atgriezties atpakaļ")]
+        sys.path.insert(0, plugin_path)
+        for f in os.listdir(plugin_path):
+            fname, ext = os.path.splitext(f)
+            if fname == "__init__":continue
+            if ext == '.py':
+                mod = __import__(fname)
+                reload(mod)
+                if "Source" in dir(mod):
+                    self.plugins[fname] = mod.Source()
+        sys.path.pop(0)
+        cfg = self.plugins["config"]
+        for pl in self.plugins.keys():
+            found = False
+            for lst in cfg.get_lists():
+                for item in cfg.lists[lst]:
+                    if item[1].split("::")[0]==pl:
+                        found = True
+                        break
+                    if found: break
+            if not found:
+                title = self.plugins[pl].title if "title" in dir(self.plugins[pl]) else pl
+                img = self.plugins[pl].img if "img" in dir(self.plugins[pl]) else ""
+                desc = self.plugins[pl].desc if "desc" in dir(self.plugins[pl]) else title
+                cfg.add_item("home",(title,"%s::home"%pl,img,desc))
+                cfg.write_streams()
+
+    def get_content(self,data):        
+        source = data.split("::")[0]
+        if source in self.plugins:
+            content = self.plugins[source].get_content(data)
+            if content:
+                if isinstance(content,list):      
+                    for i,item in enumerate(content):
+                        item2=[]
+                        for el in item:
+                            if isinstance(el,unicode):
+                                el = el.encode("utf8")
+                            item2.append(el)
+                        content[i]=tuple(item2)
+                else:
+                    item2=[]
+                    for el in content:
+                        if isinstance(el,unicode):
+                            el = el.encode("utf8")
+                        item2.append(el)
+                    content=tuple(item2)
+                return content
+            else:
+                return self.error_content
+        else:
+            return self.error_content
+
+    def get_streams(self,data):
+        if stream_type(data):
+            if "::" in data:
+                data = data.split("::")[1]                    
+            content = self.get_content(data)
+            stream = stream0.copy()
+            stream["name"] = data
+            stream["url"] = data
+            stream["type"] = stream_type(data)
+            #stream["img"] = ""
+            #stream["desc"] = ""
+            return[stream]
+
+        if not self.is_video(data):
+            return []
+        source = data.split("::")[0]
+        if source in self.plugins:
+            streams = self.plugins[source].get_streams(data)
+            for s in streams:
+                for k in s:
+                    if isinstance(s[k],unicode):
+                        s[k] = s[k].encode("utf8")            
+            return streams
+        else:
+            return []
+
+    def stream_type(self,data):
+        return stream_type(data)
+
+    def is_video(self,data):
+        if self.stream_type(data):
+            return True
+        source = data.split("::")[0]
+        if source in self.plugins:
+            return self.plugins[source].is_video(data)
+        else:
+            return False
+
+    def options_read(self,source):
+        if source in self.plugins:
+            options = self.plugins[source].options_read()
+            if options:
+                return options
+            else:
+                return None
+        else:
+            return None
+
+    def options_write(self,source,options):
+        if source in self.plugins:
+            return self.plugins[source].options_write(options)
+        else:
+            return None
+
+if __name__ == "__main__":
+
+    sources = ContentSources("sources")
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "config::home"
+
+    #options = sources.options_read("ltc")
+    #print options
+    history = []
+    cur = ("Home",data,None,None)
+    content = sources.get_content(cur[1])
+
+    exit_loop = False
+    while True:
+        print
+        for i,item in enumerate(content):
+            s = "%i: %s - %s %s %s "%(i+1,item[0],item[1],item[2],item[3])
+            print s #.encode(sys.stdout.encoding,"replace")
+
+        while True:
+            a = raw_input("Enter numeber, q for exit: ")
+            if a in ("q","Q","x","X"): 
+                exit_loop = True
+                print "Exiting"
+                break
+            try:
+                n = int(a)
+                break
+            except:
+                print "Not number!"
+        if exit_loop: break 
+        cur2 = content[n-1]
+
+        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]):
+            if sources.stream_type(cur2[1]):
+                stream = stream0.copy()
+                stream["url"] = cur2[1]
+                stream["name"] = cur2[0]
+                streams = [stream]
+            else:
+                streams = sources.get_streams(cur2[1])
+            if streams:
+                util.play_video(streams)
+            else:
+                print "**No stream to play - %s "%(cur2[1])
+                raw_input("Press any key")
+            #import os
+            #os.system('"c:\Program Files (x86)\VideoLAN\VLC\vlc.exe" "%s"'%cur2[1])
+
+        else:
+            if "{0}" in cur2[1]:
+                a = raw_input("Enter value:")
+                cur2 = (cur2[0],cur2[1].format(a),cur2[2],cur2[3])           
+            history.append(cur)
+            cur = cur2
+        content = sources.get_content(cur[1])

VideoDownload.py

@@ -0,0 +1,235 @@
+import os
+
+from enigma import eTimer, getDesktop
+from Components.ActionMap import ActionMap
+from Components.FileList import FileList
+from Components.Sources.List import List
+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
+
+class HLSDownloadJob(Job):
+	def __init__(self, url, destfile, title,downloadStop):
+		Job.__init__(self, title)
+		AddHLSProcessTask(self, url, destfile, title, downloadStop)
+
+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("")
+
+
+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)
+	
+
+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)

enigma2_api.py

@@ -0,0 +1,440 @@
+# coding: utf-8
+"""
+Enigma2 handling objects
+(c)Ivars 2013-2015, v0.2
+"""
+
+import sys, os, os.path
+from urllib import quote, unquote
+from record3 import Rec
+
+class DBServices(object):
+    """Dreambox services, stored in lamedb (E2)/services(E1) file handling class"""
+
+    def __init__(self,service_path=None,enigma=2):
+        self.enigma = enigma
+        if not service_path:
+            service_path = "enigma2" if sys.platform=="win32" else "/etc/enigma2"
+        self.service_path = service_path
+        #print service_path
+
+        if self.enigma == 2:
+            if not "ftp:" in service_path:
+                self.service_fname= os.path.join(service_path,"lamedb")
+                self.bouquets_fname = os.path.join(service_path, "bouquets.tv")
+            else:
+                sep = "" if service_path[-1]=="//" else "//"
+                self.service_fname= service_path+sep+"lamedb"
+                self.bouquets_fname = service_path+sep+"bouquets.tv"
+
+        else: # ENIGMA === "1":
+            self.service_fname = os.path.join(service_path,"services")
+            self.bouquets_fname = os.path.join(service_path, "userbouquets.tv.epl")
+        #print self.service_fname
+        self.services = []
+        self.index_sref= {}
+        self.index_chid = {}
+        self.index_name = {}
+        self.index_provider = {}
+        self.bouquets = []
+        self.bouquets_services = {}
+
+        self.transp = []
+        self.tp_index_tpid = {}
+        self.tp_index_pic ={}
+
+        self._load_services()
+        self._load_bouquets()
+
+    def _load_services(self):
+        #tpref - lamedb/transponders
+        # NS:TSID:ONID
+        #     s FREQ:SR:POLAR:FREC:49:2:0
+        #  X    X   X
+        #         D    D  D     D
+
+        # lref - lamedb/services
+        #	SID:NS:TSID:ONID:STYPE:UNUSED(channelnumber in enigma1)
+        #	0   1  2    3    4     5
+        #	X   X  X    X    D     D
+        # wref - bouquets/picon
+        #   REFTYPE:FLAGS:STYPE:SID:TSID:ONID:NS:PARENT_SID:PARENT_TSID:UNUSED
+        #   0       1     2     3   4    5    6  7          8           9
+        #   D       D     X     X   X    X    X  X          X           X
+
+        f_services = open(self.service_fname,"r") if not self.service_fname[0:4] == "ftp:" else urllib2.urlopen(self.service_fname)
+
+        line = f_services.readline()
+        if not "eDVB services" in line:
+            raise Exception("no correct lamedb file")
+        line = f_services.readline()
+
+        # Read transponders
+        i = 0
+        while True:
+            line = f_services.readline()
+            if  "end" in line: break
+            tp = Rec()
+            #tp = {}
+            ff = line.strip().split(":")
+            tp["ns"] = ns = pos_str2int(ff[0])
+            tp["tsid"] = tsid = int(ff[1],16)
+            tp["onid"] = onid = int(ff[2],16)
+            line = f_services.readline()
+            tp["params"] = params = line.strip().split(" ")[1]
+            ff = params.split(":")
+            tp["freq"] = freq = int(ff[0][:-3])
+            tp["polar"] = polar = int(ff[2])
+            tp["tpid"] = tpid = (ns,tsid,onid)
+            self.transp.append(tp)
+            self.tp_index_tpid[tpid] = i
+            self.tp_index_pic[(ns,freq,polar)] = i
+
+            line = f_services.readline()
+            i += 1
+
+        # Reading services
+        i= 0
+        line = f_services.readline()
+        while True:
+
+            line = f_services.readline()
+            if line[0:3] == "end": break
+            if not line: break
+            rec = Rec()
+            #rec = {}
+            rec["lref"] = line.lower().strip().decode("utf-8")
+
+            line = f_services.readline()
+            #line = line.replace('\xc2\x87', '').replace('\xc2\x86', '')
+            #line = decode_charset(line)
+            line = line.decode("utf-8")
+            rec["name"] = line.strip()
+
+            line = f_services.readline()
+            provider = ""
+            caid=[]
+            for p in line.split(","):
+                if p[0:2].lower() == "p:":
+                    provider = p[2:].strip()
+                elif p[0:2].lower() == "c:":
+                    caid.append(p[2:].strip())
+            if provider == "":
+                provider = "unknown"
+            rec["provider"] = provider.decode("utf-8")
+
+            rec["sref"] = lref2sref(rec["lref"])
+            r = lref_parse(rec["lref"])
+            rec["stype"] = r["stype"]
+            rec["chid"]  = (r["sid"],r["tsid"],r["onid"])
+            rec["caid"] = caid
+            self.services.append(rec)
+
+            self.index_sref[rec["sref"]] = i
+            self.index_chid[rec["chid"]] = i
+            name = rec["name"].lower()
+            if not self.index_name.has_key(name): self.index_name[name] = []
+            self.index_name[name].append(i)
+            provider = rec["provider"].lower()
+            if not self.index_provider.has_key(provider): self.index_provider[provider] = []
+            self.index_provider[provider].append(i)
+
+            i += 1
+
+        f_services.close()
+
+    def _load_bouquets(self):
+        f_bouquets = open(self.bouquets_fname,"r") if not self.bouquets_fname[0:4] == "ftp:" else urllib2.urlopen(self.bouquets_fname)
+        self.bouquets=Rec()
+        for line in f_bouquets.readlines():
+            if line[0:9] == "#SERVICE:":
+                if self.enigma==1:
+                    bn = line.strip().split("/")
+                else:
+                    bn = line.strip().split(":")
+                bfn = bn[-1]
+                bid = bfn.split(".")[1]
+
+                ### Process one bouquet file ###
+                bouq = Rec()
+                bouq.bid = bid
+                bouq.name = ""
+                bouq.services=[]
+                #fb = open(self.fname,"r") if not self.fname[0:4] == "ftp:" else urllib2.urlopen(self.fname)
+                fb = open(os.path.join(self.service_path,bfn))
+                i= 0
+                line = fb.readline()
+                while True:
+                    if line[0:5] == "#NAME":
+                        bouq.name = line.strip()[6:].decode("utf8")
+                    elif line[0:8] == "#SERVICE":
+                        sref = line.strip()[9:]
+                        s = sref_parse(sref)
+                        s["sref"] = sref
+                        if s["flags"] == 64:
+                            s["type"] = "marker"
+                            line = fb.readline()
+                            if line[0:12] =='#DESCRIPTION':
+                                s["name"] = line [13:].strip().decode("utf8")
+                            else: continue
+                        elif s["url"]: # IPTV stream
+                            s["type"] = "stream"
+                            s["sref"] = ":".join(s["sref"].split(":")[0:10])+":"
+                            line = fb.readline()
+                            if line[0:12] =='#DESCRIPTION':
+                                s["name"] = line [13:].strip().decode("utf8")
+                            else: continue
+                        bouq.services.append(s)
+                    line = fb.readline()
+                    if not line: break
+                fb.close()
+                self.bouquets[bid] = bouq
+
+        f_bouquets.close()
+
+    def _load_bouquets2(self):
+        f_bouquets = open(self.bouquets_fname,"r") if not self.bouquets_fname[0:4] == "ftp:" else urllib2.urlopen(self.bouquets_fname)
+        for line in f_bouquets.readlines():
+            if line[0:9] == "#SERVICE:":
+                if self.enigma==1:
+                    bn = line.strip().split("/")
+                else:
+                    bn = line.strip().split(":")
+                bfn = bn[-1]
+                bid = bfn.split(".")[1]
+                bouq = Bouquet(bid, self.service_path)
+                self.bouquets.append(bouq)
+        f_bouquets.close()
+
+    def create_bouqet(self,bid,name):
+        fname = "userbouquet.%s.tv"%bid
+        f_bouquets = open(self.bouquets_fname,"r") if not self.bouquets_fname[0:4] == "ftp:" else urllib2.urlopen(self.bouquets_fname)
+        lines = f_bouquets.read().strip()
+        f_bouquets.close()
+        if not fname in lines:
+            lines += "\n#SERVICE: 1:7:1:0:0:0:0:0:0:0:%s\n"%fname
+            f_bouquets = open(self.bouquets_fname,"w")
+            f_bouquets.write(lines)
+            f_bouquets.close()
+            with open(os.path.join(self.service_path,fname), 'w') as f:
+                f.write("#NAME %s"%name.encode("utf8"))
+        pass
+
+    def get_bouquets(self):
+        if not self.bouquets:
+            self._load_bouquets()
+        return self.bouquets
+
+    def get_bouquet_services(self,bn):
+        if not self.bouquets:
+            self._load_bouquets()
+        return self.bouquets[bn].services
+
+    #----------------------------------------------------------------------
+    def save_bouquet(self,bn):
+        """Save bouquet to file"""
+        fn = "userbouquet.%s.tv"%bn
+        fb = open(os.path.join(self.service_path,fn),"w")
+        fb.write("#NAME %s\n"%self.bouquets[bn].name.encode("utf8"))
+        for s in self.bouquets[bn].services:
+            if s.type=="marker":
+                fb.write("#SERVICE %s\n"%s.sref)
+                fb.write("#DESCRIPTION %s\n"%s.name.encode("utf8"))
+            elif s.type == "stream":
+                fb.write("#SERVICE %s%s:%s\n"%(s.sref,quote(s.url),s.name.encode("utf8")))
+                fb.write("#DESCRIPTION %s\n"%s.name.encode("utf8"))
+            else:
+                fb.write("#SERVICE %s\n"%s.sref)
+        fb.close()
+
+    def get_service_by_sref(self,sref):
+        return self.services[self.index_sref[sref]] if self.index_sref.has_key(sref) else None
+
+    def get_service_by_chid(self,chid):
+        return self.services[self.index_chid[chid]] if self.index_chid.has_key(chid) else None
+
+    def get_service_by_name(self,name):
+        return [self.services[i] for i in self.index_name[name]] if name in self.index_name else None
+
+    def get_service_by_provider(self,provider):
+        return [self.services[i] for i in self.index_provider[provider]] if provider in self.index_privider else Non
+
+    def get_transp_by_tpid(self,tpid):
+        return self.transp[self.tp_index_tpid[tpid]] if self.tp_index_tpid.has_key(tpid) else None
+
+    def get_transp_by_pic(self,picid):
+        return self.transp[self.tp_index_pic[picid]] if self.tp_index_pic.has_key(picid) else None
+
+    def find_sref(ns,freq,polar,sid):
+        "Find service reference according to given parameters"
+        tp = services.get_transp_by_pic((ns,freq,polar))
+        if tp:
+            serv = self.services.get_service_by_chid((sid,tp["tsid"],tp["onid"]))
+            if serv:
+                return serv["sref"]
+        return ""
+
+########################################################################
+class Bouquet(object):
+    """Bouquet file object"""
+
+    #----------------------------------------------------------------------
+    def __init__(self, bid, service_path=None):
+        """Constructor"""
+        if not service_path:
+            service_path = "enigma2" if sys.platform=="win32" else "/etc/enigma2"
+        self.service_path = service_path
+        self.bid = bid
+        if not "ftp:" in service_path:
+            self.fname = os.path.join(service_path, "userbouquet.%s.tv"%self.bid)
+        else:
+            sep = "" if service_path[-1]=="//" else "//"
+            self.fname = os.path.join(service_path, "userbouquet.%s.tv"%self.bid)
+        self.load()
+
+    #----------------------------------------------------------------------
+    def load(self):
+        """Load bouquet from file"""
+        self.services=[]
+        fb = open(self.fname,"r") if not self.fname[0:4] == "ftp:" else urllib2.urlopen(self.fname)
+        i= 0
+        line = fb.readline()
+        while True:
+            if line[0:5] == "#NAME":
+                self.name = line.strip()[6:].decode("utf8")
+            elif line[0:8] == "#SERVICE":
+                sref = line.strip()[9:]
+                s = sref_parse(sref)
+                s["sref"] = sref
+                if s["flags"] == 64:
+                    s["type"] = "marker"
+                    line = fb.readline()
+                    if line[0:12] =='#DESCRIPTION':
+                        s["name"] = line [13:].strip().decode("utf8")
+                    else: continue
+                elif s["url"]: # IPTV stream
+                    s["type"] = "stream"
+                    s["sref"] = ":".join(s["sref"].split(":")[0:10])
+                    line = fb.readline()
+                    if line[0:12] =='#DESCRIPTION':
+                        s["name"] = line [13:].strip().decode("utf8")
+                    else: continue
+                self.services.append(s)
+            line = fb.readline()
+            if not line: break
+        fb.close()
+
+
+
+def decode_charset(s):
+    u = None
+    if isinstance(s,unicode):
+        return s
+    charset_list=('iso-8859-4','iso-8859-1','iso-8859-2''iso-8859-15')
+
+    for charset in charset_list:
+        try:
+            u=unicode(s,charset,"strict")
+        except:
+            pass
+        else:
+            break
+
+    if u == None:
+        raise Error, "CHARSET ERROR while decoding lamedb. Aborting !"
+    else:
+        return(u)
+
+# lref - lamedb/services
+#	SID:NS:TSID:ONID:STYPE:UNUSED(channelnumber in enigma1)
+#	0   1  2    3    4     5
+#	X   X  X    X    D     D
+#
+# sref bouquets/picon
+#   REFTYPE:FLAGS:STYPE:SID:TSID:ONID:NS:PARENT_SID:PARENT_TSID:UNUSED
+#   0       1     2     3   4    5    6  7          8           9
+#   D       D     X     X   X    X    X  X          X           X
+
+def lref2sref(s):
+    "Converts service refefence from lamedb format to bouquets/picon (standard) format"
+    f = s.split(":")
+    sid = int(f[0],16)
+    ns = int(f[1], 16)
+    tsid = int(f[2],16)
+    onid = int(f[3],16)
+    stype = int(f[4])
+
+    s2 = "1:0:%X:%X:%X:%X:%X:0:0:0:" % (stype,sid,tsid,onid,ns)
+    return s2
+
+def lref_parse(s):
+    "Parse lamedb/service string, return dictionary of items"
+    f = s.split(":")
+    #r = {}
+    r = Rec()
+    r["sid"] = int(f[0],16)
+    r["ns"] = int(f[1], 16)
+    r["tsid"] = int(f[2],16)
+    r["onid"] = int(f[3],16)
+    r["stype"] = int(f[4])
+    return r
+
+def sref2lref(s):
+    "Converts service refefence from bouquets/picon (standard) format to lamedb format"
+    f = s.split(":")
+    reftype = int(f[0])
+    flags = int(f[1])
+    stype = int(f[2],16)
+    sid = int(f[3],16)
+    tsid = int(f[4],16)
+    onid = int(f[5],16)
+    ns = int(f[6],16)
+
+    s2 = "%04x:%08x:%04x:%04x:%i:0" % (sid,ns,tsid,onid,stype)
+    return s2
+
+def sref_parse(s):
+    "Parse service refefence string , return dictionary of items"
+    f = s.split(":")
+    #r = {}
+    r = Rec()
+    r["reftype"] = int(f[0])
+    r["flags"] = int(f[1])
+    r["stype"] = int(f[2],16)
+    r["sid"] = int(f[3],16)
+    r["tsid"] = int(f[4],16)
+    r["onid"] = int(f[5],16)
+    r["ns"] = int(f[6],16)
+    r["url"] = unquote(f[10]) if len(f)>10 else ""
+    return r
+
+pos_int2str = lambda pos_num: "%04x0000"%pos_num
+pos_str2int = lambda pos: int(pos[0:4],16)
+
+def decode_charset(s):
+    u = None
+    charset_list = ('utf-8','iso-8859-1','iso-8859-2','iso-8859-15')
+
+    for charset in charset_list:
+        try:
+            u = unicode(s,charset,"strict")
+        except:
+            pass
+        else:
+            break
+
+    if u == None:
+        print("CHARSET ERROR while decoding string")
+        sys.exit(1)
+    else:
+        return(u)
+
+import UserDict
+
+if __name__ == "__main__":
+    #print "** Starting..."
+    #sys.exit(main(sys.argv))
+    e2 = DBServices()
+    #e2.save_buquet("english")
+    e2.create_bouqet("test", "Tests")
+    pass

locale/PlayStream.pot

@@ -0,0 +1,29 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR ORGANIZATION
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2016-04-24 16:41+FLE Daylight Time\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=CHARSET\n"
+"Content-Transfer-Encoding: ENCODING\n"
+"Generated-By: pygettext.py 1.5\n"
+
+
+#: PlayStream.py:83
+msgid "Back"
+msgstr ""
+
+#: PlayStream.py:84
+msgid "Select"
+msgstr ""
+
+#: plugin.py:16 plugin.py:17
+msgid "Play online streams from various sources"
+msgstr ""
+

locale/lv.po

@@ -0,0 +1,30 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR ORGANIZATION
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: \n"
+"POT-Creation-Date: 2016-04-24 16:43+0300\n"
+"PO-Revision-Date: 2016-04-24 16:45+0300\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: pygettext.py 1.5\n"
+"X-Generator: Poedit 1.8.7\n"
+"Last-Translator: \n"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2);\n"
+"Language: lv\n"
+
+#: PlayStream.py:83
+msgid "Back"
+msgstr "Atpakaļ"
+
+#: PlayStream.py:84
+msgid "Select"
+msgstr "Izvēlies"
+
+#: plugin.py:16 plugin.py:17
+msgid "Play online streams from various sources"
+msgstr "Dažādu online plūsmu spēlēšana no dažādiem avotiem"

locale/ru.po

@@ -0,0 +1,30 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR ORGANIZATION
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: \n"
+"POT-Creation-Date: 2016-04-24 16:47+0300\n"
+"PO-Revision-Date: 2016-04-24 16:48+0300\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: pygettext.py 1.5\n"
+"X-Generator: Poedit 1.8.7\n"
+"Last-Translator: \n"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
+"Language: ru\n"
+
+#: PlayStream.py:83
+msgid "Back"
+msgstr "Назад"
+
+#: PlayStream.py:84
+msgid "Select"
+msgstr "Выбрать"
+
+#: plugin.py:16 plugin.py:17
+msgid "Play online streams from various sources"
+msgstr "Играть онлайн потоки из различных источников"

resolver.py

@@ -0,0 +1,140 @@
+# *      Copyright (C) 2011 Libor Zoubek
+# *      Modified by ivars777
+# *      Based in code from https://github.com/kodi-czsk/script.module.stream.resolver
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+# Based in code from https://github.com/kodi-czsk/script.module.stream.resolver
+
+import re
+import traceback
+
+import util
+import sys,os
+#sys.path.insert(0,os.path.dirname(os.path.abspath(__file__)))
+server_path = "resolvers"
+sys.path.append(os.path.join(os.path.dirname(__file__), server_path))
+
+RESOLVERS = []
+util.debug('%s searching for modules' % __name__)
+
+for module in os.listdir(os.path.join(os.path.dirname(__file__), server_path)):
+    if module == '__init__.py' or module[-3:] != '.py':
+        continue
+    module = module[:-3]
+    #exec 'import %s' % module
+    #resolver = eval(module)
+    resolver = __import__(module)
+    #reload(resolver)
+    
+    if not hasattr(resolver, 'resolve'):
+        continue
+    print 'found %s %s' % (resolver, dir(resolver))
+    #util.debug('found %s %s' % (resolver, dir(resolver)))
+    if not hasattr(resolver, '__priority__'):
+        resolver.__priority__ = 0
+    RESOLVERS.append(resolver)
+    del module
+RESOLVERS = sorted(RESOLVERS, key=lambda m: -m.__priority__)
+
+def item():
+    stream0 = {'name': '', 'url': '', 'quality': '???', 'surl': '', 'subs': '', 'headers': {},"desc":"","img":"","lang":"","type":"","order":0}            
+    return stream0
+
+def resolve(url):
+    """
+        resolves given url by asking all resolvers
+
+        returns None if no resolver advised to be able to resolve this url
+        returns False if resolver did his job, but did not return any value (thus failed)
+        returns Array of resolved objects in positive usecase
+    """
+    url = util.decode_html(url)
+    util.info('Resolving ' + url)
+    resolver = _get_resolver(url)
+    value = None
+    if resolver is None:
+        return None
+    util.info('Using resolver \'%s\'' % str(resolver.__name__));
+    value = resolver.resolve(url)
+    if value is None:
+        return False
+    default = item()
+    for i in value:
+        if 'name' not in i.keys():
+            i['name'] = resolver.__name__
+        if 'surl' not in i.keys():
+            i['surl'] = url
+        for key in default.keys():
+            if key not in i.keys():
+                i[key] = default[key]   
+        if "|" in i["url"]:
+            headers = i["url"].split("|")[1]
+            i["url"]=i["url"].split("|")[0]
+            for h in headers.split("&"):
+                if "=" in h:
+                    i["headers"][h.split("=")[0]] = h.split("=")[1]
+
+    return sorted(value, key=lambda i: i['quality'])
+
+
+def _get_resolver(url):
+    util.debug('Get resolver for ' + url)
+    for r in RESOLVERS:
+        util.debug('querying %s' % r)
+        if r.supports(url):
+            return r
+
+def can_resolve(url):
+    """ Returns true if we are able to resolve stream by given URL """
+    return _get_resolver(url) is not None
+
+
+if __name__ == "__main__":
+
+    from subprocess import call
+    #url = "http://hqq.tv/player/embed_player.php?vid=235238210241210222228241233208212245&autoplay=no"
+    #url = "http://hqq.tv/player/embed_player.php?vid=243221241234244238208213206212211231&autoplay=no"
+    url = "http://hqq.tv/player/embed_player.php?vid=208231211231207221227243206206221244&autoplay=no"
+    #url = "https://openload.co/embed/TMthIdpy4PI/"
+    #url = "https://www.youtube.com/watch?v=Tx1K51_F99o"
+    #url = "https://www.youtube.com/watch?v=8BkcX7O1890"
+    #url = "https://www.youtube.com/watch?v=Se07R8SYsg0"
+    #url = "https://kinostok.tv/embed/731f3437e3c53104dd56d04039a0b15a"
+    #url = "http://vk.com/video_ext.php?oid=246066565&id=169244575&hash=d430ab0e76c9f7a1&hd=3"
+    #url ="https://openload.co/embed/rPMXJYPTkw4/"
+    #url = "https://openload.co/embed/bE7WfZ-vz_A/" 
+    #url = "https://openload.co/embed/bE7WfZ/" 
+    #url = "https://openload.co/embed/OuskaKyC2GU/"
+    url = "http://hqq.tv/player/embed_player.php?vid=235238210241210222228241233208212245&autoplay=no"
+    url = "https://openload.co/embed/rmNcP-0QopE/"
+    url = "https://openload.co/embed/gpLF6Grzy80/"
+    url = "https://openload.co/embed/oQLXcU1ITAY/"
+    url = "http://hqq.tv/player/embed_player.php?vid=245208228234224222241224221239207212&autoplay=no"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+
+    for s in streams:
+        print s
+
+    print streams[0]["url"] 
+    util.play_video(streams)
+    ##call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",streams[0]["url"]])
+    pass

resolvers/__init__.py

@@ -0,0 +1,31 @@
+#/*
+# *      Copyright (C) 2011 Libor Zoubek
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+
+##########################################################3
+# all resolvers modules in this directory must have following methods:
+
+# __name__ - name of the resolver module - can override module filename
+# def supports(url) - returns true iff resolver is able to resolve url to stream otherwise false
+# def resolve(url) - returns array of all hashmaps that were resolved
+#   - if resolving fails, nothing is returned
+#   - a hash MUST contain key 'url' - it's value is stream URL
+#   - optional keys are 'subs' (link to subtitle), 'quality' (quality string like '240p' or just 'HD'

resolvers/aadecode.py

@@ -0,0 +1,209 @@
+#-*- coding: utf-8 -*-
+#
+# author : Djeman
+# Updated by Shani-08 (https://github.com/Shani-08/ShaniXBMCWork2)
+
+import re
+
+class AADecoder(object):
+    def __init__(self, aa_encoded_data):
+        self.encoded_str = aa_encoded_data.replace('/*´∇｀*/','')
+
+        self.b = ["(c^_^o)", "(ﾟΘﾟ)", "((o^_^o) - (ﾟΘﾟ))", "(o^_^o)",
+                  "(ﾟｰﾟ)", "((ﾟｰﾟ) + (ﾟΘﾟ))", "((o^_^o) +(o^_^o))", "((ﾟｰﾟ) + (o^_^o))",
+                  "((ﾟｰﾟ) + (ﾟｰﾟ))", "((ﾟｰﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ))", "(ﾟДﾟ) .ﾟωﾟﾉ", "(ﾟДﾟ) .ﾟΘﾟﾉ",
+                  "(ﾟДﾟ) ['c']", "(ﾟДﾟ) .ﾟｰﾟﾉ", "(ﾟДﾟ) .ﾟДﾟﾉ", "(ﾟДﾟ) [ﾟΘﾟ]"]
+
+    def is_aaencoded(self):
+        idx = self.encoded_str.find("ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/ ['_']; o=(ﾟｰﾟ)  =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); ")
+        if idx == -1:
+            return False
+
+        if self.encoded_str.find("(ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');", idx) == -1:
+            return False
+
+        return True
+
+    def base_repr(self, number, base=2, padding=0):
+        digits = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+        if base > len(digits):
+            base = len(digits)
+
+        num = abs(number)
+        res = []
+        while num:
+            res.append(digits[num % base])
+            num //= base
+        if padding:
+            res.append('0' * padding)
+        if number < 0:
+            res.append('-')
+        return ''.join(reversed(res or '0'))
+
+    def decode_char(self, enc_char, radix):
+        end_char = "+ "
+        str_char = ""
+        while enc_char != '':
+            found = False
+
+            if not found:
+                for i in range(len(self.b)):             
+                    enc_char=enc_char.replace(self.b[i], str(i))
+                
+                startpos=0
+                findClose=True
+                balance=1
+                result=[]
+                if enc_char.startswith('('):
+                    l=0
+                    
+                    for t in enc_char[1:]:
+                        l+=1
+                        if findClose and t==')':
+                            balance-=1;
+                            if balance==0:
+                                result+=[enc_char[startpos:l+1]]
+                                findClose=False
+                                continue
+                        elif not findClose and t=='(':
+                            startpos=l
+                            findClose=True
+                            balance=1
+                            continue
+                        elif t=='(':
+                            balance+=1
+                 
+
+                if result is None or len(result)==0:
+                    return ""
+                else:
+                    
+                    for r in result:
+                        value = self.decode_digit(r, radix)
+                        if value == "":
+                            return ""
+                        else:
+                            str_char += value
+                            
+                    return str_char
+
+            enc_char = enc_char[len(end_char):]
+
+        return str_char
+
+        
+              
+    def decode_digit(self, enc_int, radix):
+
+        rr = '(\(.+?\)\))\+'
+        rerr=enc_int.split('))+')
+        v = ''
+        
+        #new mode
+
+        for c in rerr:
+            
+            if len(c)>0:
+                if c.strip().endswith('+'):
+                    c=c.strip()[:-1]
+
+                startbrackets=len(c)-len(c.replace('(',''))
+                endbrackets=len(c)-len(c.replace(')',''))
+                    
+                if startbrackets>endbrackets:
+                    c+=')'*startbrackets-endbrackets
+                    
+                c = c.replace('!+[]','1')
+                c = c.replace('-~','1+')
+                c = c.replace('[]','0')
+                    
+                v+=str(eval(c))
+                    
+        return v
+         
+        mode = 0
+        value = 0
+
+        while enc_int != '':
+            found = False
+            for i in range(len(self.b)):
+                if enc_int.find(self.b[i]) == 0:
+                    if mode == 0:
+                        value += i
+                    else:
+                        value -= i
+                    enc_int = enc_int[len(self.b[i]):]
+                    found = True
+                    break
+
+            if not found:
+                return ""
+
+            enc_int = re.sub('^\s+|\s+$', '', enc_int)
+            if enc_int.find("+") == 0:
+                mode = 0
+            else:
+                mode = 1
+
+            enc_int = enc_int[1:]
+            enc_int = re.sub('^\s+|\s+$', '', enc_int)
+
+        return self.base_repr(value, radix)
+
+    def decode(self):
+
+        self.encoded_str = re.sub('^\s+|\s+$', '', self.encoded_str)
+
+        # get data
+        pattern = (r"\(ﾟДﾟ\)\[ﾟoﾟ\]\+ (.+?)\(ﾟДﾟ\)\[ﾟoﾟ\]\)")
+        result = re.search(pattern, self.encoded_str, re.DOTALL)
+        if result is None:
+            print "AADecoder: data not found"
+            return False
+
+        data = result.group(1)
+
+        # hex decode string
+        begin_char = "(ﾟДﾟ)[ﾟεﾟ]+"
+        alt_char = "(oﾟｰﾟo)+ "
+
+        out = ''
+
+        while data != '':
+            # Check new char
+            if data.find(begin_char) != 0:
+                print "AADecoder: data not found"
+                return False
+
+            data = data[len(begin_char):]
+
+            # Find encoded char
+            enc_char = ""
+            if data.find(begin_char) == -1:
+                enc_char = data
+                data = ""
+            else:
+                enc_char = data[:data.find(begin_char)]
+                data = data[len(enc_char):]
+
+            
+            radix = 8
+            # Detect radix 16 for utf8 char
+            if enc_char.find(alt_char) == 0:
+                enc_char = enc_char[len(alt_char):]
+                radix = 16
+
+            str_char = self.decode_char(enc_char, radix)
+            
+            if str_char == "":
+                print "no match :  "
+                print  data + "\nout = " + out + "\n"
+                return False
+            
+            out += chr(int(str_char, radix))
+
+        if out == "":
+            print "no match : " + data
+            return False
+
+        return out

resolvers/hdgo.py

@@ -0,0 +1,95 @@
+# -*- coding: UTF-8 -*-
+# /*
+# *      Copyright (C) 2016 ivars777
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+import re,os,sys
+import json
+try:
+    import util
+except:
+    pp = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
+    import util
+import urllib2
+import requests
+#from aadecode import AADecoder
+
+if __name__ <> "__main__":
+    __name__ = 'hqq'
+
+def supports(url):
+    m = re.search(r"https?://hdgo\.\w+/(.+?)$", url, re.DOTALL)
+    if m:
+        return True
+    else:
+        return False
+
+def resolve(url):
+    HTTP_HEADER = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:39.0) Gecko/20100101 Firefox/39.0',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
+        'Accept-Encoding': 'none',
+        'Accept-Language': 'en-US,en;q=0.8',
+        'Referer': url}  # 'Connection': 'keep-alive'
+    streams = []
+    m = re.search(r"https?://hdgo\.\w+/(.+?)$", url, re.DOTALL)
+    vid=m.group(1)
+    url2 = "http://couber.be/"+vid
+    r = requests.get(url2,headers=HTTP_HEADER)
+    if r.status_code <> 200:
+        return streams
+    m = re.search('<iframe src="([^"]+)"', r.content, re.DOTALL)
+    if not m: return streams
+    url3 = m.group(1)
+    HTTP_HEADER["Rererer"] = url2
+    r = requests.get(url3,headers=HTTP_HEADER)
+    m = re.search(r"else{\s+setFlash\('([^']+)'\);", r.content, re.DOTALL)
+    if not m: return streams
+    q = ["1080p","720p","480p","360p"]
+    for i,ss in enumerate(m.group(1).split(",")):
+        s = ss.split(" or ")
+        if not s[0]: continue
+        stream = util.item()
+        stream["url"] = s[0]
+        stream["name"] = s[0]
+        stream["quality"] = q[i]
+        streams.append(stream)
+    return streams
+
+
+if __name__ == "__main__":
+
+    from subprocess import call
+    url = "http://hdgo.cc/video/t/Qrz0riUvA65GtkTpDvmlD9TBOn56HSm2/127280/"
+    url = "http://hdgo.cc/video/t/Qrz0riUvA65GtkTpDvmlD9TBOn56HSm2/34879/"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+    for s in streams:
+        print s
+    util.play_video(streams)
+
+
+    #print streams[0]["url"]    
+    #call([r"gst-launch-1.0.exe",'uri="%s""'%streams[0]["url"]])
+    pass

resolvers/hqqresolver.py

@@ -0,0 +1,186 @@
+# -*- coding: UTF-8 -*-
+# *  GNU General Public License for more details.
+# *
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# *
+# *  based on https://gitorious.org/iptv-pl-dla-openpli/ urlresolver
+# */
+from StringIO import StringIO
+import json
+import re
+import util
+import base64
+import urllib
+
+__name__ = 'hqq'
+
+
+def supports(url):
+    #return False
+    return _regex(url) is not None
+
+
+def _decode(data):
+    def O1l(string):
+        ret = ""
+        i = len(string) - 1
+        while i >= 0:
+            ret += string[i]
+            i -= 1
+        return ret
+
+    def l0I(string):
+        enc = ""
+        dec = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+        i = 0
+        while True:
+            h1 = dec.find(string[i])
+            i += 1
+            h2 = dec.find(string[i])
+            i += 1
+            h3 = dec.find(string[i])
+            i += 1
+            h4 = dec.find(string[i])
+            i += 1
+            bits = h1 << 18 | h2 << 12 | h3 << 6 | h4
+            o1 = bits >> 16 & 0xff
+            o2 = bits >> 8 & 0xff
+            o3 = bits & 0xff
+            if h3 == 64:
+                enc += unichr(o1)
+            else:
+                if h4 == 64:
+                    enc += unichr(o1) + unichr(o2)
+                else:
+                    enc += unichr(o1) + unichr(o2) + unichr(o3)
+            if i >= len(string):
+                break
+        return enc
+
+    escape = re.search("var _escape=\'([^\']+)", l0I(O1l(data))).group(1)
+    return escape.replace('%', '\\').decode('unicode-escape')
+
+
+def _decode2(file_url):
+    def K12K(a, typ='b'):
+        codec_a = ["G", "L", "M", "N", "Z", "o", "I", "t", "V", "y", "x", "p", "R", "m", "z", "u",
+                   "D", "7", "W", "v", "Q", "n", "e", "0", "b", "="]
+        codec_b = ["2", "6", "i", "k", "8", "X", "J", "B", "a", "s", "d", "H", "w", "f", "T", "3",
+                   "l", "c", "5", "Y", "g", "1", "4", "9", "U", "A"]
+        if 'd' == typ:
+            tmp = codec_a
+            codec_a = codec_b
+            codec_b = tmp
+        idx = 0
+        while idx < len(codec_a):
+            a = a.replace(codec_a[idx], "___")
+            a = a.replace(codec_b[idx], codec_a[idx])
+            a = a.replace("___", codec_b[idx])
+            idx += 1
+        return a
+
+    def _xc13(_arg1):
+        _lg27 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+        _local2 = ""
+        _local3 = [0, 0, 0, 0]
+        _local4 = [0, 0, 0]
+        _local5 = 0
+        while _local5 < len(_arg1):
+            _local6 = 0
+            while _local6 < 4 and (_local5 + _local6) < len(_arg1):
+                _local3[_local6] = _lg27.find(_arg1[_local5 + _local6])
+                _local6 += 1
+            _local4[0] = ((_local3[0] << 2) + ((_local3[1] & 48) >> 4))
+            _local4[1] = (((_local3[1] & 15) << 4) + ((_local3[2] & 60) >> 2))
+            _local4[2] = (((_local3[2] & 3) << 6) + _local3[3])
+
+            _local7 = 0
+            while _local7 < len(_local4):
+                if _local3[_local7 + 1] == 64:
+                    break
+                _local2 += chr(_local4[_local7])
+                _local7 += 1
+            _local5 += 4
+        return _local2
+
+    return _xc13(K12K(file_url, 'e'))
+
+
+def resolve(url):
+    m = _regex(url)
+    if m:
+        vid = m.group('vid')
+        headers = {'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                   'Content-Type': 'text/html; charset=utf-8'}
+        player_url = "http://hqq.tv/player/embed_player.php?vid=%s&autoplay=no" % vid
+        data = util.request(player_url, headers)
+        b64enc = re.search('base64([^\"]+)', data, re.DOTALL)
+        b64dec = b64enc and base64.decodestring(b64enc.group(1))
+        enc = b64dec and re.search("\'([^']+)\'", b64dec).group(1)
+        if enc:
+            data = re.findall('<input name="([^"]+?)" [^>]+? value="([^"]+?)">', _decode(enc))
+            post_data = {}
+            for idx in range(len(data)):
+                post_data[data[idx][0]] = data[idx][1]
+            data = util.post(player_url, post_data, headers)
+            b64enc = re.search('base64([^\"]+)', data, re.DOTALL)
+            b64dec = b64enc and base64.decodestring(b64enc.group(1))
+            enc = b64dec and re.search("\'([^']+)\'", b64dec).group(1)
+            if enc:
+                data = re.findall('<input name="([^"]+?)" [^>]+? value="([^"]*)">', _decode(enc))
+                post_data = {}
+                for idx in range(len(data)):
+                    post_data[data[idx][0]] = data[idx][1]
+                data = urllib.unquote(util.request("http://hqq.tv/sec/player/embed_player.php?" +
+                                                   urllib.urlencode(post_data), headers))
+                server_1 = re.search("server_1: (\w+)",data).group(1)
+                link_1 = re.search("link_1: (\w+)",data).group(1)
+                vid_server = re.search(r'var\s*%s\s*=\s*"([^"]*?)"'%server_1, data)
+                vid_link = re.search(r'var\s*%s\s*=\s*"([^"]*?)"'%link_1, data)
+                at = re.search(r'var\s*at\s*=\s*"([^"]*?)"', data)
+                vid = re.search('vid: "([^"]+)"',data)
+                if vid_server and vid_link and at:
+                    get_data = {'server_1': vid_server.group(1),
+                                'link_1': vid_link.group(1),
+                                'at': at.group(1),
+                                'adb': '0/',
+                                'b':'1',
+                                'vid': vid.group(1)}
+                    # X-Requested-With: XMLHttpRequest
+                    headers["X-Requested-With"] = "XMLHttpRequest"
+                    html = util.request("http://hqq.tv/player/get_md5.php?"+urllib.urlencode(get_data), headers)
+                    data = json.load(StringIO(html))
+                    if 'file' in data:
+                        file_url = _decode2(data['file'])
+                        file_url = re.sub(r'\?socket=?$', '.mp4.m3u8',file_url)
+                        return [{'url': file_url, 'quality': '360p',"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"}}]
+    return None
+
+
+def _regex(url):
+    match = re.search("(hqq|netu)\.tv/watch_video\.php\?v=(?P<vid>[0-9A-Z]+)", url)
+    if match:
+        return match
+    match = re.search(r'(hqq|netu)\.tv/player/embed_player\.php\?vid=(?P<vid>[0-9A-Z]+)', url)
+    if match:
+        return match
+    match = re.search(r'(hqq|netu)\.tv/player/hash\.php\?hash=\d+', url)
+    if match:
+        match = re.search(r'var\s+vid\s*=\s*\'(?P<vid>[^\']+)\'', urllib.unquote(util.request(url)))
+        if match:
+            return match
+    b64enc = re.search(r'data:text/javascript\;charset\=utf\-8\;base64([^\"]+)', url)
+    b64dec = b64enc and base64.decodestring(b64enc.group(1))
+    enc = b64dec and re.search(r"\'([^']+)\'", b64dec).group(1)
+    if enc:
+        decoded = _decode(enc)
+        match = re.search(r'<input name="vid"[^>]+? value="(?P<vid>[^"]+?)">', decoded)
+        if re.search(r'<form(.+?)action="[^"]*(hqq|netu)\.tv/player/embed_player\.php"[^>]*>',
+                     decoded) and match:
+            return match
+    return None

resolvers/openload3.py

@@ -0,0 +1,109 @@
+# -*- coding: UTF-8 -*-
+# /*
+# *      Copyright (C) 2015 Lubomir Kucera
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+
+import re,os,sys
+import json
+try:
+    import util
+except:
+    pp = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0,os.sep.join(pp.split(os.sep)[:-1]))
+    import util
+import urllib2
+import requests
+#from aadecode import AADecoder
+
+__author__ = 'Jose Riha/Lubomir Kucera'
+__name__ = 'openload3'
+
+
+def supports(url):
+    return re.search(r'openload\.\w+/embed/.+', url) is not None
+
+
+#INFO_URL = API_BASE_URL + '/streaming/info'
+
+def resolve(url):
+    HTTP_HEADER = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:39.0) Gecko/20100101 Firefox/39.0',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
+        'Accept-Encoding': 'none',
+        'Accept-Language': 'en-US,en;q=0.8',
+        'Referer': url}  # 'Connection': 'keep-alive'    
+
+    stream = util.item()
+    m = re.search('https*://openload\.\w+/embed/([^/]+)', url)
+    if not m:
+        return stream
+    vid=m.group(1)
+    url2 = "https://api.openload.co/1/streaming/get?file="+vid
+    r = requests.get(url2,headers=HTTP_HEADER)
+    try:
+        js = json.loads(r.content)
+    except:
+        return stream
+    if js["status"] <>200:
+        raise Exception(js["msg"])
+    res = js["result"]
+    stream["url"] = res["url"]
+    stream["name"]= res["url"]
+    ### Retrieve subtitles ####
+    html = requests.get(url, headers=HTTP_HEADER).content 
+    m = re.search('<track kind="captions" src="([^"]+)" srclang="([^"]+)" label="([^"]+)"', html)
+    if m:
+        stream["subs"] = m.group(1)
+        stream["lang"] = m.group(2)   
+
+    return [stream]
+
+
+if __name__ == "__main__":
+
+    from subprocess import call
+    #url = "http://hqq.tv/player/embed_player.php?vid=235238210241210222228241233208212245&autoplay=no"
+    #url = "http://hqq.tv/player/embed_player.php?vid=243221241234244238208213206212211231&autoplay=no"
+    url = "http://hqq.tv/player/embed_player.php?vid=208231211231207221227243206206221244&autoplay=no"
+    #url = "https://openload.co/embed/TMthIdpy4PI/"
+    #url = "https://www.youtube.com/watch?v=Tx1K51_F99o"
+    #url = "https://www.youtube.com/watch?v=8BkcX7O1890"
+    #url = "https://www.youtube.com/watch?v=Se07R8SYsg0"
+    #url = "https://kinostok.tv/embed/731f3437e3c53104dd56d04039a0b15a"
+    #url = "http://vk.com/video_ext.php?oid=246066565&id=169244575&hash=d430ab0e76c9f7a1&hd=3"
+    #url ="https://openload.co/embed/rPMXJYPTkw4/"
+    #url = "https://openload.co/embed/bE7WfZ-vz_A/" 
+    #url = "https://openload.co/embed/bE7WfZ/" 
+    #url = "https://openload.co/embed/OuskaKyC2GU/"
+    url = "http://hqq.tv/player/embed_player.php?vid=235238210241210222228241233208212245&autoplay=no"
+    url = "https://openload.co/embed/rmNcP-0QopE/"
+    url = "https://openload.co/embed/oQLXcU1ITAY/"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        sys.exit()
+
+    for s in streams:
+        print s
+
+    print streams[0]["url"]    
+    call([r"c:\Program Files\VideoLAN\VLC\vlc.exe",streams[0]["url"]])
+    pass

resolvers/youtuberesolver.py

@@ -0,0 +1,347 @@
+# -*- coding: UTF-8 -*-
+
+import urllib2
+# source from https://github.com/rg3/youtube-dl/issues/1208
+# removed some unnecessary debug messages..
+class CVevoSignAlgoExtractor:
+    # MAX RECURSION Depth for security
+    MAX_REC_DEPTH = 5
+
+    def __init__(self):
+        self.algoCache = {}
+        self._cleanTmpVariables()
+
+    def _cleanTmpVariables(self):
+        self.fullAlgoCode = ''
+        self.allLocalFunNamesTab = []
+        self.playerData = ''
+
+    def _jsToPy(self, jsFunBody):
+        pythonFunBody = jsFunBody.replace('function', 'def').replace('{', ':\n\t').replace('}', '').replace(';', '\n\t').replace('var ', '')
+        pythonFunBody = pythonFunBody.replace('.reverse()', '[::-1]')
+
+        lines = pythonFunBody.split('\n')
+        for i in range(len(lines)):
+            # a.split("") -> list(a)
+            match = re.search('(\w+?)\.split\(""\)', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), 'list(' + match.group(1) + ')')
+            # a.length -> len(a)
+            match = re.search('(\w+?)\.length', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), 'len(' + match.group(1) + ')')
+            # a.slice(3) -> a[3:]
+            match = re.search('(\w+?)\.slice\(([0-9]+?)\)', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), match.group(1) + ('[%s:]' % match.group(2)))
+            # a.join("") -> "".join(a)
+            match = re.search('(\w+?)\.join\(("[^"]*?")\)', lines[i])
+            if match:
+                lines[i] = lines[i].replace(match.group(0), match.group(2) + '.join(' + match.group(1) + ')')
+        return "\n".join(lines)
+
+    def _getLocalFunBody(self, funName):
+        # get function body
+        match = re.search('(function %s\([^)]+?\){[^}]+?})' % funName, self.playerData)
+        if match:
+            # return jsFunBody
+            return match.group(1)
+        return ''
+
+    def _getAllLocalSubFunNames(self, mainFunBody):
+        match = re.compile('[ =(,](\w+?)\([^)]*?\)').findall(mainFunBody)
+        if len(match):
+            # first item is name of main function, so omit it
+            funNameTab = set(match[1:])
+            return funNameTab
+        return set()
+
+    def decryptSignature(self, s, playerUrl):
+        playerUrl = playerUrl[:4] != 'http' and 'http:' + playerUrl or playerUrl
+        util.debug("decrypt_signature sign_len[%d] playerUrl[%s]" % (len(s), playerUrl))
+
+        # clear local data
+        self._cleanTmpVariables()
+
+        # use algoCache
+        if playerUrl not in self.algoCache:
+            # get player HTML 5 sript
+            request = urllib2.Request(playerUrl)
+            try:
+                self.playerData = urllib2.urlopen(request).read()
+                self.playerData = self.playerData.decode('utf-8', 'ignore')
+            except:
+                util.debug('Unable to download playerUrl webpage')
+                return ''
+
+            # get main function name
+            match = re.search("signature=(\w+?)\([^)]\)", self.playerData)
+            if match:
+                mainFunName = match.group(1)
+                util.debug('Main signature function name = "%s"' % mainFunName)
+            else:
+                util.debug('Can not get main signature function name')
+                return ''
+
+            self._getfullAlgoCode(mainFunName)
+
+            # wrap all local algo function into one function extractedSignatureAlgo()
+            algoLines = self.fullAlgoCode.split('\n')
+            for i in range(len(algoLines)):
+                algoLines[i] = '\t' + algoLines[i]
+            self.fullAlgoCode = 'def extractedSignatureAlgo(param):'
+            self.fullAlgoCode += '\n'.join(algoLines)
+            self.fullAlgoCode += '\n\treturn %s(param)' % mainFunName
+            self.fullAlgoCode += '\noutSignature = extractedSignatureAlgo( inSignature )\n'
+
+            # after this function we should have all needed code in self.fullAlgoCode
+            try:
+                algoCodeObj = compile(self.fullAlgoCode, '', 'exec')
+            except:
+                util.debug('decryptSignature compile algo code EXCEPTION')
+                return ''
+        else:
+            # get algoCodeObj from algoCache
+            util.debug('Algo taken from cache')
+            algoCodeObj = self.algoCache[playerUrl]
+
+        # for security alow only flew python global function in algo code
+        vGlobals = {"__builtins__": None, 'len': len, 'list': list}
+
+        # local variable to pass encrypted sign and get decrypted sign
+        vLocals = { 'inSignature': s, 'outSignature': '' }
+
+        # execute prepared code
+        try:
+            exec(algoCodeObj, vGlobals, vLocals)
+        except:
+            util.debug('decryptSignature exec code EXCEPTION')
+            return ''
+
+        util.debug('Decrypted signature = [%s]' % vLocals['outSignature'])
+        # if algo seems ok and not in cache, add it to cache
+        if playerUrl not in self.algoCache and '' != vLocals['outSignature']:
+            util.debug('Algo from player [%s] added to cache' % playerUrl)
+            self.algoCache[playerUrl] = algoCodeObj
+
+        # free not needed data
+        self._cleanTmpVariables()
+
+        return vLocals['outSignature']
+
+    # Note, this method is using a recursion
+    def _getfullAlgoCode(self, mainFunName, recDepth=0):
+        if self.MAX_REC_DEPTH <= recDepth:
+            util.debug('_getfullAlgoCode: Maximum recursion depth exceeded')
+            return
+
+        funBody = self._getLocalFunBody(mainFunName)
+        if '' != funBody:
+            funNames = self._getAllLocalSubFunNames(funBody)
+            if len(funNames):
+                for funName in funNames:
+                    if funName not in self.allLocalFunNamesTab:
+                        self.allLocalFunNamesTab.append(funName)
+                        util.debug("Add local function %s to known functions" % mainFunName)
+                        self._getfullAlgoCode(funName, recDepth + 1)
+
+            # conver code from javascript to python
+            funBody = self._jsToPy(funBody)
+            self.fullAlgoCode += '\n' + funBody + '\n'
+        return
+
+decryptor = CVevoSignAlgoExtractor()
+
+'''
+   YouTube plugin for XBMC
+    Copyright (C) 2010-2012 Tobias Ussing And Henrik Mosgaard Jensen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+'''
+
+import sys
+import urllib
+import cgi
+import simplejson as json
+
+
+class YoutubePlayer(object):
+    fmt_value = {
+            5: "240p",
+            18: "360p",
+            22: "720p",
+            26: "???",
+            33: "???",
+            34: "360p",
+            35: "480p",
+            37: "1080p",
+            38: "720p",
+            43: "360p",
+            44: "480p",
+            45: "720p",
+            46: "520p",
+            59: "480",
+            78: "400",
+            82: "360p",
+            83: "240p",
+            84: "720p",
+            85: "520p",
+            100: "360p",
+            101: "480p",
+            102: "720p",
+            120: "hd720",
+            121: "hd1080"
+            }
+
+    # YouTube Playback Feeds
+    urls = {}
+    urls['video_stream'] = "http://www.youtube.com/watch?v=%s&safeSearch=none"
+    urls['embed_stream'] = "http://www.youtube.com/get_video_info?video_id=%s"
+    urls['video_info'] = "http://gdata.youtube.com/feeds/api/videos/%s"
+
+    def __init__(self):
+        pass
+
+    def removeAdditionalEndingDelimiter(self, data):
+        pos = data.find("};")
+        if pos != -1:
+            data = data[:pos + 1]
+        return data
+
+    def extractFlashVars(self, data, assets):
+        flashvars = {}
+        found = False
+
+        for line in data.split("\n"):
+            if line.strip().find(";ytplayer.config = ") > 0:
+                found = True
+                p1 = line.find(";ytplayer.config = ") + len(";ytplayer.config = ") - 1
+                p2 = line.rfind(";")
+                if p1 <= 0 or p2 <= 0:
+                    continue
+                data = line[p1 + 1:p2]
+                break
+        data = self.removeAdditionalEndingDelimiter(data)
+
+        if found:
+            data = json.loads(data)
+            if assets:
+                flashvars = data["assets"]
+            else:
+                flashvars = data["args"]
+        return flashvars
+
+    def scrapeWebPageForVideoLinks(self, result, video):
+        links = {}
+        flashvars = self.extractFlashVars(result, 0)
+        if not flashvars.has_key(u"url_encoded_fmt_stream_map"):
+            return links
+
+        if flashvars.has_key(u"ttsurl"):
+            video[u"ttsurl"] = flashvars[u"ttsurl"]
+        if flashvars.has_key("title"):
+            video["title"] = flashvars["title"]
+
+        for url_desc in flashvars[u"url_encoded_fmt_stream_map"].split(u","):
+            url_desc_map = cgi.parse_qs(url_desc)
+            if not (url_desc_map.has_key(u"url") or url_desc_map.has_key(u"stream")):
+                continue
+
+            key = int(url_desc_map[u"itag"][0])
+            url = u""
+            if url_desc_map.has_key(u"url"):
+                url = urllib.unquote(url_desc_map[u"url"][0])
+            elif url_desc_map.has_key(u"conn") and url_desc_map.has_key(u"stream"):
+                url = urllib.unquote(url_desc_map[u"conn"][0])
+                if url.rfind("/") < len(url) - 1:
+                    url = url + "/"
+                url = url + urllib.unquote(url_desc_map[u"stream"][0])
+            elif url_desc_map.has_key(u"stream") and not url_desc_map.has_key(u"conn"):
+                url = urllib.unquote(url_desc_map[u"stream"][0])
+
+            if url_desc_map.has_key(u"sig"):
+                url = url + u"&signature=" + url_desc_map[u"sig"][0]
+            elif url_desc_map.has_key(u"s"):
+                sig = url_desc_map[u"s"][0]
+                flashvars = self.extractFlashVars(result, 1)
+                js = flashvars[u"js"]
+                url = url + u"&signature=" + self.decrypt_signature(sig, js)
+
+            links[key] = url
+
+        return links
+
+    def decrypt_signature(self, s, js):
+        return decryptor.decryptSignature(s, js)
+
+
+    def extractVideoLinksFromYoutube(self, url, videoid, video):
+        result = util.request(self.urls[u"video_stream"] % videoid)
+        links = self.scrapeWebPageForVideoLinks(result, video)
+        if len(links) == 0:
+            util.error(u"Couldn't find video url- or stream-map.")
+        return links
+# /*
+# *      Copyright (C) 2011 Libor Zoubek
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+import re, util, urllib
+__name__ = 'youtube'
+
+
+def supports(url):
+    return not _regex(url) == None
+
+def resolve(url):
+    m = _regex(url)
+    if not m == None:
+        player = YoutubePlayer()
+        video = {'title':'žádný název'}
+        index = url.find('&')  # strip out everytihing after &
+        if index > 0:
+            url = url[:index]
+        links = player.extractVideoLinksFromYoutube(url, m.group('id'), video)
+        resolved = []
+        for q in links:
+            if q in player.fmt_value.keys():
+                quality = player.fmt_value[q]
+                item = {}
+                item['name'] = __name__
+                item['url'] = links[q]
+                item['quality'] = quality
+                item['surl'] = url
+                item['subs'] = ''
+                item['title'] = video['title']
+                item['fmt'] = q
+                resolved.append(item)
+        return resolved
+
+def _regex(url):
+    return re.search('www\.youtube\.com/(watch\?v=|v/|embed/)(?P<id>.+?)(\?|$|&)', url, re.IGNORECASE | re.DOTALL)

sources/SourceBase.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+
+import urllib2, urllib
+import datetime, re, sys,os
+import requests
+from collections import OrderedDict
+import ConfigParser
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+stream0 = {'name': '', 'url': '', 'quality': '???', 'surl': '', 'subs': '', 'headers': {},"desc":"","img":"","lang":"","type":"","order":0}        
+
+
+class SourceBase(object):
+    """Stream source base class"""
+
+    def __init__(self,country="lv"):
+        self.name = "name"
+        self.title = "Title"
+        self.img = ""
+        self.desc = ""
+        self.options = OrderedDict()
+        self.config_file = ""
+        self.url = "http://www.bbb.com/"
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+
+    def login(self,user="",password=""):
+        return False
+
+    def logout(self):
+        return True
+
+    def get_content(self,data):
+        ### To be overriden in child class
+        return [("..atpakaļ","back",None,"Kļūda, atgriezties atpakaļ")]
+
+    def is_video(self,data):
+        ### To be overriden in child class
+        return False
+
+    def get_streams(self,data):
+        ### Normally to be overrided in child class
+
+        if not self.is_video(data):
+            return []
+        content = self.get_content(data)
+        stream = stream0
+        stream["name"] = content[0].encode("utf8") if isinstance(content[0],unicode) else content[0]
+        stream["url"] = content[1].encode("utf8") if isinstance(content[1],unicode) else content[1]
+        stream["img"] = content[2].encode("utf8") if isinstance(content[2],unicode) else content[2]
+        stream["desc"] = content[3].encode("utf8") if isinstance(content[3],unicode) else content[3]
+        stream["type"] = stream_type(content[1]).encode("utf8") 
+        return[stream]
+
+    def options_read(self):
+        if not ("options" in dir(self) and self.options): # process options only if self.options defined, self.config_file should be defined too
+            return None
+        config = ConfigParser.ConfigParser()        
+        if os.path.exists(self.config_file):
+            config.read(self.config_file)
+            self.options = OrderedDict(config.items(self.name))             
+        else:
+            self.options_write(self.options)
+        return self.options
+
+    def options_write(self,options):        
+        config = ConfigParser.ConfigParser() 
+        config.add_section(self.name)
+        for k in options.keys():
+            config.set(self.name, k,options[k])
+        with open(self.config_file,"w") as f:
+            config.write(f)
+        self.options = OrderedDict(config.items(self.name))        
+
+    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)
+        return result
+
+    def call_json(self, data,params=None,headers=None,lang=""):
+        result = self.call(url,params,headers=headers)
+        if result:
+            result = json.loads(content)
+            return result
+        else:
+            raise "No data returned"
+
+    def _http_request(self, url,params = None, headers=None):
+        if not headers: 
+            headers = self.headers if "headers" in dir(self) else headers2dict("User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0")
+        try:
+            if params:
+                r = requests.post(url, data=params, headers=headers)
+            else:
+                r = requests.get(url, headers=headers)
+            return r.content 
+        except Exception as ex:
+            if "read" in ex:
+                content = ex.read()
+            else:
+                content = None
+            return content
+
+    @staticmethod
+    def stream_type(data):
+        return stream_type(data)
+
+    @staticmethod
+    def get_stream0():
+        return stream0.copy()
+
+    @staticmethod
+    def parse_data(data):
+        if "::" in data:
+            source = data.split("::")[0]
+            data = data.split("::")[1]
+        else:
+            source = ""
+        path = data.split("?")[0]
+        plist = path.split("/")
+        clist = plist[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        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"
+    else:
+        return prefix
+
+if __name__ == "__main__":
+    pass

sources/YouTubeVideoUrl.py

@@ -0,0 +1,404 @@
+# -*- coding: UTF-8 -*-
+# This video extraction code based on youtube-dl: https://github.com/rg3/youtube-dl
+
+import codecs
+import json
+import re
+
+from urllib import urlencode
+from urllib2 import urlopen, URLError
+import sys
+
+#from Components.config import config
+
+#from . import sslContext
+sslContext = None
+if sys.version_info >= (2, 7, 9):
+	try:
+		import ssl
+		sslContext = ssl._create_unverified_context()
+	except:
+		pass 
+from jsinterp import JSInterpreter
+from swfinterp import SWFInterpreter
+
+
+PRIORITY_VIDEO_FORMAT = []
+maxResolution =  '22'
+
+
+def createPriorityFormats():
+	global PRIORITY_VIDEO_FORMAT,maxResolution
+	PRIORITY_VIDEO_FORMAT = []
+	use_format = False
+	for itag_value in ['38', '37', '96', '22', '95', '120',
+		'35', '94', '18', '93', '5', '92', '132', '17']:
+		if itag_value == maxResolution: #config.plugins.YouTube.maxResolution.value:
+			use_format = True
+		if use_format:
+			PRIORITY_VIDEO_FORMAT.append(itag_value)
+
+createPriorityFormats()
+
+IGNORE_VIDEO_FORMAT = [
+		'43',  # webm
+		'44',  # webm
+		'45',  # webm
+		'46',  # webm
+		'100',  # webm
+		'101',  # webm
+		'102'  # webm
+	]
+
+
+def uppercase_escape(s):
+	unicode_escape = codecs.getdecoder('unicode_escape')
+	return re.sub(
+		r'\\U[0-9a-fA-F]{8}',
+		lambda m: unicode_escape(m.group(0))[0],
+		s)
+
+
+def compat_urllib_parse_unquote(string, encoding='utf-8', errors='replace'):
+	if string == '':
+		return string
+	res = string.split('%')
+	if len(res) == 1:
+		return string
+	if encoding is None:
+		encoding = 'utf-8'
+	if errors is None:
+		errors = 'replace'
+	# pct_sequence: contiguous sequence of percent-encoded bytes, decoded
+	pct_sequence = b''
+	string = res[0]
+	for item in res[1:]:
+		try:
+			if not item:
+				raise ValueError
+			pct_sequence += item[:2].decode('hex')
+			rest = item[2:]
+			if not rest:
+				# This segment was just a single percent-encoded character.
+				# May be part of a sequence of code units, so delay decoding.
+				# (Stored in pct_sequence).
+				continue
+		except ValueError:
+			rest = '%' + item
+		# Encountered non-percent-encoded characters. Flush the current
+		# pct_sequence.
+		string += pct_sequence.decode(encoding, errors) + rest
+		pct_sequence = b''
+	if pct_sequence:
+		# Flush the final pct_sequence
+		string += pct_sequence.decode(encoding, errors)
+	return string
+
+
+def _parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
+			encoding='utf-8', errors='replace'):
+	qs, _coerce_result = qs, unicode
+	pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]
+	r = []
+	for name_value in pairs:
+		if not name_value and not strict_parsing:
+			continue
+		nv = name_value.split('=', 1)
+		if len(nv) != 2:
+			if strict_parsing:
+				raise ValueError("bad query field: %r" % (name_value,))
+			# Handle case of a control-name with no equal sign
+			if keep_blank_values:
+				nv.append('')
+			else:
+				continue
+		if len(nv[1]) or keep_blank_values:
+			name = nv[0].replace('+', ' ')
+			name = compat_urllib_parse_unquote(
+				name, encoding=encoding, errors=errors)
+			name = _coerce_result(name)
+			value = nv[1].replace('+', ' ')
+			value = compat_urllib_parse_unquote(
+				value, encoding=encoding, errors=errors)
+			value = _coerce_result(value)
+			r.append((name, value))
+	return r
+
+
+def compat_parse_qs(qs, keep_blank_values=False, strict_parsing=False,
+					encoding='utf-8', errors='replace'):
+	parsed_result = {}
+	pairs = _parse_qsl(qs, keep_blank_values, strict_parsing,
+					encoding=encoding, errors=errors)
+	for name, value in pairs:
+		if name in parsed_result:
+			parsed_result[name].append(value)
+		else:
+			parsed_result[name] = [value]
+	return parsed_result
+
+
+class YouTubeVideoUrl():
+
+	def _download_webpage(self, url):
+		""" Returns a tuple (page content as string, URL handle) """
+		try:
+			if sslContext:
+				urlh = urlopen(url, context = sslContext)
+			else:
+				urlh = urlopen(url)
+		except URLError, e:
+			#raise Exception(e.reason)
+			return ""
+		return urlh.read()
+
+	def _search_regex(self, pattern, string):
+		"""
+		Perform a regex search on the given string, using a single or a list of
+		patterns returning the first matching group.
+		"""
+		mobj = re.search(pattern, string, 0)
+		if mobj:
+			# return the first matching group
+			return next(g for g in mobj.groups() if g is not None)
+		else:
+			raise Exception('Unable extract pattern from string!')
+
+	def _decrypt_signature(self, s, player_url):
+		"""Turn the encrypted s field into a working signature"""
+
+		if player_url is None:
+			raise Exception('Cannot decrypt signature without player_url!')
+
+		if player_url[:2] == '//':
+			player_url = 'https:' + player_url
+		try:
+			func = self._extract_signature_function(player_url)
+			return func(s)
+		except:
+			raise Exception('Signature extraction failed!')
+
+	def _extract_signature_function(self, player_url):
+		id_m = re.match(
+			r'.*?-(?P<id>[a-zA-Z0-9_-]+)(?:/watch_as3|/html5player(?:-new)?|/base)?\.(?P<ext>[a-z]+)$',
+			player_url)
+		if not id_m:
+			raise Exception('Cannot identify player %r!' % player_url)
+		player_type = id_m.group('ext')
+		code = self._download_webpage(player_url)
+		if player_type == 'js':
+			return self._parse_sig_js(code)
+		elif player_type == 'swf':
+			return self._parse_sig_swf(code)
+		else:
+			raise Exception('Invalid player type %r!' % player_type)
+
+	def _parse_sig_js(self, jscode):
+		funcname = self._search_regex(r'\.sig\|\|([a-zA-Z0-9$]+)\(', jscode)
+		jsi = JSInterpreter(jscode)
+		initial_function = jsi.extract_function(funcname)
+		return lambda s: initial_function([s])
+
+	def _parse_sig_swf(self, file_contents):
+		swfi = SWFInterpreter(file_contents)
+		TARGET_CLASSNAME = 'SignatureDecipher'
+		searched_class = swfi.extract_class(TARGET_CLASSNAME)
+		initial_function = swfi.extract_function(searched_class, 'decipher')
+		return lambda s: initial_function([s])
+
+	def _extract_from_m3u8(self, manifest_url):
+		url_map = {}
+
+		def _get_urls(_manifest):
+			lines = _manifest.split('\n')
+			urls = filter(lambda l: l and not l.startswith('#'), lines)
+			return urls
+
+		manifest = self._download_webpage(manifest_url)
+		formats_urls = _get_urls(manifest)
+		for format_url in formats_urls:
+			itag = self._search_regex(r'itag/(\d+?)/', format_url)
+			url_map[itag] = format_url
+		return url_map
+
+	def _get_ytplayer_config(self, webpage):
+		# User data may contain arbitrary character sequences that may affect
+		# JSON extraction with regex, e.g. when '};' is contained the second
+		# regex won't capture the whole JSON. Yet working around by trying more
+		# concrete regex first keeping in mind proper quoted string handling
+		# to be implemented in future that will replace this workaround (see
+		# https://github.com/rg3/youtube-dl/issues/7468,
+		# https://github.com/rg3/youtube-dl/pull/7599)
+		patterns = [
+			r';ytplayer\.config\s*=\s*({.+?});ytplayer',
+			r';ytplayer\.config\s*=\s*({.+?});',
+		]
+		for pattern in patterns:
+			config = self._search_regex(pattern, webpage)
+			if config:
+				return json.loads(uppercase_escape(config))
+
+	def extract(self, video_id):
+		url = 'https://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1&bpctr=9999999999' % video_id
+
+		# Get video webpage
+		video_webpage = self._download_webpage(url)
+		if not video_webpage:
+			#raise Exception('Video webpage not found!')
+			return ""
+
+		# Attempt to extract SWF player URL
+		mobj = re.search(r'swfConfig.*?"(https?:\\/\\/.*?watch.*?-.*?\.swf)"', video_webpage)
+		if mobj is not None:
+			player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
+		else:
+			player_url = None
+
+		# Get video info
+		embed_webpage = None
+		if re.search(r'player-age-gate-content">', video_webpage) is not None:
+			age_gate = True
+			# We simulate the access to the video from www.youtube.com/v/{video_id}
+			# this can be viewed without login into Youtube
+			url = 'https://www.youtube.com/embed/%s' % video_id
+			embed_webpage = self._download_webpage(url)
+			data = urlencode({
+				'video_id': video_id,
+				'eurl': 'https://youtube.googleapis.com/v/' + video_id,
+				'sts': self._search_regex(r'"sts"\s*:\s*(\d+)', embed_webpage),
+			})
+			video_info_url = 'https://www.youtube.com/get_video_info?' + data
+			video_info_webpage = self._download_webpage(video_info_url)
+			video_info = compat_parse_qs(video_info_webpage)
+		else:
+			age_gate = False
+			video_info = None
+			# Try looking directly into the video webpage
+			ytplayer_config = self._get_ytplayer_config(video_webpage)
+			if ytplayer_config:
+				args = ytplayer_config['args']
+				if args.get('url_encoded_fmt_stream_map'):
+					# Convert to the same format returned by compat_parse_qs
+					video_info = dict((k, [v]) for k, v in args.items())
+
+			if not video_info:
+				# We also try looking in get_video_info since it may contain different dashmpd
+				# URL that points to a DASH manifest with possibly different itag set (some itags
+				# are missing from DASH manifest pointed by webpage's dashmpd, some - from DASH
+				# manifest pointed by get_video_info's dashmpd).
+				# The general idea is to take a union of itags of both DASH manifests (for example
+				# video with such 'manifest behavior' see https://github.com/rg3/youtube-dl/issues/6093)
+				for el_type in ['&el=info', '&el=embedded', '&el=detailpage', '&el=vevo', '']:
+					video_info_url = (
+						'https://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
+						% (video_id, el_type))
+					video_info_webpage = self._download_webpage(video_info_url)
+					video_info = compat_parse_qs(video_info_webpage)
+					if 'token' in video_info:
+						break
+		if 'token' not in video_info:
+			if 'reason' in video_info:
+				print '[YouTubeVideoUrl] %s' % video_info['reason'][0]
+			else:
+				print '[YouTubeVideoUrl] "token" parameter not in video info for unknown reason'
+
+		# Start extracting information
+		if 'conn' in video_info and video_info['conn'][0][:4] == 'rtmp':
+			url = video_info['conn'][0]
+		elif len(video_info.get('url_encoded_fmt_stream_map', [''])[0]) >= 1 or \
+			len(video_info.get('adaptive_fmts', [''])[0]) >= 1:
+			encoded_url_map = video_info.get('url_encoded_fmt_stream_map', [''])[0] + \
+				',' + video_info.get('adaptive_fmts', [''])[0]
+			if 'rtmpe%3Dyes' in encoded_url_map:
+				raise Exception('rtmpe downloads are not supported, see https://github.com/rg3/youtube-dl/issues/343')
+
+			# Find the best format from our format priority map
+			encoded_url_map = encoded_url_map.split(',')
+			url_map_str = None
+			# If format changed in config, recreate priority list
+			if PRIORITY_VIDEO_FORMAT[0] != maxResolution: #config.plugins.YouTube.maxResolution.value:
+				createPriorityFormats()
+			for our_format in PRIORITY_VIDEO_FORMAT:
+				our_format = 'itag=' + our_format
+				for encoded_url in encoded_url_map:
+					if our_format in encoded_url and 'url=' in encoded_url:
+						url_map_str = encoded_url
+						break
+				if url_map_str:
+					break
+			# If anything not found, used first in the list if it not in ignore map
+			if not url_map_str:
+				for encoded_url in encoded_url_map:
+					if 'url=' in encoded_url:
+						url_map_str = encoded_url
+						for ignore_format in IGNORE_VIDEO_FORMAT:
+							ignore_format = 'itag=' + ignore_format
+							if ignore_format in encoded_url:
+								url_map_str = None
+								break
+					if url_map_str:
+						break
+			if not url_map_str:
+				url_map_str = encoded_url_map[0]
+
+			url_data = compat_parse_qs(url_map_str)
+			url = url_data['url'][0]
+			if 'sig' in url_data:
+				url += '&signature=' + url_data['sig'][0]
+			elif 's' in url_data:
+				encrypted_sig = url_data['s'][0]
+				ASSETS_RE = r'"assets":.+?"js":\s*("[^"]+")'
+
+				jsplayer_url_json = self._search_regex(ASSETS_RE,
+					embed_webpage if age_gate else video_webpage)
+				if not jsplayer_url_json and not age_gate:
+					# We need the embed website after all
+					if embed_webpage is None:
+						embed_url = 'https://www.youtube.com/embed/%s' % video_id
+						embed_webpage = self._download_webpage(embed_url)
+					jsplayer_url_json = self._search_regex(ASSETS_RE, embed_webpage)
+
+				player_url = json.loads(jsplayer_url_json)
+				if player_url is None:
+					player_url_json = self._search_regex(
+						r'ytplayer\.config.*?"url"\s*:\s*("[^"]+")',
+						video_webpage)
+					player_url = json.loads(player_url_json)
+
+				signature = self._decrypt_signature(encrypted_sig, player_url)
+				url += '&signature=' + signature
+			if 'ratebypass' not in url:
+				url += '&ratebypass=yes'
+		elif video_info.get('hlsvp'):
+			url = None
+			manifest_url = video_info['hlsvp'][0]
+			url_map = self._extract_from_m3u8(manifest_url)
+
+			# Find the best format from our format priority map
+			for our_format in PRIORITY_VIDEO_FORMAT:
+				if url_map.get(our_format):
+					url = url_map[our_format]
+					break
+			# If anything not found, used first in the list if it not in ignore map
+			if not url:
+				for url_map_key in url_map.keys():
+					if url_map_key not in IGNORE_VIDEO_FORMAT:
+						url = url_map[url_map_key]
+						break
+			if not url:
+				url = url_map.values()[0]
+		else:
+			#raise Exception('No supported formats found in video info!')
+			return ""
+
+		return str(url)
+
+if __name__ == "__main__":
+
+	#yt = YouTubeVideoUrl()
+	if len(sys.argv)>1:
+		video_id= sys.argv[1]
+	else:
+		video_id = "2rlTF6HiMGg"
+	e = YouTubeVideoUrl().extract(video_id)
+	print e

sources/cinemalive.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+import urllib2, urllib
+import datetime, re, sys,os
+import ConfigParser
+from SourceBase import SourceBase
+#from collections import OrderedDict
+import os
+
+#sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 
+from resolver import resolve
+import util
+
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self,country=""):
+        self.name = "cinemalive"
+        self.title = "cinemalive.tv"
+        self.img = "picons/cinemalive.png" #"https://cinemalive.tv/assets/img/logo.png"
+        self.desc = "cinemalive.tv satura skatīšanās"
+        self.country=country
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8,application/json
+""")
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+Accept-Language: en-US,en;q=0.8
+""")
+        self.url = "https://cinemalive.tv/"
+        #self.login()
+        
+            
+    ######### Entry point ########
+    def get_content(self, data):
+        print "[cinemalive] get_content:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)     
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),            
+                ("Filmas latviski - visas", "cinemalive::filmaslatviski/visas/lapa/1","","Filmas latviski - visas"),
+                ("Filmas angliski", "cinemalive::home_en","","Filmas angliski"),
+                ("Filmas latviski - jaunākās", "cinemalive::filmaslatviski/jaunakas/lapa/1","","Filmas latviski - jaunākās"),
+                ("Filmas latviski - vertētākās", "cinemalive::filmaslatviski/vertetakas/lapa/1","","Filmas latviski - vērtētākās"),
+                ("Filmas latviski - skatitakās", "cinemalive::filmaslatviski/skatitakas/lapa/1","","Filmas latviski - skatītākās"),
+            ])
+            r = self.call("filmaslatviski")
+            for item in re.findall(r'<li class="nav-submenu-item"><a href="/([\w/]+)">(.+?)</a></li>', r):
+                title = "Filmas latviski - "+item[1]
+                data2 = item[0]+"/lapa/1"
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))      
+            return content
+
+        elif clist=="home_en":
+            content.extend([
+                ("Search", "cinemalive::scripts/search.php?search={0}","","Search"),            
+                ("Movies English - all", "cinemalive::moviesenglish/all/page/1","","Movies English - all"),
+                ("Movies Latvian", "cinemalive::home","","Filmas latviski"),
+                ("Movies English - newest", "cinemalive::moviesenglish/newestmovies/page/1","","Movies English - newest"),
+                ("Movies English - top rated", "cinemalive::moviesenglish/toprated/page/1","","Movies English - top rated"),
+                ("Movies English - most watched", "cinemalive::moviesenglish/mostwatched/page/1","","Movies English - most watched"),
+            ])
+            r = self.call("moviesenglish")
+            for item in re.findall(r'<li class="nav-submenu-item"><a href="/([\w/]+)">(.+?)</a></li>', r):
+                title = "Movies English - "+item[1]
+                data2 = item[0]+"/page/1"
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))      
+            return content
+
+    
+        elif "search.php" in data:
+            
+            r=self.call(path,params=params[1:],headers=self.headers2)
+            result = re.findall(r'<div class="results.+?<a href="https://cinemalive\.tv/(.+?)">.+?<img src="(.+?)".+?<span style="color:#bcbcbc">([^<]+)</span> <span style="color:#5a606d;font-size:12px;">([^<]+)</span><br/>.+?<p class="dec" style="font-size:12px; color:#777;line-height:14px;">([^<]+)</p>', r, re.DOTALL)            
+            for item in result:
+                title = item[2]
+                title0 = re.sub(" \(\d+\)","",title)
+                if title0 == item[3]:
+                    title = title+" [EN]"
+                else:
+                    title = title + "/"+ item[3]+" [LV]"
+                title = util.unescape(title)
+                data2 = item[0]
+                img = item[1].replace("xs.","sm.")
+                desc = util.unescape(item[4])
+                content.append((title,self.name+"::"+data2,img,desc))            
+            return content
+
+        elif clist in ("filmaslatviski","moviesenglish"):
+            r = self.call(data)
+            if not r:
+                return content
+            result = re.findall(r'<div class="base-used">.+?<a href="https://cinemalive.tv/([^"]+)">.+?<img class="img-thumbnail" src="/([^"]+)" alt="([^"]+)"/>.+?<p class="year">(\d+)</p>', r, re.DOTALL)
+            for item in result:
+                title = item[2] + " (%s)"%item[3]
+                data2 = item[0]
+                img = "https://cinemalive.tv/"+item[1]
+                title = util.unescape(title)
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc)) 
+            m = re.search(r"""<a href='https://cinemalive\.tv/([^']+)' style="border-right:none;">»</a>""", r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))                                  
+            return content      
+         
+        else:
+            return content                            
+              
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)        
+        if clist=="movie":
+            return True
+        else:
+            return False
+                        
+    def get_streams(self, data):
+        print "[cinemalive] get_streams:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        r = self.call(path)
+        if not r:
+            return []
+        streams = []
+        title0 = re.search("<title>([^<]+)</title>", r).group(1)
+        lang = "LV" if "Filma Online Latviski" in title0 else "EN"
+        title = title0.replace(" - Filma Online Latviski","").replace(" - Movie Online English HD","")
+        desc = re.search('<p class="plot">(.+?)</p>', r).group(1)
+        img = "http://cinemalive.tv"+re.search('<img src="(.+?)" class="img-thumbnail"', r).group(1)
+        
+        m = re.search(r'<video id=.+?<source src="([^"]+\.mp4)"', r, re.DOTALL)
+        if m:
+            s = util.item()
+            s["url"] = m.group(1)
+            s["name"] = util.unescape(title)
+            s["desc"] = util.unescape(desc)
+            s["img"] = img
+            s["type"] = self.stream_type(s["url"])
+            s["lang"] = lang 
+            return [s]
+        
+        #m = re.search('<div class="viboom-overroll"><iframe src="([^"]+)"', r)
+        #if m:
+        result = re.findall('<div id="video_container"><iframe src="(.+?)"', r)
+        if result:
+            streams = resolve(result[0])
+            for s in streams:
+                s["name"] = util.unescape(title)
+                s["desc"] = util.unescape(desc)
+                s["img"] = img
+                s["type"] = self.stream_type(s["url"])
+                s["lang"] = lang
+            if len(result)>1:
+                lang2 = "EN" if lang=="LV" else "LV"
+                streams2 = resolve(result[1])
+                for s in streams2:
+                    s["name"] = util.unescape(title)
+                    s["desc"] = util.unescape(desc)
+                    s["img"] = img
+                    s["type"]= self.stream_type(s["url"])
+                    s["lang"] = lang2
+                    streams.append(s)  
+            return streams
+        else:
+            return []
+
+                    
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/config.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+import os.path,re
+import collections
+from SourceBase import SourceBase
+
+os.path.dirname(os.path.abspath(__file__))
+class Source(SourceBase):
+    
+    def __init__(self,country="lv"):
+        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")
+        self.lists = collections.OrderedDict()
+        self.read_streams()
+         
+    def get_content(self, data):
+        self.read_streams()
+        if "::" in data:
+            data = data.split("::")[1]
+        if not data in self.lists:
+            return []
+        return self.lists[data]
+
+    def is_video(self,data):
+        return False
+    
+    def read_streams(self):
+        for line in open(self.streams_file,"r"):
+            r = re.search("^\[(\w+)\]", line)
+            if r:
+                name = r.group(1)
+                self.lists[name] = []
+            else:
+                if len(line)<10 or line[0] in ("#"): continue
+                items = tuple(line.strip().split("|"))
+                if len(items)<2:
+                    continue
+                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)
+            for item in self.lists[l]:
+                f.write("%s|%s|%s|%s\n"%(item[0],item[1],item[2],item[3]))
+            f.write("\n")
+        f.close()
+    
+    def get_lists(self):
+        return self.lists.keys()
+    
+    def get_list_items(self,name):
+        return self.lists[name]
+    
+    def add_list(self,name):
+        if not name in self.lists.keys():
+            self.lists[name] = []
+            
+    def del_list(self,name):
+        if name in self.lists.keys():
+            del self.lists[name]
+            
+    def add_item(self,name,item,pos=None):
+        if name in self.lists.keys():
+            if pos==None:
+                self.lists[name].append(item)
+            else:
+                self.lists[name].insert(pos,item)
+                
+    def del_item(self,name,pos):
+        self.lists[name].pop(pos)
+    
+    def replace_item(self,name,item,pos):
+        self.lists[name][pos]=item
+            
+                           
+if __name__ == "__main__":
+    c = Source()
+    content = c.get_content("home")
+    for item in content: print item
+    #c.del_item("home",0)
+    #c.del_list("favorites")
+    
+    #c.add_item("home",("My Streams","config::favorites","","Mani saglabātie TV kanāli un video"),0)
+    c.replace_item("home",("My Streams","config::my_streams","default","Mani saglabātie TV kanāli un video"),0)
+    #c.add_list("favorites")
+    #c.add_item("favorites",("..return","back","","Atgriezties atpakaļ"))    
+    #c.add_item("favorites",("LTV1","http://streamltv.cloudy.services/ltv/LTV02.smil/playlist.m3u8","picons/latvia1.png", "Latvijas televīzijas 1.kanāls"))
+    
+    c.write_streams()
+    for item in content: print item
+    

sources/euronews.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, time,re, sys,os
+from collections import OrderedDict
+from SourceBase import SourceBase
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self,language="en"):
+        self.name = "euronews"
+        self.title = "Euronews"
+        self.img = "http://pbs.twimg.com/profile_images/732665354242150400/tZsCnjuh_400x400.jpg"
+        self.desc = "Euronews live and archive"
+        self.headers = headers2dict("""
+User-Agent: Euronews/4.0.126
+Content-Type: application/json
+Connection: keep-alive
+        """)
+        #self.language=language
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        self.options = OrderedDict([("language","en")])
+        self.options_read()
+        self.vid={"1": "News", "2": "European Affairs", "3": "Lifestyle", "4": "Knowledge"}
+        self.languages = []
+        try:
+            self.get_languages()
+        except:
+            pass
+        
+    def login(self,user="",password=""):
+        return True
+            
+    def get_content(self, data):
+        print "[%s] get_content:"%self.name, data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        #lang = qs["lang"] if "lang" in qs else self.language
+        lang = self.options["language"]
+        if not lang in self.get_languages():
+            raise Exception("Not valid default language - '%s'"%lang)
+    
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Search", "euronews::content/getSearch?lang=%s&byPage=40&page=1&text={0}"%lang,self.img,"Top stories timeline"),                
+                ("Live stream", "euronews::live?lang=%s"%lang,self.img,"Euronews live stream"),
+                ("Just in", "euronews::content/getTimeline?lang=%s&byPage=40&page=1"%lang,self.img,"News timeline"),
+                ("Top stories", "euronews::content/getTopStories?lang=%s"%lang,self.img,"Top stories timeline"),
+                ("Category - News", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=1"%lang,self.img,"Category - News"),
+                ("Category - European Affairs", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=2"%lang,self.img,"Category - European Affairs"),
+                ("Category - Lifestyle", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=3"%lang,self.img,"Category - Lifestyle"),
+                ("Category - Knowledge", "euronews::content/getVertical?lang=%s&byPage=40&page=1&vId=4"%lang,self.img,"Category - Knowledge"),
+                ("Latest programs", "euronews::content/getLatestPrograms?lang=%s&byPage=40&page=1"%lang,self.img,"Latest programs"),
+                ("Programs list", "euronews::content/getPrograms?lang=%s"%lang,self.img,"Programs list"),
+             ])
+            return content
+        
+
+        ### Video arhīvs ###  
+        elif clist=="content":
+            if "lang" in qs:
+                del qs["lang"]
+            params = json.dumps(qs)
+            
+            req = '{"methodName":"content.%s","apiKey":"androidPhoneEuronews-1.0","params":%s,"language":"%s"}'%(plist[1],params,lang)
+            r = self.call(req)    
+            if not r:
+                return content
+            lst = r["timeline"] if "timeline" in r else\
+                r["topstorieslist"] if "topstorieslist" in r else\
+                r["programs"] if "programs" in r else\
+                r["programDetailsList"] if "programDetailsList" in r else\
+                r["programlist"] if "programlist" in r else\
+                r["articlelist"] if "articlelist" in r else\
+                r["verticals"] if "verticals" in r else\
+                []
+            if not lst:
+                return content
+            
+            for item in lst:
+                if plist[1] in ("getTimeline"):
+                    article = item["article"]
+                    atype = item["type"]
+                    #if item["type"] == "wire":
+                        #continue # TODO
+                else:
+                    article = item
+                    atype = "article"
+                if plist[1]=="getPrograms":
+                    title = article["title"] 
+                    id = article["pId"]
+                    desc = title
+                    img = "http://static.euronews.com/articles/programs/533x360_%s"%article["img"]
+                    data2 = "content/getProgramDetails?lang=%s&byPage=40&page=1&pId=%s"%(lang,id)
+                    content.append((title,self.name+"::"+data2,img,desc))
+                else:
+                    title = article["title"] if "title" in article else article["text"] if "text" in article else "No title"
+                    if atype <> "article":
+                        title = "[%s] %s"%(atype,title)
+                    atime = datetime.datetime.fromtimestamp(int(article["uts"]))
+                    #atime = datetime.datetime.fromtimestamp(int(article["uts"])-time.altzone) 
+                    atime = atime.strftime("%Y-%m-%d %H:%M")
+                    vert = self.vid[article["vId"]] if "vId" in article else ""
+                    ptitle = article["pTitle"] if "pTitle" in article else ""
+                    id = article["id"]
+                    desc = "%s\n%s\n%s %s"%(title,atime,vert,ptitle)
+                    img = "http://static.euronews.com/articles/%s/399x225_%s.jpg"%(id,id)
+                    if not atype in ("breakingnews","wire"):
+                        data2 = "content/getArticle?lang=%s&id=%s"%(lang,id)
+                    else:
+                        data2 = ""
+                    content.append((title,self.name+"::"+data2,img,desc))
+            if "page=" in data:
+                data2 = re.sub("page=\d+","page=%s"%(int(qs["page"])+1),data)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page")) 
+            return content            
+
+    
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)        
+        if path == "live":
+            return True
+        elif clist=="content" and plist[1]=="getArticle":
+            return True
+        else:
+            return False
+        
+    def get_streams(self, data):
+        print "[euronews] get_streams:", data
+        if not self.is_video(data):
+            return []
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        #lang = qs["lang"] if "lang" in qs else self.language
+        lang = self.options["language"]
+        if not lang in self.get_languages():
+            raise Exception("Not valid default language - '%s'"%lang)        
+        
+        streams = []
+        
+        if path == "live":
+            url = "http://www.euronews.com/api/watchlive.json"
+            r = self._http_request(url)
+            try:
+                js = json.loads(r)
+                url = js["url"]
+            except:
+                raise Exception("No live stream found")
+            r = self._http_request(url)
+            try:
+                js = json.loads(r)
+                if not js["status"]=="ok":
+                    raise Exception("No live stream found")
+            except:
+                raise Exception("No live stream found")
+            
+            slist = js["primary"]
+            
+            for l in slist:
+                stream = self.get_stream0()
+                stream["url"]=slist[l]["hls"]
+                stream["lang"]=l
+                stream["quality"]="variant"
+                stream["name"]="Euronews live [%s]"%l
+                stream["desc"]=stream["name"]
+                stream["type"]="hls" #stream_type(url)
+                streams.append(stream)
+                
+        elif clist=="content" and plist[1] == "getArticle":
+            if "lang" in qs:
+                del qs["lang"]
+            languages = self.get_languages()
+            for lang in languages:
+                id = qs["id"]
+                req = '{"methodName":"content.getArticle","apiKey":"androidPhoneEuronews-1.0","params":{"id":"%s"},"language":"%s"}'%(id,lang)
+                r = self.call(req)    
+                if not r:
+                    raise Exception("No live stream found") 
+                if not "articlelist" in r:
+                    msg = r["label"] if "label" in r else "No article finde"
+                    raise Exception(msg)
+                article = r["articlelist"]
+                stream = self.get_stream0()
+                stream["url"]=article["videoUri"] if "videoUri" in article else ""
+                if not stream["url"]:
+                    return []
+                stream["lang"]=lang
+                stream["quality"]="?"
+                stream["name"]= article["title"]
+                stream["desc"]=article["text"] if "text" in article else article["title"]
+                stream["type"]="http" #stream_type(url)
+                streams.append(stream)
+            
+        else:
+            raise Exception("No live stream found")
+           
+        ### TODO - sakārtot sarakstu, lai pirmais ir labakais video
+        qlist = ["???","lq","mq","hq","hd","variant"]
+        llist = ["fr","en","ru","lv"]        
+        for s in streams:
+            if s["lang"]==self.options["language"]:
+                s["order"] = 10000
+                continue
+            lv = llist.index(s["lang"])*10 if s["lang"] in llist else 0
+            qv=qlist.index(s["quality"]) if s["quality"] in qlist else 0
+            s["order"] = lv+qv
+        streams = sorted(streams,key=lambda item: item["order"],reverse=True)
+        return streams
+    def get_languages(self):
+        if self.languages: return self.languages
+        url = "http://www.euronews.com/api/watchlive.json"
+        r = self._http_request(url)
+        try:
+            js = json.loads(r)
+            url = js["url"]
+        except:
+            raise Exception("Can not get languages list")
+        r = self._http_request(url)
+        try:
+            js = json.loads(r)
+            if not js["status"]=="ok":
+                raise Exception("Can not get languages list")
+        except:
+            raise Exception("Can not get languages list")
+        
+        slist = js["primary"]
+        self.languages=slist.keys()
+        return self.languages
+        
+    def call(self, data,params = None, headers=None):
+        if not headers: headers = self.headers
+        #if not lang: lang = self.country
+        url = "http://api.euronews.com/ipad/"
+        headers = headers2dict("""
+User-Agent: Euronews/4.0.126
+Content-Type: multipart/form-data, boundary=AaB03xBounDaRy; charset=UTF-8
+Host: api.euronews.com
+Connection: Keep-Alive
+        """)
+        params = """
+--AaB03xBounDaRy
+content-disposition: form-data; name=request
+
+%s
+--AaB03xBounDaRy--
+"""%data
+        content = self._http_request(url, params, headers)
+        if content:
+            try:
+                result = json.loads(content)
+                return result
+            except Exception, ex:
+                return None
+        else:
+            return None
+        
+
+if __name__ == "__main__":
+    language= "en"
+    c = Source(language)
+    data = '{"methodName":"content.getTimeline","apiKey":"androidPhoneEuronews-1.0","params":{"page":"1","byPage":"30"},"language":"en"}'
+    r = c.call(data)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    pass

sources/filmix.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys,os
+import ConfigParser
+from SourceBase import SourceBase
+import base64
+from collections import OrderedDict
+import sys
+
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import util
+    
+class Source(SourceBase):
+    
+    def __init__(self,country=""):
+        self.name = "filmix"
+        self.title = "Filmix.net"
+        self.img = "http://cs5324.vk.me/g33668783/a_903fcc63.jpg"
+        self.desc = "Filmix.net satura skatīšanās"
+        self.country=country
+        self.headers = headers2dict("""
+Host: filmix.net
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+""")
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+X-Requested-With: XMLHttpRequest
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+""")
+        self.url = "http://filmix.net/"
+        #self.login()
+        
+    def login(self,user="",password=""):
+        return True
+            
+    def get_content(self, data):
+        print "[filmix] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("[%\w]+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+    
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Search", "filmix::search/{0}","","Search"),                
+                ("Movies", "filmix::movies","","Movies"),
+                ("Series", "filmix::series","","TV Series"),
+                ("Cartoons", "filmix::cartoons","","Cartoons"),
+            ])
+            return content
+    
+        #elif clist=="search":
+            # TODO
+            #return content
+
+        elif data in ("movies","series","cartoons"):
+            r = self.call("")
+            r = r.decode("cp1251").encode("utf8")
+            if data == "movies":
+                sname = "Фильмы"
+            elif data=="series":
+                sname = "Сериалы"
+            else:
+                sname = "Мультфильмы"
+            m = re.search('<li><span class="menu-title">%s</span>(.+?)<li><span'%sname, r, re.DOTALL|re.UNICODE)
+            if not m: return content
+            r2 = m.group(1)
+            result = re.findall(r'<a href="http://filmix\.net/([^"]+)".*?>([^<]+)</a>', r2, re.DOTALL)
+            for item in result:
+                if "catalog" in item[0]: continue
+                title = item[1]
+                data2 = item[0]
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))      
+            return content      
+         
+        ## Video/seriāla spēlēšana
+        elif clist=="play":
+            r = self.call(path)
+            r = r.decode("cp1251").encode("utf8")
+            title = title0 = util.unescape(re.search("titlePlayer = '([^']+)'", r, re.DOTALL).group(1))
+            m = re.search('<meta itemprop="thumbnailUrl" content="([^"]+)',r,re.DOTALL)
+            img = m.group(1) if m else self.img
+            m = re.search('<meta itemprop="duration" content="([^"]+)" />', r, re.DOTALL)
+            duration = "(%s)"%m.group(1) if m else ""
+            m = re.search('<p itemprop="description"[^>]+>([^<]+)<', r, re.DOTALL)
+            desc = desc0 =  util.unescape(m.group(1).strip()) if m else ""
+            
+            #url2 = re.search('<div id="play-descr" class="title-page">.+?<a href="([^"]+)"', r, re.DOTALL).group(1)
+            #r2 = self._http_request(url2)
+             
+            m = re.search("videoLink = '([^']+)'", r, re.DOTALL)
+            if not m:
+                raise Exception("Can not find video link")
+            video_link = m.group(1)
+            if video_link<>'{video-link}':
+                video_link = self.decode_uppod_text(video_link)
+                streams = self.get_streams2(video_link)
+                data2 = streams[0][1]
+                content = (title,data2,img,desc)
+                return content
+            else:
+                m = re.search("plLink = '([^']+)'", r, re.DOTALL)
+                if not m:
+                    raise Exception("Can not find video link")
+                pl_link = m.group(1)
+                pl_link = self.decode_uppod_text(pl_link)
+                js = self._http_request(pl_link)
+                js = self.decode_uppod_text(js)
+                js = json.loads(js)
+                if "s" in qs and "e" in qs:
+                    s = int(qs["s"])
+                    e = int(qs["e"])
+                    serie = js["playlist"][s-1]["playlist"][e-1]["comment"].encode("utf8")
+                    title = title0+" - "+ serie
+                    data2 = js["playlist"][s-1]["playlist"][e-1]["file"].encode("utf8")
+                    streams = self.get_streams2(data2)
+                    data2=streams[0][1]
+                    desc = serie +"\n"+desc0
+                    content = (title,data2,img,desc)
+                    return content
+                
+                elif "s" in qs:
+                    s = int(qs["s"])
+                    for i,ep in enumerate(js["playlist"][s-1]["playlist"]):
+                        title = title0+" - "+js["playlist"][s-1]["playlist"][i]["comment"].encode("utf8")
+                        serie = js["playlist"][s-1]["playlist"][i]["comment"].encode("utf8")
+                        data2 = data+"&e=%s"%(i+1)
+                        desc = serie +"\n"+desc0
+                        content.append((title,self.name+"::"+data2,img,desc)) 
+                else:
+                    for i,ep in enumerate(js["playlist"]):
+                        title = title0 +" - "+js["playlist"][i]["comment"].encode("utf8")
+                        serie = js["playlist"][i]["comment"].encode("utf8")
+                        data2 = data+"?s=%s"%(i+1)
+                        desc = serie +"\n"+desc0
+                        content.append((title,self.name+"::"+data2,img,desc)) 
+                return content                    
+                #r = self._http_request(url)
+            
+        
+        ### saraksts ### 
+        else:
+            r = self.call(data)
+            r = r.decode("cp1251").encode("utf8")
+            for r2 in re.findall('<article class="shortstory line".+?</article>', r, re.DOTALL):
+                m = re.search(r'<a href="http://filmix\.net/play/(\d+)" class="watch icon-play">', r2, re.DOTALL)
+                if not m: continue
+                vid = m.group(1)
+                data2 = "play/%s"%vid
+                #title = re.search('itemprop="name">([^<]+)</div>', r2, re.DOTALL).group(1)
+                title = re.search('itemprop="name" content="([^"]+)"', r2, re.DOTALL).group(1)
+                m = re.search('itemprop="alternativeHeadline" content="([^"]+)"', r2, re.DOTALL)
+                if m:
+                    title = title + "/"+m.group(1)
+                m = re.search('<img src="([^"]+.jpg)"', r2, re.DOTALL)
+                img = "http://filmix.net"+m.group(1) if m else self.img
+                m = re.search(r'<a itemprop="copyrightYear".+?>(\d+)<', r2, re.DOTALL)
+                if m:
+                    year = m.group(1) if m else ""
+                    title = "%s (%s)"%(title,year)
+                title = util.unescape(title)
+                genre = re.findall('<a itemprop="genre"[^>]+?">([^<]+)</a>', r2, re.DOTALL)
+                genre = ",".join(genre)
+                m = re.search('<p itemprop="description">([^<]+)</p>', r2, re.DOTALL)
+                desc0 = util.unescape(m.group(1)) if m else ""
+                m = re.search('<div class="quality">([^<]+)</div>', r2, re.DOTALL)
+                quality = m.group(1) if m else ""
+                actors = re.findall('itemprop="actor">([^<]+)<', r2, re.DOTALL)
+                actors = ",".join(actors)
+                desc="%s\n%s\n%s\n%s\n%s"%(title,genre,desc0,actors,quality)
+                content.append((title,self.name+"::"+data2,img,desc))
+            if '<div class="navigation">' in r:
+                m = re.search(r'href="http://filmix\.net/([^"]+)" class="next icon-arowRight btn-tooltip"', r, re.DOTALL)
+                if m:
+                    data2 = m.group(1)
+                else:
+                    m = re.search("/page/(\d)+",data)
+                    if m:
+                        page = int(m.group(1))+1
+                        data2 = re.sub("/page/(\d)+", "/page/%s"%page, data)
+                    else:
+                        data2 = data + "/page/2"
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+                        
+            return content                            
+              
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        
+        if clist == "play" and "s=" in data and "e=" in data:
+            return True
+        elif clist=="play" and not params:
+            r = self.call(path)
+            #r = r.decode("cp1251").encode("utf8")
+            title = title0 = util.unescape(re.search("titlePlayer = '([^']+)'", r, re.DOTALL).group(1))
+            m = re.search("videoLink = '([^']+)'", r, re.DOTALL)
+            if not m:
+                raise Exception("Can not find video link")
+            video_link = m.group(1)
+            if video_link=='{video-link}':
+                return False
+            else:
+                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)
+        return result
+
+
+        
+    def decode_uppod_text(self, text): 
+        Client_codec_a = ["l", "u", "T", "D", "Q", "H", "0", "3", "G", "1", "f", "M", "p", "U", "a", "I", "6", "k", "d", "s", "b", "W", "5", "e", "y", "="]
+        Client_codec_b = ["w", "g", "i", "Z", "c", "R", "z", "v", "x", "n", "N", "2", "8", "J", "X", "t", "9", "V", "7", "4", "B", "m", "Y", "o", "L", "h"]    
+        text = text.replace("\n", "").strip()
+        for i in range(len(Client_codec_a)):
+            char1 = Client_codec_b[i]
+            char2 = Client_codec_a[i]
+            text = text.replace(char1, "___")
+            text = text.replace(char2, char1)
+            text = text.replace("___", char2)
+        result = base64.b64decode(text)
+        print result
+        return result
+    
+    def get_streams2(self,url0):
+        res = re.search("\[([\d,]+)]",url0).group(1)
+        streams=[]
+        for res in res.split(","):
+            if not res: continue
+            url=re.sub("\[[\d,]+]",res,url0)
+            streams.append((res,url))
+        return streams
+        
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/filmon.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+
+API_URL = 'http://www.filmon.com/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+#User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+headers0 = headers2dict("""
+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
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: deflate
+Connection: keep-alive
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self,country="lv"):
+        self.name = "filmon"
+        self.title = "FilmOn"
+        self.img = "http://behindthegloves.com/wp-content/uploads/2016/01/FilmOn-logo1.jpg"
+        self.desc = "FilmOn portāla satura skatīšanās"
+        self.headers = headers0
+
+        self.country=country
+        self.jstv = None
+        self.session_key = None
+        self.cookie = None
+
+    def get_content(self, data):
+        print "[filmon] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+
+        if not self.jstv:
+            self.jstv = self.get_tv_channels()
+        #if not self.session_key: # TODO izskatās, ka strādā bez, vismaz ja nelogojas iekšā,  jānočeko
+        #    html = self._http_request("http://www.filmon.com/api/init")
+        #    js = json.loads(html)
+        #    self.session_key = js["session_key"]
+
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Live streams", "filmon::tv","","TV live streams"),
+                ("Video on demand", "filmon::vod","","Last videos"),
+            ])
+            return content
+
+        ### TV Groups ###
+        elif clist in ("tv","home"):
+            for gr in self.jstv:
+                title = gr["name"].encode("utf8")
+                data2 = "group?id=%s"%gr["id"]
+                img = gr["logo_148x148_uri"].encode("utf8")
+                desc = gr["description"].encode("utf8")
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### TV group channels ###
+        elif clist=="group":
+            if "id" in qs:
+                group_id = qs["id"] 
+            else:
+                return content
+            group = None
+            for gr in self.jstv:
+                if gr["id"]==group_id:
+                    group = gr
+                    break
+            if not group:
+                return content
+            for ch in group["channels"]:
+                title = ch["title"].encode("utf8")
+                data2 = "channel?id=%s"%ch["id"]
+                img = ch["big_logo"].encode("utf8")
+                desc = ch["description"].encode("utf8") if ch["description"] else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### TV Channel ###
+        elif clist == "channel" or clist == "video":
+            if "id" in qs:
+                ch_id = qs["id"] 
+            else:
+                return ("No stream found %s"%data,"","","No stream found")
+            ch = self.get_tv_channel_info(ch_id)
+            if ch["now_playing"]:
+                current_event = ch["now_playing"]["programme_name"] if "programme_name" in ch["now_playing"] else ""
+            else:
+                current_event = ""
+            title = u"%s - %s"%(ch["title"],current_event)
+            title = title.encode("utf8")
+            if current_event:
+                desc = ch["now_playing"]["programme_description"].encode("utf8")
+            else:
+                desc = title
+            data2 = ""
+            for t in ("SD","HD"):
+                for s in ch["streams"]:
+                    if s["name"]==t:
+                        data2 = s["url"].encode("utf8")
+                        break
+                if data2: break
+            return (title,data2,"",desc)
+
+        ### VOD genres ###
+        elif path in ("vod","vod/genres"):
+            data = "vod/genres"
+            js = self.call(data)
+            for gr in js["response"]:
+                title = gr["name"].encode("utf8")
+                data2 = "vod/search?genre=%s&max_results=30&no_episode=true&start_index=0"%(gr["slug"].encode("utf8"))
+                img = gr["images"][0]["url"].encode("utf8")
+                desc = gr["description"].encode("utf8") if gr["description"] else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content           
+
+        ### VOD genre videos ###
+        elif path == "vod/search":
+            js = self.call(data)
+            for vid in js["response"]:
+                title = vid["title"].encode("utf8")
+                if vid["type"]=="series":
+                    title = "[Series] "+title
+                data2 = "vod/movie?id=%s&type=%s"%(vid["id"],vid["type"].encode("utf8"))
+                img = "http://static.filmon.com/assets/"+vid["poster"]["couchdb_url"].encode("utf8")
+                desc = vid["description"].encode("utf8") if vid["description"] else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            start_index = int(qs["start_index"]) if "start_index" in qs else 0
+            if start_index+js["total"]<js["total_found"]:
+                start_index += 30
+                data2 = re.sub("start_index=\d+","start_index=%s"%start_index,data) if "start_index" in qs else data +"&start_index=30"
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+            return content
+
+        ### VOD video sigle/series ###
+        elif path == "vod/movie":
+            js = self.call(data)
+            if js["response"]["type"] == "series":
+                ids = ",".join(js["response"]["episodes"])
+                data2 = "vod/movies?ids=%s"%ids
+                js2 = self.call(data2)
+                for vid in js2["response"]:
+                    title = vid["title"].encode("utf8")
+                    if vid["type"]=="series":
+                        title = "[Series] "+title
+                    data2 = "vod/movie?id=%s&type=%s"%(vid["id"],vid["type"].encode("utf8"))
+                    img = "http://static.filmon.com/assets/"+vid["poster"]["couchdb_url"].encode("utf8")
+                    desc = vid["description"].encode("utf8") if vid["description"] else title
+                    content.append((title,self.name+"::"+data2,img,desc))
+                return content
+            else:
+                title = js["response"]["title"].encode("utf8")
+                desc = js["response"]["description"].encode("utf8") if js["response"]["description"] else title
+                data2 = js["response"]["streams"]["low"]["url"].encode("utf8")
+                return (title,data2,"",desc)
+
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("?")
+        if cmd[0] in ("video","channel"):
+            return True
+        elif cmd[0] == "vod/movie" and "type=movie" in data:
+            return True
+        else:
+            return False
+
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = "http://www.filmon.com/api/" + data
+        #if not "?" in url: url += "?session_key=%s"%self.session_key
+        #if not "session_key=" in url: url += "&session_key=%s"%self.session_key
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url)
+        if content:
+            try:
+                result = json.loads(content)
+            except Exception, ex:
+                return None
+        return result
+
+    #----------------------------------------------------------------------
+    def get_tv_channel_info(self,id):
+        url = "http://www.filmon.com/ajax/getChannelInfo"
+        headers = headers2dict("""
+Host: www.filmon.com
+User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:41.0) Gecko/20100101 Firefox/41.0
+Accept: application/json, text/javascript, */*; q=0.01
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: deflate
+DNT: 1
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Requested-With: XMLHttpRequest
+Referer: http://www.filmon.com/tv/live
+Connection: keep-alive
+Pragma: no-cache
+Cache-Control: no-cache
+""")
+        headers["Cookie"] = self.cookie
+        data = "channel_id=%s&quality=low"%id
+        response = urllib2.urlopen(urllib2.Request(url, headers=headers,data=data))
+        html =  response.read()
+        js = json.loads(html)
+        return js
+
+    #----------------------------------------------------------------------
+    def get_tv_channels(self):
+        """Get tv channels list"""
+        headers = headers2dict("""
+Host: www.filmon.com
+User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:41.0) Gecko/20100101 Firefox/41.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: deflate
+DNT: 1
+Connection: keep-alive
+    """)
+
+        url = "http://www.filmon.com/tv"
+        response = urllib2.urlopen(urllib2.Request(url, headers=headers))
+        if "set-cookie" in response.headers:
+            self.cookie = response.headers["set-cookie"]
+        html =  response.read()
+        s = re.search("(?i)var groups = (.*);", html).groups(1)[0]
+        js = json.loads(s)
+        return js
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/iplayer.py

@@ -0,0 +1,519 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# 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
+from xml.sax.saxutils import unescape,escape
+from urllib import quote, unquote
+import datetime
+import HTMLParser
+import json
+import datetime,time
+from SourceBase import SourceBase, stream_type, stream0
+from collections import OrderedDict
+
+API_URL = 'https://m.lattelecom.tv/'
+user_agent = "Mozilla/5.0 (iPhone; U; CPU iPhone OS 5_1_1 like Mac OS X; da-dk) AppleWebKit/534.46.0 (KHTML, like Gecko) CriOS/19.0.1084.60 Mobile/9B206 Safari/7534.48.3"
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self):
+        self.name = "iplayer"
+        self.title = "BBC iPlayer"
+        self.img = "http://www.userlogos.org/files/logos/inductiveload/BBC_iPlayer_logo.png"
+        self.desc = "BBC iPlayer portal content"
+        
+        self.api_url = "http://ibl.api.bbci.co.uk/ibl/v1/"
+        self.headers = headers2dict("""
+User-Agent: BBCiPlayer/4.19.0.3021 (SM-G900FD; Android 4.4.2)
+Connection: Keep-Alive
+        """)
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36
+Connection: Keep-Alive
+        """)
+        
+        self.ch = []
+        self.ch_id={}
+        self.ch_id2={}
+        self.ch_name={}
+        self.logos ={
+            "bbc_one_london":"http://www.lyngsat-logo.com/hires/bb/bbc_one.png",
+            "bbc_two_england":"http://www.lyngsat-logo.com/hires/bb/bbc_two_uk.png",
+            "bbc_three":"http://www.lyngsat-logo.com/hires/bb/bbc_three_uk.png",
+            "bbc_four":"http://www.lyngsat-logo.com/hires/bb/bbc_four_uk.png",
+            "bbc_radio_one":"http://www.lyngsat-logo.com/hires/bb/bbc_radio1.png",
+            "cbbc":"http://www.lyngsat-logo.com/hires/bb/bbc_cbbc.png",
+            "cbeebies":"http://www.lyngsat-logo.com/hires/bb/bbc_cbeebies_uk.png",
+            "bbc_news24":"http://www.lyngsat-logo.com/hires/bb/bbc_news.png",
+            "bbc_parliament":"http://www.lyngsat-logo.com/hires/bb/bbc_parliament.png",
+            "bbc_alba":"http://www.lyngsat-logo.com/hires/bb/bbc_alba.png",
+            "s4cpbs":"http://www.lyngsat-logo.com/hires/ss/s4c_uk.png"          
+        }
+                       
+    def get_content(self, data):
+        print "[iplayer] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=[\w-]+",params)))
+        #lang = qs["lang"] if "lang" in qs else self.country
+    
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        ### Home ###
+        if data=="home":
+            content.extend([
+                ("Search TV", "iplayer::search/{0}","","Search in iPlayer"),
+                ("Live streams", "iplayer::live","","TV live streams"),
+                ("Channels", "iplayer::channels","","Programmes by channel/date"),
+                ("Categories", "iplayer::categories","","Programmes by categories"),
+                ("A-Z", "iplayer::a-z","","All programmes by name"),
+                ("Highlights", "iplayer::home/highlights","","Current highlights"),             
+                ("Most popular", "iplayer::groups/popular/episodes?per_page=40&page=1","","Most popular programmes")            
+            ])
+            return content
+        
+        ### Search ###
+        elif clist=="search":
+            data_ = "search-suggest/?q=%s&rights=mobile&initial_child_count=1"%data.split("/")[1]
+            r = self.call(data_)
+            for item in r["search_suggest"]["results"]:
+                title,data2,img,desc = self.get_data_element(item)
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+                        
+        
+        ### Live main ###
+        elif data=="live":
+            for ch in self.get_channels():
+                title = ch["title"]
+                img = self.logos[ch["id"]] if ch["id"] in self.logos else  "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+                desc = title
+                data2 = "live/%s"%ch["id"]
+                ee = self.get_epg_live(ch["id"])
+                desc = ee[2]
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+        ### Categories ###
+        elif data == "categories":
+            r = self.call(data)
+            if not "categories":
+                raise Exception("Error reading categories")
+            for item in r["categories"]:
+                data2 = "categories/%s"%(item["id"])
+                title = item["title"]
+                desc = title
+                img = self.img
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+        ### Catetory root ###
+        elif clist == "categories" and len(data.split("/"))==2:
+            r = self.call(data)
+            title = "%s - highlights"%r["category"]["title"]
+            content.append((title,self.name+"::"+data+"/highlights?lang=en&rights=mobile&availability=available",self.img,title))
+            title = "%s - recent (%s programmes, %s episodes)"%(r["category"]["title"],r["category"]["child_programme_count"],r["category"]["child_episode_count"])
+            content.append((title,self.name+"::"+data+"/programmes?rights=mobile&page=1&per_page=40&sort=recent&sort_direction=asc&initial_child_count=1&availability=available",self.img,title))
+            title = "%s - a-z (%s programmes, %s episodes)"%(r["category"]["title"],r["category"]["child_programme_count"],r["category"]["child_episode_count"])
+            content.append((title,self.name+"::"+data+"/programmes?rights=mobile&page=1&per_page=40&sort=title&sort_direction=asc&initial_child_count=1&availability=available",self.img,title))
+            return content
+        
+        ### Program/episodes list ###
+        elif   re.search("categories/([\w\-]+)/(highlights|programmes).+",data) or\
+               re.search("programmes/(\w+)/episodes.+",data) or\
+               re.search("groups/(\w+)/episodes.+",data) or\
+               re.search("atoz/([\w]+)/programmes.+",data) or\
+               re.search("channels/(\w+)/schedule/[\d\-].+",data) or\
+               re.search("channels/(\w+)/programmes.+",data) or\
+               re.search("channels/(\w+)/highlights.+",data) or\
+               data == "home/highlights":
+            r = self.call(data)
+            lst = r["category_highlights"] if "category_highlights" in r else\
+                  r["category_programmes"] if "category_programmes" in r else\
+                  r["programme_episodes"] if "programme_episodes" in r else\
+                  r["atoz_programmes"] if "atoz_programmes" in r else\
+                  r["group_episodes"] if "group_episodes" in r else\
+                  r["schedule"] if "schedule" in r else\
+                  r["channel_highlights"] if "channel_highlights" in r else\
+                  r["channel_programmes"] if "channel_programmes" in r else\
+                  r["home_highlights"] if "home_highlights" in r else\
+                  []
+            if not lst:
+                return content
+            for el in lst["elements"]:
+                if el["type"] == "broadcast":
+                    if not len(el["episode"]["versions"]):continue
+                    title,data2,img,desc = self.get_data_element(el["episode"])
+                    t1 = gt(el['scheduled_start'])
+                    t2 = gt(el['scheduled_end'])
+                    title = "[%s-%s]%s"%(t1.strftime("%d.%m.%Y %H:%M"),t2.strftime("%H:%M"),title)
+                else:
+                    title,data2,img,desc = self.get_data_element(el)
+                content.append((title,self.name+"::"+data2,img,desc))
+            
+            if "&page=" in data and lst["page"]*lst["per_page"]<lst["count"]:
+                data2 = re.sub("&page=\d+","&page=%s"%(lst["page"]+1),data)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page")) 
+            return content
+        
+        ### A-z root ###
+        elif data=="a-z":
+            url = "http://www.bbc.co.uk/programmes/a-z/by/x/all.json?page=1"
+            r = self._http_request(url)
+            if not r:
+                raise Exception("Can not read %s"%s)
+            js = json.loads(r)
+            for ch in js["atoz"]["letters"]:
+                title = ch.upper()
+                desc = "Programmes beginning with %s"%title
+                img = self.img
+                data2 = "atoz/%s/programmes?rights=mobile&page=1&per_page=40&initial_child_count=1&sort=title&sort_direction=asc&availability=available"%ch
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+        ###  Channels home ###
+        elif data=="channels":
+            for ch in self.get_channels():
+                title = ch["title"]
+                img = self.logos[ch["id"]] if ch["id"] in self.logos else  "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+                desc = title
+                data2 = "channels/%s"%ch["id"]
+                #ee = self.get_epg_live(ch["id"])
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+        ### Channel higlihts/progrmmes/days ###
+        elif clist=="channels" and len(data.split("/"))==2:
+            r = self.call(data)
+            chid = data.split("/")[1]
+            ch = self.get_channel_by_id(chid)
+            
+            # Highlights
+            title = ch["title"] + " - highlights"
+            img = "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+            data2 = "channels/%s/highlights?lang=en&rights=mobile&availability=available"%ch["id"]
+            desc = title
+            content.append((title,self.name+"::"+data2,img,desc))
+            
+            #AtoZ
+            title = ch["title"] + " - programmes AtoZ"
+            data2 = "channels/%s/programmes?rights=mobile&page=1&per_page=40&sort=recent&sort_direction=asc&initial_child_count=1&availability=available"%ch["id"]
+            desc = title
+            content.append((title,self.name+"::"+data2,img,desc))
+            
+            day0 = datetime.date.today()
+            for i in range(10):
+                day = day0-datetime.timedelta(days=i)
+                days = day.strftime("%Y-%m-%d")
+                title = ch["title"] + " - " + days
+                img = "http://static.bbci.co.uk/mobileiplayerappbranding/1.9/android/images/channels/tv-guide-wide-logo/layout_normal/xxhdpi/%s_tv-guide-wide-logo.png"%ch["id"]
+                data2 = "channels/%s/schedule/%s?availability=available"%(ch["id"],days)
+                #ee = self.get_epg_live(ch["id"])
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+            
+    def get_streams(self, data):
+        print "[iplayer] get_streams:", data
+        if "::" in data: data = data.split("::")[1]         
+        if not self.is_video(data):
+            return []
+        cmd = data.split("/")
+        vid = cmd[1].split("?")[0]
+        if cmd[0] == "live":
+            title,img,desc = self.get_epg_live(vid)
+        else:
+            data_ = "episodes/%s"%vid
+            r = self.call(data_)
+            title,img,desc,vid = self.get_epg_video(vid)
+        url = "http://open.live.bbc.co.uk/mediaselector/5/select/version/2.0/format/json/mediaset/iptv-all/vpid/%s"%vid
+        print "vid=%s"%vid
+        print url
+        r = self._http_request(url) #,headers=self.headers2
+        if not r:
+            raise Exception("No streams found")
+        js = json.loads(r)
+        if "result" in js and js["result"]=="geolocation":
+            raise Exception("BBC iPlayer service available only from UK")
+        if not "media" in js:
+            raise Exception("No streams found")
+        streams = []
+        captions = []
+        for s in js["media"]:
+            if s["kind"] == "captions":
+                if s["connection"][0]["href"]:
+                    sub = {}
+                    sub["url"] = s["connection"][0]["href"].encode('utf8')
+                    sub["type"] = s["type"]
+                    sub["name"] = s["service"] if "service" in s else "captions (taff)"
+                    sub["lang"] = "en"
+                    captions.append(sub)
+                    
+            if s["kind"] <> "video":
+                continue
+            for c in s["connection"]:
+                if c["transferFormat"] <> "hls": continue
+                #if not (c["supplier"].startswith("mf_") or c["supplier"].startswith("ll_")) : continue # TODO ir kaut kādas VPN problēmas ar akamaihd
+                #if c["priority"] <> "1": continue
+                url=c["href"].encode("utf8")
+                r2 = self._http_request(url)
+                if not r2: continue
+                slist = re.findall("#EXT-X-STREAM-INF:([^\n]+)\n([^\n]+)", r2, re.DOTALL)
+                if not slist:
+                    stream = stream0.copy()
+                    stream["url"]=url
+                    stream["name"]=title 
+                    stream["desc"]=desc
+                    stream["img"]=img
+                    stream["type"]="hls"
+                    stream["quality"]=("%s %sx%s %s,%s"%(s["bitrate"],s["width"],s["height"],c["supplier"],c["priority"])).encode("utf8")
+                    stream["lang"]="en"
+                    stream["subs"]=captions
+                    stream["order"]=int(s["bitrate"])
+                    streams.append(stream)
+                else:
+                    for cc in slist:
+                        m = re.search("RESOLUTION=([\dx]+)",cc[0])
+                        resolution = m.group(1) if m else "%sx%s"%(s["width"],s["height"])
+                        m = re.search("BANDWIDTH=([\d]+)",cc[0])
+                        bitrate = m.group(1) if m else s["bitrate"]
+                        url2 = cc[1].encode("utf8")
+                        if not url2.startswith("http"):
+                            uu = url.split("/")[:-1]
+                            uu.append(url2)
+                            url2 = "/".join(uu)
+                        stream = stream0.copy()
+                        stream["url"]=url2
+                        stream["name"]=title 
+                        stream["desc"]=desc
+                        stream["img"]=img
+                        stream["type"]="hls"
+                        stream["quality"]=("%s %s %s,%s"%(bitrate,resolution,c["supplier"],c["priority"])).encode("utf8")
+                        stream["lang"]="en"
+                        stream["subs"]=captions
+                        stream["order"]=int(bitrate)
+                        streams.append(stream)
+        if captions:
+            for s in streams:
+                s["subs"]=captions
+        streams = sorted(streams,key=lambda item: item["order"],reverse=True)
+        return streams
+        
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0]=="live" and  len(cmd)==2:
+            return True
+        elif cmd[0]=="episodes" and len(cmd)==2:
+            return True
+        else:
+            return False
+        
+    def get_data_element(self,item):
+        if ("programme" in item["type"] or "group" in item["type"]) and item["count"]>1:
+            ep = item.copy()
+        elif ("programme" in item["type"] or "group" in item["type"]) and item["count"]==1:
+            ep = item["initial_children"][0].copy()
+        elif item["type"] == "episode":
+            ep = item.copy()
+        elif item["type"] == "broadcast":
+            ep = item["episode"].copy()
+        else:
+            ep = item.copy()
+        title = ep["title"]
+        if "subtitle" in ep and ep["subtitle"]:
+            title = title+". "+ ep["subtitle"]
+        desc = ep["synopses"]["large"] if "large" in ep["synopses"] else ep["synopses"]["medium"] if "medium" in ep["synopses"] else ep["synopses"]["small"]
+        #TODO papildus info pie apraksta
+        img = ep["images"]["standard"].replace("{recipe}","512x288") if "images" in ep else self.img
+        if ep["type"] == "episode":
+            data2 = "episodes/%s"%ep["id"]
+        elif "programme" in ep["type"]:
+            data2 = "programmes/%s/episodes?per_page=40&page=1"%ep["id"]
+            title = "%s [%s episodes]"%(title,ep["count"])
+        elif "group" in ep["type"]:
+            data2 = "groups/%s/episodes?per_page=40&page=1"%ep["id"]
+            title = "%s [%s episodes]"%(title,ep["count"])
+        else:
+            data2 = "programmes/%s/episodes?per_page=40&page=1"%ep["id"]
+            title = "%s [%s episodes]"%(title,ep["count"])            
+        return title,data2,img,desc
+    
+    def get_epg_video(self,vid):
+        data = "episodes/%s"%vid
+        r = self.call(data)
+        if "episodes" in r :
+            ep = r["episodes"][0]
+            title = ep["title"]
+            if "subtitle" in ep:
+                title = title +". "+ ep["subtitle"]
+            title = title
+            desc = ep["synopses"]["medium"] if "medium" in ep["synopses"] else p["synopses"]["small"] if "small" in ep["synopses"] else title
+            desc = desc
+            ver = ep["versions"][0]
+            vid = ver["id"]
+            remaining = ver["availability"]["remaining"]["text"]
+            duration = ver["duration"]
+            first_broadcast = ver["first_broadcast"]
+            desc =u"%s\n%s\%s\n%s\n%s"%(title,duration,remaining,first_broadcast,desc)
+            img = ep["images"]["standard"].replace("{recipe}","512x288")
+            return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8"),vid.encode("utf8")
+        else:
+            raise Exception("No video info")
+    
+    def get_epg_live(self,channelid):
+        data = "channels/%s/highlights?live=true"%channelid
+        r = self.call(data)
+        if "channel_highlights" in r and r["channel_highlights"]["elements"][0]["id"] == "live":
+            epg = r["channel_highlights"]["elements"][0]["initial_children"][0].copy()
+            t1 = gt(epg['scheduled_start'])
+            t2 = gt(epg['scheduled_end'])
+            ep = epg["episode"]
+            title = ep["title"]
+            if "subtitle" in ep:
+                title = title +". "+ ep["subtitle"]
+            title = "%s (%s-%s)"%(title,t1.strftime("%H:%M"),t2.strftime("%H:%M"))
+            title = title
+            desc = ep["synopses"]["medium"] if "medium" in ep["synopses"] else p["synopses"]["small"] if "small" in ep["synopses"] else title
+            desc = desc
+            desc ="%s\n%s"%(title,desc)
+            img = ep["images"]["standard"].replace("{recipe}","512x288")
+            #return title,img,desc
+        else:
+            title = r["channel_highlights"]["channel"]["title"]
+            img = ""
+            desc = title
+            
+        return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8")
+        
+    def get_channels(self):
+        if self.ch:
+            return self.ch
+        r= self.call("channels")
+        self.ch=[]
+        for i,item in enumerate(r["channels"]):
+            self.ch.append(item)
+            self.ch_id[item["id"]]=i
+            self.ch_id2[item["master_brand_id"]]=i
+            self.ch_name[item["title"]]=i
+        return self.ch
+                
+    def get_channel_by_id(self,chid):
+        if not self.ch:
+            self.get_channels()
+        if not self.ch:
+            return None
+        return self.ch[self.ch_id[chid]] if self.ch_id.has_key(chid) else None
+    
+    def get_channel_by_id2(self,chid):
+        if not self.ch:
+            self.get_channels()
+        if not self.ch:
+            return None
+        return self.ch[self.ch_id2[chid]] if self.ch_id2.has_key(chid) else None
+     
+    def get_channel_by_name(self,name):
+        if not self.ch:
+            self.get_channels()
+        ch2 = self.get_channel_by_name2(name)
+        if not ch2:
+            return None
+        ch = self.get_channel_by_id2(ch2["id2"]) 
+        return ch
+                
+        
+    def call(self, data,params = None, headers=None):
+        if not headers: headers = self.headers
+        #if not lang: lang = self.country
+        url = self.api_url + data
+        content = self._http_request(url,params, headers)
+        if content:
+            try:
+                result = json.loads(content)
+                return result
+            except Exception, ex:
+                return None
+        else:
+            return None
+        
+    def call2(self, data,params = None, headers=None):
+        if not headers: headers = self.headers2
+        #if not lang: lang = self.country
+        url = self.api_url2 + data
+        content = self._http_request(url,params, headers)
+        return content
+
+    def _http_request(self, url,params = None, headers=None):
+        if not headers: headers = self.headers
+        import requests
+        try:
+            r = requests.get(url, headers=headers)
+            return r.content
+        
+        except Exception as ex:
+            if ex.code==403:
+                return ex.read()
+            else:
+                return None
+
+def gt(dt_str):
+    dt, _, us= dt_str.partition(".")
+    dt= datetime.datetime.strptime(dt, "%Y-%m-%dT%H:%M:%S")
+    dt = dt - datetime.timedelta(seconds=time.altzone)
+    #us= int(us.rstrip("Z"), 10)
+    #r = dt + datetime.timedelta(microseconds=us)a
+    return dt
+   
+if __name__ == "__main__":
+    c = Source()
+    from subprocess import call
+    #ch = c.get_channels()
+    #c.get_epg_live("bbc_two_england")
+    
+    if len(sys.argv)>1 and  not "iplayer::" in sys.argv[1]:
+        
+        vid = sys.argv[1]
+        print "login - %s"%c.login("ivars777","xxx")        
+        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
+ 
+
+        
+    else:
+        if len(sys.argv)>1:
+            data= sys.argv[1]
+        else:
+            data = "iplayer::home"
+        content = c.get_content(data)
+        for item in content:
+            print item
+        #cat = api.get_categories(country)
+        #chan = api.get_channels("lv")
+        #prog = api.get_programs(channel=6400)
+        #prog = api.get_programs(category=55)
+        #seas = api.get_seasons(program=6453)
+        #str = api.get_streams(660243)
+        #res = api.get_videos(802)
+        #formats = api.getAllFormats()
+        #det = api.detailed("1516")
+        #vid = api.getVideos("13170")
+        pass

sources/jsinterp.py

@@ -0,0 +1,261 @@
+# This code comes from youtube-dl: https://github.com/rg3/youtube-dl/blob/master/youtube_dl/jsinterp.py
+
+from __future__ import unicode_literals
+
+import json
+import operator
+import re
+
+
+_OPERATORS = [
+    ('|', operator.or_),
+    ('^', operator.xor),
+    ('&', operator.and_),
+    ('>>', operator.rshift),
+    ('<<', operator.lshift),
+    ('-', operator.sub),
+    ('+', operator.add),
+    ('%', operator.mod),
+    ('/', operator.truediv),
+    ('*', operator.mul),
+]
+_ASSIGN_OPERATORS = [(op + '=', opfunc) for op, opfunc in _OPERATORS]
+_ASSIGN_OPERATORS.append(('=', lambda cur, right: right))
+
+_NAME_RE = r'[a-zA-Z_$][a-zA-Z_$0-9]*'
+
+
+class JSInterpreter(object):
+    def __init__(self, code, objects=None):
+        if objects is None:
+            objects = {}
+        self.code = code
+        self._functions = {}
+        self._objects = objects
+
+    def interpret_statement(self, stmt, local_vars, allow_recursion=100):
+        if allow_recursion < 0:
+            print '[JSInterpreter] Recursion limit reached'
+            return None
+
+        should_abort = False
+        stmt = stmt.lstrip()
+        stmt_m = re.match(r'var\s', stmt)
+        if stmt_m:
+            expr = stmt[len(stmt_m.group(0)):]
+        else:
+            return_m = re.match(r'return(?:\s+|$)', stmt)
+            if return_m:
+                expr = stmt[len(return_m.group(0)):]
+                should_abort = True
+            else:
+                # Try interpreting it as an expression
+                expr = stmt
+
+        v = self.interpret_expression(expr, local_vars, allow_recursion)
+        return v, should_abort
+
+    def interpret_expression(self, expr, local_vars, allow_recursion):
+        expr = expr.strip()
+
+        if expr == '':  # Empty expression
+            return None
+
+        if expr.startswith('('):
+            parens_count = 0
+            for m in re.finditer(r'[()]', expr):
+                if m.group(0) == '(':
+                    parens_count += 1
+                else:
+                    parens_count -= 1
+                    if parens_count == 0:
+                        sub_expr = expr[1:m.start()]
+                        sub_result = self.interpret_expression(
+                            sub_expr, local_vars, allow_recursion)
+                        remaining_expr = expr[m.end():].strip()
+                        if not remaining_expr:
+                            return sub_result
+                        else:
+                            expr = json.dumps(sub_result) + remaining_expr
+                        break
+            else:
+                print '[JSInterpreter] Premature end of parens in %r' % expr
+                return None
+
+        for op, opfunc in _ASSIGN_OPERATORS:
+            m = re.match(r'''(?x)
+                (?P<out>%s)(?:\[(?P<index>[^\]]+?)\])?
+                \s*%s
+                (?P<expr>.*)$''' % (_NAME_RE, re.escape(op)), expr)
+            if not m:
+                continue
+            right_val = self.interpret_expression(
+                m.group('expr'), local_vars, allow_recursion - 1)
+
+            if m.groupdict().get('index'):
+                lvar = local_vars[m.group('out')]
+                idx = self.interpret_expression(
+                    m.group('index'), local_vars, allow_recursion)
+                assert isinstance(idx, int)
+                cur = lvar[idx]
+                val = opfunc(cur, right_val)
+                lvar[idx] = val
+                return val
+            else:
+                cur = local_vars.get(m.group('out'))
+                val = opfunc(cur, right_val)
+                local_vars[m.group('out')] = val
+                return val
+
+        if expr.isdigit():
+            return int(expr)
+
+        var_m = re.match(
+            r'(?!if|return|true|false)(?P<name>%s)$' % _NAME_RE,
+            expr)
+        if var_m:
+            return local_vars[var_m.group('name')]
+
+        try:
+            return json.loads(expr)
+        except ValueError:
+            pass
+
+        m = re.match(
+            r'(?P<var>%s)\.(?P<member>[^(]+)(?:\(+(?P<args>[^()]*)\))?$' % _NAME_RE,
+            expr)
+        if m:
+            variable = m.group('var')
+            member = m.group('member')
+            arg_str = m.group('args')
+
+            if variable in local_vars:
+                obj = local_vars[variable]
+            else:
+                if variable not in self._objects:
+                    self._objects[variable] = self.extract_object(variable)
+                obj = self._objects[variable]
+
+            if arg_str is None:
+                # Member access
+                if member == 'length':
+                    return len(obj)
+                return obj[member]
+
+            assert expr.endswith(')')
+            # Function call
+            if arg_str == '':
+                argvals = tuple()
+            else:
+                argvals = tuple([
+                    self.interpret_expression(v, local_vars, allow_recursion)
+                    for v in arg_str.split(',')])
+
+            if member == 'split':
+                assert argvals == ('',)
+                return list(obj)
+            if member == 'join':
+                assert len(argvals) == 1
+                return argvals[0].join(obj)
+            if member == 'reverse':
+                assert len(argvals) == 0
+                obj.reverse()
+                return obj
+            if member == 'slice':
+                assert len(argvals) == 1
+                return obj[argvals[0]:]
+            if member == 'splice':
+                assert isinstance(obj, list)
+                index, howMany = argvals
+                res = []
+                for i in range(index, min(index + howMany, len(obj))):
+                    res.append(obj.pop(index))
+                return res
+
+            return obj[member](argvals)
+
+        m = re.match(
+            r'(?P<in>%s)\[(?P<idx>.+)\]$' % _NAME_RE, expr)
+        if m:
+            val = local_vars[m.group('in')]
+            idx = self.interpret_expression(
+                m.group('idx'), local_vars, allow_recursion - 1)
+            return val[idx]
+
+        for op, opfunc in _OPERATORS:
+            m = re.match(r'(?P<x>.+?)%s(?P<y>.+)' % re.escape(op), expr)
+            if not m:
+                continue
+            x, abort = self.interpret_statement(
+                m.group('x'), local_vars, allow_recursion - 1)
+            if abort:
+                print '[JSInterpreter] Premature left-side return of %s in %r' % (op, expr)
+                return None
+            y, abort = self.interpret_statement(
+                m.group('y'), local_vars, allow_recursion - 1)
+            if abort:
+                print '[JSInterpreter] Premature right-side return of %s in %r' % (op, expr)
+                return None
+            return opfunc(x, y)
+
+        m = re.match(
+            r'^(?P<func>%s)\((?P<args>[a-zA-Z0-9_$,]+)\)$' % _NAME_RE, expr)
+        if m:
+            fname = m.group('func')
+            argvals = tuple([
+                int(v) if v.isdigit() else local_vars[v]
+                for v in m.group('args').split(',')])
+            if fname not in self._functions:
+                self._functions[fname] = self.extract_function(fname)
+            return self._functions[fname](argvals)
+
+        print '[JSInterpreter] Unsupported JS expression %r' % expr
+        return None
+
+    def extract_object(self, objname):
+        obj = {}
+        obj_m = re.search(
+            (r'(?:var\s+)?%s\s*=\s*\{' % re.escape(objname)) +
+            r'\s*(?P<fields>([a-zA-Z$0-9]+\s*:\s*function\(.*?\)\s*\{.*?\}(?:,\s*)?)*)' +
+            r'\}\s*;',
+            self.code)
+        fields = obj_m.group('fields')
+        # Currently, it only supports function definitions
+        fields_m = re.finditer(
+            r'(?P<key>[a-zA-Z$0-9]+)\s*:\s*function'
+            r'\((?P<args>[a-z,]+)\){(?P<code>[^}]+)}',
+            fields)
+        for f in fields_m:
+            argnames = f.group('args').split(',')
+            obj[f.group('key')] = self.build_function(argnames, f.group('code'))
+
+        return obj
+
+    def extract_function(self, funcname):
+        func_m = re.search(
+            r'''(?x)
+                (?:function\s+%s|[{;,]%s\s*=\s*function|var\s+%s\s*=\s*function)\s*
+                \((?P<args>[^)]*)\)\s*
+                \{(?P<code>[^}]+)\}''' % (
+                re.escape(funcname), re.escape(funcname), re.escape(funcname)),
+            self.code)
+        if func_m is None:
+            print '[JSInterpreter] Could not find JS function %r' % funcname
+            return None
+        argnames = func_m.group('args').split(',')
+
+        return self.build_function(argnames, func_m.group('code'))
+
+    def call_function(self, funcname, *args):
+        f = self.extract_function(funcname)
+        return f(args)
+
+    def build_function(self, argnames, code):
+        def resf(args):
+            local_vars = dict(zip(argnames, args))
+            for stmt in code.split(';'):
+                res, abort = self.interpret_statement(stmt, local_vars)
+                if abort:
+                    break
+            return res
+        return resf

sources/kinofilmnet.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+import urllib2, urllib
+import datetime, re, sys,os
+import ConfigParser
+from collections import OrderedDict
+from SourceBase import SourceBase
+import resolver
+import util
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self,country=""):
+        self.name = "kinofilmnet"
+        self.title = "KinoFilmNet.lv"
+        self.img = "http://kinofilmnet.lv/MusuBaneri/1268.png"
+        self.desc = "Kinofilmnet.lv satura skatīšanās"
+        self.country=country
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+""")
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+X-Requested-With: XMLHttpRequest
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+""")
+        self.url = "http://kinofilmnet.lv/"
+
+
+    ######### Entry point ########        
+    def get_content(self, data):
+        print "[kinofilmnet] get_content:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Meklēt", "kinofilmnet::search/?q={0}","","Meklēt"),                
+                ("Jaunākās", "kinofilmnet::jaunakas","","Visu žanru jaunākās filmas"),
+                ("Top50", "kinofilmnet::top50","","Top 50 filmas"),
+            ])
+            r = self.call("")
+            i = r.find('<div class="cat-title">Meklēt pēc žanriem</div>')
+            if i<=0:
+                return content
+            for item in re.findall('<li><a href=".*load/([^"]+)">([^<]+)</a></li>', r[i:]):
+                title = item[1]
+                data2 = "filmas/" + item[0]
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))      
+            return content
+    
+        elif clist=="search":
+            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://kinofilmnet.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)
+                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
+            
+        # Žanru saraksti ##
+        elif clist in ("jaunakas","top50") or clist=="filmas" and len(plist)==3:
+            if clist == "jaunakas":
+                r = self.call("")
+            else:
+                r = self.call(data)
+            #r = r.decode("cp1251").encode("utf8")
+            result = re.findall(r'<div id="entryID\w+">.+?<img src="([^"]+)" alt="([^"]+)".+?data-link="([^"]+)".+?<span>([^<]*)</span>.+?<div class="movie-date">([^<]+)</div>.+?<div class="movie-director"><b>Žanrs:</b> ([^<]+)</div>.+?<div class="movie-text">([^<]+)</div>', r, re.DOTALL)
+            for item in result:
+                title = item[1]+"[%s]"%item[3]
+                img = "http://kinofilmnet.lv"+item[0]
+                data2 = item[2][1:]
+                desc = "%s %s\n%s"%(item[4],item[5],item[6])
+                content.append((title,self.name+"::"+data2,img,desc))                      
+            m = re.search('href="/([^"]+)" onclick="[^"]+" ><span>&raquo;', r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))    
+            return content      
+         
+        ### Seriāls ###
+        elif clist=="filmas" and len(plist)==4:
+            r = self.call(path)
+            title0 = re.search("<h1>([^<]+)</h1>", r, re.DOTALL).group(1)
+            desc0 = re.search('<div class="m-desc full-text clearfix">([^<]+)</div>', r, re.DOTALL).group(1)
+            img0 = "http://kinofilmnet.lv" + re.search('<div class="m-img">.*?<img src="([^"]+)" alt', r, re.DOTALL).group(1)
+            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+"?s=%s"%i
+                img = img0
+                desc = desc0
+                content.append((title,self.name+"::"+data2,img,desc))                                      
+                i += 1
+            return content                    
+            
+        ### kaut kas neparedzets ###
+        else:
+            return content                            
+              
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if clist=="filmas" and len(plist) == 4 and "s"in qs:
+            return True
+        if not (clist=="filmas" and len(plist) == 4):
+            return False
+        if "sezona" in data:
+            return False
+        r = self.call(path)
+        result = re.findall(r'iframe src="https://openload\.co/embed/[^/]+/"', r, re.DOTALL)
+        if len(result)>1:
+            return False
+        else:
+            return True
+
+        
+    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)
+        return result
+      
+    def get_streams(self,data):
+        print "[kinofilmnet] 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)
+        title = re.search("<h1>([^<]+)</h1>", r, re.DOTALL).group(1)
+        desc = re.search('<div class="m-desc full-text clearfix">([^<]+)</div>', r, re.DOTALL).group(1)
+        img = "http://kinofilmnet.lv" + re.search('<div class="m-img">.*?<img src="([^"]+)" alt', r, re.DOTALL).group(1)
+        if "s" in qs: # serialā sērija
+            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]
+        streams =  resolver.resolve(url0)
+        for s in streams:
+            if "hqq." in url0:
+                s["url"] = util.streamproxy_encode(s["url"],s["headers"])
+                s["headers"]={}
+            s["name"] = title
+            s["desc"] = desc
+            s["img"] = img
+            s["type"] = self.stream_type(s["url"])
+            #s["lang"] = lang        
+        return streams
+        
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/mtgplay.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+
+
+try:
+    import json
+except:
+    import simplejson as json
+#!/usr/bin/env python
+# coding=utf8
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+
+API_URL = 'http://playapi.mtgx.tv/v3/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+
+REGIONS = [
+    ("Latvia",None,"lv",""),
+    ("Estonia",None,"ee",""),
+    ("Lituania",None,"lt",""),
+    ("Sweden",None,"se",""),
+    ("Denmark",None,"dk",""),
+    ("Norway",None,"no",""),
+    ("Bulgaria",None,"bg","")
+]
+
+
+class Source(SourceBase):
+    
+    def __init__(self,country="lv"):
+        self.name = "mtgplay"
+        self.title = "Skaties.lv (TV3)"
+        self.img = "http://skaties.lv/touch-icon-192x192.png"
+        self.desc = "MTG skaties.lv satura skatīšanās (LNT,TV3, TV6 u.c.)"
+        
+        self.country=country
+        self.pic_size = "327x250" #"1000x765"
+        
+    def get_content(self, data):
+        print "[mtgplay] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1]        
+        if "/" in data:
+            citem,cid = data.split("/")
+            clist = ""
+        else:
+            clist = data.split("?")[0]
+            qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",data)))
+            citem,cid = ("","")
+            self.country = qs["country"] if "country" in qs else "lv"
+        
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                #("Search", "mtgplay::meklet?country=%s&term={0}"%self.country,"","Search videos"), ### TODO                
+                ("TV Live", "mtgplay::videos?country=%s&order=title&type=live"%self.country,"","TV live streams(not always available)"),
+                ("Last videos", "mtgplay::videos?country=%s&order=-airdate"%self.country,"","Last aired videos"),
+                ("Categories", "mtgplay::categories?country=%s&order=name"%self.country,"","Categories"),
+                ("Channels", "mtgplay::channels?country=%s&order=id"%self.country,"","TV channels"),
+                ("Programs by name", "mtgplay::formats?country=%s&order=-title"%self.country,"","Programs by name"),             
+                ("Programs by popularity", "mtgplay::formats?country=%s&order=-popularity"%self.country,"","Programs by popularity")             
+            ])
+            return content
+        
+        r = self.call(data)
+        if not r:
+            content.append(("Error", "","","Error reading '%s'"%data))
+            return content
+        
+        if clist:
+            if r["_links"].has_key("prev"):
+                data2 = r["_links"]["prev"]["href"].replace(API_URL,"")
+                content.append(("Previous page", self.name+"::"+data2.encode("utf8"),"", "Goto previous page"))
+                
+            if "_embedded" in r:
+                for item in r["_embedded"][clist]:
+                    if "title" in item:
+                        title = item["title"]
+                    elif "name" in item:
+                        title = item["name"]
+                    #data2 = self.name+"::"+"%s/%s"%(clist,item["id"]) 
+                    img = item["_links"]["image"]["href"].replace("{size}",self.pic_size) if "image" in item["_links"] else ""
+                    desc = item["summary"] if "summary" in item and item["summary"] else ""
+                    
+                    ### Video ###
+                    if clist=="videos":
+                        data2 = "videos/%s"%item["id"]                            
+                        summary = item["summary"] if item["summary"] else ""
+                        air_at = item["broadcasts"][0]["air_at"] if "broadcasts" in item and len(item["broadcasts"])>0 and "air_at" in item["broadcasts"][0] else ""
+                        if not air_at:
+                            air_at = item["publish_at"] if "publish_at" in item else ""
+                        air_at = air_at[0:16].replace("T"," ") if air_at else ""
+                        try: playable_to = item["broadcasts"][0]["playable_to"]
+                        except: playable_to =""
+                        playable_to = "(till "+playable_to[0:10].replace("T"," ")+")" if playable_to else ""
+                        duration = item["duration"] if "duration" in item else ""
+                        duration = str(datetime.timedelta(seconds=int(duration))) if duration else ""
+                        try:
+                            views = item["views"]["total"] if "views" in item and "total" in item["views"] else ""
+                            views = views+" views"
+                        except: views = ""
+                        desc = "Aired: %s %s\nDuration: %s %s\n\n%s"%(air_at, playable_to,duration,views,summary)
+                        
+                    ### Categories ###     
+                    elif clist == "categories":
+                        #data2 = item["_links"]["formats"]["href"].replace(API_URL,"")
+                        data2 = "formats?category=%s"%item["id"]
+                        if "country" in qs: data2 += "&country="+qs["country"]
+                        if "category" in qs: data2 += "&category="+qs["category"]
+                        if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=title"
+                        
+                    ### Channels ###     
+                    elif clist == "channels":
+                        #data2 = item["_links"]["categories"]["href"].replace(API_URL,"")
+                        data2 = "categories?channel=%s"%item["id"]
+                        if "country" in qs: data2 += "&country="+qs["country"]
+                        if "category" in qs: data2 += "&category="+qs["category"]
+                        if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=name"
+                        
+                    ### Formats (programs) ###     
+                    elif clist == "formats":
+                        #data2 = item["_links"]["videos"]["href"].replace(API_URL,"")
+                        data2 = "seasons?format=%s"%item["id"]
+                        #if "country" in qs: data2 += "&country="+qs["country"]
+                        #if "category" in qs: data2 += "&category="+qs["category"]
+                        #if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=title"
+                        air_at = item["latest_video"]["publish_at"] if "publish_at" in item["latest_video"] else ""
+                        air_at = air_at[0:16].replace("T"," ") if air_at else ""
+                        if air_at:
+                            desc = "Last video: %s\n"%air_at + desc                        
+                        
+                    ### Seasons ###     
+                    elif clist == "seasons":
+                        #data2 = item["_links"]["videos"]["href"].replace(API_URL,"")
+                        data2 = "videos?season=%s"%item["id"]
+                        #if "country" in qs: data2 += "&country="+qs["country"]
+                        #if "category" in qs: data2 += "&category="+qs["category"]
+                        #if "channel" in qs: data2 += "&channel="+qs["channel"]
+                        data2 += "&order=title"
+                        
+                        summary = item["summary"] if "summary" in item and item["summary"] else ""
+                        try:
+                            latest_video = item["latest_video"]["publish_at"]
+                            latest_video = latest_video[0:16].replace("T"," ")
+                        except: latest_video = ""
+                        desc = ("%s\nLatest video: %s"%(summary,latest_video))
+                                      
+                    content.append((title.encode("utf8"),self.name+"::"+data2.encode("utf8"),img.encode("utf8"),desc.encode("utf8")))
+                    
+            if r["_links"].has_key("next"):
+                data2 = r["_links"]["next"]["href"].replace(API_URL,"").encode("utf8")
+                content.append(("Next page", self.name+"::"+data2.encode("utf8"),"","Goto next page"))
+                
+        elif citem:
+            item = r
+            if "title" in item:
+                title = item["title"]
+            elif "name" in item:
+                title = r["name"]
+            #data2 = self.name+"::"+"%s/%s"%(clist,item["id"]) 
+            img = item["_links"]["image"]["href"].replace("{size}",self.pic_size) if "image" in item["_links"] else ""
+            desc = item["summary"] if "summary" in item and item["summary"] else ""
+            
+            dd = "videos/stream/%s"%cid
+            r2 = self.call(dd)
+            if "streams" in r2 and "hls" in r2["streams"]:
+                data2 = r2["streams"]["hls"]
+                content = (title.encode("utf8"),data2.encode("utf8"),img.encode("utf8"),desc.encode("utf8"))
+            elif "msg" in r2:
+                content = (r2["msg"].encode("utf8"),"","","")
+            else: 
+                content = ("Error getting stream","","","")            
+            
+        else:
+            pass
+        return content
+    
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0]=="videos":
+            return True
+        else:
+            return False
+    
+    def get_stream(self,id):   
+        dd = "videos/stream/%s"%id
+        r2 = self.call(dd)
+        if "streams" in r2 and "hls" in r2["streams"]:
+            data2 = r2["streams"]["hls"]
+        else:
+            data2 = ""
+        return data2.encode("utf8")
+        
+    def call_all(self, endpoint, params = None):
+        url = API_URL % (endpoint)
+        if params:
+            url += '?' + params
+        print "[TVPlay Api] url: ",url
+        result = []
+        while True:
+            content = self._http_request(url)
+            if content:
+                try:
+                    content = json.loads(content)
+                except Exception, ex:
+                    return {" Error " : "in call_api: %s" % ex}
+            else: break
+            if content.has_key("_embedded") and content["_embedded"].has_key(endpoint):
+                result.extend(content["_embedded"][endpoint])
+                pass
+            else: break
+            if content.has_key("_links") and content["_links"].has_key("next"):
+                url = content["_links"]["next"]["href"]
+            else: break
+        return result
+    
+    def call(self, data,headers=headers0):
+        url = API_URL + data
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url)
+        if content:
+            try:
+                result = json.loads(content)
+            except Exception, ex:
+                return None
+        return result
+
+    def _http_request0(self, url,headers=headers0):
+        try:
+            r = urllib2.Request(url, headers=headers)
+            u = urllib2.urlopen(r)
+            content = u.read()
+            u.close()
+            return content
+        except Exception as ex:
+            if "read" in ex:
+                content = ex.read()
+            else:
+                content = None
+            return content
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/play24.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+
+API_URL = 'http://replay.lsm.lv/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self,country="lv"):
+        self.name = "play24"
+        self.title = "Play24.lv"
+        self.img = "http://play24.lv/images/play24-logo-black.png"
+        self.desc = "play24.lv (Riga24TV) satura skatīšanās"
+        
+        self.country=country
+        
+    def get_content(self, data):
+        print "[play24] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+    
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Live stream", "play24::tiesraide","","TV live streams"),
+                ("Last videos", "play24::jaunakie","","Last videos"),
+                ("Categories", "play24::kategorijas","","Categories"),
+                ("Programs", "play24::raidijumi","","Programs"),             
+             ])
+            return content
+  
+        ### Jaunākie video ###
+        elif clist=="jaunakie":
+            url = "http://play24.lv/"
+            r = self._http_request(url)
+            for item in re.findall(' <div class="top-article__image">.*?<a class="top-article__image-link" href="([^"]+)">.*?<img.+?src="([^"]+)".+?alt="([^"]+)" />.+?</picture>', r, re.DOTALL):
+                title = item[2]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = item[1]
+                data2 = item[0].replace("http://play24.lv/","")
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+                
+        ### Kategorijas ###
+        elif clist=="kategorijas":
+            url = "http://play24.lv/"
+            r = self._http_request(url)
+            r2 = r[r.find('<div class="footer-navigation">'):]
+            for item in re.findall('<a href="http://play24.lv/(kategorija/[^"]+)" class="navigation__link">([^<]+)</a>', r2, re.DOTALL):
+                title = item[1]
+                data2 = item[0]
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+       
+        elif clist=="kategorija":
+            url = "http://play24.lv/"+data
+            r = self._http_request(url)
+            for article in re.findall(r"<article\b[^>]*>(.+?)</article>", r, re.DOTALL):
+                m = re.search('<a class="masonry-item__link" href="http://play24\.lv/([^"]+)">', article, re.DOTALL)
+                data2 = m.group(1) if m else ""
+                m = re.search('<img src="([^"]+)" alt="([^"]+)" />', article, re.DOTALL)
+                if m:
+                    img = m.group(1)
+                    title = m.group(2)
+                    title =  h.unescape(title.decode("utf8")).encode("utf8")
+                else:
+                    img = ""
+                    title = ""
+                m = re.search(r'<span class="masonry-item__tags">\s+<a href="([^"]+)">([^<]+)</a>.*?</span>', article, re.DOTALL)
+                progr = m.group(2) if m else ""
+                m = re.search('<span class="masonry-item__date">([^<]+)</span>', article, re.DOTALL)
+                date = m.group(1).strip() if m else ""
+                         
+                if date:
+                    title = title + " (%s %s)"%(date,progr)
+                desc = title + "\n%s - %s"%(progr,date)
+                content.append((title,self.name+"::"+data2,img,desc))
+            m = re.search(r'<li><a href="http://play24\.lv/([^"]+)" rel="next">&raquo;</a></li>', r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+            return content
+        
+        ### Raidijumi (programmas)
+        elif clist=="raidijumi":
+            url = "http://play24.lv/"
+            r = self._http_request(url)
+            for item in re.findall(r'<li class="tag-box__item">.*?<a href="http://play24\.lv/(birka/[^"]+)">([^<]+)</a>.*?</li>', r, re.DOTALL):
+                title = item[1]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                data2 = item[0]
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Programmas (video saraksts)
+        elif clist=="birka":
+            url = "http://play24.lv/"+data
+            r = self._http_request(url)
+            for item in re.findall(r'<article\b[^>]*>.+?<a class="masonry-item__link" href="http://play24.lv/([^"]+)">.*?<img src="([^"]+)" alt="([^"]+)" />.*?<span class="masonry-item__tags">.+?<a href="([^"]+)">([^<]+)</a>.*?<span class="masonry-item__date">([^<]+)</span>.*?</article>', r, re.DOTALL):
+                title = item[2]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                title = title + " (%s)"%item[5].strip()
+                img = item[1]
+                data2 = item[0]
+                desc = title + "\n%s - %s"%(item[4],item[5].strip())
+                content.append((title,self.name+"::"+data2,img,desc))
+            m = re.search(r'<li><a href="http://play24\.lv/([^"]+)" rel="next">&raquo;</a></li>', r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,"","Next page"))                                            
+            return content
+
+        elif clist == "video" or clist == "tiesraide":
+            if clist == "video":  
+                url = "http://play24.lv/"+data
+                r = self._http_request(url)
+                # var ov_video_id = '59422';
+                m = re.search(r"var ov_video_id = '(\d+)';", r, re.DOTALL)
+                if m:
+                    id = m.group(1)
+                else:
+                    return ("No stream found %s"%data,"","","No stream found")
+                m = re.search('<meta name="description" content="([^"]+)" />', r, re.DOTALL)
+                desc = m.group(1) if m else ""
+                desc = h.unescape(desc.decode("utf8")).encode("utf8")
+                
+                url = "http://player.tvnet.lv/v/%s"%id
+            else:
+                url = "http://player.tvnet.lv/l/11"
+                desc = ""
+            r = self._http_request(url)
+            m = re.search('<h1 class="static title">.+?<a href="[^"]+">([^<]+)</a>', r, re.DOTALL)
+            title = m.group(1) if m else ""   
+            s = {}
+            for item in re.findall('source src="([^"]+)" data-stream="([^"]+)" data-quality="([^"]+)"', r, re.DOTALL):
+                s[item[1]] = (item[0],item[2])
+            data2 = ""
+            for t in ("hls","http","rtmp"):
+                if t in s:
+                    data2 = s[t][0]
+                    break
+            return (title,data2,"",desc)
+               
+    
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0] in ("video","tiesraide"):
+            return True
+        else:
+            return False
+    
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = API_URL%lang + data
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url)
+        return content
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/replay.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys
+from SourceBase import SourceBase
+
+API_URL = 'http://replay.lsm.lv/%s/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+from YouTubeVideoUrl import YouTubeVideoUrl
+    
+class Source(SourceBase):
+    
+    def __init__(self,country="lv"):
+        self.name = "replay"
+        self.title = "Replay.lv (LTV)"
+        self.img = "http://replay.lsm.lv/apple-touch-icon.png"
+        self.desc = "LSM replay.lv satura skatīšanās"
+        
+        self.country=country
+        self.pic_size = "327x250" #"1000x765"
+        
+    def get_content(self, data):
+        print "[replay] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+    
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Live streams", "replay::tiesraide","","TV live streams"),
+                ("Search LV", "replay::search/?term={0}&lang=lv","","Search content LV"),                
+                ("Last videos LV", "replay::visi/jaunakie/?source=ltv&lang=lv","","Last aired videos LV"),
+                ("Last videos by categories LV", "replay::kategorijas/?lang=lv","","Last videos by categories LV"),                
+                ("All programs LV", "replay::raidijumi/?type=video","","All programs by name LV"),
+                ("Programs by categories LV", "replay::categories?lang=lv","","All programs by categories LV"),
+                #("Channels", "replay::channels?language=%s"%self.country,"","TV channels"),
+                ("Videos by popularity LV", "replay::visi/popularie/?source=ltv&lang=lv","","Programs by popularity"), 
+                
+                ("Search RU", "replay::search/?term={0}&lang=ru","","Search content RU"),                
+                ("Last videos RU", "replay::vse/novie/?source=ltv&lang=ru","","Last aired videos RU"),
+                ("Last videos by categories RU", "replay::kategorijas/?lang=ru","","Last videos by categories RU"),                                
+                ("All programs RU", "replay::peredachi/?lang=ru&type=video","","All programs by name"),         
+                ("Programs by categories RU", "replay::categories?lang=ru","","Programs by categories RU")
+            ])
+            return content
+        
+        ### programmu kategorijas ###
+        elif clist=="categories":
+            url = "http://replay.lsm.lv/lv/raidijumi/?lang=lv&type=video" if lang =="lv" else "http://replay.lsm.lv/ru/peredachi/?lang=ru&type=video"        
+            r = self._http_request(url)
+            for item in re.findall(r'<a .+href="(\?lang=\w+&type=video&theme=\d+)">([^<]+)</a>\t', r):
+                title = item[1]
+                data2 = url.split("?")[0]+item[0]
+                data2 = data2.replace(API_URL%lang,"")
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+        ### jaunāko raidijumu kategorijas ###
+        elif clist=="kategorijas":
+            url = "http://replay.lsm.lv/lv/" if lang =="lv" else "http://replay.lsm.lv/ru/"        
+            r = self._http_request(url)
+            for item in re.findall(r'<a href="/(lv|ru)/kategorija/(\w+)/">.+?<i class="[^"]+"></i>.+?<span>([^<]+)</span>', r, re.DOTALL):
+                title = item[2]
+                data2 = "kategorija/%s/?lang=%s"%(item[1],item[0])
+                img = ""
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+        ### Tiešraides kanānālu saraksts
+        elif path=="tiesraide":
+            url = "http://replay.lsm.lv/styles/main.css"
+            r= self._http_request(url)
+            for item in re.findall(r'channel-logo--(\w+)\{background-image:url\("([^"]+\.png)"', r):
+                ch = item[0]
+                title = ch.upper()
+                data2 = "tiesraide/%s/"%ch
+                img = "http://replay.lsm.lv"+item[1]
+                veids = "video "if "tv" in ch else "audio"
+                desc = title+" tiesraide (%s)"%veids
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+        
+        ### Kanāla tiesraide
+        elif clist == "tiesraide" and "/" in data:
+            ch = data.split('/')[1]
+            veids = "video" if "tv" in ch else "audio"           
+            #url = "http://replay.lsm.lv/lv/tiesraide/ltv7/"
+            url = "http://replay.lsm.lv/lv/tiesraide/%s/"%ch
+            r= self._http_request(url)
+            
+            m = re.search('%s/">.+?<h5>([^<]+)+</h5>.*?<time>([^<]+)</time>'%ch, r, re.DOTALL)
+            tagad = m.group(1).strip() if m else ""
+            laiks = m.group(2).strip() if m else ""
+            laiks = h.unescape(laiks).encode("utf8")
+            m = re.search("<h1>([^<]+)</h1>", r)
+            title = m.group(1).strip() if m else path.split("/")[1].upper()
+            title = "%s - %s (%s)"%(title,tagad,laiks)
+            
+            if veids == "video":
+                m = re.search('<div class="video"><iframe.+src="([^"]+)"', r)
+                if not m: 
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content           
+                url = m.group(1)
+                headers = headers2dict("""
+            User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+            Referer: http://replay.lsm.lv/lv/ieraksts/ltv/70398/tiesa-runa.-lielbritanija-gatavojas-referendumam-par-tu/
+                    """)
+                r = self._http_request(url,headers=headers)
+            
+                m = re.search('<div class="video-player"><iframe.+src="([^"]+)"', r)
+                if not m:
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content
+                url = m.group(1)
+                            
+                r = self._http_request(url,headers=headers)
+                m = re.search('"([^"]+m3u8[^"]+)"', r)
+                if not m:
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content           
+                data2 = m.group(1).replace("\\","")
+                
+            else: # audio
+                lrn = ch.replace("lr","")
+                url = "http://www.latvijasradio.lsm.lv/lv/tiesraide/?channel=%s"%lrn
+                r = self._http_request(url)
+                m = re.search('"file":"([^"]+?m3u8.*?)"', r)
+                if not m:
+                    content=("No stream found %s"%data,"","","No stream found")
+                    return content           
+                data2 = m.group(1).replace("\\","")
+                
+            img = ""
+            desc = ""
+            content =(title,data2,img,desc)
+            return content           
+                       
+        #m = re.search(r'(\?page=\d+)" class=" paging__prev', r, re.IGNORECASE)
+        #if m:
+        #    data = re.sub("\?page=\d+", "", data)
+        #    data2 = data+m.group(1)
+        #    content.append(("Previous page",self.name+"::"+data2,"","Previous page"))                            
+        
+        r = self.call(data, lang=lang)
+        if not r:
+            return content
+        
+        if clist == "search":
+            #for r2 in re.findall('<article itemtype="http://schema.org/Article" itemscope class="thumbnail thumbnail--default ">(.+?)</article>', r2, re.DOTALL):
+            for item in re.findall('itemprop="image" data-image="([^"]+)".+?<figcaption><h5 itemprop="name"><a itemprop="url" href="([^<]+)">([^<]+)</a></h5></figcaption>', r):
+                title = item[2]
+                data2 = item[1].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = "http://replay.lsm.lv" + item[0]
+                desc  = title
+                content.append((title,self.name+"::"+data2,img,desc))
+                
+            #for item in re.findall('itemprop="image" data-image="([^"]+)".+?<figcaption><h4 itemprop="about"><a href="([^"]+)">([^<]+)</a></h4>.*?<h5 itemprop="name"><a itemprop="url" href="([^"]+)">([^<]+)</a></h5>.+?datetime="([^"]+)" class="thumbnail__date ">([^<]+)</time>', r2):
+            for item in re.findall('itemprop="image" data-image="([^"]+)".+? class="icon-(ltv|lr).+?<figcaption><h4 itemprop="about"><a href="([^"]+)">([^<]+)</a></h4>.*?<h5 itemprop="name"><a itemprop="url" href="([^"]+)">([^<]+)</a></h5>.+?datetime="([^"]+)" class="thumbnail__date ">([^<]+)</time>', r):  
+                if item[1]=="lr":continue
+                title = "%s - %s (%s)"%(item[3],item[5],item[7])
+                data2 = item[4].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = item[0].replace("https:","http:")
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+    
+        ### Raidijumi (programmas) ###
+        elif clist in ( "raidijumi","peredachi"):
+            for item in re.findall('<li itemprop="name"><a href="([^"]+)" itemprop="url">([^<]+)', r):
+            #for item in re.findall('<li itemprop="name"><a href="([^"]+)" itemprop="url">([^<]+)</a></li>', r):
+                title = item[1]
+                data2 = item[0].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = ""
+                desc  = ""
+                content.append((title,self.name+"::"+data2,img,desc))
+                 
+        ### Raidijuma ieraksti speciālie###
+        elif clist in ( "visi","vse",):
+            for item in re.findall('(?i)<figure><a href="([^"]+)" itemprop="image" data-image="([^"]+)".+class="thumbnail__duration">([^<]+)</time></figure><figcaption><h4 itemprop="about"><a href="[^"]+">([^<]+)</a></h4>.+>([^<]+).*</h5>.+>([^<]+)</time></figcaption>', r):
+                title = item[3]
+                data2 = item[0].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = item[1].replace("https:","http:")
+                desc  = "%s - %s\n%s"%(item[5],item[2],item[4])
+                content.append((title,self.name+"::"+data2,img,desc))
+                
+        ### Raidijuma ieraksti (videos)
+        elif clist in ("raidijums","peredacha","kategorija"): 
+            for item in re.findall('<article .+ href="([^"]+)".+image="([^"]+)".+class="thumbnail__duration">([^<]+).+">([^<]+).+class="thumbnail__date ">([^"]+)</time></figcaption></article>', r):
+                title = item[3]
+                data2 = item[0].replace("/%s/"%lang,"")+"?lang=%s"%lang
+                img = item[1].replace("https:","http:")
+                desc = "%s - %s"%(item[4],item[2])
+                content.append((title,self.name+"::"+data2,img,desc))
+        
+        ### Ieraksts (video) ###
+        elif clist in ("ieraksts","statja"):
+            m = re.search('src="([^"]+)"></iframe>', r)
+            if m:
+                url2 = m.group(1)
+                headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+Referer: http://replay.lsm.lv/lv/ieraksts/ltv/70398/tiesa-runa.-lielbritanija-gatavojas-referendumam-par-tu/
+            """)
+                r2 = self._http_request(url2,headers=headers)
+                m = re.search('"file":"([^"]+)', r2)
+                if m:
+                    data2 = m.group(1).replace("\\","")
+                    m = re.search('"idstring":"([^"]+)', r2)                    
+                    title = m.group(1) if m else ""
+                    title = title.decode("unicode-escape").encode("utf8")
+                    title = title.replace("\n","")
+                    img = ""
+                    desc = ""
+                    if "youtube" in data2:
+                        video_id = re.search(r"/watch\?v=([^&]+)",data2).group(1)
+                        data2 = YouTubeVideoUrl().extract(video_id)
+                        if not data2:
+                            content=("No stream found %s"%data,"","","No stream found")
+                            return content                           
+                    content =(title,data2,img,desc)
+                    return content
+            content=("No stream found %s"%data,"","","No stream found")
+            return content
+                
+        m = re.search(r'href="\?([^"]+)" class=" paging__next', r)
+        if m:
+            page = int(re.search("page=(\d+)",m.group(1)).group(1))
+            if "page="in data:
+                data2 = re.sub("page=\d+","page=%i"%page,data)
+            else:
+                if "?" in data:
+                    data2 =data+"&page=%i"%page
+                else:
+                    data2 =data+"?page=%i"%page
+            content.append(("Next page",self.name+"::"+data2,"","Next page"))                            
+                
+        return content
+    
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        cmd = data.split("/")
+        if cmd[0] in ("ieraksts","statja"):
+            return True
+        elif cmd[0]=="tiesraide" and len(cmd)>1:
+            return True
+        else:
+            return False
+    
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = API_URL%lang + data
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url,headers=headers0)
+        return content
+
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/serialguru.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys,os
+import ConfigParser
+from SourceBase import SourceBase
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+    
+class Source(SourceBase):
+    
+    def __init__(self,country=""):
+        self.name = "serialguru"
+        self.title = "SerialGURU.ru"
+        self.img = "http://serialguru.ru/images/xlogo_new.png.pagespeed.ic.0sre2_2OJN.png"
+        self.desc = "Serialguru.ru portāla satura skatīšanās"
+        self.country=country
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36
+Referer: http://serialguru.ru/        
+""")
+        self.headers2 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36
+X-Requested-With: XMLHttpRequest
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+Referer: http://serialguru.ru/        
+""")
+        self.url = "http://serialguru.ru/"
+        #self.login()
+        
+    def login(self,user="",password=""):
+        return True
+            
+    def get_content(self, data):
+        print "[tvdom] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("[%\w]+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+    
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Search", "serialguru::search/{0}","","Search content"),                
+                ("Last", "serialguru::last","","Last series"),                
+                ("Series", "serialguru::serials","","TV Series"),
+                ("Shows", "serialguru::tv","","TV Shows"),
+                ("Animations", "serialguru::mult","","Animation series"),
+                
+                #("Archive - all", "tvdom::arhivs_all","","Video archive all"),
+            ])
+            return content
+    
+        elif data=="last":
+            r = self.call("")
+            for item in re.findall(r'<li><a href="(http://serialguru\.ru/[^"]+)"><i>([^<]+)</i>  <i>([^<]+)</i> <b>([^<]+)</b></a></li>', r, re.DOTALL):
+                title = item[1] + " - " + item[2]+"/"+item[3]
+                img = ""
+                data2 = item[0].replace(self.url,"")
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        elif data=="serials":
+            content.extend([
+                ("All", "serialguru::serials?o=0&t=S","","All series"),                
+                ("Russian", "serialguru::serials?c%5B%5D=53&c%5B%5D=61&c%5B%5D=33&c%5B%5D=42&c%5B%5D=31&o=0&t=S","","Russian countries series"),                
+                ("English", "serialguru::serials?c%5B%5D=27&c%5B%5D=26&c%5B%5D=43&c%5B%5D=30&c%5B%5D=34&c%5B%5D=25&o=0&t=S","","English countries series"),
+                ("Europe", "serialguru::serials?c%5B%5D=29&c%5B%5D=66&c%5B%5D=44&c%5B%5D=28&c%5B%5D=51&c%5B%5D=65&c%5B%5D=62&c%5B%5D=40&c%5B%5D=45&c%5B%5D=68&c%5B%5D=59&c%5B%5D=39&c%5B%5D=35&c%5B%5D=47&o=0&t=S","","European countries series"),
+                ("Other", "serialguru::serials?c%5B%5D=36&c%5B%5D=32&c%5B%5D=67&c%5B%5D=63&c%5B%5D=60&c%5B%5D=64&c%5B%5D=38&c%5B%5D=52&c%5B%5D=41&c%5B%5D=58&c%5B%5D=57&c%5B%5D=37&c%5B%5D=50&c%5B%5D=46&o=0&t=S","","Other countries series"),
+                #("Archive - all", "tvdom::arhivs_all","","Video archive all"),
+            ])
+            return content
+        
+        elif data=="tv":
+            content.extend([
+                ("All", "serialguru::tv?o=0&t=S","","All series"),                
+                ("Russian", "serialguru::tv?c%5B%5D=53&c%5B%5D=61&c%5B%5D=33&c%5B%5D=42&c%5B%5D=31&o=0&t=P","","Russian countries TV shows"),                
+                ("English", "serialguru::tv?c%5B%5D=27&c%5B%5D=26&c%5B%5D=43&c%5B%5D=30&c%5B%5D=34&c%5B%5D=25&o=0&t=P","","English countries TV shows"),
+                ("Europe", "serialguru::tv?c%5B%5D=29&c%5B%5D=66&c%5B%5D=44&c%5B%5D=28&c%5B%5D=51&c%5B%5D=65&c%5B%5D=62&c%5B%5D=40&c%5B%5D=45&c%5B%5D=68&c%5B%5D=59&c%5B%5D=39&c%5B%5D=35&c%5B%5D=47&o=0&t=P","","European countries TV shows series"),
+                ("Other", "serialguru::tv?c%5B%5D=36&c%5B%5D=32&c%5B%5D=67&c%5B%5D=63&c%5B%5D=60&c%5B%5D=64&c%5B%5D=38&c%5B%5D=52&c%5B%5D=41&c%5B%5D=58&c%5B%5D=57&c%5B%5D=37&c%5B%5D=50&c%5B%5D=46&o=0&t=P","","Other countries TV shows"),
+                #("Archive - all", "tvdom::arhivs_all","","Video archive all"),
+            ])
+            return content
+        
+        elif data=="mult":
+            content.extend([
+                ("All", "serialguru::mult?o=0&t=S","","All series"),                
+                ("Russian", "serialguru::mult?c%5B%5D=53&c%5B%5D=61&c%5B%5D=33&c%5B%5D=42&c%5B%5D=31&o=0&t=M","","Russian countries animantions"),                
+                ("English", "serialguru::mult?c%5B%5D=27&c%5B%5D=26&c%5B%5D=43&c%5B%5D=30&c%5B%5D=34&c%5B%5D=25&o=0&t=M","","English countries animantions"),
+                ("Europe", "serialguru::mult?c%5B%5D=29&c%5B%5D=66&c%5B%5D=44&c%5B%5D=28&c%5B%5D=51&c%5B%5D=65&c%5B%5D=62&c%5B%5D=40&c%5B%5D=45&c%5B%5D=68&c%5B%5D=59&c%5B%5D=39&c%5B%5D=35&c%5B%5D=47&o=0&t=M","","European countries animantions"),
+                ("Other", "serialguru::mult?c%5B%5D=36&c%5B%5D=32&c%5B%5D=67&c%5B%5D=63&c%5B%5D=60&c%5B%5D=64&c%5B%5D=38&c%5B%5D=52&c%5B%5D=41&c%5B%5D=58&c%5B%5D=57&c%5B%5D=37&c%5B%5D=50&c%5B%5D=46&o=0&t=M","","Other countries animantions"),
+                #("Archive - all", "tvdom::arhivs_all","","Video archive all"),
+            ])
+            return content
+        
+        elif clist=="search":
+            if data.split("/")>1:
+                term = data.split("/")[1]
+            else:
+                return content
+            r = self.call("main/autocomplete?term=%s"%(term))
+            if r=="null":
+                return content
+            js = json.loads(r)
+            for item in js:
+                title = item["name"].encode("utf8")
+                data2 = item["url"].encode("utf8")
+                img = "http://serialguru.ru/uploads/cover/"+item["image_s"].replace("_s","")+".jpg"
+                rating = item["rating"].encode("utf8") if item["rating"] else ""
+                desc = title +"\nRating:%s (%s+/%s-)"%(rating,item["plus_cnt"].encode("utf8"),item["minus_cnt"].encode("utf8"))
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+                        
+        elif path=="serials" or path=="tv" or path=="mult":
+            if path=="serials" and not "cat%5B%5D" in data:
+                #content.append(("All", "serialguru::"+data+"&cat%5B%5D=","","All series"))
+                categories = self.get_categories(path)
+                for c in categories:
+                    content.append((c[1], "serialguru::"+data+"&cat%5B%5D="+c[0],"",c[1]))
+                return content
+            else:
+                r = self.call("main/load", params[1:], headers=self.headers2)
+                for item in re.findall('<li><a href="([^"]+)"><div>.*?<img src="([^"]+)" alt="([^"]+)"[^<]*?><p>([^<]+)<i><span class="r">([^<]+)</span> <span class="plus">([^<]+)</span> <span class="minus">([^<]+)</span></i></p></div>([^<]+)</a></li>', r, re.DOTALL):
+                    title = "%s (%s)"%(item[2],item[3])
+                    img = item[1].replace("_s.jpg","_l.jpg")
+                    data2 = item[0].replace(self.url,"")
+                    desc = title +"\nRating:%s (%s+/%s-)"%(item[4],item[5],item[6])
+                    content.append((title,self.name+"::"+data2,img,desc))
+                page=int(re.search("o=(\d+)",data).group(1))
+                data2 = re.sub("o=(\d+)","o=%s"%(page+15),data)
+                content.append(("Next page",self.name+"::"+data2,"","Go to next page"))                 
+                return content
+        
+        
+        ### Pārraide  
+        else:
+            r = self.call(clist)
+            title0=re.search('<h2>(.+?)</h2>',r,re.DOTALL).group(1)
+            m=re.search('<div class="description">(.+?)</div>',r,re.DOTALL)
+            desc0=m.group(1) if m else ""
+            desc0=desc0.replace("<p>","").replace("</p>","\n").replace('<a href="#">ПОКАЗАТЬ ПОЛНОСТЬЮ</a>',"")
+            desc0=title0+"\n"+desc0.strip()
+            img0=""
+            m = re.search("http://serialguru.ru/main/playlist/\d+",r)
+            if m:
+                url = m.group()
+            else:
+                raise Exception ("No stream found")
+            r = self._http_request(url)
+            js = json.loads(r,"utf8")
+            if not "/" in data: # sezonas
+                for i,item in enumerate(js["playlist"]):
+                    title = title0 + " - " + item["comment"].encode("utf8")
+                    img = img0
+                    data2 = "%s/%s"%(data,i)
+                    desc = desc0
+                    content.append((title,self.name+"::"+data2,img,desc))
+            else:
+                snum = int(data.split("/")[1])
+                title1 = js["playlist"][snum]["comment"].encode('utf8')
+                for i,item in enumerate(js["playlist"][snum]["playlist"]):
+                    title = title0 + " - " + title1+"/"+item["comment"].encode("utf8")
+                    img = img0
+                    data2 = item["file"].encode("utf8")
+                    desc = desc0
+                    content.append((title,data2,img,desc))               
+            return content
+ 
+            
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        if "live/view" in data:
+            return True
+        else:
+            return False
+    
+    def get_categories(self,data):
+        r = self.call(data)
+        r2 = re.search('<td class="category">(.+?)</td>', r, re.DOTALL).group(1)
+        items = re.findall(r'<a href="#" data-id="(\d+)">([^<]+)</a>', r2, re.DOTALL)
+        return items
+
+        
+    def call(self, data,params = None, headers=None):
+        if not headers: headers = self.headers
+        #if not lang: lang = self.country
+        url = self.url + data
+        content = self._http_request(url,params, headers)
+        return content
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/swfinterp.py

@@ -0,0 +1,828 @@
+# This code comes from youtube-dl: https://github.com/rg3/youtube-dl/blob/master/youtube_dl/swfinterp.py
+
+from __future__ import unicode_literals
+
+import collections
+import io
+import struct
+import zlib
+
+
+def _extract_tags(file_contents):
+    if file_contents[1:3] != b'WS':
+        print '[SWFInterpreter] Not an SWF file; header is %r' % file_contents[:3]
+    if file_contents[:1] == b'C':
+        content = zlib.decompress(file_contents[8:])
+    else:
+        raise NotImplementedError(
+            'Unsupported compression format %r' %
+            file_contents[:1])
+
+    # Determine number of bits in framesize rectangle
+    framesize_nbits = struct.unpack('!B', content[:1])[0] >> 3
+    framesize_len = (5 + 4 * framesize_nbits + 7) // 8
+
+    pos = framesize_len + 2 + 2
+    while pos < len(content):
+        header16 = struct.unpack('<H', content[pos:pos + 2])[0]
+        pos += 2
+        tag_code = header16 >> 6
+        tag_len = header16 & 0x3f
+        if tag_len == 0x3f:
+            tag_len = struct.unpack('<I', content[pos:pos + 4])[0]
+            pos += 4
+        assert pos + tag_len <= len(content), \
+            ('Tag %d ends at %d+%d - that\'s longer than the file (%d)'
+                % (tag_code, pos, tag_len, len(content)))
+        yield (tag_code, content[pos:pos + tag_len])
+        pos += tag_len
+
+
+class _AVMClass_Object(object):
+    def __init__(self, avm_class):
+        self.avm_class = avm_class
+
+    def __repr__(self):
+        return '%s#%x' % (self.avm_class.name, id(self))
+
+
+class _ScopeDict(dict):
+    def __init__(self, avm_class):
+        super(_ScopeDict, self).__init__()
+        self.avm_class = avm_class
+
+    def __repr__(self):
+        return '%s__Scope(%s)' % (
+            self.avm_class.name,
+            super(_ScopeDict, self).__repr__())
+
+
+class _AVMClass(object):
+    def __init__(self, name_idx, name, static_properties=None):
+        self.name_idx = name_idx
+        self.name = name
+        self.method_names = {}
+        self.method_idxs = {}
+        self.methods = {}
+        self.method_pyfunctions = {}
+        self.static_properties = static_properties if static_properties else {}
+
+        self.variables = _ScopeDict(self)
+        self.constants = {}
+
+    def make_object(self):
+        return _AVMClass_Object(self)
+
+    def __repr__(self):
+        return '_AVMClass(%s)' % (self.name)
+
+    def register_methods(self, methods):
+        self.method_names.update(methods.items())
+        self.method_idxs.update(dict(
+            (idx, name)
+            for name, idx in methods.items()))
+
+
+class _Multiname(object):
+    def __init__(self, kind):
+        self.kind = kind
+
+    def __repr__(self):
+        return '[MULTINAME kind: 0x%x]' % self.kind
+
+
+def _read_int(reader):
+    res = 0
+    shift = 0
+    for _ in range(5):
+        buf = reader.read(1)
+        assert len(buf) == 1
+        b = struct.unpack('<B', buf)[0]
+        res = res | ((b & 0x7f) << shift)
+        if b & 0x80 == 0:
+            break
+        shift += 7
+    return res
+
+
+def _u30(reader):
+    res = _read_int(reader)
+    assert res & 0xf0000000 == 0
+    return res
+_u32 = _read_int
+
+
+def _s32(reader):
+    v = _read_int(reader)
+    if v & 0x80000000 != 0:
+        v = - ((v ^ 0xffffffff) + 1)
+    return v
+
+
+def _s24(reader):
+    bs = reader.read(3)
+    assert len(bs) == 3
+    last_byte = b'\xff' if (ord(bs[2:3]) >= 0x80) else b'\x00'
+    return struct.unpack('<i', bs + last_byte)[0]
+
+
+def _read_string(reader):
+    slen = _u30(reader)
+    resb = reader.read(slen)
+    assert len(resb) == slen
+    return resb.decode('utf-8')
+
+
+def _read_bytes(count, reader):
+    assert count >= 0
+    resb = reader.read(count)
+    assert len(resb) == count
+    return resb
+
+
+def _read_byte(reader):
+    resb = _read_bytes(1, reader=reader)
+    res = struct.unpack('<B', resb)[0]
+    return res
+
+
+StringClass = _AVMClass('(no name idx)', 'String')
+ByteArrayClass = _AVMClass('(no name idx)', 'ByteArray')
+TimerClass = _AVMClass('(no name idx)', 'Timer')
+TimerEventClass = _AVMClass('(no name idx)', 'TimerEvent', {'TIMER': 'timer'})
+_builtin_classes = {
+    StringClass.name: StringClass,
+    ByteArrayClass.name: ByteArrayClass,
+    TimerClass.name: TimerClass,
+    TimerEventClass.name: TimerEventClass,
+}
+
+
+class _Undefined(object):
+    def __bool__(self):
+        return False
+    __nonzero__ = __bool__
+
+    def __hash__(self):
+        return 0
+
+    def __str__(self):
+        return 'undefined'
+    __repr__ = __str__
+
+undefined = _Undefined()
+
+
+class SWFInterpreter(object):
+    def __init__(self, file_contents):
+        self._patched_functions = {
+            (TimerClass, 'addEventListener'): lambda params: undefined,
+        }
+        code_tag = next(tag
+                        for tag_code, tag in _extract_tags(file_contents)
+                        if tag_code == 82)
+        p = code_tag.index(b'\0', 4) + 1
+        code_reader = io.BytesIO(code_tag[p:])
+
+        # Parse ABC (AVM2 ByteCode)
+
+        # Define a couple convenience methods
+        u30 = lambda *args: _u30(*args, reader=code_reader)
+        s32 = lambda *args: _s32(*args, reader=code_reader)
+        u32 = lambda *args: _u32(*args, reader=code_reader)
+        read_bytes = lambda *args: _read_bytes(*args, reader=code_reader)
+        read_byte = lambda *args: _read_byte(*args, reader=code_reader)
+
+        # minor_version + major_version
+        read_bytes(2 + 2)
+
+        # Constant pool
+        int_count = u30()
+        self.constant_ints = [0]
+        for _c in range(1, int_count):
+            self.constant_ints.append(s32())
+        self.constant_uints = [0]
+        uint_count = u30()
+        for _c in range(1, uint_count):
+            self.constant_uints.append(u32())
+        double_count = u30()
+        read_bytes(max(0, (double_count - 1)) * 8)
+        string_count = u30()
+        self.constant_strings = ['']
+        for _c in range(1, string_count):
+            s = _read_string(code_reader)
+            self.constant_strings.append(s)
+        namespace_count = u30()
+        for _c in range(1, namespace_count):
+            read_bytes(1)  # kind
+            u30()  # name
+        ns_set_count = u30()
+        for _c in range(1, ns_set_count):
+            count = u30()
+            for _c2 in range(count):
+                u30()
+        multiname_count = u30()
+        MULTINAME_SIZES = {
+            0x07: 2,  # QName
+            0x0d: 2,  # QNameA
+            0x0f: 1,  # RTQName
+            0x10: 1,  # RTQNameA
+            0x11: 0,  # RTQNameL
+            0x12: 0,  # RTQNameLA
+            0x09: 2,  # Multiname
+            0x0e: 2,  # MultinameA
+            0x1b: 1,  # MultinameL
+            0x1c: 1,  # MultinameLA
+        }
+        self.multinames = ['']
+        for _c in range(1, multiname_count):
+            kind = u30()
+            assert kind in MULTINAME_SIZES, 'Invalid multiname kind %r' % kind
+            if kind == 0x07:
+                u30()  # namespace_idx
+                name_idx = u30()
+                self.multinames.append(self.constant_strings[name_idx])
+            elif kind == 0x09:
+                name_idx = u30()
+                u30()
+                self.multinames.append(self.constant_strings[name_idx])
+            else:
+                self.multinames.append(_Multiname(kind))
+                for _c2 in range(MULTINAME_SIZES[kind]):
+                    u30()
+
+        # Methods
+        method_count = u30()
+        MethodInfo = collections.namedtuple(
+            'MethodInfo',
+            ['NEED_ARGUMENTS', 'NEED_REST'])
+        method_infos = []
+        for method_id in range(method_count):
+            param_count = u30()
+            u30()  # return type
+            for _ in range(param_count):
+                u30()  # param type
+            u30()  # name index (always 0 for youtube)
+            flags = read_byte()
+            if flags & 0x08 != 0:
+                # Options present
+                option_count = u30()
+                for c in range(option_count):
+                    u30()  # val
+                    read_bytes(1)  # kind
+            if flags & 0x80 != 0:
+                # Param names present
+                for _ in range(param_count):
+                    u30()  # param name
+            mi = MethodInfo(flags & 0x01 != 0, flags & 0x04 != 0)
+            method_infos.append(mi)
+
+        # Metadata
+        metadata_count = u30()
+        for _c in range(metadata_count):
+            u30()  # name
+            item_count = u30()
+            for _c2 in range(item_count):
+                u30()  # key
+                u30()  # value
+
+        def parse_traits_info():
+            trait_name_idx = u30()
+            kind_full = read_byte()
+            kind = kind_full & 0x0f
+            attrs = kind_full >> 4
+            methods = {}
+            constants = None
+            if kind == 0x00:  # Slot
+                u30()  # Slot id
+                u30()  # type_name_idx
+                vindex = u30()
+                if vindex != 0:
+                    read_byte()  # vkind
+            elif kind == 0x06:  # Const
+                u30()  # Slot id
+                u30()  # type_name_idx
+                vindex = u30()
+                vkind = 'any'
+                if vindex != 0:
+                    vkind = read_byte()
+                if vkind == 0x03:  # Constant_Int
+                    value = self.constant_ints[vindex]
+                elif vkind == 0x04:  # Constant_UInt
+                    value = self.constant_uints[vindex]
+                else:
+                    return {}, None  # Ignore silently for now
+                constants = {self.multinames[trait_name_idx]: value}
+            elif kind in (0x01, 0x02, 0x03):  # Method / Getter / Setter
+                u30()  # disp_id
+                method_idx = u30()
+                methods[self.multinames[trait_name_idx]] = method_idx
+            elif kind == 0x04:  # Class
+                u30()  # slot_id
+                u30()  # classi
+            elif kind == 0x05:  # Function
+                u30()  # slot_id
+                function_idx = u30()
+                methods[function_idx] = self.multinames[trait_name_idx]
+            else:
+                print '[SWFInterpreter] Unsupported trait kind %d' % kind
+                return None
+
+            if attrs & 0x4 != 0:  # Metadata present
+                metadata_count = u30()
+                for _c3 in range(metadata_count):
+                    u30()  # metadata index
+
+            return methods, constants
+
+        # Classes
+        class_count = u30()
+        classes = []
+        for class_id in range(class_count):
+            name_idx = u30()
+
+            cname = self.multinames[name_idx]
+            avm_class = _AVMClass(name_idx, cname)
+            classes.append(avm_class)
+
+            u30()  # super_name idx
+            flags = read_byte()
+            if flags & 0x08 != 0:  # Protected namespace is present
+                u30()  # protected_ns_idx
+            intrf_count = u30()
+            for _c2 in range(intrf_count):
+                u30()
+            u30()  # iinit
+            trait_count = u30()
+            for _c2 in range(trait_count):
+                trait_methods, trait_constants = parse_traits_info()
+                avm_class.register_methods(trait_methods)
+                if trait_constants:
+                    avm_class.constants.update(trait_constants)
+
+        assert len(classes) == class_count
+        self._classes_by_name = dict((c.name, c) for c in classes)
+
+        for avm_class in classes:
+            avm_class.cinit_idx = u30()
+            trait_count = u30()
+            for _c2 in range(trait_count):
+                trait_methods, trait_constants = parse_traits_info()
+                avm_class.register_methods(trait_methods)
+                if trait_constants:
+                    avm_class.constants.update(trait_constants)
+
+        # Scripts
+        script_count = u30()
+        for _c in range(script_count):
+            u30()  # init
+            trait_count = u30()
+            for _c2 in range(trait_count):
+                parse_traits_info()
+
+        # Method bodies
+        method_body_count = u30()
+        Method = collections.namedtuple('Method', ['code', 'local_count'])
+        self._all_methods = []
+        for _c in range(method_body_count):
+            method_idx = u30()
+            u30()  # max_stack
+            local_count = u30()
+            u30()  # init_scope_depth
+            u30()  # max_scope_depth
+            code_length = u30()
+            code = read_bytes(code_length)
+            m = Method(code, local_count)
+            self._all_methods.append(m)
+            for avm_class in classes:
+                if method_idx in avm_class.method_idxs:
+                    avm_class.methods[avm_class.method_idxs[method_idx]] = m
+            exception_count = u30()
+            for _c2 in range(exception_count):
+                u30()  # from
+                u30()  # to
+                u30()  # target
+                u30()  # exc_type
+                u30()  # var_name
+            trait_count = u30()
+            for _c2 in range(trait_count):
+                parse_traits_info()
+
+        assert p + code_reader.tell() == len(code_tag)
+
+    def patch_function(self, avm_class, func_name, f):
+        self._patched_functions[(avm_class, func_name)] = f
+
+    def extract_class(self, class_name, call_cinit=True):
+        try:
+            res = self._classes_by_name[class_name]
+        except KeyError:
+            print '[SWFInterpreter] Class %r not found' % class_name
+            return None
+
+        if call_cinit and hasattr(res, 'cinit_idx'):
+            res.register_methods({'$cinit': res.cinit_idx})
+            res.methods['$cinit'] = self._all_methods[res.cinit_idx]
+            cinit = self.extract_function(res, '$cinit')
+            cinit([])
+
+        return res
+
+    def extract_function(self, avm_class, func_name):
+        p = self._patched_functions.get((avm_class, func_name))
+        if p:
+            return p
+        if func_name in avm_class.method_pyfunctions:
+            return avm_class.method_pyfunctions[func_name]
+        if func_name in self._classes_by_name:
+            return self._classes_by_name[func_name].make_object()
+        if func_name not in avm_class.methods:
+            print '[SWFInterpreter] Cannot find function %s.%s' % (
+                avm_class.name, func_name)
+            return None
+        m = avm_class.methods[func_name]
+
+        def resfunc(args):
+            # Helper functions
+            coder = io.BytesIO(m.code)
+            s24 = lambda: _s24(coder)
+            u30 = lambda: _u30(coder)
+
+            registers = [avm_class.variables] + list(args) + [None] * m.local_count
+            stack = []
+            scopes = collections.deque([
+                self._classes_by_name, avm_class.constants, avm_class.variables])
+            while True:
+                opcode = _read_byte(coder)
+                if opcode == 9:  # label
+                    pass  # Spec says: "Do nothing."
+                elif opcode == 16:  # jump
+                    offset = s24()
+                    coder.seek(coder.tell() + offset)
+                elif opcode == 17:  # iftrue
+                    offset = s24()
+                    value = stack.pop()
+                    if value:
+                        coder.seek(coder.tell() + offset)
+                elif opcode == 18:  # iffalse
+                    offset = s24()
+                    value = stack.pop()
+                    if not value:
+                        coder.seek(coder.tell() + offset)
+                elif opcode == 19:  # ifeq
+                    offset = s24()
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    if value2 == value1:
+                        coder.seek(coder.tell() + offset)
+                elif opcode == 20:  # ifne
+                    offset = s24()
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    if value2 != value1:
+                        coder.seek(coder.tell() + offset)
+                elif opcode == 21:  # iflt
+                    offset = s24()
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    if value1 < value2:
+                        coder.seek(coder.tell() + offset)
+                elif opcode == 32:  # pushnull
+                    stack.append(None)
+                elif opcode == 33:  # pushundefined
+                    stack.append(undefined)
+                elif opcode == 36:  # pushbyte
+                    v = _read_byte(coder)
+                    stack.append(v)
+                elif opcode == 37:  # pushshort
+                    v = u30()
+                    stack.append(v)
+                elif opcode == 38:  # pushtrue
+                    stack.append(True)
+                elif opcode == 39:  # pushfalse
+                    stack.append(False)
+                elif opcode == 40:  # pushnan
+                    stack.append(float('NaN'))
+                elif opcode == 42:  # dup
+                    value = stack[-1]
+                    stack.append(value)
+                elif opcode == 44:  # pushstring
+                    idx = u30()
+                    stack.append(self.constant_strings[idx])
+                elif opcode == 48:  # pushscope
+                    new_scope = stack.pop()
+                    scopes.append(new_scope)
+                elif opcode == 66:  # construct
+                    arg_count = u30()
+                    args = list(reversed(
+                        [stack.pop() for _ in range(arg_count)]))
+                    obj = stack.pop()
+                    res = obj.avm_class.make_object()
+                    stack.append(res)
+                elif opcode == 70:  # callproperty
+                    index = u30()
+                    mname = self.multinames[index]
+                    arg_count = u30()
+                    args = list(reversed(
+                        [stack.pop() for _ in range(arg_count)]))
+                    obj = stack.pop()
+
+                    if obj == StringClass:
+                        if mname == 'String':
+                            assert len(args) == 1
+                            assert isinstance(args[0], (
+                                int, unicode, _Undefined))
+                            if args[0] == undefined:
+                                res = 'undefined'
+                            else:
+                                res = unicode(args[0])
+                            stack.append(res)
+                            continue
+                        else:
+                            raise NotImplementedError(
+                                'Function String.%s is not yet implemented'
+                                % mname)
+                    elif isinstance(obj, _AVMClass_Object):
+                        func = self.extract_function(obj.avm_class, mname)
+                        res = func(args)
+                        stack.append(res)
+                        continue
+                    elif isinstance(obj, _AVMClass):
+                        func = self.extract_function(obj, mname)
+                        res = func(args)
+                        stack.append(res)
+                        continue
+                    elif isinstance(obj, _ScopeDict):
+                        if mname in obj.avm_class.method_names:
+                            func = self.extract_function(obj.avm_class, mname)
+                            res = func(args)
+                        else:
+                            res = obj[mname]
+                        stack.append(res)
+                        continue
+                    elif isinstance(obj, unicode):
+                        if mname == 'split':
+                            assert len(args) == 1
+                            assert isinstance(args[0], unicode)
+                            if args[0] == '':
+                                res = list(obj)
+                            else:
+                                res = obj.split(args[0])
+                            stack.append(res)
+                            continue
+                        elif mname == 'charCodeAt':
+                            assert len(args) <= 1
+                            idx = 0 if len(args) == 0 else args[0]
+                            assert isinstance(idx, int)
+                            res = ord(obj[idx])
+                            stack.append(res)
+                            continue
+                    elif isinstance(obj, list):
+                        if mname == 'slice':
+                            assert len(args) == 1
+                            assert isinstance(args[0], int)
+                            res = obj[args[0]:]
+                            stack.append(res)
+                            continue
+                        elif mname == 'join':
+                            assert len(args) == 1
+                            assert isinstance(args[0], unicode)
+                            res = args[0].join(obj)
+                            stack.append(res)
+                            continue
+                    raise NotImplementedError(
+                        'Unsupported property %r on %r'
+                        % (mname, obj))
+                elif opcode == 71:  # returnvoid
+                    res = undefined
+                    return res
+                elif opcode == 72:  # returnvalue
+                    res = stack.pop()
+                    return res
+                elif opcode == 73:  # constructsuper
+                    # Not yet implemented, just hope it works without it
+                    arg_count = u30()
+                    args = list(reversed(
+                        [stack.pop() for _ in range(arg_count)]))
+                    obj = stack.pop()
+                elif opcode == 74:  # constructproperty
+                    index = u30()
+                    arg_count = u30()
+                    args = list(reversed(
+                        [stack.pop() for _ in range(arg_count)]))
+                    obj = stack.pop()
+
+                    mname = self.multinames[index]
+                    assert isinstance(obj, _AVMClass)
+
+                    # We do not actually call the constructor for now;
+                    # we just pretend it does nothing
+                    stack.append(obj.make_object())
+                elif opcode == 79:  # callpropvoid
+                    index = u30()
+                    mname = self.multinames[index]
+                    arg_count = u30()
+                    args = list(reversed(
+                        [stack.pop() for _ in range(arg_count)]))
+                    obj = stack.pop()
+                    if isinstance(obj, _AVMClass_Object):
+                        func = self.extract_function(obj.avm_class, mname)
+                        res = func(args)
+                        assert res is undefined
+                        continue
+                    if isinstance(obj, _ScopeDict):
+                        assert mname in obj.avm_class.method_names
+                        func = self.extract_function(obj.avm_class, mname)
+                        res = func(args)
+                        assert res is undefined
+                        continue
+                    if mname == 'reverse':
+                        assert isinstance(obj, list)
+                        obj.reverse()
+                    else:
+                        raise NotImplementedError(
+                            'Unsupported (void) property %r on %r'
+                            % (mname, obj))
+                elif opcode == 86:  # newarray
+                    arg_count = u30()
+                    arr = []
+                    for i in range(arg_count):
+                        arr.append(stack.pop())
+                    arr = arr[::-1]
+                    stack.append(arr)
+                elif opcode == 93:  # findpropstrict
+                    index = u30()
+                    mname = self.multinames[index]
+                    for s in reversed(scopes):
+                        if mname in s:
+                            res = s
+                            break
+                    else:
+                        res = scopes[0]
+                    if mname not in res and mname in _builtin_classes:
+                        stack.append(_builtin_classes[mname])
+                    else:
+                        stack.append(res[mname])
+                elif opcode == 94:  # findproperty
+                    index = u30()
+                    mname = self.multinames[index]
+                    for s in reversed(scopes):
+                        if mname in s:
+                            res = s
+                            break
+                    else:
+                        res = avm_class.variables
+                    stack.append(res)
+                elif opcode == 96:  # getlex
+                    index = u30()
+                    mname = self.multinames[index]
+                    for s in reversed(scopes):
+                        if mname in s:
+                            scope = s
+                            break
+                    else:
+                        scope = avm_class.variables
+
+                    if mname in scope:
+                        res = scope[mname]
+                    elif mname in _builtin_classes:
+                        res = _builtin_classes[mname]
+                    else:
+                        # Assume unitialized
+                        # TODO warn here
+                        res = undefined
+                    stack.append(res)
+                elif opcode == 97:  # setproperty
+                    index = u30()
+                    value = stack.pop()
+                    idx = self.multinames[index]
+                    if isinstance(idx, _Multiname):
+                        idx = stack.pop()
+                    obj = stack.pop()
+                    obj[idx] = value
+                elif opcode == 98:  # getlocal
+                    index = u30()
+                    stack.append(registers[index])
+                elif opcode == 99:  # setlocal
+                    index = u30()
+                    value = stack.pop()
+                    registers[index] = value
+                elif opcode == 102:  # getproperty
+                    index = u30()
+                    pname = self.multinames[index]
+                    if pname == 'length':
+                        obj = stack.pop()
+                        assert isinstance(obj, (unicode, list))
+                        stack.append(len(obj))
+                    elif isinstance(pname, unicode):  # Member access
+                        obj = stack.pop()
+                        if isinstance(obj, _AVMClass):
+                            res = obj.static_properties[pname]
+                            stack.append(res)
+                            continue
+
+                        assert isinstance(obj, (dict, _ScopeDict)),\
+                            'Accessing member %r on %r' % (pname, obj)
+                        res = obj.get(pname, undefined)
+                        stack.append(res)
+                    else:  # Assume attribute access
+                        idx = stack.pop()
+                        assert isinstance(idx, int)
+                        obj = stack.pop()
+                        assert isinstance(obj, list)
+                        stack.append(obj[idx])
+                elif opcode == 104:  # initproperty
+                    index = u30()
+                    value = stack.pop()
+                    idx = self.multinames[index]
+                    if isinstance(idx, _Multiname):
+                        idx = stack.pop()
+                    obj = stack.pop()
+                    obj[idx] = value
+                elif opcode == 115:  # convert_
+                    value = stack.pop()
+                    intvalue = int(value)
+                    stack.append(intvalue)
+                elif opcode == 128:  # coerce
+                    u30()
+                elif opcode == 130:  # coerce_a
+                    value = stack.pop()
+                    # um, yes, it's any value
+                    stack.append(value)
+                elif opcode == 133:  # coerce_s
+                    assert isinstance(stack[-1], (type(None), unicode))
+                elif opcode == 147:  # decrement
+                    value = stack.pop()
+                    assert isinstance(value, int)
+                    stack.append(value - 1)
+                elif opcode == 149:  # typeof
+                    value = stack.pop()
+                    return {
+                        _Undefined: 'undefined',
+                        unicode: 'String',
+                        int: 'Number',
+                        float: 'Number',
+                    }[type(value)]
+                elif opcode == 160:  # add
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    res = value1 + value2
+                    stack.append(res)
+                elif opcode == 161:  # subtract
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    res = value1 - value2
+                    stack.append(res)
+                elif opcode == 162:  # multiply
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    res = value1 * value2
+                    stack.append(res)
+                elif opcode == 164:  # modulo
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    res = value1 % value2
+                    stack.append(res)
+                elif opcode == 168:  # bitand
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    assert isinstance(value1, int)
+                    assert isinstance(value2, int)
+                    res = value1 & value2
+                    stack.append(res)
+                elif opcode == 171:  # equals
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    result = value1 == value2
+                    stack.append(result)
+                elif opcode == 175:  # greaterequals
+                    value2 = stack.pop()
+                    value1 = stack.pop()
+                    result = value1 >= value2
+                    stack.append(result)
+                elif opcode == 192:  # increment_i
+                    value = stack.pop()
+                    assert isinstance(value, int)
+                    stack.append(value + 1)
+                elif opcode == 208:  # getlocal_0
+                    stack.append(registers[0])
+                elif opcode == 209:  # getlocal_1
+                    stack.append(registers[1])
+                elif opcode == 210:  # getlocal_2
+                    stack.append(registers[2])
+                elif opcode == 211:  # getlocal_3
+                    stack.append(registers[3])
+                elif opcode == 212:  # setlocal_0
+                    registers[0] = stack.pop()
+                elif opcode == 213:  # setlocal_1
+                    registers[1] = stack.pop()
+                elif opcode == 214:  # setlocal_2
+                    registers[2] = stack.pop()
+                elif opcode == 215:  # setlocal_3
+                    registers[3] = stack.pop()
+                else:
+                    raise NotImplementedError(
+                        'Unsupported opcode %d' % opcode)
+
+        avm_class.method_pyfunctions[func_name] = resfunc
+        return resfunc

sources/tvdom.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys,os
+from collections import OrderedDict
+from SourceBase import SourceBase
+
+API_URL = 'http://replay.lsm.lv/'
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Linux; U; Android 4.4.4; Nexus 5 Build/KTU84P) AppleWebkit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self,country="lv"):
+        self.name = "tvdom"
+        self.title = "TVDom.tv"
+        self.img = "https://tvdom.tv/front/assets/images/logo.png"
+        self.desc = "TVDom.tv portāla satura skatīšanās"
+        self.headers = headers0
+
+        self.country=country
+        self.session = None
+        self.token = None
+
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        self.options = OrderedDict([("user","lietotajs"),("password","parole")])
+        self.options_read()
+
+    def login(self,user="",password=""):
+        self.options_read()        
+        if not user: user=self.options["user"]
+        if not password: password = self.options["password"]
+        headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0
+Accept: */*
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: gzip, deflate, br
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Requested-With: XMLHttpRequest
+Referer: https://tvdom.tv/
+        """)
+        url = "https://tvdom.tv/infinity/on_register_user"
+        params = "email=%s&password=%s&remember=false&auth_type=login"%(user,password)
+        import requests
+        r = requests.post(url, data=params, headers=headers)	
+        js = json.loads(r.content)
+        if 'success' in r.content:
+            self.token = js["access_token"] 
+            if 'PHPSESSID' in r.cookies:
+                self.session = r.cookies["PHPSESSID"]
+            return True
+        else:
+            raise Exception(js["error"])
+
+
+    def get_content(self, data):
+        print "[tvdom] get_content:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        lang = qs["lang"] if "lang" in qs else self.country
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Live stream", "tvdom::tiesraides","","TV live streams"),
+                ("Archive - categories", "tvdom::arhivs","","Video archive by categories"),
+                ("Search", "tvdom::search/?srch-term={0}","","Search archive"),
+
+                #("Archive - all", "tvdom::arhivs_all","","Video archive all"),
+            ])
+            return content
+
+        ### Tiesraides kanalu saraksts ###
+        elif data=="tiesraides":
+            ch_name = {"49":"Дом Кино","50":"Карусель","51":"Время","52":"Музыка Первого","53":"Телекафе"}
+            url = "https://tvdom.tv/"
+            r = self._http_request(url)
+            #channels1 = re.findall(r'data-xprs_status="\d" data-href="/tiesraides/([^/]+)/[^"]+">.+?src="([^"]+)" alt="([^"]+)">', r, re.DOTALL)
+            channels2 = re.findall(r'<a class="channel-name">([^<]*)</a>\s+<div class="redirect-to-url" data-href="/tiesraides/([^/]+)/[^"]+">.+?<img style="width:100%;" src="([^"]+)".+?<h3>([^<]+)</h3>.+?<p class="unix">([^<]+)</p>', r, re.DOTALL)
+            channels = {}
+            for item in channels2:
+                title = item[0]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = "https://tvdom.tv"+item[2]
+                data2 = "tiesraides/%s/"%item[1]
+                desc = "%s\n%s\n%s"%(title,item[3],item[4])		    
+                channels[item[1]]={"title":title,"img":img,"desc":desc}
+                #content.append((title,self.name+"::"+data2,img,desc))
+
+            for r2 in re.findall(r'<div class="thumbnail-menu pull-left updater"(.+?)</div>\s+</div>', r, re.DOTALL):
+                ch = re.search('data-href="/tiesraides/([^/]+)/[^"]+"', r2, re.DOTALL).group(1)
+                data2 = "tiesraides/"+ch
+                m = re.search('src="(.+?)" alt="(.+?)">', r2, re.DOTALL)
+                title = m.group(2)
+                img = m.group(1)
+                desc = title
+                if ch in channels:
+                    img = channels[ch]["img"]
+                    desc = channels[ch]["desc"]
+                else:
+                    m = re.search('<img src="([^"]+)" alt="aaaaaa([^"]+)"><h3>.+<p class="unix">([^<]+)</p>', r2, re.DOTALL)
+                    if m:
+                        desc  = "%s\n%s\n%s"%(title,m.group(1),m.group(3))
+                        img = m.group(2)
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        elif clist == "tiesraides":
+            if not self.session:
+                self.login()
+            url = "https://tvdom.tv/" + data
+            headers = self.headers
+            headers["Cookie"] = "PHPSESSID=%s; neverending_story=1;"%self.session
+            r = self._http_request(url,headers=headers)
+            m = re.search("var streamConnectionUrl = '([^']+)'", r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+            else:
+                return ("No stream found %s"%data,"","","No stream found")
+            m = re.search('title: "([^"]+)"', r, re.DOTALL)
+            title = m.group(1) if m else data2
+            m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
+            desc = m.group(1) if m else title
+            m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
+            desc = m.group(1) if m else title 
+            m = re.search('var promo_image *= "([^"]+)', r, re.DOTALL)
+            img = m.group(1) if m else ""            
+            return (title,data2,img,desc)
+
+        ### Search ###
+        elif clist=="search":
+            url = "https://tvdom.tv/" + data
+            r = self._http_request(url)
+            for item in re.findall(r'<li data-xprs-search="\d+" data-href="([^"]+)".*?<img class="img-responsive" src="([^"]+)".*?<h3>([^<]+)</h3>.*?<h5>([^<]+)</h5>', r, re.DOTALL):
+                title = item[2] + " "+ item[3]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = "https://tvdom.tv" + item[1]
+                data2 = item[0][1:]
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Arhīva kategorijas ###
+        elif data=="arhivs":
+            url = "https://tvdom.tv/"+data
+            r = self._http_request(url)
+            for item in re.findall('pointer" href="/([^"]+)">([^<]+)</a>', r, re.DOTALL):
+                title = item[1]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = ""
+                data2 = item[0]
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Arhīva kategorijas programmas ###
+        elif clist=="arhivs":
+            url = "https://tvdom.tv/"+data
+            r = self._http_request(url)
+            for item in re.findall(r"""<li><div class="thumbnail pull-left" onclick="location\.href='([^']+)'" data-toggle="popover" title="([^"]+)" data-content="([^"]*)".+?<img class="img-responsive archive-image" src="([^"]+)""", r, re.DOTALL):
+            #for item in re.findall(r"""<li><div class="thumbnail pull-left" onclick="location\.href='([^']+)'" data-toggle="popover" title="([^"]+)" data-content="([^"]+)".+?<img class="img-responsive archive-image" src="([^"]+)""", r, re.DOTALL):
+                title = item[1].replace("&lt;br&gt;"," - ")
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = "https://tvdom.tv"+item[3]
+                data2 = item[0][1:]
+                desc = item[2]
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Arhīva programmas video saraksts ###
+        elif clist=="play_arhivs" and len(data.split("/"))==3 and not re.search("_\d+",plist[2]):
+            url = "https://tvdom.tv/"+data
+            r = self._http_request(url)
+            vid=re.search(r"id:(\d+), type: type", r, re.DOTALL).group(1)
+            data2 = data+"_"+vid
+            m = re.search('program_title        = "([^"]+)"', r, re.DOTALL)
+            title = m.group(1) if m else data2
+            m = re.search('<a class="episode">Pārraides laiks ēterā: <span>([^<]+)</span></a>', r, re.DOTALL)
+            datums = m.group(1) if m else ""
+            title = title + " " + datums
+            m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
+            desc = m.group(1) if m else title
+            m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
+            desc = m.group(1) if m else title 
+            m = re.search('var share_image *= "([^"]+)', r, re.DOTALL)
+            img = m.group(1) if m else ""            
+            content.append((title,self.name+"::"+data2,img,desc)) 
+            i = r.find('<span class="slider-top-title"')
+            if i>0: r = r[:i]
+            for item in re.findall('<div class="col-md-9 redirect-to-url same-event" data-href="/([^"]+)">.+?image" src="([^"]+)".+?<h3 class="same-title">([^<]+)</h3>.*?<h5 class="same-online">([^<]+)</h5>', r, re.DOTALL):
+                title = item[2] + " " + item[3]
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = "https://tvdom.tv"+item[1]
+                data2 = item[0]
+                desc = title # TODO
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Arhīva video
+        elif clist=="play_arhivs" and len(data.split("/"))==3 and re.search("_\d+",plist[2]):
+            url = "https://tvdom.tv/" + data
+            headers = self.headers
+            headers["Cookie"] = "PHPSESSID=%s; neverending_story=1;"%self.session
+            r = self._http_request(url,headers=headers)
+            m = re.search('var streamConnectionUrl  = "([^"]+)"', r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+            else:
+                return ("No stream found %s"%data,"","","No stream found")
+            m = re.search('program_title        = "([^"]+)"', r, re.DOTALL)
+            title = m.group(1) if m else data2
+            m = re.search('<a class="episode">Pārraides laiks ēterā: <span>([^<]+)</span></a>', r, re.DOTALL)
+            datums = m.group(1) if m else ""
+            title = title + " " + datums
+            m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
+            desc = m.group(1) if m else title
+            m = re.search('<div id="panel">([^<]+)<', r, re.DOTALL)
+            desc = m.group(1) if m else title 
+            m = re.search('var share_image *= "([^"]+)', r, re.DOTALL)
+            img = m.group(1) if m else ""            
+            return (title,data2,img,desc)
+
+
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        cmd = data.split("/")
+        if cmd[0] in ("tiesraides") and len(cmd)>1:
+            return True
+        elif cmd[0]=="play_arhivs" and len(cmd)==3 and re.search("_\d+",plist[2]):
+            return True
+        else:
+            return False
+
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = API_URL%lang + data
+        #print "[TVPlay Api] url: ",url
+        result = []
+        content = self._http_request(url)
+        return content
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/ustvnow.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import urllib2, urllib
+import datetime, re, sys,os
+from collections import OrderedDict
+from SourceBase import SourceBase
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+Host: m-api.ustvnow.com
+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
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+DNT: 1
+Connection: keep-alive
+""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self,country="lv"):
+        self.name = "ustvnow"
+        self.title = "USTVNow"
+        self.img = "http://watch.ustvnow.com/assets/ustvnow/img/ustvnow_og_image.png"
+        self.desc = "USTVNow kanālu tiešraide"
+        self.headers = headers0
+
+        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")
+        self.options = OrderedDict([("user","lietotajs"),("password","parole")])
+        self.options_read()
+
+    def login(self,user="",password=""):
+        if not user: user=self.options["user"]
+        if not password: password = self.options["password"]
+        self.options_read()        
+        headers = headers2dict("""
+        Host: m-api.ustvnow.com
+        Accept-Language: en-US,en;q=0.5
+        User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0
+        Accept: text/html,application/xhtml+xml,application/xml
+        Connection: keep-alive
+        """)
+
+        url = "http://m-api.ustvnow.com/iphone/1/live/login?username=%s&password=%s&device=gtv&redir=0"%(user,password)
+        r = self._http_request(url,headers)
+        if 'success' in r:
+            self.token = re.search('"token":"([^"]+)',r).group(1)
+            return True
+        else:
+            return False
+
+    def get_content(self, data):
+        print "[tvdom] get_content:", data
+        if "::" in data:
+            data = data.split("::")[1] 
+        path = data.split("?")[0]
+        clist = path.split("/")[0]
+        params = data[data.find("?"):] if "?" in data else ""
+        qs = dict(map(lambda x:x.split("="),re.findall("\w+=\w+",params)))
+        lang = qs["lang"] if "lang" in qs else self.country
+
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("TV live streams", "ustvnow::tvlive","","TV live streams"),
+                ("Movies", "ustvnow::movies","","Movies (not implemented yet"),
+                ("Recordings", "ustvnow::recordings","","Recordings (not implemented yet"),
+            ])
+            return content
+
+        if clist=="movies":
+            return content
+
+        if clist=="recordings":
+            return content
+
+        ### Tiesraides kanalu saraksts ###
+        elif data=="tvlive":
+            if not self.token:
+                if not self.login():
+                    raise Exception("Can not login\nPlease check USTVNow username/password in\n/usr/lib/enigma2/python/Plugins/Extensions/sources/ustvnow.cfg file")
+            data = "live/channelguide?token=%s"%self.token
+            self.r = self.call(data)
+            if not self.r:
+                return content
+            for item in self.r["results"]:
+                if item["order"] == 1:    
+                    title = item["stream_code"]
+                    title =  h.unescape(title.decode("utf8")).encode("utf8")
+                    img = "http://m-api.ustvnow.com/"+item["prg_img"] #item["img"]
+                    data2 = "live/view?scode=%s&token=%s"%(item["scode"],self.token)
+                    desc = "%s\n%s (+%s')\n%s"%(item["title"],item["event_time"],int(item["actualremainingtime"])/60,item["description"])
+                    content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Tiesraides kanāls ###
+        elif path == "live/view":
+            url = "http://m-api.ustvnow.com/stream/1/%s"%data
+            r = self._http_request(url)
+            if not r:
+                return ("No stream found %s"%data,"","","No stream found")
+            r = json.loads(r)
+            if self.r:
+                ch = qs["scode"]
+                for item in self.r["results"]:
+                    if item["order"] == 1 and item["scode"] == ch:
+                        title = item["stream_code"]
+                        title = "%s - %s (%s)"%(item["stream_code"],item["title"],item["event_time"])
+                        img = "http://m-api.ustvnow.com/"+item["prg_img"]
+                        data2 = "live/view?scode=%s&token=%s"%(item["scode"],self.token)
+                        desc = "%s\n%s (+%s')\n%s"%(item["title"],item["event_time"],int(item["actualremainingtime"])/60,item["description"])
+            else:
+                title = data
+            data2 = r["stream"]
+            desc = title
+            img = ""          
+            return (title,data2,img,desc)               
+
+    def is_video(self,data):
+        if "::" in data:
+            data = data.split("::")[1]
+        if "live/view" in data:
+            return True
+        else:
+            return False
+
+    def call(self, data,headers=headers0,lang=""):
+        if not lang: lang = self.country
+        url = "http://m-api.ustvnow.com/gtv/1/"+data
+        content = self._http_request(url)
+        result = None
+        if content:
+            try:
+                result = json.loads(content)
+            except Exception, ex:
+                return None
+        return result
+
+
+if __name__ == "__main__":
+    country= "lv"
+    c = Source(country)
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "home"
+    content = c.get_content(data)
+    for item in content:
+        print item
+    #cat = api.get_categories(country)
+    #chan = api.get_channels("lv")
+    #prog = api.get_programs(channel=6400)
+    #prog = api.get_programs(category=55)
+    #seas = api.get_seasons(program=6453)
+    #str = api.get_streams(660243)
+    #res = api.get_videos(802)
+    #formats = api.getAllFormats()
+    #det = api.detailed("1516")
+    #vid = api.getVideos("13170")
+    pass

sources/viaplay.py

@@ -0,0 +1,477 @@
+#!/usr/bin/env python
+# coding=utf8
+#
+# This file is part of PlayStream - enigma2 plugin to play video streams from various sources
+# Copyright (c) 2016 ivars777 (ivars777@gmail.com)
+# Distributed under the GNU GPL v3. For full terms see http://www.gnu.org/licenses/gpl-3.0.en.html
+#
+try:
+    import json
+except:
+    import simplejson as json
+
+import requests, urlparse, urllib
+import datetime, time,re, sys,os
+from collections import OrderedDict
+from SourceBase import SourceBase
+try:
+    import util
+except:
+    parent = os.path.dirname(os.path.abspath(__file__))
+    parent = os.sep.join(parent.split(os.sep)[:-1])
+    sys.path.insert(0,parent)
+    import util
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+    
+class Source(SourceBase):
+    
+    def __init__(self,language="en"):
+        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.desc = "Viaplay.lv saturs"
+        self.url = "https://viaplay.lv/"
+        self.headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Connection: keep-alive
+Upgrade-Insecure-Requests: 1
+        """)
+        #self.language=language
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        self.config_file = os.path.join(cur_directory,self.name+".cfg")
+        self.options = OrderedDict([("user","change_user"),("password","change_password"),("device","")])
+        self.options_read()
+        self.device = self.options["device"]
+        self.r = None # requests
+        self.play_session = None
+        self.s = None
+        
+    def login(self,user="",password=""):
+        self.options_read()
+        if not user: user=self.options["user"]
+        if not password: password = self.options["password"]
+        self.s = requests.Session()
+        
+        ### Dabu sesijas ID ===
+        headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: gzip, deflate, br
+Referer: https://viaplay.lv/
+Cookie: ott_cookies_confirmed=1; 
+DNT: 1
+Connection: keep-alive
+Upgrade-Insecure-Requests: 1
+""")   
+        r = requests.get(self.url,headers=headers)
+        if not "PLAY_SESSION" in r.cookies:
+            return False
+        self.play_session = r.cookies["PLAY_SESSION"]
+        self.csrfToken = re.search("csrfToken=(.+)",self.play_session).group(1)
+        
+        ### Ielogojamies ###
+        headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: gzip, deflate, br
+Referer: https://viaplay.lv/
+Cookie: ott_cookies_confirmed=1; PLAY_SESSION=e618c42b377a65021298ff63309d5a907988ed1b-PSESSIONID=b010ea1b-fc5e-4a18-aa15-ebbe8b57b3f0&csrfToken=b4eb35263d9be16ef9f7b2f5d10a8ee99dfe75a8-1478051634814-63682b20f1e7e5579de6d056
+DNT: 1
+Connection: keep-alive
+Upgrade-Insecure-Requests: 1
+Content-Type: application/x-www-form-urlencoded
+""")
+        url = "https://viaplay.lv/tdi/login/nav/formular?csrfToken=%s"%self.csrfToken
+        params = "nav_redirectUri=https%3A%2F%2Fviaplay.lv%2F&nav_email={}&nav_password={}".format(urllib.quote(user),urllib.quote(password))
+        headers["Cookie"] = "ott_cookies_confirmed=1; PLAY_SESSION=%s;"%self.play_session
+        if self.device:
+            headers["Cookie"] += "ott_dids=%s"%self.device
+        #cookie = dict(PLAY_SESSION=self.play_session,_hjIncludedInSample=1, mobileAppPromo="shown")
+        r = requests.post(url,params,headers=headers,allow_redirects=False)
+        if not "Set-Cookie" in r.headers:
+            self.play_session = None
+            return False
+        self.ott = r.cookies["ott_web_sac"]
+        
+        ### Dabu iekārtas ID ###
+        if not self.device:
+            headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36
+Accept: application/xml, text/xml, */*; q=0.01
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: gzip, deflate, br
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Requested-With: XMLHttpRequest
+Referer: https://viaplay.lv/movies/me-and-earl-and-the-dying-girl
+DNT: 1
+Connection: keep-alive    """)
+            url = "https://viaplay.lv/tdi/account/device/create?_infuse=1&csrfToken=%s"%self.csrfToken
+            params = "successRedirectUri=https%3A%2F%2Fviaplay.lv%2Fmovies%2F&slotId=&title=Enigma2"
+            headers["Cookie"] = "PLAY_SESSION=%s; ott_cookies_confirmed=1; ott_web_sac=%s;"%(self.play_session,self.ott)
+            #cookie = dict(PLAY_SESSION=self.play_session,_hjIncludedInSample=1, mobileAppPromo="shown")
+            r = requests.post(url,params,headers=headers,allow_redirects=False)
+            if not ("Set-Cookie" in r.headers and "ott_dids" in r.headers["Set-Cookie"]):
+                self.play_session = None
+                return False
+            self.device =  r.cookies["ott_dids"]
+            self.options["device"] = self.device
+            self.options_write(self.options)
+        return True
+    
+    def logout(self):
+        return True
+    
+    def is_logedin(self):
+        if self.play_session:
+            return True
+        else:
+            return False
+
+    def get_video_info(self,vid):
+        import demjson
+        ### Dabu strimus ###
+        headers = headers2dict("""
+Host: viaplay.lv
+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
+Accept: application/xml, text/xml, */*; q=0.01
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: gzip, deflate, br
+X-Requested-With: XMLHttpRequest
+DNT: 1
+Connection: keep-alive
+Referer: https://viaplay.lv/
+""")   
+        url = "https://viaplay.lv/prehravac/init?_infuse=1&productId=%s"%vid #t110623
+        headers["Cookie"] = "ott_cookies_confirmed=1; ott_dids=%s; PLAY_SESSION=%s"%(self.device,self.play_session)
+        r = requests.get(url,headers=headers,allow_redirects=False)
+        statuss = re.search("<status>(.+?)</status>", r.content).group(1)
+        if statuss.lower() <> "ok":
+            raise Exception(statuss)
+        #print r.content
+        m = re.search(r"<!\[CDATA\[\s+var TDIPlayerOptions = (.+?);[\n\t\s]+\]\]>\s+</script>", r.content, re.DOTALL)
+        if not m:
+            raise "Can not find stream info"
+        txt = m.group(1)
+        txt = re.sub("// .+$", "", txt, flags=re.MULTILINE)
+        #print txt
+        #for m in re.finditer("// .+$", txt, re.MULTILINE):
+        #    txt = txt[:m.start()] + txt[m.end():]
+        #print txt
+        js = demjson.decode(txt)
+        return js
+        #return txt
+            
+    
+    def get_content(self, data):
+        print "[%s] get_content:"%self.name, data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        content=[]
+        content.append(("..return", "back","","Return back"))
+        
+        if clist=="home":
+            content.extend([
+                ("Search", "viaplay::search-results-all?query={0}",self.img,"Meklēt"),                
+                ("Filmas", "viaplay::movies",self.img,"Filmas"),
+                ("Seriāli", "viaplay::series",self.img,"Seriāli"),
+                ("Bērniem", "viaplay::kids",self.img,"Bērniem"),
+                ("Dokumentalās filmas", "viaplay::documentary",self.img,"Dokumentalās filmas"),
+                ("Sports", "viaplay::live",self.img,"Sports"),
+             ])
+            return content
+        
+        ### Meklēt ###
+        elif clist=="search-results-all":
+            url = "https://viaplay.lv/"+data
+            r = self._http_request(url)
+            result = re.findall(r'<div id="product-(\w+)".+?<a href="([^"]+)">.+?<img data-srcset="([^ ]+).+?alt="([^"]+)">.+?<h3 class="is-size-h6">([^<]+)</h3>.*?<p>([^<]+).+?</p>.+?<p class="promo-notice">([^<]+)</p>.+?<p class="info">([^<]+)</p>', r, re.DOTALL)
+            for item in result:
+                vid = item[0]
+                data2 = item[1].replace("https://viaplay.lv/","")
+                img = item[2]
+                ep = item[3]
+                title= item[4]
+                seas = item[5].replace("\n","").replace("\t","")
+                desc = item[6]
+                desc2 = item[7]
+                if ep==title:
+                    title = "%s (%s)"%(title,seas)
+                else:
+                    title = "%s - %s%s"%(title,seas,ep)
+                desc = "%s\n%s\n%s"%(title,desc2,desc)
+                content.append((title,self.name+"::"+data2,img,desc))             
+            return content
+        
+        ### Sadalas ##  
+        elif data in ["movies","series","kids","documentary"]:
+            r = self._http_request(self.url+data)
+            # https://viaplay.lv/tdi/movies/next?sections[]=MOVIES&genres[]=a3591&sort[]=latest&offset=0
+            # https://viaplay.lv/tdi/series/next?sections[]=SERIES&sort[]=latest&offset=0
+            # https://viaplay.lv/tdi/kids/next?sections[]=KIDS&cat[]=SERIES&cat[]=MOVIE&sort[]=latest&offset=18
+            # https://viaplay.lv/kids?sections[]=KIDS&cat[]=SERIES&sort[]=latest
+            sections =  {"movies":"MOVIES","series":"SERIES","kids":"KIDS","documentary":"DOCUMENTS"}
+            nosaukums = {"movies":"Flmas","series":"Seriāli","kids":"Bērnu","documentary":"Dokumentalās"}
+            #availability = {"new":"jaunākās","last":"pēdējā iespēja"}
+            sort = OrderedDict([("latest","jaunākais"),("title","pēc nosaukuma"),("popular","pēc popularitātes"),("year","pēc gada")])
+            for s in sort:
+                if data in ("movies","series"):
+                    title = "%s - %s"%(nosaukums[data],sort[s])
+                    data2 = "%s/next?sections[]=%s&sort[]=%s"%(data,sections[data],s)
+                    content.append((title,self.name+"::"+data2,self.img,title)) 
+                else:
+                    title = "%s filmas - %s"%(nosaukums[data],sort[s])
+                    data2 = "%s/next?sections[]=%s&cat[]=MOVIE&sort[]=%s"%(data,sections[data],s)
+                    content.append((title,self.name+"::"+data2,self.img,title)) 
+                    title = "%s seriāli - %s"%(nosaukums[data],sort[s])
+                    data2 = "%s/next?sections[]=%s&cat[]=SERIES&sort[]=%s"%(data,sections[data],s)
+                    content.append((title,self.name+"::"+data2,self.img,title))             
+                    
+            # Pievienojam žanru sarakstu 
+            result = re.findall(r'name="genres\[\]" value="([^"]+)">.+?class="">([^<]+)</label>', r, re.DOTALL)
+            for item in result:
+                s = "latest"
+                genre = item[1].replace("&amp;","&")
+                title = "%s: %s"%(nosaukums[data],genre)
+                data2 = "%s/next?sections[]=%s&genres[]=%s&sort[]=%s"%(data,sections[data],item[0],s)
+                content.append((title,self.name+"::"+data2,self.img,title))                 
+                
+            return content
+        
+        ### Filmu/seriālu/sēriju saraksts ###
+        elif clist in ("movies","series","kids","documentary") and plist[1] == "next":
+            url = "https://viaplay.lv/tdi/"+data
+            r = self._http_request(url)
+            if clist == "series" and "season" in qs:
+                result = re.findall(r'<div id="product-(\w+)".+?<a href="([^"]+)">.+?<img data-srcset="([^ ]+).+?alt="([^"]+)">.+?<h3 class="is-size-h6">([^<]+)</h3>.*?<p>([^<]+).+?</p>.+?<p class="promo-notice">([^<]+)</p>.+?<p class="info">([^<]+)</p>', r, re.DOTALL)
+                for item in result:
+                    vid = item[0]
+                    data2 = item[1].replace("https://viaplay.lv/","")
+                    img = item[2]
+                    ep = item[3]
+                    title= item[4]
+                    seas = item[5]
+                    desc = item[6]
+                    desc2 = item[7]
+                    title = "%s - %s%s"%(title,seas,ep)
+                    desc = "%s\n%s\n%s"%(title,desc2,desc)
+                    content.append((title,self.name+"::"+data2,img,desc))  
+            else: # filmas
+                result = re.findall(r'<div id="product-(\w+)".+?<a href="([^"]+)">.+?<img data-srcset="([^ ]+).+?alt="([^"]+)">.+?<p>([^<]+)</p>.+?<p class="promo-notice">([^<]+).+?<p class="is-strong detail">(.+?)</p>.+?<p class="info">([^<]+)</p>', r, re.DOTALL)
+                for item in result:
+                    vid = item[0]
+                    data2 = item[1].replace("https://viaplay.lv/","")
+                    img = item[2]
+                    title = item[3]
+                    year = item[4]
+                    year  = year.replace("\n","").replace("\t","")
+                    title = title +"(%s)"%year
+                    desc= item[5]
+                    genre = re.findall(">([^<]+)<", item[6], re.DOTALL)
+                    genre = ("".join(genre)).replace("&amp;","&")
+                    desc2 = item[7]
+                    desc = "%s\n%s\n%s"%(genre,desc2,desc)
+                    content.append((title,self.name+"::"+data2, img,desc))   
+            m = re.search(r"data\('href', 'https://viaplay\.lv/tdi/([^']+)'\)", r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+                content.append(("Next page",self.name+"::"+data2,img,"Next page"))                 
+            return content
+        
+        ### Seriāls ###
+        elif clist == "series" and len(plist)==2:
+            url = "https://viaplay.lv/"+data
+            r = self._http_request(url)
+            result = re.findall(r'<li>.*?<a class="tdi" href="https://viaplay\.lv/([^"]+)" data-related-ancestor="\.js-tdi-items-filter-and-items">([^<]+)</a>.*?</li>', r, re.DOTALL)
+            for item in result:
+                title = item[1]
+                data2 = item[0]
+                data2 = data2.replace("series/","series/next/")
+                data2 = data2+"&sort[]=ord"
+                #series/littlest-pet-shop?season=t6821
+                #series/next/peppa-pig?season=t8430
+                # &sort[]=ord
+                if "availability=" in data2: continue
+                content.append((title,self.name+"::"+data2,self.img,title)) #TODO bilde
+            return content
+                              
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)        
+        if clist in ("movies","documentary","kids") and len(plist)>1 and plist[1]<>"next":
+            return True
+        elif clist == "series"  and len(plist)>1 and plist[1] == "episode":
+            return True
+        else:
+            return False
+        
+    def get_streams(self, data):
+        print "[viaplay] get_streams:", data
+        if not self.is_video(data):
+            return []
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if not self.is_logedin():
+            self.login()
+        if not self.is_logedin():
+            raise Exception("Could not login to viaplay.lv, check username/password in options")
+        
+        streams = []
+        url = "https://viaplay.lv/"+data
+        r = self._http_request(url)
+        if clist=="series":
+            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")
+            title = m.group(1).replace("\n"," ").replace("\t","").strip()
+            title = re.sub("<[^>]+>","",title).strip()
+            desc2 = m.group(2).replace("\n"," ").replace("\t","").strip()
+            desc2 = re.sub("<[^>]+>","",desc2).strip()
+            desc = m.group(3)
+            desc = "%s\n%s"%(desc2,desc)
+            vid = re.search('data-productid="(\w+)"',r).group(1)
+        else:
+            m = re.search(r'<h1 class="is-strong is-bottom-sticked is-size-h2" jnp-id="(\w+)">([^<]+)</h1>.*?<h2 class="is-strong is-size-h4">([^<]+)</h2>.*?<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")
+            title = m.group(2).strip()
+            title2 = m.group(3).strip()
+            title = "%s | %s"%(title,title2)
+            desc = m.group(5).strip()
+            desc2 = m.group(4).strip()
+            desc2 = re.sub("<[^>]+>","",desc2)
+            desc2 = desc2.replace("\n"," ").replace("\t","")
+            desc = "%s\n%s"%(desc2,desc)
+            vid = m.group(1)
+        
+        js = self.get_video_info(vid)
+        #for m in re.finditer(r"lang: '(?P<lang>\w+)',\s+src: '(?P<url>[^']+)',\s+type: '(?P<mime>[^']+)',\s+drm: \[(?P<drm>.+?)\]\s*\}", r, re.DOTALL):               
+        if not js:
+            return []
+        tracks = js["tracks"]
+        #if not tracks["HLS"]:
+        #    raise Exception("Encrypted DASH playing not yet implemented")
+        
+        captions = []
+        llist = ["fr","en","ru","lv"]
+        for st in js["plugins"]["settings"]["subtitles"]:
+            sub = {}
+            sub["url"] = st["src"]
+            sub["lang"] = st["srclang"]
+            sub["name"] = st["label"]
+            sub["type"] = "vtt"
+            sub["order"] = llist.index(sub["lang"])*10 if sub["lang"] in llist else 0            
+            captions.append(sub)       
+        captions = sorted(captions,key=lambda item: item["order"],reverse=True) 
+        
+        for s in tracks["HLS"] if tracks["HLS"]  else tracks["DASH"] :
+            stype = "DASH" if "dash" in s["type"] else "HLS"
+            if "drm" in s: ### 
+                # TODO, encrypted stream
+                continue
+            url = s["src"]
+            urlp = util.streamproxy_encode(s["src"])
+            stream = util.item()
+            stream["url"]=urlp
+            stream["lang"]=s["lang"]
+            stream["quality"]="variant"
+            stream["bitrate"]= "1000000"
+            stream["name"]= title
+            stream["desc"]=desc
+            stream["type"]=stype
+            stream["subs"] = captions
+            print urlp
+            if stype=="DASH": streams.append(stream)
+            
+            if stype == "HLS": # izvelkam individuālos strimus
+                r = requests.get(url)
+                result = re.findall("#EXT-X-STREAM-INF:BANDWIDTH=(\d+),RESOLUTION=(\d+x\d+)\n(\w+.m3u8)", r.content)            
+                if not result:
+                    continue
+                for s2 in result:
+                    ### TODO vajag lietot cookie ar tokenu no playlista requesta
+                    if "set-cookie" in r.headers:
+                        headers = {"Cookie":r.headers["set-cookie"]}
+                    else:
+                        headers={}
+                    #url2 = re.sub(r"(http.*://.+/)\w+.m3u8", r"\1"+s2[2], url)
+                    url2 = "/".join(url.split("/")[:-1])+"/"+s2[2]
+                    #r2 = requests.get(url2,headers=headers)
+                    #if "set-cookie" in r2.headers:
+                        #headers = {"Cookie":r2.headers["set-cookie"]}
+                    #else:
+                        #headers={}                   
+                    url2p=util.streamproxy_encode(url2,headers)
+                    stream = util.item()
+                    stream["url"]=url2p
+                    stream["lang"]=s["lang"]
+                    stream["quality"]="%s"%(s2[1])
+                    stream["name"]= title
+                    stream["desc"]=desc
+                    stream["bitrate"]=s2[0]
+                    stream["type"]="DASH" if "dash" in s["type"] else "HLS"
+                    streams.append(stream)
+                        
+        ### TODO - sakārtot sarakstu, lai pirmais ir labakais video
+        qlist = ["","512","640","758","1024","variant"]
+        llist = ["lt","et","fr","en","ru","lv"]        
+        for s in streams:
+            lv = llist.index(s["lang"])*10000000 if s["lang"] in llist else 0
+            #qv=qlist.index(s["quality"]) if s["quality"] in qlist else 0
+            qv = int(s["bitrate"]) if s["bitrate"] else 0
+            s["order"] = lv+qv
+            #print s["lang"],s["quality"],s["bitrate"],s["order"]
+            
+        streams = sorted(streams,key=lambda item: item["order"],reverse=True)
+        return streams
+        
+    def call(self, data,params = None, headers=None):
+        if not headers: headers = self.headers
+        #if not lang: lang = self.country
+        url = "https://viaplay.lv/tdi/" + data
+        content = self._http_request(url, params, headers)
+        return content        
+
+if __name__ == "__main__":
+    if len(sys.argv)>1:
+        data= sys.argv[1]
+    else:
+        data = "kids/child-and-karlson"
+    c = Source()
+    print "login: %s"%c.login()
+    if "/" in data:
+        streams = c.get_streams(data)
+        util.play_video(streams)
+    else:
+        vinfo = c.get_video_info(data)
+        if "HLS" in vinfo["tracks"] and vinfo["tracks"]["HLS"]:
+            url = vinfo["tracks"]["HLS"][0]["src"]
+            urlp = util.streamproxy_encode(url)
+            util.player(urlp)
+        else:
+            print "No HLS stream"
+    sys.exit()
+
+    r = requests.get("https://viaplay.lv/movies?sections[]=MOVIES")
+    result = re.findall(r'<div id="product-(\w+)".+?<a href="([^"]+)">.+?<img data-srcset="([^ ]+).+?alt="([^"]+)">.+?<p class="promo-notice">([^<]+)<', r.content, re.DOTALL)
+    for item in result:
+        vid = item[0]
+        url = item[1]
+        img = item[2]
+        title = item[3]
+        desc= item[4]
+        print "\n%s (%s):"%(title,vid)
+        vinfo = c.get_video_info(vid)
+        if "HLS" in vinfo["tracks"]:
+            for s in vinfo["tracks"]["HLS"]:
+                print "HLS %s: \n%s"%(s["lang"],s["src"])
+                
+        if "DASH" in vinfo["tracks"]:
+            for s in vinfo["tracks"]["DASH"]:
+                print "DASH %s: \n%s"%(s["lang"],s["src"])
+        #except Exception,ex:
+            #print ex.message
+    #content = c.get_content(data)
+    #for item in content:
+    #    print item
+    pass

streamproxy.py

@@ -0,0 +1,291 @@
+#!/usr/bin/python
+""" 
+StreamProxy daemon (based on Livestream daemon)
+Ensures persistent cookies, User-Agents and others tricks to play protected HLS/DASH streams
+"""
+import os
+import sys
+import time
+import atexit
+import re
+
+from signal import SIGTERM
+
+from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
+from SocketServer import ThreadingMixIn
+from urllib import unquote, quote
+import urllib,urlparse
+#import cookielib,urllib2
+import requests
+from requests.packages.urllib3.exceptions import InsecureRequestWarning
+requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+
+HOST_NAME = ""
+PORT_NUMBER = 88
+DEBUG = True
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+sessions = {}
+
+class StreamHandler(BaseHTTPRequestHandler):
+
+    def do_HEAD(self):
+        self.send_response(200)
+        self.send_header("Server", "StreamProxy")
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+
+    def do_GET(self):
+        """Respond to a GET request."""
+        SPLIT_CHAR = "~"
+        SPLIT_CODE = "%7E"
+        EQ_CODE = "%3D"
+        COL_CODE = "%3A"
+        
+        p = self.path.split("~")
+        url = urllib.unquote(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
+        """)
+        if len(p)>1:
+            for h in p[1:]:
+                headers[h.split("=")[0]]=urllib.unquote(h.split("=")[1])
+        #self.fetch_offline(self.wfile)
+        try:
+            self.fetch_url2(self.wfile, url, headers)
+        except Exception as e:
+            print "Got Exception: ", str(e)
+        
+    def fetch_offline(self,wfile):
+        self.send_response(200)
+        self.send_header("Server", "StreamProxy")
+        self.send_header("Content-type", "video/mp4")
+        self.end_headers()
+        self.wfile.write(open("offline.mp4", "rb").read())
+        self.wfile.close()
+        
+    
+    def fetch_url2(self, wfile, url, headers):
+        if DEBUG: print "\n***********************************************************"
+        self.log_message("fetch_url: %s", url)
+        #self.log_message("headers: %s", headers)
+        
+        base_url = "/".join(url.split("/")[0:-1])
+        if base_url not in sessions:
+            sessions[base_url] = requests.Session()
+            #cj = cookielib.CookieJar()
+            #sessions[base_url] = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))    
+        else:
+            pass
+        ses=sessions[base_url]
+        if DEBUG: print "**Request headers: "
+        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)
+        for h in r.headers:
+            if h in ("user-agent","server"):continue
+            if h=="connection":
+                if DEBUG: print h," skipped"
+                continue
+            self.send_header(h, r.headers[h])
+            if DEBUG:print h,"=",r.headers[h]
+        self.end_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(2)
+            #self.wfile.close()
+            
+            
+        else:
+            print code
+            self.fetch_offline(wfile)
+            pass
+  
+class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
+    """Handle requests in a separate thread."""
+
+def start():
+    httpd = ThreadedHTTPServer((HOST_NAME, PORT_NUMBER), StreamHandler)
+    print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, PORT_NUMBER)
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    httpd.server_close()
+    print time.asctime(), "Server Stops - %s:%s" % (HOST_NAME, PORT_NUMBER)
+
+
+class Daemon:
+    """
+    A generic daemon class.
+    Usage: subclass the Daemon class and override the run() method
+    """
+    def __init__(self, pidfile, stdin="/dev/null", stdout="/dev/null", stderr="/dev/null"):
+        self.stdin = stdin
+        self.stdout = stdout
+        self.stderr = stderr
+        self.pidfile = pidfile
+
+    def daemonize(self):
+        """
+        do the UNIX double-fork magic, see Stevens' "Advanced 
+        Programming in the UNIX Environment" for details (ISBN 0201563177)
+        http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
+        """
+        try: 
+            pid = os.fork() 
+            if pid > 0:
+                # exit first parent
+                sys.exit(0) 
+        except OSError, e: 
+            sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
+            sys.exit(1)
+
+        # decouple from parent environment
+        os.chdir("/") 
+        os.setsid() 
+        os.umask(0) 
+
+        # do second fork
+        try: 
+            pid = os.fork() 
+            if pid > 0:
+                # exit from second parent
+                sys.exit(0) 
+        except OSError, e: 
+            sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
+            sys.exit(1) 
+
+        # redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+        si = file(self.stdin, "r")
+        so = file(self.stdout, "a+")
+        se = file(self.stderr, "a+", 0)
+        os.dup2(si.fileno(), sys.stdin.fileno())
+        os.dup2(so.fileno(), sys.stdout.fileno())
+        os.dup2(se.fileno(), sys.stderr.fileno())
+
+        # write pidfile
+        atexit.register(self.delpid)
+        pid = str(os.getpid())
+        file(self.pidfile,"w+").write("%s\n" % pid)
+
+    def delpid(self):
+        os.remove(self.pidfile)
+
+    def start(self):
+        """
+        Start the daemon
+        """
+        # Check for a pidfile to see if the daemon already runs
+        try:
+            pf = file(self.pidfile,"r")
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+
+        if pid:
+            message = "pidfile %s already exist. Daemon already running?\n"
+            sys.stderr.write(message % self.pidfile)
+            sys.exit(1)
+
+        # Start the daemon
+        self.daemonize()
+        self.run()
+
+    def stop(self):
+        """
+        Stop the daemon
+        """
+        # Get the pid from the pidfile
+        try:
+            pf = file(self.pidfile,"r")
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+
+        if not pid:
+            message = "pidfile %s does not exist. Daemon not running?\n"
+            sys.stderr.write(message % self.pidfile)
+            return # not an error in a restart
+
+        # Try killing the daemon process	
+        try:
+            while 1:
+                os.kill(pid, SIGTERM)
+                time.sleep(0.1)
+        except OSError, err:
+            err = str(err)
+            if err.find("No such process") > 0:
+                if os.path.exists(self.pidfile):
+                    os.remove(self.pidfile)
+            else:
+                print str(err)
+                sys.exit(1)
+
+    def restart(self):
+        """
+        Restart the daemon
+        """
+        self.stop()
+        self.start()
+
+    def run(self):
+        """
+        You should override this method when you subclass Daemon. It will be called after the process has been
+        daemonized by start() or restart().
+        """
+
+class ProxyDaemon(Daemon):
+    def run(self):
+        start()
+
+if __name__ == "__main__":
+    daemon = ProxyDaemon("/var/run/streamproxy.pid")
+    if len(sys.argv) == 2:
+        if "start" == sys.argv[1]:
+            daemon.start()
+        elif "stop" == sys.argv[1]:
+            daemon.stop()
+        elif "restart" == sys.argv[1]:
+            daemon.restart()
+        elif "manualstart" == sys.argv[1]:
+            start()
+        else:
+            print "Unknown command"
+            sys.exit(2)
+        sys.exit(0)
+    else:
+        print "usage: %s start|stop|restart|manualstart" % sys.argv[0]
+        sys.exit(2)
+

util.py

@@ -0,0 +1,552 @@
+# -*- coding: UTF-8 -*-
+# /*
+# *      Copyright (C) 2011 Libor Zoubek,ivars777
+# *
+# *
+# *  This Program is free software; you can redistribute it and/or modify
+# *  it under the terms of the GNU General Public License as published by
+# *  the Free Software Foundation; either version 2, or (at your option)
+# *  any later version.
+# *
+# *  This Program is distributed in the hope that it will be useful,
+# *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+# *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# *  GNU General Public License for more details.
+# *
+# *  You should have received a copy of the GNU General Public License
+# *  along with this program; see the file COPYING.  If not, write to
+# *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+# *  http://www.gnu.org/copyleft/gpl.html
+# *
+# */
+import os
+import re
+import sys
+import urllib
+import urllib2
+import traceback
+import cookielib
+import requests
+from htmlentitydefs import name2codepoint as n2cp
+import HTMLParser
+import StringIO
+
+#import threading
+#import Queue
+import pickle
+import string
+import simplejson as json
+#from demjson import demjson
+#import demjson
+import json
+#from bs4 import BeautifulSoup
+
+UA = 'Mozilla/6.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.5) Gecko/2008092417 Firefox/3.0.3'
+LOG = 2
+
+_cookie_jar = None
+CACHE_COOKIES = 'cookies'
+
+def play_video(streams):
+    if len(streams)>1:
+        for i,s in enumerate(streams):
+            
+            print "%s: [%s,%s,%s] %s"%(i,s["quality"],s["lang"].encode("utf8"),s["type"],s["name"])
+        a = raw_input("Select stram to play: ")
+        try:
+            n = int(a)
+        except:
+            n = 0
+        if n>=len(streams):
+            stream = streams[-1]
+        else:
+            stream = streams[n]
+    else:
+        stream = streams[0]
+
+    title = stream["name"]
+    url = stream["url"]
+    suburl = ""
+    print url
+    if "subs" in stream and stream["subs"]:
+        suburl = stream["subs"][0]["url"]
+        print "\n**Download subtitles %s - %s"%(title,suburl)  
+        subs = urllib2.urlopen(suburl).read()
+        if subs:
+            fname0 = re.sub("[/\n\r\t,]","_",title)                
+            subext = ".srt"
+            subfile = os.path.join("",fname0+subext)
+            if ".xml" in suburl:
+                subs = ttaf2srt(subs) 
+            with open(subfile,"w") as f:
+                f.write(subs)
+        else:
+            print "\n Error downloading subtitle %s"%suburl
+    return player(url,stream["name"],suburl)
+            
+def player(url,title="",suburl=""):
+    from subprocess import call
+    print "\n**Play stream %s\n%s"%(title,url.encode("utf8"))
+    cmd1 = [r"c:\Program Files\VideoLAN\VLC\vlc.exe",url,
+           "--meta-title",title.decode("utf8").encode(sys.getfilesystemencoding()),
+           "--http-user-agent","Enigma2"
+    ]
+    # gst-launch-1.0 -v souphttpsrc ssl-strict=false proxy=127.0.0.1:8888 extra-headers="Origin:adadadasd"  location="http://bitdash-a.akamaihd.net/content/sintel/sintel.mpd" ! decodebin! autovideosink
+    cmd2 = [
+        r"C:\gstreamer\1.0\x86_64\bin\gst-launch-1.0","-v",
+        "playbin", 'uri="%s"'%url,
+        #"souphttpsrc", "ssl-strict=false",       
+        #"proxy=127.0.0.1:8888",
+        #'location="%s"'%url,
+        #'!decodebin!autovideosink'
+    ]
+    cmd = cmd1 if url.startswith("https") else cmd2
+    ret = call(cmd)
+    #if ret:
+        #a = raw_input("*** Error, continue")
+    return
+
+SPLIT_CHAR = "~"
+SPLIT_CODE = "%7E"
+EQ_CODE = "%3D"
+COL_CODE = "%3A"
+PROXY_URL = "http://localhost:88/"
+
+def streamproxy_encode(url,headers=[]):
+    if not "?" in url:
+        url = url+"?"
+    url2 = url.replace(SPLIT_CHAR,SPLIT_CODE).replace(":",COL_CODE)
+    url2 = PROXY_URL + url2
+    if headers:
+        headers2 = []
+        for h in headers:
+            headers2.append("%s=%s"%(h,headers[h].replace("=",EQ_CODE).replace(SPLIT_CHAR,SPLIT_CODE)))
+        headers2 = SPLIT_CHAR.join(headers2)
+        url2 = url2+SPLIT_CHAR+headers2
+    return url2
+
+def streamproxy_decode(urlp):
+    import urlparse
+    path = urlp.replace(re.search("http://[^/]+",urlp).group(0),"")
+    p = path.split(SPLIT_CHAR)
+    url = urllib.unquote(p[0][1:])
+    #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"}    
+    headers={}
+    if len(p)>1:
+        for h in p[1:]:
+            headers[h.split("=")[0]]=urllib.unquote(h.split("=")[1])
+    return url,headers
+
+class Captions(object):
+    def __init__(self,uri):
+        self.subs = []
+        self.styles = {}
+        if uri.startswith("http"):
+            r = requests.get(uri)
+        if r.status_code == 200:
+            self.loads(r.content)
+            
+    def loads(self,s):
+        if "WEBVTT" in s[:s.find("\n")]: # vtt captions
+            self.load_vtt(s)
+        elif "<?xml" in s[:s.find("\n")]:
+            self.load_ttaf(s)
+        else:
+            return
+        
+    def load_ttaf(self,s):
+        for r2 in re.findall("<style .+?/>", s):
+            st = {}
+            for a in re.findall(r'(\w+)="([^ "]+)"', r2):
+                st[a[0]] = a[1]
+                if a[0] == "id":
+                    sid = a[1]
+            self.styles[sid] = st  
+        for r2 in re.findall("<p .+?</p>", s):
+            sub = {}
+            sub["begin"] = str2sec(re.search('begin="([^"]+)"', r2).group(1)) if re.search('begin="([^"]+)"', r2) else -1
+            sub["end"] = str2sec(re.search('end="([^"]+)"', r2).group(1)) if re.search('end="([^"]+)"', r2) else -1
+            sub["style"] = re.search('style="([^"]+)"', r2).group(1) if re.search('style="([^"]+)"', r2) else None
+            sub["text"] = re.search("<p[^>]+>(.+)</p>", r2).group(1).replace("\n","")
+            sub["text"] = re.sub("<br\s*?/>","\n",sub["text"])
+            sub["text"] = re.sub("<.+?>"," ",sub["text"])
+            self.subs.append(sub)  
+        pass
+                  
+    def load_vtt(self,s):
+        f = StringIO.StringIO(s)
+        while True:
+            line = f.readline()
+            if not line:
+                break
+            m = re.search(r"([\d\.\,:]+)\s*-->\s*([\d\.\,\:]+)",line)
+            if m:
+                sub = {}
+                sub["begin"] = str2sec(m.group(1))
+                sub["end"] = str2sec(m.group(2))
+                sub["style"] = None
+                sub["text"] = []
+                line = f.readline()
+                while line.strip():
+                    txt = line.strip()
+                    if isinstance(txt,unicode):
+                        txt = txt.encode("utf8")
+                    sub["text"].append(txt)
+                    line = f.readline()
+                sub["text"] = "\n".join(sub["text"])
+                self.subs.append(sub)                    
+            else:
+                continue
+        pass
+            
+def str2sec(r):
+    # Convert str time to miliseconds
+    r= r.replace(",",".")
+    m = re.search(r"(\d+\:)*(\d+)\:(\d+\.\d+)", r)
+    if m:
+        sec = int(m.group(1)[:-1])*60*60*1000 if m.group(1) else 0 
+        sec += int(m.group(2))*60*1000 + int(float(m.group(3))*1000)
+        return sec
+    else:
+        return -1
+
+#c = Captions("http://195.13.216.2/mobile-vod/mp4:lb_barbecue_fr_lq.mp4/lb_barbecue_lv.vtt")  
+#c = Captions("http://www.bbc.co.uk/iplayer/subtitles/ng/modav/bUnknown-0edd6227-0f38-411c-8d46-fa033c4c61c1_b05ql1s3_1479853893356.xml")
+#url = "http://195.13.216.2/mobile-vod/mp4:ac_now_you_see_me_2_en_lq.mp4/ac_now_you_see_me_2_lv.vtt"
+#c = Captions(url)
+
+#pass
+
+
+def ttaf2srt(s):
+    out = u""
+    i = 0
+    for p,txt in re.findall("<p ([^>]+)>(.+?)</p>", s, re.DOTALL):
+        i +=1
+        begin = re.search('begin="(.+?)"',p).group(1)
+        begin = begin.replace(".",",")
+        end = re.search('end="(.+?)"',p).group(1)
+        end = end.replace(".",",")
+        txt2 = re.sub("<br */>","\n",txt)
+        out += "%s\n%s --> %s\n%s\n\n"%(i,begin,end,txt2)
+    return out    
+
+
+def item():
+    stream0 = {'name': '', 'url': '', 'quality': '???', 'surl': '', 'subs': '', 'headers': {},"desc":"","img":"","lang":"","type":"","order":0}            
+    return stream0
+
+class _StringCookieJar(cookielib.LWPCookieJar):
+
+    def __init__(self, string=None, filename=None, delayload=False, policy=None):
+        cookielib.LWPCookieJar.__init__(self, filename, delayload, policy)
+        if string and len(string) > 0:
+            self._cookies = pickle.loads(str(string))
+
+    def dump(self):
+        return pickle.dumps(self._cookies)
+
+
+def init_urllib(cache=None):
+    """
+    Initializes urllib cookie handler
+    """
+    global _cookie_jar
+    data = None
+    if cache is not None:
+        data = cache.get(CACHE_COOKIES)
+    _cookie_jar = _StringCookieJar(data)
+    opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(_cookie_jar))
+    urllib2.install_opener(opener)
+
+
+def cache_cookies(cache):
+    """
+    Saves cookies to cache
+    """
+    global _cookie_jar
+    if _cookie_jar:
+        cache.set(CACHE_COOKIES, _cookie_jar.dump())
+
+
+def request0(url, headers={}):
+    debug('request: %s' % url)
+    req = urllib2.Request(url, headers=headers)
+    req.add_header('User-Agent', UA)
+    try:
+        response = urllib2.urlopen(req)
+        data = response.read()
+        response.close()
+    except urllib2.HTTPError, error:
+        data = error.read()    
+
+    debug('len(data) %s' % len(data))
+    return data
+
+def request(url, headers={}):
+    debug('request: %s' % url)
+    #req = urllib2.Request(url, headers=headers)
+    #req.add_header('User-Agent', UA)
+    if 'User-Agent' not in headers:
+        headers['User-Agent']= UA
+    try:
+        r = requests.get(url, headers=headers)
+        data = r.content
+    except:
+        data = r.content   
+
+    debug('len(data) %s' % len(data))
+    return data
+
+def post(url, data, headers={}):
+    postdata = urllib.urlencode(data)
+    #req = urllib2.Request(url, postdata, headers)
+    #req.add_header('User-Agent', UA)
+    import requests
+    if 'User-Agent' not in headers:
+        headers['User-Agent']= UA    
+    try:
+        r = requests.post(url, data=postdata,headers=headers)
+        data = r.content
+    except urllib2.HTTPError, error:
+        data = r.content   
+    return data
+
+def post0(url, data, headers={}):
+    postdata = urllib.urlencode(data)
+    req = urllib2.Request(url, postdata, headers)
+    req.add_header('User-Agent', UA)
+    try:
+        response = urllib2.urlopen(req)
+        data = response.read()
+        response.close()
+    except urllib2.HTTPError, error:
+        data = error.read()    
+    return data
+
+
+def post_json(url, data, headers={}):
+    postdata = json.dumps(data)
+    headers['Content-Type'] = 'application/json'
+    req = urllib2.Request(url, postdata, headers)
+    req.add_header('User-Agent', UA)
+    response = urllib2.urlopen(req)
+    data = response.read()
+    response.close()
+    return data
+
+
+#def run_parallel_in_threads(target, args_list):
+    #result = Queue.Queue()
+    ## wrapper to collect return value in a Queue
+
+    #def task_wrapper(*args):
+        #result.put(target(*args))
+
+    #threads = [threading.Thread(target=task_wrapper, args=args) for args in args_list]
+    #for t in threads:
+        #t.start()
+    #for t in threads:
+        #t.join()
+    #return result
+
+
+def substr(data, start, end):
+    i1 = data.find(start)
+    i2 = data.find(end, i1)
+    return data[i1:i2]
+
+
+def save_to_file(url, file):
+    try:
+        return save_data_to_file(request(url), file)
+    except:
+        traceback.print_exc()
+
+
+def save_data_to_file(data, file):
+    try:
+        f = open(file, 'wb')
+        f.write(data)
+        f.close()
+        info('File %s saved' % file)
+        return True
+    except:
+        traceback.print_exc()
+
+
+def read_file(file):
+    if not os.path.exists(file):
+        return ''
+    f = open(file, 'r')
+    data = f.read()
+    f.close()
+    return data
+
+
+def _substitute_entity(match):
+    ent = match.group(3)
+    if match.group(1) == '#':
+        # decoding by number
+        if match.group(2) == '':
+            # number is in decimal
+            return unichr(int(ent))
+        elif match.group(2) == 'x':
+            # number is in hex
+            return unichr(int('0x' + ent, 16))
+    else:
+        # they were using a name
+        cp = n2cp.get(ent)
+        if cp:
+            return unichr(cp)
+        else:
+            return match.group()
+
+
+def decode_html(data):
+    if not type(data) == str:
+        return data
+    try:
+        if not type(data) == unicode:
+            data = unicode(data, 'utf-8', errors='ignore')
+        entity_re = re.compile(r'&(#?)(x?)(\w+);')
+        return entity_re.subn(_substitute_entity, data)[0]
+    except:
+        traceback.print_exc()
+        print[data]
+        return data
+
+def unescape(s0):
+    #s2 = re.sub("&#\w+;",HTMLParser.HTMLParser().unescape("\1"),s)
+    s0 = s0.replace("&amp;","&")
+    for s in re.findall("&#\w+;",s0):
+        s2 = HTMLParser.HTMLParser().unescape(s)
+        if isinstance(s0,str):
+            s2 = s2.encode("utf8")
+        s0 = s0.replace(s,s2)
+        pass
+    return s0
+
+def debug(text):
+    if LOG > 1:
+        print('[DEBUG] ' + str([text]))
+
+def info(text):
+    if LOG > 0:
+        print('[INFO] ' + str([text]))
+
+def error(text):
+    print('[ERROR] ' + str([text]))
+
+_diacritic_replace = {u'\u00f3': 'o',
+                      u'\u0213': '-',
+                      u'\u00e1': 'a',
+                      u'\u010d': 'c',
+                      u'\u010c': 'C',
+                      u'\u010f': 'd',
+                      u'\u010e': 'D',
+                      u'\u00e9': 'e',
+                      u'\u011b': 'e',
+                      u'\u00ed': 'i',
+                      u'\u0148': 'n',
+                      u'\u0159': 'r',
+                      u'\u0161': 's',
+                      u'\u0165': 't',
+                      u'\u016f': 'u',
+                      u'\u00fd': 'y',
+                      u'\u017e': 'z',
+                      u'\xed': 'i',
+                      u'\xe9': 'e',
+                      u'\xe1': 'a',
+                      }
+
+
+def replace_diacritic(string):
+    ret = []
+    for char in string:
+        if char in _diacritic_replace:
+            ret.append(_diacritic_replace[char])
+        else:
+            ret.append(char)
+    return ''.join(ret)
+
+
+def params(url=None):
+    if not url:
+        url = sys.argv[2]
+    param = {}
+    paramstring = url
+    if len(paramstring) >= 2:
+        params = url
+        cleanedparams = params.replace('?', '')
+        if (params[len(params) - 1] == '/'):
+            params = params[0:len(params) - 2]
+        pairsofparams = cleanedparams.split('&')
+        param = {}
+        for i in range(len(pairsofparams)):
+            splitparams = {}
+            splitparams = pairsofparams[i].split('=')
+            if (len(splitparams)) == 2:
+                param[splitparams[0]] = splitparams[1]
+    for p in param.keys():
+        param[p] = param[p].decode('hex')
+    return param
+
+
+def int_to_base(number, base):
+    digs = string.digits + string.letters
+    if number < 0:
+        sign = -1
+    elif number == 0:
+        return digs[0]
+    else:
+        sign = 1
+    number *= sign
+    digits = []
+    while number:
+        digits.append(digs[number % base])
+        number /= base
+    if sign < 0:
+        digits.append('-')
+    digits.reverse()
+    return ''.join(digits)
+
+
+def extract_jwplayer_setup(data):
+    """
+    Extracts jwplayer setup configuration and returns it as a dictionary.
+
+    :param data: A string to extract the setup from
+    :return: A dictionary containing the setup configuration
+    """
+    data = re.search(r'<script.+?}\(\'(.+)\',\d+,\d+,\'([\w\|]+)\'.*</script>', data, re.I | re.S)
+    if data:
+        replacements = data.group(2).split('|')
+        data = data.group(1)
+        for i in reversed(range(len(replacements))):
+            if len(replacements[i]) > 0:
+                data = re.sub(r'\b%s\b' % int_to_base(i, 36), replacements[i], data)
+        data = re.search(r'\.setup\(([^\)]+?)\);', data)
+        if data:
+            return json.loads(data.group(1).decode('string_escape'))
+        #return demjson.decode(data.group(1).decode('string_escape')) ### III
+    return None
+
+
+#def parse_html(url):
+#    return BeautifulSoup(request(url), 'html5lib', from_encoding='utf-8')
+
+if __name__ == "__main__":
+    s = 'B\xc4\x93thovena D\xc4\x81rgumu Taka (2014)/Beethoven&#x27;s Treasure [LV]'
+    #s = s.decode("utf8")
+    #s=unescape(s)
+    #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"}
+    urlp = streamproxy_encode(url,headers)
+    print urlp
+    player(urlp)
+    
+    pass
+    
+