iekopēts saturs

ContentSources.py

@@ -0,0 +1,262 @@
+#!/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 glob, traceback
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from sources.SourceBase import stream_type
+import util
+
+show_hidden = False  # Ja True, tad vienalga radā hidden sources (noder izstradē)
+
+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):
+        #for f in next(os.walk(plugin_path))[2]:
+        print "ContentSources: Importing sources from "+plugin_path
+        files = glob.glob(os.path.join(plugin_path, "*.py"))
+        for f in files:
+            fname, ext = os.path.splitext(f)
+            fname = os.path.split(fname)[1]
+            if fname == "__init__": continue
+            if ext == '.py':
+                print "Importing %s"%fname
+                mod = __import__(fname)
+                reload(mod)
+                if "Source" in dir(mod):
+                    self.plugins[fname] = mod.Source()
+                    print fname+ " imported"
+                else:
+                    pass
+                    #print fname+ "skipped"
+        sys.path.pop(0)
+        if not "config" in self.plugins:
+            raise Exception("Problem importing content sources")
+        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:
+            content0 = self.plugins[source].get_content(data)
+            if content0:
+                content = []
+                if isinstance(content0,list):
+                    for i,item in enumerate(content0):
+                        source2 = item[1].split("::")[0]
+                        if not (source2 == "back" or item[1].startswith("http") or item[1].startswith("rtmp")):
+                            if source2 not in self.plugins or (not show_hidden and "hidden" in dir(self.plugins[source2]) and self.plugins[source2].hidden):
+                                continue
+                        item2=[]
+                        for el in item:
+                            if isinstance(el,unicode):
+                                el = el.encode("utf8")
+                            item2.append(el)
+                        content.append(tuple(item2))
+                else:
+                    item2=[]
+                    for el in content0:
+                        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 = util.item()
+            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")
+                if not "resolver" in s:
+                    s["resolver"] = source
+                if not "surl" in s or not s["surl"]:
+                    s["surl"] = data
+                if not "nfo" in s:
+                    s["nfo"]={"movie":{"title":s["name"],"thumb":s["img"],"plot":s["desc"]}}
+            return streams
+        else:
+            return []
+
+    def get_info(self,data):
+        nfo = {}
+        if self.is_video(data):
+            source = data.split("::")[0]
+            if source in self.plugins:
+                if "get_info" in dir(self.plugins[source]):
+                    streams = self.get_streams(data)
+                    nfo = streams[0]["nfo"] if streams and "nfo" in streams[0] else {}
+                else:
+                    nfo = self.plugins[source].get_info(data)
+        else:
+            pass    # TODO create nfo for listing
+        return nfo
+
+
+    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__":
+
+    show_hidden = False
+    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"%(i,item[0],item[1],item[2])
+            print s #.encode(sys.stdout.encoding,"replace")
+
+        while True:
+            a = raw_input("Enter number, (-) for download, 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
+        download = False
+        if n<0:
+            n = abs(n)
+            download = True
+        cur2 = content[n]
+        data0 = cur2[1].split("::")[1] if "::" in cur2[1] else cur2[1]
+        if not data0:
+            pass
+        elif cur2[1] == "back":
+            cur = history.pop()
+        elif sources.is_video(cur2[1]):
+            if sources.stream_type(cur2[1]):
+                stream = util.item()
+                stream["url"] = cur2[1]
+                stream["name"] = cur2[0]
+                streams = [stream]
+            else:
+                try:
+                    if not download:
+                        streams = sources.get_streams(cur2[1])
+                    else:
+                        stream = util.item()
+                        stream["url"] = cur2[1]
+                        stream["name"] = cur2[0]
+                        stream["url"] = util.streamproxy_encode2(stream["url"])
+                        print stream["url"]
+                        streams = [stream]
+                except Exception as e:
+                    print unicode(e)
+                    traceback.print_exc()
+                    streams = []
+            if streams:
+                if not download:
+                    util.play_video(streams)
+                else:
+                    #urlp = util.streamproxy_encode2(streams[0]["url"])
+                    #print urlp
+                    #util.player(urlp)
+                    #Downloader.download_video(streams)
+                    pass
+            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
+        try:
+            content = sources.get_content(cur[1])
+        except Exception as e:
+            print unicode(e)
+            traceback.print_exc()
+            raw_input("Continue?")
+
+

resolver.py

@@ -0,0 +1,138 @@
+# *      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 resolve(url):
+    """
+        resolves given url by asking all resolvers
+        returns Array of resolved objects in positive usecase
+    """
+    url = util.decode_html(url)
+    util.info('Resolving ' + url)
+    resolver = _get_resolver(url)
+    if resolver is None:
+        return []
+    util.info('Using resolver \'%s\'' % str(resolver.__name__));
+    value = resolver.resolve(url)
+    if not value:
+        return []
+    default = util.item()
+    for i in value:
+        i["resolver"] = resolver.__name__
+        if 'name' not in i.keys():
+            i['name'] = resolver.__name__
+        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'], reverse=True) # TODO sorted by order?
+
+
+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://hqq.tv/player/embed_player.php?vid=235242211228257255206246241253244213194271217261258"
+    #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"
+    url = "https://goo.gl/yMTzqf"
+    url = "http://cdn.kapnob.ru/video/5e67c8b1ad018ffa/iframe"
+    url = "http://kodik.cc/video/10830/4269a802d1a9d9bdc53fe38488d53a52/720p"
+    url = "https://www.youtube.com/embed/RUyQ_JJ6A84?rel=0&fs=1&wmode=transparent"
+    streams = resolve(url)
+    if not streams:
+        print "No streams found"
+        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,100 @@
+# -*- 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
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+#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,239 @@
+# -*- 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 base64
+import urllib
+import sys,os
+
+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 requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+
+__author__ = 'ivars777'
+if __name__ <> "__main__":
+    __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:
+        headers = {'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                   'Content-Type': 'text/html; charset=utf-8'}
+        if "goo.gl" in url:
+            data = util.request(url, headers)
+            player_url = re.search("var ppage = '(.+?)'",data).group(1)
+            player_url = urllib.unquote(player_url)
+        else:
+            vid = m.group('vid')
+            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)
+                sub_url = re.search('sub:"(.+?)"',data).group(1) if re.search('sub:"(.+?)"',data) else ""
+                subs_lang = re.search('sublangs:"(.+?)"',data).group(1) if re.search('sub:"(.+?)"',data) else ""
+                if sub_url:
+                    subs=[{"url":sub_url,'name':subs_lang,"lang":subs_lang}]
+                else:
+                    subs = []
+                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)
+                        stream  = {
+                            'url': file_url,
+                            'name': file_url,
+                            'subs':subs,
+                            'quality': 'hqq',
+                            'resolver': 'hqq',
+                            "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 [stream]
+    return []
+
+
+def _regex(url):
+    # https://goo.gl/yMTzqf
+    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-Za-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
+    # https://goo.gl/yMTzqf
+    match = re.search("(goo)\.gl/(?P<vid>[\w]+)", 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
+
+if __name__ == "__main__":
+
+    url = "http://hqq.tv/player/embed_player.php?vid=nYAKgzBAf7ll"
+    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)
+    pass

resolvers/kapnob.py

@@ -0,0 +1,99 @@
+# -*- 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 requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+
+__author__ = 'ivars777'
+if __name__ <> "__main__":
+    __name__ = 'kapnob'
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+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
+""")
+
+
+def supports(url):
+    return True if "kapnob.ru" in url else False
+
+def resolve(url):
+    HTTP_HEADER = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:39.0) Gecko/20100101 Firefox/39.0',
+        'Referer': url}  # 'Connection': 'keep-alive'
+    stream = util.item()
+    data = requests.get(url,headers = HTTP_HEADER).content
+    m = re.search(r'subtitles: \[\s+{\s+src: "(.+?)",\s+label: "(.+?)",\s+language: "(.+?)"', data, re.DOTALL)
+    if m:
+        sub = {}
+        sub["url"] = m.group(1)
+        sub["name"] = m.group(2)
+        sub["lang"] = m.group(3)
+        sub["type"] = "srt"
+        stream["subs"]=[sub]
+
+    video_token = re.search("video_token: '(.+?)'",data).group(1)
+    content_type = re.search("content_type: '(.+?)'",data).group(1)
+    mw_key = re.search("mw_key: '(.+?)'",data).group(1)
+    mw_domain_id = re.search("mw_domain_id: (\d+)",data).group(1)
+    uuid = re.search("uuid: '(.+?)'",data).group(1)
+    params = "video_token=%s&content_type=%s&mw_key=%s&mw_pid=&mw_domain_id=%s&ad_attr=0&debug=false&uuid=%s"%(
+        video_token,content_type,mw_key,mw_domain_id,uuid)
+    headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Iframe-Option: Direct
+X-Requested-With: XMLHttpRequest
+""")
+    data = requests.post("http://cdn.kapnob.ru/sessions/new_session", data=params,headers=headers).content
+    js = json.loads(data)
+    stream["url"] = js["mans"]["manifest_m3u8"]
+    stream["name"]= stream["url"]
+    return [stream]
+
+
+if __name__ == "__main__":
+
+    url = "http://cdn.kapnob.ru/video/5e67c8b1ad018ffa/iframe"
+    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)
+    pass

resolvers/kodik.py

@@ -0,0 +1,100 @@
+# -*- 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 requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+
+__author__ = 'ivars777'
+if __name__ <> "__main__":
+    __name__ = 'kodik'
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Upgrade-Insecure-Requests: 1
+DNT: 1
+Connection: keep-alive
+Upgrade-Insecure-Requests: 1
+Cache-Control: max-age=0
+
+""")
+
+
+def supports(url):
+    return True if "kodik.cc" in url else False
+
+def resolve(url):
+    global headers0
+    streams = []
+    try:
+        r = requests.get(url,headers=headers0)
+    except:
+        return []
+    if r.status_code<>200:
+        return []
+    data = r.content
+    hash = re.search('hash: "(.+?)"',data).group(1)
+    vid = re.search('id: "(.+?)"',data).group(1)
+    quality = re.search('quality: "(.+?)"',data).group(1)
+    params = "domain=&url=&type=database&hash=%s&id=%s&quality=%s"%(hash,vid,quality)
+    headers = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+Accept: application/json, text/javascript, */*; q=0.01
+Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+X-Requested-With: XMLHttpRequest
+Referer: %s
+"""%url)
+    data = requests.post("http://kodik.cc/get-video", data=params,headers=headers).content
+    js = json.loads(data)
+    for st in js["qualities"]:
+        stream = util.item()
+        stream["url"] = js["qualities"][st]["src"]
+        stream["quality"]=int(st)
+        stream["name"]= stream["url"]
+        streams.append(stream)
+    return streams
+
+if __name__ == "__main__":
+
+    url = "http://kodik.cc/video/10830/4269a802d1a9d9bdc53fe38488d53a52/720p"
+    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)
+    pass

resolvers/openload3.py

@@ -0,0 +1,114 @@
+# -*- 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
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+#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,169 @@
+#!/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, json
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+from collections import OrderedDict
+import ConfigParser
+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 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 = util.item()
+        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 get_epg(self,data):
+        ### Normally to be overrided in child class
+        return [self.get_info(data)]
+
+    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):
+            options0 = self.options
+            config.read(self.config_file)
+            self.options = OrderedDict(config.items(self.name))
+            for k in options0:
+                if not k in self.options:
+                    self.options[k] = options0[k]
+                    self.options_write(self.options)
+        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(data,params,headers)
+        if result:
+            result = json.loads(result)
+            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,verify=False)
+            else:
+                r = requests.get(url, headers=headers,verify=False)
+            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 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):
+    data = data.lower()
+    m = re.search(r"^(\w+)://", data)
+    prefix = m.group(1) if m else ""
+    if prefix in ("http","https"):
+        if ".m3u8" in data:
+            return "hls"
+        elif ".mpd" in data:
+            return "dash"
+        else:
+            return "http"
+    else:
+        return prefix
+
+if __name__ == "__main__":
+    pass

sources/YouTubeVideoUrl.py

@@ -0,0 +1,407 @@
+# -*- 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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+#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,213 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+#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="",cfg_path=None):
+        self.hidden = True # nerāda menu nestrādājošos avotus
+        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,115 @@
+#!/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",cfg_path=None):
+        self.name = "config"
+        self.country=country
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        if not cfg_path: cfg_path = cur_directory
+        self.streams_file = os.path.join(cfg_path,"streams.cfg")
+        self.lists = collections.OrderedDict()
+        self.titles = {}
+        self.read_streams()
+
+    def get_content(self, data):
+        print "[config] get_content",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 line[0] in ("#"): continue
+                items = line.strip().split("|")
+                if not items[0]: continue
+                if len(items)==1:
+                    self.titles[name] = items[0]
+                else:
+                    if len(items) == 4:
+                        items[3] = items[3].replace("\\n","\n")
+                    self.lists[name].append(items)
+
+    def write_streams(self):
+        f = open(self.streams_file,"w")
+        for l in self.lists.keys():
+            f.write("[%s]\n"%l)
+            t = self.get_title(l)
+            if t<>l:
+                f.write("%s\n"%t)
+            for item in self.lists[l]:
+                f.write("%s|%s|%s|%s\n"%(item[0].replace("\n",""),item[1],item[2],item[3].replace("\n","\\n")))
+            f.write("\n")
+        f.close()
+
+    def get_lists(self):
+        return self.lists.keys()
+
+    def get_list_items(self,name):
+        return self.lists[name]
+
+    def get_title(self,name):
+        if name in self.titles:
+            return self.titles[name]
+        else:
+            return 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,305 @@
+#!/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
+import util
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+
+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",cfg_path=None):
+        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__))
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
+        self.options = OrderedDict([("language","en")])
+        self.options_read()
+        self.vid={"1": "News", "2": "European Affairs", "3": "Lifestyle", "4": "Knowledge"}
+        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" if lang == "en" else "http://%s.euronews.com/api/watchlive.json" % lang
+            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")
+
+            stream = util.item()
+            stream["url"]=js["primary"]
+            stream["lang"]= lang
+            stream["quality"]="variant"
+            stream["name"]="Euronews live [%s]"%lang
+            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 find"
+                    continue
+                    #raise Exception(msg)
+                article = r["articlelist"]
+                stream = util.item()
+                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/"
+        r = self._http_request(url)
+        result = re.findall(r'<option value="([^"]+)"\s*(selected)*\slang="([^"]+)" hreflang="([^"]+)">', r, re.DOTALL)
+        languages = []
+        for item in result:
+            languages.append(item[3])
+        if not languages:
+            raise Exception("Can not get languages list")
+        self.languages = languages
+        return self.languages
+
+
+    def get_languages0(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,412 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+try:
+    import util
+except:
+    sys.path.insert(0,'..')
+    import util
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+
+class Source(SourceBase):
+
+    def __init__(self,country="",cfg_path=None):
+        self.name = "filmix"
+        self.title = "filmix.me"
+        self.img = "http://cs5324.vk.me/g33668783/a_903fcc63.jpg"
+        self.desc = "filmix.me satura skatīšanās"
+        self.country=country
+        self.headers = headers2dict("""
+Host: filmix.me
+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 = "https://filmix.me/"
+        #self.login()
+
+    def login(self,user="",password=""):
+        return True
+
+    def get_content(self, data):
+        print "[filmix] 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", "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 = "Мультфильмы"
+            # <span class="menu-title">Фильмы</span>
+            m = re.search('<span class="menu-title">%s</span>(.+?)<li>\s+?<span'%sname, r, re.DOTALL|re.UNICODE)
+            if not m: return content
+            r2 = m.group(1)
+            result = re.findall(r'<a .*?href="https://filmix\.me/([^"]+)".*?>([^<]+)</', 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
+
+        ## Seriāls
+        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 ""
+            vid = plist[-1]
+            m = re.search(r"meta_key = \['(\w+)', '(\w+)', '(\w+)'\]", r, re.IGNORECASE)
+            key = m.group(3) if m else ""
+            js = self.get_movie_info(vid,key)
+            translations = js["message"]["translations"]["html5"]
+            for pl  in translations:
+                if translations[pl].startswith("http"):
+                    continue
+                pl_link = translations[pl]
+                lang = pl.encode("utf8")
+                break
+            else:
+                raise Exception("No episodes list found!")
+            #pl_link = js["message"]["translations"]["flash"].values()[0]
+            #  TODO process several players, currently taking the first
+            #TODO - kļuda, vairs nesradā
+            if not pl_link.startswith("http"):
+                pl_link = self.decode_direct_media_url(pl_link)
+            js = self._http_request(pl_link)
+            js = self.decode_direct_media_url(js)
+            js = json.loads(js)
+            if "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")
+                    if "file" in ep and ep["file"]:
+                        data2 = data+"?e=%s"%(i+1)
+                    else:
+                        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):
+                #m2 = re.search(r'<a class="watch icon-play" itemprop="url" href="([^"]+)"', r2, re.DOTALL)
+                #<a class="watch icon-play" itemprop="url" href="https://filmix.me/dramy/110957-stolik-19-2017.html"
+                #m = re.search(r'<a href="https://filmix\.me/play/(\d+)" class="watch icon-play">', r2, re.DOTALL)
+                m = re.search(r'<a class="watch icon-play" itemprop="url" href="https://filmix.me/\w+/(\d+)-', 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 = 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="https://filmix\.me/([^"]+)" 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):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if clist == "play" and "e=" in data:
+            return True
+        elif clist=="play" and not params:
+            r = self.call(path)
+            #r = r.decode("cp1251").encode("utf8")
+            #m = re.search('itemprop="contentUrl" content="(.+?)"', r, re.IGNORECASE | re.DOTALL)
+            #if not m:
+            if u"Фильм <a href=" in r.decode("cp1251"):
+                return True
+            else:
+                return False
+
+        else:
+            return False
+
+    def get_streams(self, data):
+        print "[filmix] get_streams:", data
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+
+        r = self.call(path)
+        if not r:
+            return []
+        streams = []
+        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 ""
+        m = re.search('itemprop="contentUrl" content="(.+?)"', r, re.IGNORECASE | re.DOTALL)
+        if not m:
+            raise Exception("Can not find video link")
+            #return []
+        video_link = m.group(1)
+        series = False if u"Фильм <a href=" in r.decode("utf8") else True
+        vid = plist[1]
+        m = re.search(r"meta_key = \['(\w+)', '(\w+)', '(\w+)'\]", r, re.IGNORECASE)
+        key = m.group(3) if m else ""
+        js = self.get_movie_info(vid,key)
+        translations = js["message"]["translations"]["html5"]
+        for pl in translations:
+            if translations[pl].startswith("http"):
+                continue
+            pl_link = translations[pl]
+            lang = pl.encode("utf8")
+            break
+        else:
+            raise Exception("No episodes list found!")
+        if not pl_link.startswith("http"):
+            pl_link = self.decode_direct_media_url(pl_link)
+
+        if not series : # Filma
+            url0 = pl_link
+            streams2 = self.get_streams2(url0)
+            for st in streams2:
+                stream = util.item()
+                stream["url"]=st[1]
+                stream["lang"]=lang
+                stream["quality"]=st[0]
+                stream["name"]= title
+                stream["desc"]=desc
+                streams.append(stream)
+            return streams
+
+        else: # Seriāls
+            #pl_link = video_link
+            js = self._http_request(pl_link)
+            js = self.decode_direct_media_url(js)
+            js = json.loads(js)
+            if "e" in qs:
+                if "s" in qs:
+                    s = int(qs["s"])
+                else:
+                    s = None
+                e = int(qs["e"])
+                if s: # sezona + epizode
+                    serie = js["playlist"][s-1]["playlist"][e-1]["comment"].encode("utf8")
+                    title = title0+" - "+ serie
+                    url0 = js["playlist"][s-1]["playlist"][e-1]["file"].encode("utf8")
+                else: # tikai epizode, nav sezonas
+                    title = title0 +" - "+js["playlist"][e-1]["comment"].encode("utf8")
+                    serie = js["playlist"][e-1]["comment"].encode("utf8")
+                    url0 = js["playlist"][e-1]["file"].encode("utf8")
+                streams2 = self.get_streams2(url0)
+                for st in streams2:
+                    stream = util.item()
+                    stream["url"]=st[1]
+                    stream["lang"]=lang
+                    stream["quality"]=st[0]
+                    stream["name"]= title
+                    stream["desc"]=desc
+                    streams.append(stream)
+                return streams
+
+    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_movie_info(self,vid,key=""):
+        headers = headers2dict("""
+    User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
+    Accept: application/json, text/javascript, */*; q=0.01
+    Accept-Language: en-US,en;q=0.5
+    Content-Type: application/x-www-form-urlencoded; charset=UTF-8
+    X-Requested-With: XMLHttpRequest
+    Referer: https://filmix.me/play/%s
+    Cookie: ad_win12=1;
+    """%vid )
+        post_data = {"post_id":vid,"key=":key}
+        r = util.post("https://filmix.me/api/movies/player_data", data=post_data, headers = headers)
+        if not r:
+            raise Exception("Can not get movie info")
+            #return []
+        js = json.loads(r)
+        return js
+
+    def decode_base64(self, encoded_url):
+        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", "=")
+        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")
+        i = 0
+        for a in codec_a:
+            b = codec_b[i]
+            i += 1
+            encoded_url = encoded_url.replace(a, '___')
+            encoded_url = encoded_url.replace(b, a)
+            encoded_url = encoded_url.replace('___', b)
+        return base64.b64decode(encoded_url)
+
+    def decode_unicode(self, encoded_url):
+        from itertools import izip_longest
+        def grouper(n, iterable, fillvalue=None):
+            "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
+            args = [iter(iterable)] * n
+            return izip_longest(fillvalue=fillvalue, *args)
+
+        _ = (encoded_url[1:] if encoded_url.find('#') != -1 else encoded_url)
+        tokens = map(lambda items: '\u0'+''.join(items), grouper(3, _))
+        return ''.join(tokens).decode('unicode_escape')
+
+    def decode_direct_media_url(self, encoded_url, checkhttp=False):
+        if(checkhttp == True and (encoded_url.find('http://') != -1 or encoded_url.find('https://') != -1)):
+            return False
+
+        try:
+            if encoded_url.find('#') != -1:
+                return self.decode_unicode(encoded_url)
+            else:
+                return self.decode_base64(encoded_url)
+        except:
+            return False
+
+
+
+    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):
+        m = re.search("\[([\d\w,]+)\]",url0)
+        if not m:
+            return [("?",url0)]
+        res = m.group(1)
+        streams=[]
+        for res in res.split(","):
+            if not res: continue
+            if res in ["1080p"]: continue #TODO fullhd only in PRO+ version
+            url=re.sub("\[[\d\w,]+\]",res,url0)
+            streams.append((res,url))
+        return streams
+
+
+if __name__ == "__main__":
+
+    c = Source()
+    #s = "ZnVuY3Rpb24gc2VuZE1lc3NhZ2U2MDc3ODkoZSl7dmFyIGg9bWdfd3M2MDc3ODkub25tZXNzYWdlOyBtZ193czYwNzc4OS5yZWFkeVN0YXRlPT1tZ193czYwNzc4OS5DTE9TRUQmJihtZ193czYwNzc4OT1uZXcgV2ViU29ja2V0KG1nX3dzNjA3Nzg5X2xvY2F0aW9uKSksbWdfd3M2MDc3ODkub25tZXNzYWdlPWgsd2FpdEZvclNvY2tldENvbm5lY3Rpb242MDc3ODkobWdfd3M2MDc3ODksZnVuY3Rpb24oKXttZ193czYwNzc4OS5zZW5kKGUpfSl9ZnVuY3Rpb24gd2FpdEZvclNvY2tldENvbm5lY3Rpb242MDc3ODkoZSx0KXtzZXRUaW1lb3V0KGZ1bmN0aW9uKCl7cmV0dXJuIDE9PT1lLnJlYWR5U3RhdGU/dm9pZChudWxsIT10JiZ0KCkpOnZvaWQgd2FpdEZvclNvY2tldENvbm5lY3Rpb242MDc3ODkoZSx0KX0sNSl9OyB2YXIgbWdfd3M2MDc3ODlfbG9jYXRpb24gPSAid3NzOi8vd3NwLm1hcmtldGdpZC5jb20vd3MiOyBtZ193czYwNzc4OSA9IG5ldyBXZWJTb2NrZXQobWdfd3M2MDc3ODlfbG9jYXRpb24pLCBtZ193czYwNzc4OS5vbm1lc3NhZ2UgPSBmdW5jdGlvbiAodCkge3Bvc3RNZXNzYWdlKHQuZGF0YSk7fSwgb25tZXNzYWdlID0gZnVuY3Rpb24oZSl7c2VuZE1lc3NhZ2U2MDc3ODkoZS5kYXRhKX0="
+
+    #txt = c.decode_uppod_text(s)
+    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,276 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+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",cfg_path=None):
+        #self.hidden = True
+        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,559 @@
+#!/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
+import util
+from collections import OrderedDict
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+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,cfg_path=None):
+        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"
+        }
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
+        self.options = OrderedDict([("user","lietotajs"),("password","parole")])
+        self.options_read()
+
+    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,nfo = self.get_epg_live(vid)
+        else:
+            #data_ = "episodes/%s"%vid
+            #r = self.call(data_)
+            title,img,desc,vid,nfo = 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")
+                #print url.split("/")[2]
+                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 = util.item()
+                    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"])
+                    stream["nfo"] = nfo
+                    #print url.split("/")[2]
+                    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)
+                        #print url.split("/")[2]
+                        stream = util.item()
+                        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)
+                        stream["nfo"] = nfo
+                        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
+        nfo = {}
+        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"]["end"].split("T")[0] #["remaining"]["text"]
+            duration = ver["duration"]["text"]
+            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")
+
+            #Create nfo dictionary
+            tt = lambda dd,k,d: dd[k] if k in dd else d
+            nfo_type = "movie" if True else "tvswhow" # TODO
+            t = OrderedDict()
+            t["title"] = title
+            t["originaltitle"] = tt(ep,"original_title","")
+            t["thumb"] = img
+            t["id"] = vid
+            t["outline"] = ep["synopses"]["small"] if "small" in ep["synopses"] else ep["synopses"]["editorial"] if "editorial" in ep["synopses"] else ""
+            t["plot"] = ep["synopses"]["large"] if "large" in ep["synopses"] else ep["synopses"]["medium"] if "medium" in ep["synopses"] else p["synopses"]["small"] if "small" in ep["synopses"] else title
+            t["tagline"] = ep["synopses"]["editorial"] if "editorial" in ep["synopses"] else ""
+            t["runtime"] = tt(ver["duration"],"text","")
+            t["premiered"] = tt(ep,"release_date","")
+            t["aired"] = ver["availability"]["start"].split("T")[0] if "start" in ver["availability"] else ""
+            if "parent_position" in ep: t["episode"] = ep["parent_position"]
+            nfo[nfo_type] = t
+
+            return title.encode("utf8"),img.encode("utf8"),desc.encode("utf8"),vid.encode("utf8"),nfo
+        else:
+            raise Exception("No video info")
+
+    def get_epg_live(self,channelid):
+        data = "channels/%s/highlights?live=true"%channelid
+        r = self.call(data)
+        nfo = {}
+        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"),nfo
+
+    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:
+            from requests.packages.urllib3.exceptions import InsecureRequestWarning
+            requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+        except:
+            pass
+        try:
+            r = requests.get(url, headers=headers)
+            return r.content
+
+        except Exception as ex:
+            if "code" in dir(ex) and 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/lmt.py

@@ -0,0 +1,219 @@
+#!/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
+import datetime, re, sys,os
+import ConfigParser
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+from SourceBase import SourceBase
+
+import resolver
+try:
+    import util
+except:
+    sys.path.insert(0,'..')
+    import util
+from YouTubeVideoUrl import YouTubeVideoUrl
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self, country="",cfg_path=None):
+        self.name = "lmt"
+        self.title = "LMT straume"
+        self.img = "http://www.lob.lv/images/logo/lmt_straume_vert_rgb.png"
+        self.desc = "LMT straume - dažādi video latviesu valodā"
+        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://straume.lmt.lv/lv/"
+
+    ######### Entry point ########
+    def get_content(self, data):
+        print "[lmt] 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", "lmt::meklet?q={0}","","Meklēt"),
+                ("Straumes", "lmt::straumes","","Tiešraides un aktuāli video"),
+                #("TV", "lmt::tv","","TV tiešraides (tikai LMT tīklā)"),
+                ("Jaunākie", "lmt::video/jaunakie?videoPage=1", "", "Visu žanru jaunākie video"),
+                ("Sports", "lmt::video/sports?videoPage=1", "", "Sports"),
+                ("Kultūra un māksla", "lmt::video/kultura?videoPage=1", "", "Kultūra un māksla"),
+                ("Konferences", "lmt::video/konferences?videoPage=1", "", "Konferences"),
+                ("Raidījumi", "lmt::video/raidijumi?videoPage=1", "", "Raidījumi"),
+                ("Notikumi", "lmt::video/notikumi?videoPage=1", "", "Notikumi"),
+                ("Filmas un seriāli", "lmt::video/filmas?videoPage=1", "", "Filmas un seriāli"),
+                ("Dažādi video", "lmt::video/dazadi?videoPage=1", "", "Dažādi video"),
+                ("Viedtelevīzija", "lmt::video/viedtelevizija?videoPage=1", "", "Viedtelevīzija"),
+            ])
+            return content
+
+        elif clist in ("meklet","video", "straumes","video-saraksts"):
+            r=self.call(data)
+            result = re.findall('<a class="video-picture" (.+?)</li>', r, re.IGNORECASE | re.MULTILINE)
+            for r2 in result:
+                m = re.search('<a class="video-title" href="/lv/([^"]+)">([^<]+)<', r2)
+                title = m.group(2)
+                data2 = m.group(1)
+                m = re.search("([^ ]+) 2x", r2)
+                if m:
+                    img = m.group(1)
+                else:
+                    m = re.search('<img src="([^"]+)', r2)
+                    img = m.group(1) if m else ""
+                m = re.search('<span class="playlist-overlay">([^<]+)</span>', r2)
+                overlay = m.group(1) if m else ""
+                m = re.search('<span class="badge badge-[^>]+>([^<]+)(<[^>]+>([^<]+))*</span>', r2, re.IGNORECASE)
+                badge = ""
+                if m:
+                    badge = m.group(1)
+                    if m.group(3):
+                        badge = badge + m.group(3)
+                categories = re.findall('<span class="category-title">([^<]+)</span>', r2)
+                categories = "".join(categories)
+                if overlay:
+                    title = "%s [%s]"%(title,overlay)
+                if badge:
+                    title = "%s [%s]"%(title,badge)
+                desc = title
+                if categories:
+                    desc = desc + "\n"+ categories
+                content.append((title,self.name+"::"+data2,img,desc))
+            m = re.search("videoPage=(\d+)",data)
+            if m:
+                page = int(m.group(1))+1
+                data2 = re.sub(r"videoPage=\d+", r"videoPage=%s"%page, data)
+                content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            #print content
+            return content
+
+
+        ### kaut kas neparedzets ###
+        else:
+            return content
+
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if not clist in ("meklet","video", "straumes","video-saraksts","home"):
+            return True
+
+    def call(self, data,params=None,headers=None,lang=""):
+        if not headers: headers = self.headers
+        url = self.url+data
+        r = requests.get(url,headers = headers)
+        return r.content
+        #result = self._http_request(url,params,headers=headers)
+        return result
+
+    def get_streams(self,data):
+        print "[lmt] get_streams:", data
+        if not self.is_video(data):
+            return []
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        r = self.call(path)
+        title = re.search("<h1>(.+?)</h1", r, re.IGNORECASE).group(1)
+        m = re.search('<a class="category-title".+?[^>]+>([^<]+)<', r, re.IGNORECASE | re.DOTALL)
+        categories = m.group(1) if m else ""
+        m = re.search('<span class="category-title">([^<]+)</span>.+?</p>', r, re.IGNORECASE | re.DOTALL)
+        if m:
+            categories = categories + m.group(1)
+        if categories:
+            tite = "%s [%s]"%(title,categories)
+        img = re.search('<meta property="twitter:image" content="([^"]+)">', r, re.IGNORECASE | re.DOTALL).group(1)
+        desc = title + "\n" + re.search('<meta property="og:description" content="([^"]+)">', r, re.IGNORECASE | re.DOTALL).group(1)
+        m = re.search('file: "([^"]+)"', r, re.IGNORECASE)
+        if m:
+            data2 = m.group(1)
+            stream = util.item()
+            stream["name"] = title
+            stream["url"] = data2
+            stream["img"] = img
+            stream["desc"] = desc
+            stream["resolver"] = "lmt"
+            return [stream]
+        elif re.search('src="http*://www.youtube.com/embed/([\w-]+).*"',r):
+            m = re.search('src="http*://www.youtube.com/embed/([\w-]+).*"',r)
+            video_id = m.group(1)
+            #http://www.youtube.com/embed/RUyQ_JJ6A84?rel=0&fs=1&wmode=transparent
+            data2 = YouTubeVideoUrl().extract(video_id)
+            s = util.item()
+            s["name"] = title
+            s["url"] = data2
+            s["desc"] = desc
+            s["img"] = img
+            s["resolver"] = "lmt"
+            return [s]
+        elif 'src="http://cdn.tiesraides.lv/lmtstraume.lv/' in r:
+            m = re.search('src="(http://cdn\.tiesraides\.lv/[^"]+)"',r)
+            url = m.group(1)
+            # src="http://cdn.tiesraides.lv/lmtstraume.lv/live-record2-ip/40?c=614127284dcd58d8a84afcf498a3ac7a&v=1405"
+            r = self._http_request(url)
+            #http://edge-telia2.tiesraides.lv/live-record2/lmtstraume.lv.40_1/manifest.f4m
+            m = re.search("'(http://.+?\.m3u8)'",r)
+            data2 = m.group(1) if m else ""
+            s = util.item()
+            s["name"] = title
+            s["url"] = data2
+            s["desc"] = desc
+            s["img"] = img
+            s["resolver"] = "lmt"
+            return [s]
+        else:
+            raise Exception("No stream found")
+
+
+                # streams = resolver.resolve(url)
+            # for s in streams:
+            #     s["name"] = title
+            #     s["desc"] = desc
+            #     s["img"] = img
+            #     streams.append(s)
+            # return streams
+
+
+if __name__ == "__main__":
+    country= "lv"
+    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/movieplace.py

@@ -0,0 +1,235 @@
+#!/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 ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+import resolver
+try:
+    import util
+except:
+    sys.path.insert(0,'..')
+    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="",cfg_path=None):
+        self.hidden = True # nerāda menu nestrādājošos avotus
+        self.name = "movieplace"
+        self.title = "MoviePlace.lv"
+        self.img = "http://movieplace.lv/images/logo.png"
+        self.desc = "Movieplace.lv - filmas latviesu valodā"
+        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://movieplace.lv/"
+
+
+    ######### Entry point ########
+    def get_content(self, data):
+        print "[movieplace] 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", "movieplace::search/?q={0}","","Meklēt"),
+                ("Jaunākās filmas", "movieplace::load/?page1","","Visu žanru jaunākās filmas"),
+                ("Jaunākie seriāli", "movieplace::dir/?page1","","Visu žanru jaunākās filmas"),
+                #("Top50 filmas", "movieplace::index/top_50_filmas/0-4","","Top 50 filmas"),
+            ])
+            r = self.call("load/")
+            #i = r.find('<div class="cat-title">Meklēt pēc žanriem</div>')
+            #if i<=0:
+            #    return content
+            i = 0
+            for item in re.findall('<a href="/([^"]+)" class="catName">([^>]+)</a>', r[i:]):
+                title = item[1]
+                data2 = item[0]+"-1"
+                img = self.img
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        elif clist=="search":
+            # TODO
+            r=self.call(data)
+            result = re.findall('<a href="([^"]+)"> (.+?) </a></div>.+?> (.+?)</div>', r, re.DOTALL)
+            for item in result:
+                title = item[1].replace("<b>","").replace("</b>","")
+                data2 = item[0].replace("http://movieplace.lv/","")
+                img = self.img
+                desc = item[2].replace("<b>","").replace("</b>","")
+                content.append((title,self.name+"::"+data2,img,desc))
+            if '<span>&raquo;</span>' in r:
+                m = re.search("p=(\d+)",data)
+                if m:
+                    page = int(m.group(1))+1
+                    data2 = re.sub(r"p=\d+", r"p=%s"%page, data)
+                    content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            return content
+
+        # Filmu saraksti ##
+        elif clist in ["load","dir"] and len(plist)<=3:
+            if clist == "jaunakas":
+                r = self.call("")
+            else:
+                r = self.call(data)
+            #r = r.decode("cp1251").encode("utf8")
+            if clist == "load":
+                result = re.findall(r' <a href="/([^"]+)" alt="([^"]+)"><img src="/([^"]+)" title="([^"]+)">.+?<div class="years">([^<]+)</div>\s+<div class="country">([^<]+)</div>', r, re.DOTALL)
+            else:
+                result = re.findall(r' <a href="/([^"]+)" alt="([^"]+)"><img src="/([^"]+)" title="[^"]+">.+?<span>([^<]+)</span>\s*<div class="country">([^<]+)</div>', r, re.IGNORECASE | re.DOTALL)
+            for item in result:
+                title = item[1]+" [%s]"%item[4] if clist=="load" else item[1]+" / %s [%s]"%(item[3],item[4])
+                img = "http://movieplace.lv/"+item[2]
+                data2 = item[0]
+                desc = "%s\n%s"%(title,item[5]) if clist=="load" else title
+                content.append((title,self.name+"::"+data2,img,desc))
+            m = re.search('<[ab] class="swchItemA*1"( href="/([^"]+)" onclick="[^"]+")*><span>([^<]+)</span></[ab]> </span>', r, re.DOTALL)
+            if m:
+                if m.group(1):
+                    page = int(re.search("\d+$",data).group())
+                    page = page+1
+                    data2 = re.sub("\d$","%s"%page,data)
+                    content.append(("Next page",self.name+"::"+data2,self.img,"Next page"))
+            return content
+
+        ### Seriāls ###
+        elif clist=="dir" and len(plist)==4:
+            r = self.call(path)
+            title0 = re.search('<h2 class="title" itemprop="name">(.+?)</h2>', r, re.DOTALL).group(1)
+            m = re.search(r'<span>VALODA:</span> <b><em itemprop="alternativeHeadline"><a href="[^"]*" class="entAllCats">([^<]+)</a></em></b></div>\s+?<div><span>SEZONA:</span> <b>([^<]+)</b></div>', r, re.IGNORECASE | re.DOTALL)
+            if m:
+                title0 = "%s / Season %s [%s]"%(title0,m.group(2),m.group(1))
+            desc0 = title0
+            img0 = "http://movieplace.lv" + re.search('<img src="(.+?)".+?itemprop="image">', r, re.DOTALL).group(1)
+            #TODO
+            result = re.findall(r'<summary>([^<]+)</summary><iframe src="https://openload\.co/embed/[^/]+/"', r, re.DOTALL)
+            i = 1
+            for item in result:
+                title = title0+" - " + item
+                data2 = data+"?e=%s"%i
+                img = img0
+                desc = desc0
+                content.append((title,self.name+"::"+data2,img,desc))
+                i += 1
+            return content
+
+        ### kaut kas neparedzets ###
+        else:
+            return content
+
+    def is_video(self,data):
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        if clist=="dir" and len(plist) == 4 and "e"in qs: # sērija
+            return True
+        elif clist=="load" and len(plist) == 4:
+            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 get_streams(self,data):
+        print "[movieplace] get_streams:", data
+        if not self.is_video(data):
+            return []
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        r = self.call(path)
+        if clist=="load":
+            m = re.search('<h2 class="title" itemprop="name">([^<]+)</h2>', r, re.DOTALL)
+            title = re.search('<itemprop="name">(.+?)</itemprop="name">', r, re.DOTALL).group(1)
+            m = re.search(r'<div role="tabpanel" class="tab-pane fade in active" id="heading-tab4">\s*(.+?)\s*</div>', r, re.DOTALL)
+            desc = m.group(1) if m else title
+            m = re.search('<meta property="og:image" content="([^"]+)" />', r, re.DOTALL)
+            img = m.group(1) if m else ""
+            rr = []
+            for m in re.finditer("(RU|ENG|LAT|LAT SUB)<BR( /)*>.*?>?<BR( /)*>.*?<iframe", r, re.IGNORECASE | re.DOTALL):
+                if len(rr)>0:
+                    rr[-1]["end"] = m.start()
+                rr.append({"lang":m.group(1),"start":m.start(),"end":len(r)})
+            streams = []
+            for m in re.finditer(r'src="(https*://(goo\.gl|songs2dl|kodik|cdn\.kapnob|hqq|openload|sv1.servkino|vidwatch|online\.kinozz).+?)"', r, re.IGNORECASE | re.DOTALL):
+                url = m.group(1)
+                lang = "?"
+                for rrr in rr:
+                    if m.start()>rrr["start"] and m.start()<rrr["end"]:
+                        lang = rrr["lang"]
+                        break
+                for s in resolver.resolve(url):
+                    s["name"] = title
+                    s["desc"] = desc
+                    s["img"] = img
+                    s["type"] = self.stream_type(s["url"])
+                    s["lang"] = lang
+                    streams.append(s)
+            return streams
+
+
+        elif clist=="dir" and "e" in qs: # serialā sērija
+            #TODO
+            result = re.findall(r'<summary>([^<]+)</summary><iframe src="([^"]+)"', r, re.DOTALL)
+            i = int(qs["s"])-1
+            url0 = result[i][1]
+            title = title + " - " + result[i][0]
+        else:
+            #iframe src="https://openload.co/embed/wlw6Vl9zwL0/"
+            result = re.findall(r'<iframe src="([^"]+)"', r, re.DOTALL)
+            if not result:
+                return []
+            url0 = result[0]
+        return streams
+
+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,283 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+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",cfg_path=None):
+        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,216 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+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",cfg_path=None):
+        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,310 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+from SourceBase import SourceBase
+import util
+
+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",cfg_path=None):
+        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("\\","")
+                #r = self._http_request(data2, headers=headers)
+
+            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,235 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+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="",cfg_path=None):
+        self.hidden = True # nerāda menu nestrādājošos avotus
+        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,345 @@
+#!/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
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+from SourceBase import SourceBase
+import util
+
+headers2dict = lambda  h: dict([l.strip().split(": ") for l in h.strip().splitlines()])
+headers0 = headers2dict("""
+User-Agent: Mozilla/5.0 (Windows NT 6.3; rv:36.0) Gecko/20100101 Firefox/36.04
+Accept: application/json, text/javascript, */*; 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""")
+import HTMLParser
+h = HTMLParser.HTMLParser()
+
+class Source(SourceBase):
+
+    def __init__(self,country="lv",cfg_path=None):
+        self.name = "tvdom"
+        self.title = "TVDom.tv"
+        self.img = "https://tvdom.tv/front/assets/images/logo.png"
+        self.desc = "TVDom.tv portāla satura skatīšanās"
+        self.headers = headers0
+        self.url = "https://tvdom.tv/"
+
+        self.country=country
+        self.session = None
+        self.token = None
+
+        cur_directory = os.path.dirname(os.path.abspath(__file__))
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
+        self.options = OrderedDict([("user","lietotajs"),("password","parole"), ("region", "lv"), ("lang", "lv")])
+        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
+        try:
+            from requests.packages.urllib3.exceptions import InsecureRequestWarning
+            requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+        except:
+            pass
+        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 = self.options["lang"]
+        region = self.options["region"]
+        content=[]
+        content.append(("..return", "back","","Return back"))
+
+        if clist=="home":
+            content.extend([
+                ("Live stream", "tvdom::tiesraides","","TV live streams"),
+                ("Archive - last", "tvdom::arhivs?filter=new&page=0&limit=30&region=%s&language=%s" % (region, lang),"","Video archive - last videos"),
+                ("Archive - popular", "tvdom::arhivs?filter=new&page=0&limit=30&region=%s&language=%s"% (region, lang),"","Video archive - popular video"),
+                ("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":
+            data1 = "infinity/on_front_filter_channels_list.json"
+            params = "hd=&language=%s&region=%s" % (self.options["lang"], self.options["region"])
+            r = self.call_json(data1, params)
+            for genre in  r["data"]:
+                for item in r["data"][genre]:
+                    ch = item["channel_name"]
+                    title = u"%s - %s" % (item["channel_name"], item["program_title"])
+                    img = "https://tvdom.tv"+item["channel_logo"]
+                    data2 = item["program_url"][1:]
+                    desc = u"%s\n%s-%s"%(title,item["time_start"],item["time_stop"])
+                    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)
+            result = re.findall(r'<div class="film-block_img">\s*<img src="([^"]+).+?<a href="/([^"]+)">([^<]+)</a>\s*</div>\s*<ul class="film-block_descr_tag">\s*<li><a href="">([^<]+)</a>', r, re.DOTALL)
+            for item in result:
+                title = item[2] + " ("+ item[3] + ")"
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = "https://tvdom.tv" + item[0]
+                data2 = item[1]
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Arhīva kategorijas ###
+        elif data=="arhivs":
+            url = "https://tvdom.tv/"+data
+            headers = self.headers
+            headers["Cookie"] = "neverending_story=1; user_selected_language=%s"% (self.options["lang"])
+            r = self._http_request(url)
+            result = re.findall(r'data-text-mobile="(.+?)" data-id="(\d+)" data-filter-type="archive_genre">', r)
+            for item in result:
+                title = item[0]
+                img = ""
+                data2 = "arhivs?" + "genre1=%s&filter=new&region=%s&lang=%s&page=0&limit=30" % (item[1], region, lang)
+                desc = title
+                content.append((title,self.name+"::"+data2,img,desc))
+            return content
+
+        ### Arhīva kategorijas programmas ###
+        elif clist=="arhivs":
+            data1 = "infinity/on_front_archive_get_events2.json"
+            r = self.call_json(data1, params[1:])
+
+            for item in r["data"]:
+                title = item["title"] + "- " + item["online_time"]
+                img = "https://tvdom.tv"+item["image"]
+                data2 = item["url"][1:]
+                desc = u"%s\nlast: %s\npopularity: %s\n%s" % (title, item["online_time"], item["popularity"], item["channel_code"])
+                content.append((title,self.name+"::"+data2,img,desc))
+            if len(r["data"]) == 30:
+                page = int(qs["page"]) + 1
+                data2 = re.sub("page=\d+", "page=%s" % page, data)
+                content.append(("Next page",self.name+"::"+data2,"","Go to next page"))
+            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('materialIdentifier : "(\d+)', r, re.DOTALL).group(1)
+            pname = re.split("[_\.\-]", plist[-1])[0]
+            data2 = data+"_"+vid
+            m = re.search(r'var program_title\s*= "(.+?)"', r)
+            title = title0 = m.group(1) if m else data2
+            m = re.search('<p class="content-info__descr-item">(.+?)</p>', r, re.DOTALL)
+            datums = m.group(1).strip() if m else ""
+            title = title + " " + datums
+            m = re.search('<p class="video-player__descr-text" style="height: 100px;">(.+?)<span', r, re.DOTALL)
+            desc = m.group(1).strip() if m else title
+            m = re.search('var share_image\s*= "([^"]+)', r, re.DOTALL)
+            img = m.group(1) if m else ""
+            content.append((title,self.name+"::"+data2,img,desc))
+            i2 = r.find("content  content--indent-pb")
+            r2 = r if i2 == -1 else r[:i2]
+            result = re.findall(r'<img src="([^"]+)" class="content-item__image" alt=""><a href="/([^"]+)" class="content-item__hide-info">.+?<h3 class="content-item__name">\s*<a href="#">\s*([^<]*)\s*<br>\s*([^<]*)\s*</a>\s*</h3>', r2, re.DOTALL)
+            for item in result:
+                if pname not in item[1]:
+                    continue
+                title = item[2] + " " + item[3].strip()
+                title =  h.unescape(title.decode("utf8")).encode("utf8")
+                img = "https://tvdom.tv"+item[0]
+                data2 = item[1]
+                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 get_streams(self,data):
+        print "[tvdom] get_streams:", data
+        if not self.is_video(data):
+            return []
+        source,data,path,plist,clist,params,qs = self.parse_data(data)
+        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)
+
+        if clist == "play_arhivs":
+            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 ""
+
+            m = re.search(r"var streams\s*= ({[^;]+);", r, re.DOTALL)
+            if not m:
+                raise Exception("No stream found")
+            js = json.loads(m.group(1))
+            streams = []
+            for st in js:
+                if st == "qualities": continue
+                s = js[st]
+                data2 = s["url"]
+                stream = util.item()
+                stream["name"] = title
+                stream["url"] = data2
+                stream["img"] = img
+                stream["desc"] = desc
+                stream["resolver"] = "tvdom"
+                stream["quality"] = st
+                stream["order"] = int(st[:-1])
+                streams.append(stream)
+
+            streams = sorted(streams,key=lambda item: item["order"],reverse=True)
+            return streams
+
+        # Tiešraides video
+        else:
+            m = re.search("var streamConnectionUrl = '([^']+)'", r, re.DOTALL)
+            if m:
+                data2 = m.group(1)
+            else:
+                raise Exception("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 ""
+            stream = util.item()
+            stream["name"] = title
+            stream["url"] = data2
+            stream["img"] = img
+            stream["desc"] = desc
+            stream["resolver"] = "tvdom"
+            return [stream]
+
+
+    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
+
+
+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,193 @@
+#!/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 traceback
+from collections import OrderedDict
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+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",cfg_path=None):
+        self.hidden = True
+        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__))
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
+        self.options = OrderedDict([("user","lietotajs"),("password","parole")])
+        self.options_read()
+
+    def login(self,user="",password=""):
+        self.options_read()
+        if not user: user=self.options["user"]
+        if not password: password = self.options["password"]
+        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)
+        #url = "http://m-api.ustvnow.com/gtv/1/live/login?username=%s&password=%s&device=gtv&redir=0"%(user,password)
+        r = self._http_request(url,headers=headers)
+        if 'success' in r:
+            self.token = re.search('"token":"([^"]+)',r).group(1)
+            return True
+        else:
+            return False
+
+    def get_content(self, data):
+        print "[ustvnow] 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
+            #url = "http://m.ustvnow.com/stream/1/live/view?scode=whphd&token=o7oxits4dcjd8hbxusf9d9cgcyad&br_n=Chrome&br_v=60&br_d=desktop"
+            url =  "http://m.ustvnow.com/stream/1/live/%s"%data
+            headers = headers2dict("""
+Accept: application/json, text/javascript, */*; q=0.01
+User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36
+Referer: http://watch.ustvnow.com/guide
+                """)
+            r = self._http_request(url, headers=headers )
+            if not r:
+                return ("No stream found %s"%data,"","","No stream found")
+            r = json.loads(r)
+            if not "r" in dir(self):
+                if not self.token:
+                    self.login()
+                self.r = self.call("live/channelguide?token=%s"%self.token)
+            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 = "" # img TODO
+            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,496 @@
+#!/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
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+import urlparse, urllib
+import datetime, time,re, sys,os
+from collections import OrderedDict
+import ssl
+if "_create_unverified_context" in dir(ssl):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+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",cfg_path=None):
+        self.hidden = True # nerāda menu nestrādājošos avotus
+        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__))
+        if not cfg_path: cfg_path = cur_directory
+        self.config_file = os.path.join(cfg_path,self.name+".cfg")
+        self.options = OrderedDict([("user","change_user"),("password","change_password"),("device","")])
+        self.options_read()
+        self.device = self.options["device"]
+        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/form?csrfToken=%s"%self.csrfToken
+        #      https://viaplay.lv/tdi/login/nav/form?_infuse=1&_ts=1490554674901&csrfToken=
+        params = "nav_redirectUri=https%3A%2F%2Fviaplay.lv%2F&nav_email={}&nav_password={}".format(urllib.quote(user),urllib.quote(password))
+        #         nav_redirectUri=https%3A%2F%2Fviaplay.lv%2F&nav_email=ivars777%40gmail.com&nav_password=kaskade7&nav_remember=true
+        headers["Cookie"] = "ott_cookies_confirmed=1; PLAY_SESSION=%s;"%self.play_session
+        if self.device:
+            headers["Cookie"] += "ott_dids=%s"%self.device
+        #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
+        if not "ott_web_sac" in r.cookies:
+            self.play_session = None
+            return False
+        self.ott = r.cookies["ott_web_sac"]
+
+        ### Dabu iekārtas ID ###
+        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 in ("series","livestream"): # TODO nerāda overtime u.c.
+            m = re.search(r'<h1 class="is-bottom-sticked is-size-h2">(.+?)</h1>.*?<h2 class="is-size-h4">.*?<p class="is-size-h6 is-strong is-bottom-sticked">(.+?)<div class="toggler-content">\s+<p>(.+?)</p>', r, re.DOTALL)
+            if not m:
+                raise Exception("Problem getting video information")
+            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
+                raise Exception("Can not play DRM protected stream!\nOnly local and Russian content available without DRM")
+                continue
+            url = s["src"]
+            #urlp = util.streamproxy_encode(s["src"])
+            stream = util.item()
+            stream["url"]=url
+            stream["resolver"] = "viaplay"
+            stream["lang"]=s["lang"]
+            stream["quality"]="variant"
+            stream["bitrate"]= "1000000"
+            stream["name"]= title
+            stream["desc"]=desc
+            stream["type"]=stype
+            stream["subs"] = captions
+            print url
+            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"]=url2
+                    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

util.py

@@ -0,0 +1,741 @@
+# -*- 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, sys, re
+import urllib, urllib2
+import datetime
+import traceback
+import cookielib
+import requests
+try:
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+except:
+    pass
+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 system():
+    if "kodi" in sys.executable.lower():
+        return "kodi"
+    elif sys.platform == "win32":
+        return "windows"
+    elif sys.platform == "linux2":
+        return "enigma2"
+    else:
+        return "unknown"
+
+def nfo2xml(nfo_dict):
+    nfo_type,nfo = next(nfo_dict.iteritems())
+    s= "<%s>\n"%nfo_type.encode("utf8")
+    for k,v in nfo.iteritems():
+        if isinstance(v,list):
+            for v2 in v:
+                if isinstance(v2,unicode): v2 = v2.encode("utf8")
+                s += "    <%s>%s</%s>\n"%(k.encode("utf8"), v2, k.encode("utf8"))
+        else:
+            if isinstance(v,unicode): v = v.encode("utf8")
+            s += "    <%s>%s</%s>\n"%(k.encode("utf8"), v, k.encode("utf8"))
+    s += "</%s>\n"%nfo_type.encode("utf8")
+    return s
+
+def nfo2desc(nfo):
+
+    if not "title" in nfo:
+        nfo_type, nfo = next(nfo.iteritems())
+    desc = nfo2title(nfo)
+    dd = lambda t: "\n" + nfo[t] if t in nfo and nfo[t] else ""
+    dd2 = lambda t: "\n" + ",".join(nfo[t]) if t in nfo and nfo[t] else ""
+
+    def ddd(t,title=""):
+        if title:
+            title = title + ": "
+        if t in nfo and nfo[t]:
+            if isinstance(nfo[t],list):
+                return "\n" + title + ",".join(nfo[t])
+            else:
+                return "\n" + title + nfo[t]
+        else:
+            return ""
+
+    desc += ddd("tagline")
+    if "plot" in nfo and "tagline" in nfo and nfo["tagline"] <> nfo["plot"]:
+        desc += ddd("plot")
+    elif "plot" in nfo and not "tagline" in nfo:
+        desc += ddd("plot")
+    desc += ddd("genre","Genre")
+    desc += ddd("runtime","Length")
+    desc += ddd("director","Director")
+    desc += ddd("actor","Actors")
+    desc += ddd("language","Languages")
+    desc += ddd("quality","Quality")
+    return desc.encode("utf8") if isinstance(desc,unicode) else desc
+
+def nfo2title(nfo):
+    if not "title" in nfo:
+        nfo_type, nfo = next(nfo.iteritems())
+    title = nfo["title"]
+    if "originaltitle" in nfo and nfo["originaltitle"] and nfo["originaltitle"]<>nfo["title"]:
+        title +=" ~ "+nfo["originaltitle"]
+    if "year" in nfo and nfo["year"]:
+        title += " (%s)"%nfo["year"]
+    return title.encode("utf8") if isinstance(title,unicode) else title
+
+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"],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]
+
+    stream = stream_change(stream)
+    title = stream["name"] if not "nfo" in stream or not stream["nfo"] else nfo2title(stream["nfo"])
+    desc = stream["desc"] if not "nfo" in stream or not stream["nfo"] else nfo2desc(stream["nfo"])
+    img = stream["img"]
+    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
+    print "\n**Play stream %s\n%s" % (title, url.encode("utf8"))
+    return player(url,title,suburl,stream["headers"])
+
+def player(url, title = "", suburl= "",headers={}):
+    from subprocess import call
+    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'
+    ]
+    cmd3 = ["ffplay.exe",url]
+    cmd = cmd3 if url.startswith("https") else cmd2
+    ret = call(cmd)
+    #if ret:
+        #a = raw_input("*** Error, continue")
+    return
+
+def stream_type(data):
+    data = data.lower()
+    m = re.search(r"^(\w+)://", data)
+    prefix = m.group(1) if m else ""
+    if prefix in ("http","https"):
+        if ".m3u8" in data:
+            return "hls"
+        elif ".mpd" in data:
+            return "dash"
+        else:
+            return "http"
+    else:
+        return prefix
+
+def check_version(package,url="http://feed.blue.lv/Packages"):
+    "Return current package version from OPKG feed"
+    url = "http://feed.blue.lv/Packages"
+    r = requests.get(url)
+    if not r.ok:
+        return ""
+    m = re.search("Package: %s\nVersion: (.+?)\n"%package, r.content)
+    if not m:
+        return ""
+    return m.group(1)
+
+SPLIT_CHAR = "~"
+SPLIT_CODE = urllib.quote(SPLIT_CHAR)
+EQ_CODE = urllib.quote("=")
+COL_CODE = urllib.quote(":")
+SPACE_CODE = urllib.quote(" ")
+
+def make_fname(title):
+    "Make file name from title"
+    title = title.strip()
+    fname0 = re.sub("[/\n\r\t,:]"," ",title)
+    fname0 = re.sub("['""]","",fname0)
+    return fname0
+
+def hls_base(url):
+    url2 = url.split("?")[0]
+    url2 = "/".join(url2.split("/")[0:-1])+ "/"
+    return url2
+
+def stream_change(stream):
+    #return stream # TODO
+    if "resolver" in stream and stream["resolver"] in ("viaplay","hqq","filmas") or \
+        "surl" in stream and re.search("https*://(hqq|goo\.gl)",stream["surl"]):
+        stream["url"] = streamproxy_encode(stream["url"],stream["headers"])
+        stream["headers"] = {}
+        return stream
+    else:
+        return stream
+
+def streamproxy_encode(url,headers=[],proxy_url=None):
+    PROXY_URL = "http://localhost:8880/"
+    if not "?" in url:
+        url = url+"?"
+    url2 = url.replace(SPLIT_CHAR,SPLIT_CODE).replace(":",COL_CODE).replace(" ",SPACE_CODE)
+    if not proxy_url:
+        proxy_url = PROXY_URL
+    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).replace(" ",SPACE_CODE)))
+        headers2 = SPLIT_CHAR.join(headers2)
+        url2 = url2+SPLIT_CHAR+headers2
+    #return url2.encode("utf8") if isinstance(url2,unicode) else url2
+    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:]:
+            #h = urllib.unquote()
+            headers[h.split("=")[0]]=urllib.unquote(h.split("=")[1])
+    return url,headers
+
+def streamproxy_encode2(url,headers=[],proxy_url=None):
+    PROXY_URL = "http://localhost:8880/"
+    #url2 = url.replace(SPLIT_CHAR,SPLIT_CODE).replace(":",COL_CODE).replace(" ",SPACE_CODE)
+    url2 = urllib.quote_plus(url)
+    if not proxy_url:
+        proxy_url = PROXY_URL
+    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).replace(" ",SPACE_CODE)))
+        headers2 = SPLIT_CHAR.join(headers2)
+        url2 = url2+SPLIT_CHAR+headers2
+    return url2
+
+def streamproxy_decode2(urlp):
+    path = urlp.replace(re.search("http://[^/]+",urlp).group(0),"")
+    p = path.split(SPLIT_CHAR)
+    url = urllib.unquote_plus(p[0][1:-2])
+    #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:]:
+            #h = urllib.unquote()
+            headers[h.split("=")[0]]=urllib.unquote(h.split("=")[1])
+    return url,headers
+
+class Captions(object):
+    def __init__(self,uri):
+        self.uri = 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:
+            self.load_vtt(s) # TODO
+
+
+    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 get_srt(self):
+        out = ""
+        i = 0
+        for sub in self.subs:
+            i +=1
+            begin = sub["begin"]
+            begin = "%s,%03i"%(str(datetime.timedelta(seconds=begin/1000)),begin%1000)
+            end = sub["end"]
+            end = "%s,%03i"%(str(datetime.timedelta(seconds=end/1000)),end%1000)
+            txt2 = sub["text"]
+            out += "%s\n%s --> %s\n%s\n\n\n"%(i,begin,end,txt2)
+        return out
+
+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():
+    """Default item content"""
+    stream0 = {
+        'name': '', #
+        'url': '',
+        'quality': '?',
+        'surl': '',
+        'subs': [],
+        'headers': {},
+        "desc":"",
+        "img":"",
+        "lang":"",
+        "type":"",
+        "resolver":"",
+        "order":0,
+        "live":False
+        }
+    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"}
+    url = "http://str1e.lattelecom.tv/mobile-vod/mp4:sf_fantastic_beasts_and_where_to_find_them_en_hd.mp4/playlist.m3u8?resource_id=fantastic_beasts_and_where_to_find_them&auth_token=6NAvMFDG+rYTAc4hb5JeL2bmsaRR7bAE23M6KDmhKYOGyXoo0gDpJUE9scYy+nQmfbgk03cWMe9MuXWSH1GqwolEk2jOQ/8Mrg7tOdbwrA8zM7nmkfCZPqQkwajZN4mfSJQVKHqXqJ8="
+    headers={}
+    print url
+    url = "replay::tiesraide/ltv1/"
+    url = "ltc::content/live-streams/103?include=quality"
+    urlp = streamproxy_encode2(url,headers)
+    print urlp
+    url2,headers2 = streamproxy_decode2(urlp)
+    print url2
+    player(urlp)
+    pass
+
+