add vpu_live4.py pixel-perfect block-wall alignment

media/video_player.py

@@ -212,12 +212,13 @@ while v.success and success:
     if wn:
         v.draw(wn) #,x=0,y=0)
 
+        sub = grab(10,10,60,60)
+        sub = pygame.transform.rotate(sub,90)
+        wn.blit(sub, (500,10))
+
         # overlay 
         v.overlay(wn,d)
 
-        sub = grab()
-        #sub = pygame.transform.rotate(sub,90)
-        #wn.blit(sub, (500,10))
         pygame.display.update()
     clock.tick(420)
     #clock.tick(60)

vpu/vpu_live4.py

@@ -0,0 +1,2568 @@
+#!/usr/bin/python3
+
+import math
+import random
+import time
+import os
+import sys
+import traceback
+import gc
+
+HOME = os.getenv('HOME')
+
+import _thread as thread
+
+
+from optparse import OptionParser
+...
+parser = OptionParser()
+parser.add_option("-m", "--mode", dest="mode",
+                  help="pixel mode pix,x,y --mode 40,10,8") #, metavar="FILE")
+
+parser.add_option("-X", "--XX", dest="XX", #default=1,
+                  help="x-split") #, metavar="FILE")
+
+parser.add_option("-x", "--xx", dest="xsplit", #default=1,
+                  help="x-split") #, metavar="FILE")
+parser.add_option("-y", "--yy", dest="ysplit",#default=1,
+                  help="y-split") #, metavar="FILE")
+
+parser.add_option("", "--start-univ", dest="start_univ",default=2,
+                  help="set start-univers default=2") #, metavar="FILE")
+
+parser.add_option("", "--gobo-ch", dest="gobo_ch",default=0,
+                  help="gobo ch univ on 1") #, metavar="FILE")
+
+parser.add_option("", "--gobo-ch2", dest="gobo_ch2",default=0,
+                  help="gobo ch univ on 1") #, metavar="FILE")
+
+#os.environ['SDL_VIDEO_WINDOW_POS'] = '%i,%i' % (200,164)
+parser.add_option("", "--win-pos", dest="win_pos",default="200,164",
+                  help="SDL_VIDEO_WINDOW_POS --win-pos=200,164") #, metavar="FILE")
+
+parser.add_option("", "--pixel-mapping", dest="pixel_mapping",default=0,
+                  help="pixel_mapping file/on --pixel-mapping=_x") #, metavar="FILE")
+
+parser.add_option("", "--dual-vpu", dest="dual_vpu",default=0,
+                  help=" --dual-vpu=1/0") #, metavar="FILE")
+
+
+parser.add_option("", "--grid-a1-idim", dest="grid_a1_idim",default=0,
+                  help=" grid_a1_idim") #, metavar="FILE")
+
+parser.add_option("", "--grid-a2-idim", dest="grid_a2_idim",default=0,
+                  help=" grid_a2_idim") #, metavar="FILE")
+
+
+parser.add_option("", "--countdown", dest="countdown",#default=1,
+                  help="enable countdown") #, metavar="FILE")
+
+parser.add_option("", "--videoplayer", dest="videoplayer",#default=1,
+              help="enable videoplayer") #, metavar="FILE")
+
+parser.add_option("", "--title", dest="title",default="SCREEN",
+              help="set title") #, metavar="FILE")
+
+
+(options, args) = parser.parse_args()
+
+
+import numpy
+
+
+for o in dir(options):
+    if "_" in o:
+        continue
+    print(o,options.__getattribute__(o))
+
+START = time.time()
+
+# ===== ARTNET DMX =========
+
+import memcache
+mc = memcache.Client(['127.0.0.1:11211'], debug=0)
+
+def read_index():
+    ips=mc.get("index")#cmd)
+    if ips is None:
+        ips = {}
+
+    return ips
+
+def select_ip(ips, univ=2): # artnet univ
+    _univ = ":{}".format(univ)
+    for ip in ips: #high priority
+        if "2.0.0" in ip and _univ in ip:
+            return ip
+
+    for ip in ips:
+        if "ltp-out" in ip and _univ in ip:
+            return ip
+
+
+FUNC = 0
+COUNTER = []
+
+if options.countdown:
+    
+    cdmx_start = options.countdown.split(",")
+    for cdmx in cdmx_start:
+        try:
+            cdmx = int(cdmx)
+            _tmp={"DMX":cdmx,"DIM":0,"PAN":127,"TILT":127
+                    ,"CONTROL":0,"SEC":10
+                    ,"RED":255,"GREEN":255,"BLUE":255
+                    ,"_time":time.time(),"_RUN":0,"_pause":0,"_start":0
+                    ,"_SEC":">{}<".format(cdmx)
+                    }
+            COUNTER.append(_tmp)
+        except Exception as e:
+            print("EXCEPTION COUNTER INIT ",cdmx)
+
+
+
+def read_dmx(ip):
+    r = ""
+    if ip:
+        #t = int(math.sin(time.time() - s)*10)
+        r = mc.get(ip) #"2.0.0.13:2")
+        rr = [0]*512
+        for i,v in enumerate(r):
+            try: #cleanup ltp-out to int
+                v = int(v)
+                rr[i] = v
+            except:pass
+        r = rr
+
+
+    if not r:
+        c = 0
+        #time.sleep(0.1)
+        r = [0] *512
+        for i in range(12*8+1):
+            dmx = i*4
+            #print(dmx)
+            r[dmx:dmx+4] = [255,10,10,40] 
+    return r
+
+
+
+# ===== ARTNET DMX =========
+
+PLAYLIST = []
+try:
+    PLAYLIST = open_playlist()
+except:pass
+
+#import json
+#import pickle
+
+sys.path.insert(0,"/opt/LibreLight/Xdesk/")
+from tool.video_capture import scan_capture #as scan_capture
+
+class Vopen():
+
+    def __init__(self,dmx=None,_id=None):
+        global PLAYLIST
+
+        self._id = _id
+        self.fpath = HOME+'/Downloads/'
+        self.fpath = HOME+'/LibreLight/video/'
+        self.fname = '' #'bbb_sunflower_480x320.mp4'
+        #self.fname = 'no-video.mp4'
+        try:
+            self.fname = PLAYLIST[0]
+        except Exception as e:
+            print("Exception set video from PLAYLIST 5543:",e)
+        
+        self.restart_t = time.time()
+        self.fps = 0
+        self.scale = 50 #%
+        self.angle = 0 #%
+        self.dmx=dmx
+        if self._id >= 250:
+            self.fname = "cam_"
+        self.dim = 0
+        self.x = 0
+        self.y = 0
+        self.init_count = 0
+        self.cap = None
+        self.shape = [200,200]  
+        self.img = None
+        self.success = 1
+        self.cv2 = None
+        self._run = 0
+        self.end = 0
+        self._video_nr = 0
+
+        self._stop = 0 # fix buffer-overflow ... ?? opencv
+
+        self.shape_x = 370
+        self.shape_y = 235
+        try:
+            global cv2
+            self.cv2 = cv2
+        except:
+            pass
+
+        self.init()
+
+    def __repr__(self):
+        sizeof = int(sys.getsizeof(self.buffer)/8)
+        return "< id:{} buf:{} run:{} fps:{} scale:{} name:{} {}kb>".format(
+                id(self),len(self.buffer),self._run,self.fps,self.scale
+                ,self.fname,sizeof
+                )
+    def restart(self):
+        print(self,"reset()")
+        self.pos = 0 
+        self.restart_t = time.time()
+
+    def init(self):
+        print("---- ---- Vopen.init()",[self.fname,self._video_nr])
+        print(PLAYLIST)
+        self.time = 0
+        self.t_delta = 0 
+        self.t_last  = time.time()
+        self.im = None
+        self.pos = 0
+        self.buffer = []
+        self._init()
+        self.init_count = 1
+
+    def select_video(self,dmx_value):
+        try:
+            dmx_value = int(dmx_value/10)
+
+            if self._video_nr != dmx_value:
+                self._video_nr = dmx_value
+
+                if self._video_nr >= 25:
+                    self.fname = "cam_"
+                    self.init()
+                elif self._video_nr < len(PLAYLIST):
+                    self.fname = str(PLAYLIST[self._video_nr])
+                    self.init()
+
+        except Exception as e:
+            print("Vopen.select_video()",dmx_value,e)
+
+    def close_cap():
+        print(dir(self.Rcap)) # = self.cv2.VideoCapture(self.fpath+self.fname)
+
+    def _cam_cfg_new(self,fn):
+        #fn = HOME+'/LibreLight/video_in.txt'
+        txt = [
+            "# Example",
+            "d0 w640 h480 # PAL",
+            "d0 w800 h600 # SVGA",
+            "d0 w960 h540 # 540p",
+            "d0 w1024 h768 # XGA <---",
+            "d0 w1280 h720 # 720p",
+            "d0 w1440 h900  # WSXGA+",
+            "d0 w1600 h900  # WSXGA - Laptop 16:9",
+            "d0 w1920 h1080 # HD 1080p",
+            "",
+            "# config",
+            "d0 w1024 h768 # XGA",
+        ]
+        f = open(fn ,"w")
+        f.write("\n".join(txt))
+        f.close()
+    
+    def _cam_cfg(self):
+        fn = HOME+'/LibreLight/video_in.txt'
+        if not os.path.isfile(fn):
+            self._cam_cfg_new(fn)
+        f = open(fn ,"r")
+        lines = f.readlines()
+        f.close()
+        cfg = ""
+        for i in lines:
+            if i.startswith("d"):
+                cfg = i
+        cfg = cfg.split()
+        capture = scan_capture(name="MiraBox",serial="")
+        if capture:
+            print("capture",capture)
+            try:
+                cfg.append(capture[0][0])
+            except Exception as e:
+                print("except 2992",e)
+        else:
+            print("---- ERROR NO VIDEO CAPTURE DEV - FOUND ----")
+        print("_cam_cfg:",len(cfg),[cfg])
+        
+        return cfg
+
+    def _open_cam(self):
+        # LIVE VIDEO INPUT UVC DEVICE
+        cfg = self._cam_cfg()
+
+
+        res = "HD"
+        #res = "4K"
+        #res = ""
+
+        if res == "HD":
+            # HD
+            w = 1920
+            h = 1080
+        elif res == "4K":
+            # 4K
+            w = 3840
+            h = 2160
+        else:
+
+            # LOW
+            w = 1280
+            h = 720
+        d = 0 # VIDEO INPUT DEV 
+
+        for c in cfg:
+            try:
+                if c.startswith("d"):
+                    d = int(c[1:])
+                if c.startswith("h"):
+                    h = int(c[1:])
+                if c.startswith("w"):
+                    w = int(c[1:])
+                if c.startswith("video"):
+                    d = int(c[-1])
+            except Exception as e:
+                print("Exception", "cam_cfg 878",e)
+
+        df = "video{}".format(d)
+        if self._stop:
+            df += "_stop"
+        elif os.path.exists("/dev/{}".format(df)):
+            self.Rcap = self.cv2.VideoCapture(d)
+            self.Rcap.set(self.cv2.CAP_PROP_FRAME_WIDTH, w)
+            self.Rcap.set(self.cv2.CAP_PROP_FRAME_HEIGHT, h)
+        else:
+            #self.Rcap = None
+            #self.end = 1
+            df += "_error"
+
+        if self.fname.startswith("cam_"): 
+            self.fname = "cam_{}".format(df)
+
+
+    def _init(self):
+        print(self)
+        print("videoplayer.init()",self.fpath,self.fname)
+
+        if not os.path.isfile(self.fpath+self.fname):
+            print()
+            print("video file does not exits !! >",self.fpath,self.fname)
+            print()
+            #exit()
+    
+        self.Rsuccess = 0
+        if self.cv2:
+            if self._stop:
+                return
+
+            if self.fname.startswith("cam_"): 
+                self._open_cam()
+            else:
+                self.Rcap = self.cv2.VideoCapture(self.fpath+self.fname, cv2.CAP_FFMPEG) 
+                #FFMPEG malloc(): unsorted double linked list corrupted ... Abgebrochen
+
+            print("_init ?",self.Rcap)
+            print("open ?" ,self.Rcap.isOpened())
+            self.Rcap.read()
+
+            #self.Rfvs = FileVideoStream(self.fpath+self.fname).start()
+            self.Rsuccess = 1
+            self._read()
+
+    def _del(self):
+        self._stop = 1
+
+        self.buffer = [] #.append(self.img)
+        self.Rcap.release()
+        self.Rcap.retrieve()
+
+        self.Rcap = None
+        self.cap = None
+        del self.Rcap #.release()
+        gc.collect()
+
+
+    def _read(self):
+        success = self.Rsuccess
+        ok = 0
+        if success and self.fname:
+            cap = self.Rcap
+            #fvs = self.Rfvs
+            _break = 0
+
+            try:
+                success, img = cap.read()
+
+                if not success:
+                    self.Rcap.release()
+                    self.Rcap.retrieve()
+                    self.end = 1
+                    #j = json.dumps(self.buffer) #.append(img)
+                    #f = open("/tmp/buff")
+                    #f.write(j)
+                    #f.close()
+                    return
+
+                if self.fps == 0:
+                    self.fps = cap.get(cv2.CAP_PROP_FPS)
+                
+                img = self.cv2.cvtColor(img, self.cv2.COLOR_BGR2RGB)
+                if self.fname.startswith("cam_"): 
+                    pass
+                    #img = self.rescale_frame2(img, 1200)
+                else:
+                    img = self.rescale_frame2(img, 200)
+
+                
+                # store frame into buffer list
+                if self.fname.startswith("cam_"): 
+                    self.buffer = [ img ]
+                else:
+                    self.buffer.append(img)
+
+                ok = 1
+                if len(self.buffer) % 100 == 0:
+                    _id = str(self.__repr__)[-5:-1]
+                    print(_id,"video read",self.dmx,len(self.buffer),self.fname,"fps",self.fps,self.dim)
+
+            except Exception as e:
+                print("Excetpion","_init",self,e,end="")
+        self.success = 1
+        return ok
+
+    def read(self):
+        pass
+
+    def prev(self):
+        self.pos -= 1
+        if self.pos < 0:
+            self.pos = len(self.buffer)-1
+        if self.pos >= len(self.buffer):
+            self.pos = len(self.buffer)-1
+        self.im = self.buffer[int(self.pos)]
+
+    def rotateImage(self,image, angle):
+        if angle in [0,360]:
+            pass#return image
+        try:
+            #print("EE",image.shape)
+            #print("EE",dir(image))
+            shape = list(image.shape[1::-1])
+            bg_shape = shape[:]
+
+            delta_x = 0 # + nach rechts
+            delta_y = 0 # + nach unten
+            r = []
+            r.extend(list(range(0-3,0+3)))
+            r.extend(list(range(180-3,180+3)))
+            r.extend(list(range(360-3,360+3)))
+
+            r2 = []
+            r2.extend(list(range(90-3,90+3)))
+            r2.extend(list(range(270-3,270+3)))
+            if angle in r:
+                pass
+            elif  0:#angle in r2:
+                bg_shape = bg_shape[::-1]
+                delta_y = -65 #shape[1]/2 # # + nach unten
+                delta_x = 30 #shape[1]/2 # # + nach unten
+
+                delta_y -= bg_shape[1]/2 - 20
+                delta_x  = bg_shape[0]/2 - 10
+
+                pass
+            else:
+                if shape[0] > shape[1]:
+                    # landscape video 
+                    bg_shape = (shape[0],shape[0])
+                    delta_y = (shape[0]-shape[1])/2
+                else:
+                    # portrait video
+                    bg_shape = (shape[1],shape[1])
+                    delta_x = (shape[1]-shape[0])/2
+
+            center  = (shape[0]/2+delta_x,shape[1]/2+delta_y)
+            image = self.moveImage(image,x=delta_x,y=delta_y,shape=bg_shape)
+
+            bg_shape = tuple(bg_shape) # exception ... if angle 0 no tuple !!!
+            rot_mat = self.cv2.getRotationMatrix2D(center,angle,1.0) 
+            frame   = self.cv2.warpAffine(image, rot_mat,  bg_shape  ) #,flags=self.cv2.INTER_LINEAR)
+            return frame
+        except Exception as e:
+            raise(e)
+    def moveImage(self,img,x=0,y=0,shape=None):
+        # Creating a translation matrix
+        np = numpy
+        translation_matrix = np.float32([ [1,0,x], [0,1,y] ])
+        
+        if shape is None:
+            num_cols,num_rows = img.shape[1::-1]
+        else:
+            num_cols,num_rows = shape #[1::-1]
+        # Image translation
+        frame = self.cv2.warpAffine(img, translation_matrix, (num_cols,num_rows))
+        return frame
+
+    def rescale_frame2(self,frame, width):
+        height = int(frame.shape[0]/frame.shape[1] * width )
+        dim = (width, height)
+        return self.cv2.resize(frame, dim, interpolation =cv2.INTER_AREA)
+
+    def rescale_frame(self,frame, percent=75):
+        width  = int(frame.shape[1] * percent/ 100)
+        height = int(frame.shape[0] * percent/ 100)
+        dim = (width, height)
+        return self.cv2.resize(frame, dim, interpolation =cv2.INTER_AREA)
+
+    def pause(self):
+        #print("pause",self.t_last)
+        t = time.time()
+        self.t_delta = 0 
+        self.t_last = t
+
+    def next_frame(self):
+        #return 0
+        
+        if self._run and len(self.buffer) > 30:
+            t = time.time()
+            self.t_delta = t-self.t_last 
+            self.pos += self.t_delta*self.fps
+            self.t_last = t
+        else:
+            self.pause()
+
+        if self.restart_t > time.time()-0.5:
+            # prevent flickerung by reset
+            #self.pause()
+            self.pos = 5
+            pass
+
+        # restart at the end
+        if int(self.pos) >= len(self.buffer)-1:
+            self.pos = 0 
+        
+        self.img = None
+        if self.buffer:
+            self._img = self.buffer[int(self.pos)]
+            self.img = self._img
+
+    def next(self):
+         
+        try:
+            self.next_frame()
+            if self.img is None:
+                return
+
+            self.img = self.rescale_frame(self.img, percent=self.scale)
+            
+            # rotate frame BUG: x,y offset ??? !!!
+            self.img = self.rotateImage(self.img, self.angle)
+            self.shape = self.img.shape[1::-1]
+
+            if len(self.buffer) % 100 == 0:
+                _id = str(self.__repr__)[-5:-1]
+                print("next",_id)
+
+            # add DIMER to videplayer
+            self.cv2.normalize(self.img, self.img, 0, self.dim, self.cv2.NORM_MINMAX) 
+            
+            img = self.img 
+            if img is None:
+                return 
+            self.im = None
+            self.im = pygame.image.frombuffer(img.tobytes(), self.shape, "RGB")
+
+            #self.next_frame()
+
+        except AttributeError as e:
+            time.sleep(.05)
+            #if self.init_count % 100 == 0:
+            print("except 776",e)
+            #self.init()
+        except Exception as e:
+            print("except 756",e)
+            print(traceback.format_exc())
+            print(sys.exc_info()[2])
+            print()
+
+    def draw(self,wn=None):
+        
+        if self.dim <= 1:
+            return
+
+        if self.scale < 255*.05:
+            self.scale = 255*0.05
+
+        # draw video background box
+        __xw = int(self.shape_x*self.scale/255)
+        __yw = int(self.shape_y*self.scale/255)
+    
+        #xx ,yy = (370,235)
+        xx = self.shape_x #= xx
+        yy = self.shape_y #= yy
+        try:
+            xx ,yy = self.im.get_size()[:2]
+            self.shape_x = xx
+            self.shape_y = yy
+        except AttributeError as e:
+            pass
+
+        xx = int(xx*self.scale/255)
+        yy = int(yy*self.scale/255)
+
+        __xw = int(xx) #*self.scale/255)
+        __yw = int(yy) #*self.scale/255)
+        yellow = [105,50,0]
+        yellow[0] = int(yellow[0]*self.dim/255)  
+        yellow[1] = int(yellow[1]*self.dim/255)  
+        yellow[2] = int(yellow[2]*self.dim/255)  
+
+        if self.fname.startswith("cam_"):
+            pass
+        elif 1: #corner left up
+            p1 = [self.x+2,self.y+2]  
+            p2 = [self.x+__xw-4,self.y+__yw-4]
+            p3 = [self.x+__xw-4,self.y+2]
+            p4 = [self.x+2,self.y+__yw-4]
+
+            p1 = [self.x,self.y]  
+            p2 = [self.x+__xw,self.y+__yw]
+            p3 = [self.x+__xw,self.y]
+            p4 = [self.x,self.y+__yw]
+            
+            hx=int(xx/2)
+            hy=int(yy/2)
+
+            p1 = [self.x-hx,self.y-hy]  
+            p2 = [self.x+__xw-hx,self.y+__yw-hy]
+            p3 = [self.x+__xw-hx,self.y-hy]
+            p4 = [self.x-hx,self.y+__yw-hy]
+
+            pygame.draw.rect(wn,yellow    ,[p1[0]  ,p1[1]  ,__xw  ,__yw])
+            pygame.draw.rect(wn,[25,20,20],[p1[0]+1,p1[1]+1,__xw-2,__yw-2])
+            pygame.draw.line(wn,yellow    ,p1      ,p2)
+            pygame.draw.line(wn,yellow    ,p3      ,p4)
+        if 0: #corner right down
+            pygame.draw.rect(wn,yellow,[self.x-__xw,self.y-__yw,__xw,__yw])
+            pygame.draw.rect(wn,[25,20,20],[self.x+1-__xw,self.y+1-__yw,__xw-2,__yw-2])
+            pygame.draw.line(wn,yellow,[self.x+2-__xw,self.y+2-__yw],[self.x+__xw-4-__xw,self.y+__yw-4-__yw])
+            pygame.draw.line(wn,yellow,[self.x+__xw-4-__xw,self.y+2-__yw],[self.x+2-__xw,self.y+__yw-4-__yw])
+
+        pz = 0
+
+        if self.success and wn and self.im: # is not None:
+            xx ,yy = self.im.get_size()[:2]
+            if self.fname.startswith("cam_"):
+                #wn.blit(self.im, (int(self.x-xx/2), int(self.y))) # corner center-top
+                #wn.blit(self.im, (int(self.x-xx/2), int(self.y-yy))) # corner center-bottom
+                wn.blit(self.im, (int(self.x-xx/2), int(self.y-yy))) # corner center-bottom
+            else:
+                wn.blit(self.im, (int(self.x-xx/2), int(self.y-yy/2)))
+
+    def overlay(self,wn=None,mode="x"):
+        # overlay 
+
+        pygame.draw.rect(wn,[255,200,0],[5,MAIN_SIZE[1]-(self._id+1)*35,300,28])
+        font15 = pygame.font.SysFont("freemonobold",17)
+
+        pz = 0
+
+        if self.end:
+            rgb = [ 100,255,100]
+        else:
+            rgb = [255,100,0]
+        pygame.draw.rect(wn,rgb,[220,MAIN_SIZE[1]-(self._id+1)*35,80,13])
+
+        _line = "error no _line"
+        _line ="FPS:{} F:{:05} von {:05} sec:{:0.02f} von {:0.02f}"
+        if self.fps == 0: # check if div zerro
+            _line = _line.format(self.fps,int(self.pos),len(self.buffer),(-1),pz )
+        else:
+            pz = (len(self.buffer)/self.fps)
+            _line = _line.format(self.fps,int(self.pos),len(self.buffer),(self.pos/self.fps),pz )  
+
+        fr = font15.render(_line ,1, (0,0,0))
+        wn.blit(fr,(10,MAIN_SIZE[1]-(self._id+1)*35))
+
+        if self._run:
+            mode = "run"
+        else:
+            mode = "pause"
+        fr = font15.render(" {} {} >:{} ".format(self._id+1,self._video_nr,mode) ,1, (0,0,0))
+        wn.blit(fr,(3,MAIN_SIZE[1]-(self._id+1)*35+15))
+
+        fr = font15.render("{}".format(self.fname) ,1, (0,0,0))
+        wn.blit(fr,(70,MAIN_SIZE[1]-(self._id+1)*35+15))
+
+Vopen = Vopen
+
+VIDEO = []
+videoplayer=[]            
+cv2 = None
+FileVideoStream = None
+
+_vid = 0
+if type(options.videoplayer) is str:
+    try:
+        import cv2
+    except Exception as e:
+        print("Except Import:",e)
+    try:
+        # faster video reading ... ???
+        from imutils.video import FileVideoStream
+    except Exception as e:
+        print("Except Import:",e)
+
+    max_videoplayer = 4
+    dmx_start =  options.videoplayer.split(",")
+    for cdmx in dmx_start:
+        if len(videoplayer) > max_videoplayer:
+            print("-- videoplayer max count {} !! break".format(max_videoplayer))
+            break
+        print("-- videoplayer dmx:",cdmx)
+        try:
+            cdmx = int(cdmx)
+            videoplayer.append( Vopen(cdmx,_id=_vid) )
+            _vid += 1
+            _tmp = {"DMX":cdmx,"DIM":0,"PAN":127,"TILT":127
+                    ,"CONTROL":0,"SEC":10,"VIDEO":"3"
+                    ,"RED":255,"GREEN":255,"BLUE":255
+                    ,"_time":time.time()
+                    ,"_RUN":0,"_SEC":">{}<".format(cdmx)
+                   }
+            VIDEO.append(_tmp)
+        except Exception as e:
+            print("EXCEPTION COUNTER INIT ",cdmx)
+
+def loop_videoplayer():
+    while 1:
+        _videoplayer = videoplayer[:]
+        #print(".")
+        ok = 0
+        for i in _videoplayer: #.append( Vopen(cdmx,_id=_vid) )
+            try:
+                r = i._read() # read next frame from file
+                if r:
+                    ok = 1
+            except Exception as e:
+                print("EXCEPTION loop_videoplayer ",e)
+
+        if ok == 0:
+            time.sleep(0.1)
+        else:
+            time.sleep(0.005)
+
+thread.start_new_thread(loop_videoplayer,())
+# ===== ======
+
+#self.fname = PLAYLIST[0]
+videoplayer2 = []
+def loop2_videoplayer():
+    while 1:
+        print()
+        print()
+        print()
+        for i,v in enumerate(PLAYLIST):
+            try:
+                video1 = videoplayer2[i] 
+                video1.select_video(i)
+            except:
+                vi = Vopen(181,1) 
+                videoplayer2.append( vi )
+
+
+        _videoplayer = videoplayer2[:]
+
+        ok = 0
+        j =0 
+        for i in _videoplayer: #.append( Vopen(cdmx,_id=_vid) )
+            try:
+                r = i._read() # read next frame from file
+                if r:
+                    print(j,len(videoplayer2),i,len(i.buffer))
+                    ok = 1
+            except Exception as e:
+                print("EXCEPTION loop2_videoplayer ",e)
+
+            time.sleep(0.002)
+            j += 1
+
+
+
+p = 16
+block = [p,p]
+_x = 8
+_y = 8
+
+
+#HD = "0"
+if options.mode:
+    try:
+        HD = options.mode
+        p,_x,_y = HD.split(",")
+        _x = int(_x)
+        _y = int(_y)
+        p = int(p)
+
+        block = [p,p]
+    except Exception as e:
+        print( "Exc",options.mode,e)
+
+# PARSE COMMANDLINE ARGUMENTS
+CFG_IN    = {"name":"CFG_IN","x1":40,"y1":60,"x2":300,"y2":300 ,"w":300,"h":300}
+CFG_OUT   = {"name":"CFG_OUT","x1":40,"y1":60,"x2":300,"y2":300 ,"w":300,"h":300,"on":0}
+#CFG_OUT2   = {"name":"CFG_OUT2","x1":p*8+142,"y1":60,"x2":300,"y2":300 ,"w":300,"h":300,"on":0}
+CFG_OUT2   = {"name":"CFG_OUT2","x1":p*8+(16*2)+8,"y1":60,"x2":300,"y2":300 ,"w":300,"h":300,"on":0}
+CFG_BLOCK = {"name":"CFG_BLOCK","size":16,"h-split":2,"v-split":2,"h-count":8,"v-count":8}
+
+    
+
+if _x < 1:
+    _x = 1
+if _y < 1:
+    _y = 1
+
+CFG_BLOCK["h-count"] = _x
+CFG_BLOCK["v-count"] = _y # int(8*8/_x) #/_x+0.5) #_y
+CFG_BLOCK["size"]    = p
+
+print( [options.xsplit])
+print( [options.ysplit])
+
+try:
+    if options.xsplit:
+        CFG_BLOCK["h-split"] = int(options.xsplit)
+    if options.ysplit:
+        CFG_BLOCK["v-split"] = int(options.ysplit)
+except Exception as e:
+    print( "Exc",options.mode,e)
+
+
+print("HD",CFG_BLOCK["h-split"],CFG_BLOCK["v-split"])
+print("xy",_x,_y)
+print("++++++++++++++++++", p,_x,_y)
+
+_x2 = _x
+
+try:
+    if options.XX:
+        pass#_x2 = int(options.XX)
+except Exception as e:
+    print( "Exc",options.mode,e)
+
+print("_x2 , -X",_x2)
+# ===== GUI =========
+import pygame
+import pygame.gfxdraw
+import pygame.font
+clock = pygame.time.Clock()
+
+os.environ['SDL_VIDEO_WINDOW_POS'] = '%i,%i' % (200,164)
+if options.win_pos:
+    if "," in options.win_pos:
+        win_pos = options.win_pos.split(",")
+        try:
+            WIN_POS = '%i,%i' % (int(win_pos[0]),int(win_pos[1]) )
+            os.environ['SDL_VIDEO_WINDOW_POS'] = WIN_POS
+        except Excetpion as e:
+            print("win_pos",win_pos,e)
+
+
+os.environ['SDL_VIDEO_CENTERED'] = '0'
+
+pg = pygame
+pygame.init()
+pygame.mixer.quit()
+
+
+f = pygame.font.get_fonts()
+for i in f:
+    if "mono" in i.lower():
+        print(i)
+    
+
+font = pygame.font.SysFont("freemonobold",22)
+font10 = pygame.font.SysFont("freemonobold",10)
+font12 = pygame.font.SysFont("freemonobold",12)
+font12l = pygame.font.SysFont("freemono",12)
+font15 = pygame.font.SysFont("freemonobold",15)
+font40 = pygame.font.SysFont("freemonobold",40)
+font80 = pygame.font.SysFont("freemonobold",70)
+#font = pygame.font.SysFont(None,30)
+
+fr = font.render("hallo" ,1, (200,0,255))
+
+
+def clean_path(path):
+    _path = path[:]
+    _path = _path.replace("/","-")
+    _path = _path.replace(".","-")
+    _path = _path.replace("\"","-")
+    _path = _path.replace("'","-")
+    return _path
+
+
+PIXEL_MAPPING = 0
+vpu_wall_conf_file = HOME+"/LibreLight/vpu_wall_conf.csv"
+
+grid_file = "/tmp/vpu_grid_hd.csv"
+text_file = HOME+"/LibreLight/vpu_text_hd.csv"
+play_list = "/tmp/vpu_playlist_hd.csv"
+play_list = HOME+"/LibreLight/video/" #.format(path)
+pm_wy = 0
+if options.pixel_mapping:
+    PIXEL_MAPPING = 1
+    CFG_OUT["on"] = 1
+    path = options.pixel_mapping
+    path = clean_path(path)
+    grid_file = HOME+"/LibreLight/vpu_grid_hd{}.csv".format(path)
+    if options.dual_vpu:
+        grid_file = HOME+"/LibreLight/vpu_grid_dual{}.csv".format(path)
+    text_file = HOME+"/LibreLight/vpu_text_hd{}.csv".format(path)
+    play_list = HOME+"/LibreLight/vpu_playlist_hd{}.csv".format(path)
+    play_list = HOME+"/LibreLight/video/" #.format(path)
+    #_x = 8
+    #_y = 8
+
+if options.dual_vpu:
+    CFG_OUT2["on"] = 1
+
+print("  ",[options.pixel_mapping],"grid_file",grid_file)
+#grid_file = HOME+"/LibreLight/vpu_grid_hd.csv"
+
+
+MAIN_SIZE=(600,500)
+try:
+    if _x < 8 and PIXEL_MAPPING >= 1:
+        wx = 30+30+block[0] * 8
+        CFG_IN["w"] = CFG_BLOCK["size"] * 8
+    else:
+        wx = 30+30+block[0] * _x 
+
+    wy = 40+40+block[1] * _y 
+
+    if type(options.videoplayer) is str:
+        wy += 150 # video playlist
+
+    MAIN_SIZE=(wx,wy)
+
+    if PIXEL_MAPPING >= 1:
+        pm_wy = 11*p #+ p*3
+        CFG_IN["y1"] += 11*p
+        if options.dual_vpu:
+            if wx < p*16+155:
+                wx = p*16+155
+        MAIN_SIZE=(wx,wy+pm_wy)
+
+except Exception as e:
+    print("Exception:",e)
+
+CFG_IN["w"] = CFG_BLOCK["size"] * CFG_BLOCK["h-count"] 
+CFG_IN["h"] = CFG_BLOCK["size"] * CFG_BLOCK["v-count"] 
+
+CFG_OUT["w"] = CFG_BLOCK["size"] * 8
+CFG_OUT["h"] = CFG_BLOCK["size"] * 8
+
+CFG_OUT2["w"] = CFG_BLOCK["size"] * 8
+CFG_OUT2["h"] = CFG_BLOCK["size"] * 8
+
+
+def CFG_CALC_P(CFG):
+    CFG["x2"] = CFG["x1"]+CFG["w"]
+    CFG["y2"] = CFG["y1"]+CFG["h"] 
+    CFG["p1"] = [CFG["x1"] ,CFG["y1"]] 
+    CFG["p2"] = [CFG["x2"] ,CFG["y2"]] 
+    print("CFG",CFG)
+
+# ?
+#CFG_IN["w"] = int(CFG_BLOCK["v-count"]-2) * CFG_BLOCK["size"] 
+
+CFG_CALC_P(CFG_IN)
+CFG_CALC_P(CFG_OUT)
+CFG_CALC_P(CFG_OUT2)
+
+print("CFG_BLOCK",CFG_BLOCK)
+print()
+print()
+print()
+print()
+print()
+
+window = pygame.display.set_mode(MAIN_SIZE,pg.RESIZABLE)#,32)#,pygame.FULLSCREEN) #x left->right ,y top-> bottom
+
+pg.display.set_caption('LibreLight VPU-{}'.format(options.title))
+
+
+class Fix():
+    def __init__(self,_id,pos,block=[16,16],univ=0,dmx=0,ch=4):
+        #print("Fix",_id)
+        self._id = _id
+        self.dmx = (_id-1) * ch +1 #dmx
+        self.univ = univ
+        self.ch  = ch
+        self.pos = pos
+        self.rgb = [0,0,0]
+        self.block = block #[10,10]
+        self.x = pos[0]
+        self.y = pos[1]
+        self._x = 0
+        self._y = 0
+        self.strobo = time.time()
+        self.bmp = 250
+        self.sub_fix = []
+        
+        sub_block =[block[0]/CFG_BLOCK["h-split"],block[1]/CFG_BLOCK["v-split"]] 
+        if _id <= 0: #exit 
+            return
+
+        spalte = (_id-1)%_y +1
+        zeile = int((_id-1)/_x2) #+1
+
+        add_row = _x*CFG_BLOCK["h-split"]*CFG_BLOCK["v-split"]
+
+        #zeile 1
+        sid = (_id-1)*2  + zeile*CFG_BLOCK["h-split"]*_x2
+        sid = sid+1
+        sub_pos= [pos[0]*block[0],pos[1]*block[1]]
+        sub_fix = SubFix(sid,sub_pos,sub_block,univ,dmx,ch)
+        self.sub_fix.append(sub_fix)
+
+        sid = sid+1
+        sub_pos= [pos[0]*block[0]+block[0]/2,pos[1]*block[1]]
+        sub_fix = SubFix(sid,sub_pos,sub_block,univ,dmx,ch)
+        self.sub_fix.append(sub_fix)
+
+        #zeile 2
+        sid = (_id-1)*2+1 + _x2*CFG_BLOCK["h-split"]  + zeile*CFG_BLOCK["h-split"]*_x2 # int(add_row)
+        sub_pos= [pos[0]*block[0],pos[1]*block[1]+block[1]/2]
+        sub_fix = SubFix(sid,sub_pos,sub_block,univ,dmx,ch)
+        self.sub_fix.append(sub_fix)
+
+        #sid = sid+1
+        sid = sid+1   
+        sub_pos= [pos[0]*block[0]+block[0]/2,pos[1]*block[1]+block[1]/2]
+        sub_fix = SubFix(sid,sub_pos,sub_block,univ,dmx,ch)
+        self.sub_fix.append(sub_fix)
+
+    def __repr__(self):
+        return "<Fix: {} {} {} {}>".format(id(self),self.x,self.y,self.dmx)
+
+
+    def calc(self,data):
+        _rgb = [0,255,0]
+        return _rgb
+
+    def sub_calc(self,data):
+        _rgb = [0,255,0]
+        for sub_fix in self.sub_fix:
+            sub_fix.block = self.block[:]
+            _rgb = sub_fix.dmx_calc(data)
+        return _rgb
+        
+    def _calc(self,a,b):
+        A = (self.pos[0])*self.block[0]
+        B = (self.pos[1])*self.block[1]
+        C = self.block[0]-a
+        D = self.block[1]-b
+        return A,B,C,D
+
+    def POS(self,x=None,y=None,a=0,b=0):
+        if type(x) is int:
+            self._x=x
+        if type(y) is int:
+            self._y=y
+
+        A,B,C,D = self._calc(a,b)
+
+        return [self._x+A,self._y+B,C,D]
+
+    def XXXsubPOS(self,x=0,y=0,a=0,b=0):
+        __out = []
+        for sub_fix in self.sub_fix:
+            __out.append( sub_fix.POS(x,y,a,b) )
+        return __out 
+
+
+class SubFix():
+    def __init__(self,_id,pos,block=[16,16],univ=0,dmx=0,ch=4):
+        #print("Fix",_id)
+        self._id = _id
+        self.dmx = (_id-1) * ch +1 #dmx
+        self.univ = univ
+        self.ch  = ch
+        self.pos = pos
+        self.rgb = [0,0,40]
+        self.block = block #[10,10]
+        self.x = pos[0]
+        self.y = pos[1]
+        self._x = 0
+        self._y = 0
+        self.strobo = time.time()
+        self.bmp = 250
+
+    def dmx_calc(self,data):
+        #return [130,30,20]
+        dmx_sub = [30]*10
+        dmx = self.dmx -1
+        _dmx_sub = []
+        if self.dmx >= 0:
+            dmx = rDMX(self.univ,self.dmx)-1
+            if dmx+self.ch < len(data):
+                _dmx_sub = data[dmx:dmx+self.ch]
+        if _dmx_sub:
+            dmx_sub = _dmx_sub
+        dim = dmx_sub[0]/255
+
+        r = dmx_sub[1]*dim
+        g = dmx_sub[2]*dim
+        b = dmx_sub[3]*dim
+
+        r = int(r)
+        g = int(g)
+        b = int(b)
+        self.rgb = [r,g,b]
+        return self.rgb
+     
+    def _calc(self,a,b):
+        A = (self.pos[0]) #+self.block[0]
+        B = (self.pos[1]) #+self.block[1]
+        C = self.block[0]-a
+        D = self.block[1]-b
+        return A,B,C,D
+
+    def POS(self,x=None,y=None,a=0,b=0):
+        if type(x) is int:
+            self._x=x
+        if type(y) is int:
+            self._y=y
+
+        A,B,C,D = self._calc(a,b)
+        #if NR:
+        #    C-=1
+        #    D-=1
+        return [int(self._x+A),int(self._y+B),int(C),int(D)]
+
+class POINTER():
+    def __init__(self):
+        self.pos = [0,0,0,0]
+        self.on = 0
+        self.rgb = [0,100,10]
+        self._x = 0
+        self._y = 0
+        self.x = 0
+        self.y = 0
+        self.fix = Fix(0 ,[999,999],[16,16],0,0,0)
+
+    def row_move(self,x,y):
+        self._x = x
+        self._y = y
+
+    def move(self,pos):
+        self.pos = pos
+        self.on = 1
+
+    def cross(self,x,y):
+        self.x = x
+        self.y = y
+
+    def draw(self,x,y):
+        pos = self.pos[:]
+        #print("draw",x,y,pos)
+        pos[0] += x
+        pos[1] += y
+        fix_x= self.fix.x
+        fix_y= self.fix.y +y
+
+        if 0:# self.on:
+            pygame.draw.rect(window,self.rgb,pos)
+        
+            # mouse grid posision
+            fr = font15.render("{}/{}".format(fix_x+1,fix_y) ,1, (200,200,200))
+            
+            _nr = fix_y * _x + fix_x +1
+            fr = font15.render("{:02}".format(_nr ) ,1, (200,200,200))
+
+            window.blit(fr,(pos[0]+2,pos[1]+2 ))
+            window.blit(fr,(130,1))
+
+        # fix pos
+        #txt=str(pos) #"[0, 0, 0, 0]"
+        #fr = font15.render(txt ,1, (200,200,200))
+        #window.blit(fr,(10,1))
+
+        # pointer
+        fr = font15.render("X:{:03}".format(self._x) ,1, (200,200,200))
+        window.blit(fr,(10,30))
+        fr = font15.render("Y:{:03}".format(self._y) ,1, (200,200,200))
+        window.blit(fr,(10,40))
+        
+        p=110
+
+        # crosshair
+        self.rgb = [0,0,200]
+        pygame.draw.line(window,self.rgb, (self.x-p,self.y) , (self.x-2,self.y),2 ) 
+        pygame.draw.line(window,self.rgb, (self.x,self.y-p) , (self.x,self.y-2),2 ) 
+
+        self.rgb = [0,200,0]
+        pygame.draw.line(window,self.rgb, (self.x+2,self.y) , (self.x+p,self.y),2 ) 
+        pygame.draw.line(window,self.rgb, (self.x,self.y+2) , (self.x,self.y+p),2 ) 
+        self.rgb = [200,0,0]
+
+pointer = POINTER()
+
+NR = 0
+
+running = True
+def event():
+    global NR,running
+    for event in pygame.event.get(): 
+        #print(event.dict)
+
+        _button = None
+        if "button" in event.dict:
+             _button =  event.dict["button"]
+
+        _state = None
+        if "state" in event.dict:
+            _state  = event.state 
+
+        _key = None
+        if "key" in event.dict:
+            _key  = event.key 
+
+        _pos = None
+        if "pos" in event.dict:
+            _pos  = event.pos 
+
+        _type = None
+        if "type" in event.dict:
+            _type  = event.type 
+        _type  = event.type 
+
+        _mod = None
+        if "mod" in event.dict:
+            _mod  = event.mod 
+        if 0:
+            print( " ")
+            print( "{:.02f}".format( time.time() - START ))
+            print("button -",_button,end="\t| ")
+            #print("state  -",_state)
+            print("pos    -",_pos)
+            print("type   -",_type, end="\t| ")
+            print("key    -",_key)
+            print("mod    -",_mod)
+
+        try:
+            if _type in [5,1025]:
+                if _button == 1:
+                    NR += 1
+                    if NR > 1:
+                        NR = 0
+                if _button == 3:
+                    NR -= 1
+                    if NR < 0:
+                        NR = 1
+
+            if _pos:
+                posA = _pos 
+                fix = find_pix(_pos[0]-40,_pos[1]-60+pm_wy)
+                if fix:
+                    #pos = fix.POS(40,60+pm_wy) 
+                    pos = fix.POS() #(CFG_IN["x1"],CFG_IN["y1"])#0,0) #+pm_wy) 
+                    rgb = [0,0,0] 
+                    pointer.move(pos) 
+                    pointer.fix  = fix
+                else:
+                    pointer.on = 0
+                pointer.row_move(_pos[0],_pos[1]) 
+                pointer.cross(_pos[0],_pos[1])
+
+            if event.type == pygame.VIDEORESIZE:
+                 window = pygame.display.set_mode((event.w, event.h), pygame.RESIZABLE)
+        except Exception as e:
+            print(e)
+
+        if event.type==pygame.QUIT: 
+            print("QUIT")
+            running=False
+            #time.sleep(1)
+            sys.exit()
+
+
+fps = 0
+fps2 = 0
+frame = 0
+frame2 = 0
+frame_t = time.time()
+frame2_t = time.time()
+IP = "yyy"
+
+vplay1=0
+vplay2=0
+if options.videoplayer:
+    try:
+        t=options.videoplayer.split(",")
+        vplay1=t[0]
+        vplay2=t[1]
+    except:pass
+
+def draw_overlay():
+    global fps,fps2
+    fr = font15.render("DMX-FPS: {}".format(fps) ,1, (200,0,255))
+    window.blit(fr,(10,2))
+
+    fr = font15.render("GUI-FPS  : {}".format(fps2) ,1, (200,0,255))
+    window.blit(fr,(10,12))
+
+    #fr = font15.render("ip:{}".format(IP) ,1, (200,0,255))
+    #window.blit(fr,(100,2))
+
+    fr = font15.render("start-uni: {:}.xx dRGB".format(options.start_univ) ,1, (200,0,255))
+    window.blit(fr,(90,2))
+
+    fr = font15.render("a1_idim: 1.{:}".format(options.grid_a1_idim) ,1, (200,0,255))
+    window.blit(fr,(90,12))
+
+    fr = font15.render("a2_idim: 1.{:}".format(options.grid_a2_idim) ,1, (200,0,255))
+    window.blit(fr,(90,22))
+
+    fr = font15.render("gobo_ch1: 1.{:}".format(options.gobo_ch) ,1, (200,0,255))
+    window.blit(fr,(180,12))
+    fr = font15.render("gobo_ch2: 1.{:}".format(options.gobo_ch2) ,1, (200,0,255))
+    window.blit(fr,(180,22))
+
+    fr = font15.render("v-play1: 1.{:}".format(vplay1) ,1, (200,0,255))
+    window.blit(fr,(270,12))
+    fr = font15.render("v-play2: 1.{:}".format(vplay2) ,1, (200,0,255))
+    window.blit(fr,(270,22))
+
+def draw_box_frame(window,rgb,pos,offset=0):
+    p1 = [pos[0],pos[1]]
+    p2 = [pos[0]+pos[2],pos[1]+pos[3]]
+    o = offset 
+    _p1 = [p1[0]-o,p1[1]-o]
+    _p2 = [p1[0]-o,p2[1]+o]
+    pygame.draw.line(window,rgb,_p1,_p2)  # left
+    _p1 = [p2[0]+o,p2[1]+o]
+    pygame.draw.line(window,rgb,_p1,_p2)  # bottom
+    _p2 = [p2[0]+o,p1[1]-o]
+    pygame.draw.line(window,rgb,_p1,_p2)  # right
+    _p1 = [p1[0]-o,p1[1]-o]
+    pygame.draw.line(window,rgb,_p1,_p2)  # top
+
+def draw_frame(window,rgb,p1,p2,offset=0):
+    o = offset 
+    _p1 = [p1[0]-o,p1[1]-o]
+    _p2 = [p1[0]-o,p2[1]+o]
+    #pygame.draw.line(window,rgb,_p1,_p2)  # left
+    _p1 = [p2[0]+o,p2[1]+o]
+    pygame.draw.line(window,rgb,_p1,_p2)  # bottom
+    _p2 = [p2[0]+o,p1[1]-o]
+    #pygame.draw.line(window,rgb,_p1,_p2)  # right
+    _p1 = [p1[0]-o,p1[1]-o]
+    pygame.draw.line(window,rgb,_p1,_p2)  # top
+
+def calc_fps():
+    global fps,frame,frame_t
+    t = time.time()
+    if frame_t+1 < t:
+        fps = frame #frame_t- t #frame
+        frame = 1
+        frame_t = time.time()
+
+def calc_fps2():
+    global fps2,frame2,frame2_t
+    t = time.time()
+    if frame2_t+0.1 < t:
+        fps2 = frame2*10 #frame_t- t #frame
+        frame2 = 1
+        frame2_t = t #time.time()
+
+
+TEXT_BLOCK = []
+
+def _create_text_block():
+    print("======== CREATE NEW TEXT FILE !!",text_file)
+    f = open(text_file,"w")
+    for i in range(10):
+        f.write("TEXT {}\n".format(i+1))
+    f.close()
+
+def open_text_block():
+    print("======== OPEN TEXT FILE !!",text_file)
+    _lines = []
+    try:
+        f = open(text_file,"r")
+        _lines = f.readlines()
+        f.close()
+    except FileNotFoundError as e:
+        print("TEXT",e)
+        _create_text_block()
+
+    if len(_lines) <= 0:
+        _create_text_block()
+    lines = []
+    for l in _lines:
+        #print(">> ",l.strip())
+        lines.append(l.strip())
+    if len(lines) <= 10:
+        for i in range(10-len(lines)):
+            lines.append("LINE ERROR")
+    return lines
+
+TEXT_BLOCK = open_text_block()
+TEXT_BLOCK_TIME = time.time()
+
+# video playlist 
+
+PLAYLIST = []
+
+
+def open_playlist():
+    print("======== OPEN PLAYLIST DIR !!",play_list)
+
+    if not os.path.isdir(play_list):
+        os.system("mkdir -p {}".format(play_list))
+
+    _lines = os.listdir(play_list)
+    _lines.sort()
+
+    lines = ['']*25 
+    i=0
+    for l in _lines:
+        l = l.strip()
+        if "_" in l:
+            ll = l.split("_",1)
+            print(">> ",ll)
+            try:
+                lll = int(ll[0])
+                lines[lll] = l
+            except:pass
+
+    if len(lines) <= 10:
+        for i in range(10-len(lines)):
+            lines.append("")#"LINE ERROR")
+    return lines
+
+PLAYLIST_TIME = time.time()
+PLAYLIST = open_playlist()
+# ===== GUI =========
+
+
+def draw_circle(surface,color, pos, radius):
+    x,y=pos
+    pygame.gfxdraw.aacircle(surface, int(x), int(y), radius-1, color)
+    pygame.gfxdraw.filled_circle(surface, int(x), int(y), radius-1, color)
+
+def rDMX(univ,dmx):
+    return univ*512+dmx
+
+def generate_grid(mapping=0):
+    _log = []
+    #if PIXEL_MAPPING:
+    #    log = open(grid_file,"w")
+    head = "i,univ,dmx,x,y,ch\n"
+    head = "i,univ,dmx,ch\n"
+    head = "univ,dmx,x,y,ch\n"
+    head = "nr,id,info\n"
+    print("csv:",head)
+
+    _log.append(head)
+    dmx = 1-1
+    ch = 4
+
+    y=0
+    x=0
+
+    for i in range((_y)*(_x)):
+        #if x > _x and i%_x == 0:
+        if x > 8 and i%8 == 0:
+            #print("--> -->")
+            x=0
+            y+=1
+        
+        _univ = int(dmx/512)
+        _dmx = dmx - (_univ)*512 
+
+        pos=[x,y]
+        line="{},{},x\n".format(i+1,i+1)
+        _log.append(line)
+        dmx += ch
+        x+=1
+
+    if mapping and PIXEL_MAPPING:
+        print("CREATE NEW PIXELMAP FILE !!",grid_file)
+        log = open(grid_file,"w")
+        log.writelines(_log)
+        log.close()
+
+    return _log[:] #GRID
+
+
+
+def init_grid(mapping=0,_x=4,_y=4,_xp=0,_yp=0,start=0,name="init_gird"):
+
+    if mapping and PIXEL_MAPPING:
+        try:
+            log = open(grid_file,"r")
+        except:
+            generate_grid(mapping=mapping)
+            log = open(grid_file,"r")
+        lines = log.readlines()
+    else:
+        lines = generate_grid()
+    
+
+    GRID = []
+    
+    y=0
+    x=0
+    print("CSV header",[lines[0]],[PIXEL_MAPPING,"len:",len(lines),"start:",start,name])
+
+    for i,line in enumerate(lines[1+start:]): #exclude first line
+        #print("rcsv",[line])
+        line = line.strip()
+        line = line.split(",") # csv
+
+        if i >= _x and i%_x == 0:
+            x=0
+            y+=1
+        if y >= _y:
+            break
+
+        _id    = int(line[1])
+
+        pos = [x+_xp,y+_yp] 
+        f   = Fix(_id,pos,block) #pos,univ,dmx,ch)
+        GRID.append(f)
+        x+=1
+    return GRID
+
+def find_pix(x,y):
+    global GRID
+    for fix in GRID:
+        X = 0
+        Y = 0
+
+        pos = fix.POS()
+        if x > pos[0] and x < pos[0]+pos[2]:
+            X = 1
+        if y > pos[1] and y < pos[1]+pos[3]:
+            Y = 1
+        if X and Y:
+            return fix
+            
+GRID = []
+
+GRID_A = []
+
+NR = 0
+START_UNIV=2
+if options.start_univ:
+    try:
+        START_UNIV=int(options.start_univ)
+    except Exception as e:
+        print("Exception START UNIV",e) 
+
+gobo_ch=1
+if options.gobo_ch:
+    try:
+        gobo_ch=int(options.gobo_ch)
+    except Exception as e:
+        print("Exception gobo_ch",e) 
+
+if gobo_ch <= 0:
+    gobo_ch = 1
+
+
+def draw_box(pos1,pos2,color=[128,128,128],text=1):
+
+    color = [200,0,0,127]
+
+    if text:
+        fr = font15.render("A" ,1, (200,200,200))
+        window.blit(fr,pos1)
+
+        fr = font15.render("B" ,1, (200,200,200))
+        window.blit(fr,[pos2[0]-10,pos2[1]-10])
+
+    # h unten
+    _pos1 = [pos1[0],pos2[1]]
+    _pos2 = [pos2[0],pos2[1]]
+    pygame.draw.aaline(window,color,_pos1,_pos2,1)
+
+    color = [255,255,0,127]
+    # h rechts
+    _pos1 = [pos2[0],pos1[1]]
+    _pos2 = [pos2[0],pos2[1]]
+    pygame.draw.aaline(window,color,_pos1,_pos2,1)
+
+
+    color = [0,200,0,127]
+    # h links
+    _pos1 = [pos1[0],pos1[1]]
+    _pos2 = [pos1[0],pos2[1]]
+    pygame.draw.aaline(window,color,_pos1,_pos2,1)
+
+
+    color = [0,0,200,127]
+    # h oben
+    _pos1 = [pos1[0],pos1[1]]
+    _pos2 = [pos2[0],pos1[1]]
+    pygame.draw.aaline(window,color,_pos1,_pos2,1)
+
+def grab(x=55,y=55,w=60,h=60):
+    crop = None
+    rect = pygame.Rect(x, y, w, h)
+    try:
+        sub = window.subsurface(rect)
+        crop = pygame.Surface((w,h))
+        crop.blit(sub, (0,0))
+    except ValueError as e:
+        pass
+        
+    return crop
+        
+vpu_wall_txt="""---,quelle,,---,ziel,---,---
+out,x,y,ang,row,col,info
+Wall1,0,0,0,1,1,
+Wall1,0,0,0,2,2,
+Wall1,0,0,0,3,3,
+Wall1,0,0,0,4,4,
+Wall1,0,0,0,5,5,
+Wall1,0,0,0,6,6,
+Wall1,0,0,0,7,7,
+,,,,,,
+Wall2,0,0,0,4,1,----
+Wall2,0,0,0,5,2,
+Wall2,4,4,0,6,3,
+Wall2,0,0,0,7,4,
+Wall2,0,0,0,8,5,
+Wall2,0,0,0,9,6,
+,,,,,,
+,,,,,,
+Wall3,64,48,0,12,1,----
+Wall3,64,64,0,12,2,
+Wall3,64,80,0,12,3,
+Wall3,64,96,0,12,4,
+Wall3,64,112,0,12,5,
+Wall3,64,128,0,12,6,"""
+def create_vpu_wall_conf():
+    f=open(vpu_wall_conf_file,"w")
+    f.write(vpu_wall_txt)
+    f.close() 
+    print("CREATE VPU CONFIG !")
+
+wall_data = []
+def read_wall_pix(init=0):
+    global wall_data, NR
+    grid = []
+
+    #if not NR and init==0:
+    #    return
+    if init == 0:
+        if NR:
+            if int(time.time()*100) % 20 != 0: # fast reload
+                return 
+        elif int(time.time()*100) % 100 != 0: # slow reload
+                return 
+    if not os.path.isfile(vpu_wall_conf_file):
+        create_vpu_wall_conf()
+
+    f=open(vpu_wall_conf_file,"r") 
+    lines = f.readlines()
+    for i,line in enumerate(lines):
+        line = line.strip()
+        if not line:
+            continue
+        line = line.split(",")
+        if not line[0]:
+            continue
+        #print(i,line)
+        if len(line) >= 3:
+            _l = []
+            for i in line:
+                try:
+                    _l.append(int(i))
+                except Exception as e:
+                    _l.append(i)
+            grid.append(_l)
+
+    for i,v in enumerate(grid):
+        print(i,v)
+
+    wall_data = grid
+read_wall_pix(init=1)
+
+def reshape2(GRID,GRID_OUT,_x,_y,name="GRID_Z"): 
+    _w = 16
+    _h = 16
+    from_x_min = 40 #320
+    from_y_min = 236
+
+    target_x = 40 # min
+    target_y = 60 # min
+    ang=0
+
+    #read_block_pix()
+    read_wall_pix()
+    _wall_data = wall_data[:]
+    for i,_wall in enumerate(_wall_data):
+        print(_wall)
+        if len(_wall) <=6:
+            continue
+        try:
+            from_x=from_x_min+_wall[1]#*_w
+            from_y=from_y_min+_wall[2]#*_h
+            _a= _wall[3]
+            ang=0
+            if _a < 0:
+                ang=0
+            elif _a > 0 and _a <= 90:
+                ang = 90
+            elif _a > 90 and _a <= 180:
+                ang = 180
+            elif _a > 180 and _a <= 270:
+                ang = 270
+            target_x=40+(_wall[4]-1)*_w
+            target_y=60+(_wall[5]-1)*_h
+            sub = grab(from_x,from_y,_w,_h)
+            #draw_box_frame(window,[0,40,0],[from_x+x,from_y+y,_w,_h])
+            if sub:
+                sub = pygame.transform.rotate(sub,ang)
+                window.blit(sub,(target_x,target_y))
+        except Exception as e:
+            print("WALL err:",e)
+
+
+
+def reshape(GRID,GRID_OUT,_x,_y,name="GRID_Z"): 
+    """reshape LED-WALL Block/Pixel mapping"""
+    if PIXEL_MAPPING <= 0:
+        return None
+
+
+    x = _x
+    y = _y
+    i = 0
+    counter = 0
+    z=0
+    x_min = 99999
+    x_max = 0
+    y_min = 99999
+    y_max = 0
+
+    pos= [0,0]
+    pos[0] = _x+p*3 #+10
+    pos[1] = p*8+65 #-10 #_y+p*8+80 
+
+    
+    tmp_font = pygame.font.SysFont("freemonobold",int(p*0.8))
+
+    #fr   = tmp_font.render("OUTPUT: "+str(name) ,1, (255,255,255))
+    #fr_r = fr.get_rect(center=(int(wx/2),int(0+pm_wy-p*0-10)))
+    #window.blit(fr,pos)
+
+    fr   = tmp_font.render("INPUT" ,1, (255,255,255))
+    fr_r = fr.get_rect(center=(int(wx/2),int(60+pm_wy-p/2)))
+    window.blit(fr,fr_r)
+
+
+    j = 0
+    for fix in GRID_OUT:
+        if j >= 64:
+            break
+        j+=1
+        ii = i
+        #pos = fix.POS(40,60)
+        pos = fix.POS() #(0,0)
+        rgb = fix.rgb
+        pos[0]+=_x
+        pos[1]+=_y
+
+        # green
+        pygame.draw.rect(window,[0,40,0],pos)
+
+        xposs = [] #None #pos[:]
+        for fix2 in GRID:
+            if fix._id == fix2._id:
+                #_xposs = fix2.POS(40,60) 
+                #_xposs = fix2.POS(0,0)#_x,_y) 
+                _xposs = fix2.POS() #(CFG_IN["x1"],CFG_IN["y1"])
+                xposs.append( _xposs) #fix2.POS(40,60) )
+        # ToDo
+        #sub = grab(10,10,60,60)
+        #sub = pygame.transform.rotate(sub,90)
+        #wn.blit(sub, (500,10))
+        for xpos in xposs:
+            #sub = grab(xpos[0],xpos[1]+pm_wy,xpos[2],xpos[3])
+            sub = grab(xpos[0],xpos[1],xpos[2],xpos[3])
+            if NR:
+                pygame.draw.rect(window,[255,0,255],xpos,1) # frame on grab area
+            if sub:
+                window.blit(sub, (pos[0]+z,pos[1]+z))
+            else:
+                # red
+                pygame.draw.rect(window,[40,0,0],pos) #[x+pos[0]+2+z,y+pos[1]+2+z-pm_wy,12,9])
+
+
+            if xpos[0] < x_min:
+                x_min = xpos[0]
+            if xpos[0] > x_max:
+                x_max += xpos[2]
+
+            if xpos[1] < y_min:
+                y_min = xpos[1]
+            if xpos[1] > x_max:
+                y_max += xpos[3]
+            # DRAW FIX NUMBER on TOP
+
+        #apos = fix.POS(40,60)#+pm_wy)
+        apos = fix.POS() #0,0)#+pm_wy)
+        apos[0]+=_x
+        apos[1]+=_y
+        argb = fix.rgb
+
+        # overwrite number overlay
+        if  NR:
+            pygame.draw.rect(window,[20,20,20],[apos[0],apos[1],12,8])
+
+        fix_id = fix._id
+        if fix_id > 8*8:
+            fix_id -= 8*8 
+        if NR:# == 2: # sub fix_nr
+            if fix_id != i+1:
+                fr = font12.render("{:02}".format(fix._id) ,1, (255,255,0))
+                window.blit(fr,(apos[0],apos[1]))
+            else:
+                fr = font12.render("{:02}".format(fix._id) ,1, (100,100,255))
+                window.blit(fr,(apos[0],apos[1]))
+        i += 1
+        #print("--#")
+
+    # frame box
+    pos1= [x+x_min,y+x_min]
+    pos2= [x_max+x_min,y_min+y_max]
+
+
+
+class Timer():
+    def __init__(self,start=120):
+        self.start = start
+        self.timer = self.start
+
+        self.timer_t = time.time()
+
+    def reset(self):
+        self.timer = self.start
+
+    def get(self):
+        self.timer -= time.time()-self.timer_t
+        self.timer_t = time.time()
+        if self.timer <= 0:
+            self.reset()
+        return self.timer
+
+def reload_grid():
+    print("==== reload_grid")
+    global GRID
+    global GRID_A
+    try:
+        GRID   = init_grid(_x=_x,_y=_y,name="GRID") #init_gird()
+        GRID_A = init_grid(_x=8,_y=16,mapping=1,name="GRID_A") #init_gird()
+    except Exception as e:
+        print("Except: grid re init",e)
+
+VPU_TEXT = []
+def load_vpu_text(nr=0):
+    txt = "NONE"
+    if len(VPU_TEXT) > nr:
+        txt = VPU_TEXT[0]
+    return txt
+
+import string
+def draw_kachel_nr(): #GRID,_x=0,_y=0):
+    if not NR:
+        return
+    n = 0
+    _max_row = 40
+    _y=0
+    for i in range(8):
+        _x=0
+        for j in range(20):
+            pygame.draw.rect(window,[10,20,10],[40+_x+2,60+_y+2,14,9]) #background
+            _j=j #string.ascii_uppercase[j]
+            fr = font12.render("{}:{}".format(_j+1,i+1) ,1, (200,200,55))
+            window.blit(fr,(40+_x+2,60+_y+2))
+            #fr = font12.render("{}".format(_j) ,1, (200,200,55))
+            #window.blit(fr,(40+_x+2,60+_y+2))
+            #fr = font12.render(":{}".format(i+1) ,1, (200,200,55))
+            #window.blit(fr,(40+_x+2+6,60+_y+2))
+            _x+=16
+        _y +=16
+
+grid_counter = time.time()
+ 
+
+def draw_counter(COUNTER):
+    for count in COUNTER:
+        cpan = 0
+        ctilt = 0
+        cr=255
+        cg=255
+        cb=255
+        csize=10
+        cdim=0
+        k = "DIM"
+        if k in count:
+            cdim = int(count[k])
+        k = "RED"
+        if k in count:
+            cr = int(count[k])
+        k = "GREEN"
+        if k in count:
+            cg = int(count[k])
+        k = "BLUE"
+        if k in count:
+            cb = int(count[k])
+
+        k = "SIZE"
+        if k in count:
+            csize = int(count[k]) #/60*p)
+        if csize < 5:
+            csize = 5
+
+        k = "PAN"
+        if k in count:
+            cpan = int(count[k])/255*(block[0] *(_x))
+            #cpan = int(cpan * 1.2)
+            cpan = int(cpan)
+        k = "TILT"
+        if k in count:
+            ctilt = int(count[k])/255*(block[1] *(_y))
+            #ctilt = int(cpan * 1.2)
+            ctilt = int(ctilt)
+
+        ddim = cdim/255
+        if "DIM" in count and count["DIM"] > 0:
+            tmp_font = pygame.font.SysFont("freemonobold",int(p/100*csize))
+            rgb =(int(cr*ddim),int(cg*ddim),int(cb*ddim),cdim) 
+            
+            _sec = count["_SEC"]
+            
+            try:
+                _sec = int(count["_SEC"])
+            except:
+                pass
+
+            if type(_sec) is int:
+                #print(_sec)
+                if _sec <= 60:
+                    fr = tmp_font.render("{:0}".format(_sec) ,1, rgb)
+                else:
+                    _xx = time.strftime("%M:%S",time.localtime(_sec))
+                    #print("_xx",_xx)
+                    fr = tmp_font.render("{}".format(_xx) ,1, rgb)
+            else:
+                fr = tmp_font.render("{}".format((count["_SEC"])) ,1, rgb)
+
+            fr_r = fr.get_rect(center=(40+cpan-(block[0]),60+ctilt+pm_wy))
+            pygame.draw.rect(window,[0,0,0],fr_r)
+            window.blit(fr,fr_r)
+
+class FADE():
+    def __init__(self,sec):
+        self.start = time.time()
+        self.sec = sec
+        self.val
+    def next(self):
+        pass
+def draw_video(VIDEO):
+    global videplayer
+    i = 0
+
+    # set DMX-VALUE to videoplayer Object
+    for count in VIDEO:
+        cpan = 0
+        ctilt = 0
+        cr=255
+        cg=255
+        cb=255
+        csize=10
+        cang=0
+        cdim=0
+        
+
+        video1 = videoplayer[i]
+        k = "VIDEO"
+        if k in count:
+            #video1.select_video(count[k])
+
+            play_nr = int(count[k]/10)
+            if play_nr != video1._video_nr:
+                print( "+ + + +  + + + + + + +", play_nr , video1._video_nr ,str(video1))
+                _vid  = video1._id
+                _cdmx = video1.dmx
+                del_video1 = video1
+
+                video1 = Vopen(cdmx,_id=_vid) 
+                video1.select_video(count[k])
+                videoplayer[i] = video1
+
+                del_video1._del()
+                del del_video1
+
+        k = "DIM"
+        if k in count:
+            cdim = int(count[k])
+            video1.dim = cdim
+        #if i == 0:
+        #    print(i,cdim)
+
+        k = "ANG"
+        if k in count:
+            cang = int(count[k])
+
+        k = "SIZE"
+        if k in count:
+            csize = int(count[k]/16*p)
+        if csize < 5:
+            csize = 5
+
+        k = "PAN"
+        cpan_max = block[0] *(_x) #+block[0]
+        if k in count:
+            if 0:#video1.fname.startswith("cam_"):
+                cpan = int(count[k]) #/ 255*cpan_max
+            else:
+                cpan = int(count[k]) / 255*cpan_max
+            cpan = int(cpan)
+
+        k = "TILT"
+        ctilt_max = block[1] *(_y) #+block[1]
+        if k in count:
+            ctilt = int(count[k]) / 255*ctilt_max
+            ctilt = int(ctilt)
+
+        
+
+
+        k = "_reset"
+        if k in count:
+            if count[k]:
+                count[k] = 0
+                video1.restart()
+
+        k = "_RUN"
+        if k in count:
+            video1._run = count[k]
+
+
+
+        video1.pos 
+        #video1.x=40+0+cpan 
+        #video1.y=60+0+pm_wy+ctilt
+        video1.x=CFG_IN["x1"]+cpan 
+        video1.y=CFG_IN["y1"]+ctilt
+        video1.scale = int((csize))
+        video1.angle = int(360-(cang))
+
+        if cdim:
+            video1.next()
+        i += 1
+
+    # draw
+
+    i=0
+    for count in VIDEO:
+        video1 = videoplayer[i]
+        video1.draw(window) #,x=0,y=0)
+        i+=1
+
+
+    i=0
+    for count in VIDEO:
+        video1 = videoplayer[i]
+        video1.overlay(window,"run")
+        i += 1
+
+
+
+def counter_dmx(COUNTER,dataA):
+    for count in COUNTER:
+        cDMX=count["DMX"]-1
+        try:
+            count["DIM"]   = dataA[cDMX]
+            count["PAN"]   = dataA[cDMX+1]
+            count["TILT"]  = dataA[cDMX+2]
+            count["CONTROL"] = dataA[cDMX+3]
+            count["SIZE"]  = dataA[cDMX+4]
+            count["SEC"]   = dataA[cDMX+5]
+            count["RED"]   = dataA[cDMX+6]
+            count["GREEN"] = dataA[cDMX+7]
+            count["BLUE"]  = dataA[cDMX+8]
+
+            if count["CONTROL"] >= 10 and count["CONTROL"] < 20: # RESET COUNTER
+                count["_RUN"]   = 0 
+                count["_pause"] = 0
+                count["_time"]  = time.time()
+                count["_start"] = int(count["SEC"])
+                count["_SEC"]   = int(count["_start"]) 
+            if count["CONTROL"] >= 20 and count["CONTROL"] < 30: # PAUSE COUNTER
+                count["_RUN"] = 0 
+            if count["CONTROL"] >= 30 and count["CONTROL"] < 40: # PLAY COUNTER
+                count["_RUN"] = 1
+
+
+
+            if count["_RUN"]:
+                try:
+                    if count["_pause"] > 0:
+                        count["_time"] += time.time()-count["_pause"]
+                        count["_pause"] = 0
+                    count["_SEC"] = int(count["_start"] - (time.time() - count["_time"]))
+
+                except Exception as e:
+                    pass
+            else:
+                if count["_pause"] == 0:
+                    count["_pause"] = time.time()
+            if type(count["_SEC"]) is int:
+                if count["_SEC"] < 0:
+                    count["_SEC"] = 0
+            for ti in range(10):
+                #print(ti,(ti+6)*10)
+                if count["CONTROL"] >= (ti+6)*10 and count["CONTROL"] < (ti+7)*10:
+                    count["_SEC"] = "----" #text 1
+                    try:
+                        count["_SEC"] = TEXT_BLOCK[ti]
+                    except Exception as e:
+                        pass
+
+            if count["CONTROL"] >= 250 and count["CONTROL"] < 256:
+                count["_SEC"] = "DMX:{}-{}".format(cDMX+1,cDMX+8+1)
+
+        except Exception as e:
+            print("EXC FUNC",e,count)
+        #print(count)
+
+
+def video_dmx(VIDEO,dataA):
+    for count in VIDEO:
+        cDMX=count["DMX"]-1
+        try:
+            count["DIM"]   = dataA[cDMX]
+            count["PAN"]   = dataA[cDMX+1]
+            count["TILT"]  = dataA[cDMX+2]
+            count["CONTROL"] = dataA[cDMX+3]
+
+            if count["CONTROL"] >= 10 and count["CONTROL"] < 20:
+                count["_reset"] = 1
+
+            if count["CONTROL"] >= 20 and count["CONTROL"] < 30:
+                if count["_RUN"] == 1:
+                    print(  "_RUN:0",count["DMX"]-1)
+                count["_RUN"] = 0 
+
+            if count["CONTROL"] >= 30 and count["CONTROL"] < 40:
+                if count["_RUN"] == 0:
+                    print(  "_RUN:1",count["DMX"]-1)
+                count["_RUN"] = 1
+
+            count["SIZE"]  = dataA[cDMX+4]#*2
+            count["SEC"]   = dataA[cDMX+5]
+
+            #count["RED"]   = dataA[cDMX+6]
+            count["VIDEO"] = dataA[cDMX+6]
+            #count["GREEN"] = dataA[cDMX+7]
+            count["ANG"] = (int(dataA[cDMX+7])/255*360)
+            #count["BLUE"]  = dataA[cDMX+8]
+        except Exception as e:
+            print("VIDEOPLAYER EXCEPT FUNC",e,count)
+        #print(count)
+
+def read_dmx_data(ip,ips):
+    ip = select_ip(ips,univ=START_UNIV)
+    IP = ip
+    data = read_dmx(ip)
+
+
+    ip = select_ip(ips,univ=START_UNIV+1)
+    data3 = read_dmx(ip)
+    data.extend(data3)
+
+    ip = select_ip(ips,univ=START_UNIV+2)
+    data3 = read_dmx(ip)
+    data.extend(data3)
+
+    ip = select_ip(ips,univ=START_UNIV+3)
+    data3 = read_dmx(ip)
+    data.extend(data3)
+
+    if options.dual_vpu:
+        ip = select_ip(ips,univ=START_UNIV+4)
+        data3 = read_dmx(ip)
+        data.extend(data3)
+        
+        ip = select_ip(ips,univ=START_UNIV+5)
+        data3 = read_dmx(ip)
+        data.extend(data3)
+    return data
+
+def set_pos(GRID,_x=0,_y=0):
+    for fix in GRID:
+        pos = fix.POS(_x,_y)#40,60+pm_wy)
+        for subfix in fix.sub_fix:
+            #subfix.dmc_calc(data)
+            spos = subfix.POS(_x,_y)
+        
+def draw_gobo(GRID,data,_x=0,_y=0):
+
+    i = 0
+    dmx = 1
+    h = 1
+    v = 1
+    for fix in GRID:
+        rgb = fix.rgb
+        pos = fix.POS() #CFG_IN["x1"],CFG_IN["y1"]) 
+
+        pygame.draw.rect(window,rgb,pos)
+
+        # DRAW SUB-FIXTURE
+        j = 0
+        for subfix in fix.sub_fix:#calc(data):
+            subfix.dmx_calc(data)
+            spos = subfix.POS() #_x,_y)#+pm_wy)
+            srgb = subfix.rgb
+
+            if FUNC > 10 and FUNC <= 20: # big dot
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/2))
+            elif FUNC > 20 and FUNC <= 30:#small dot
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/3.5))
+            elif FUNC > 30 and FUNC <= 40:#donut
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/2))
+                draw_circle(window,[0,0,0],(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/3.5))
+            elif FUNC > 40 and FUNC <= 50: # rec with hole
+                pygame.draw.rect(window,srgb,spos)
+                draw_circle(window,[0,0,0],(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/3.5))
+            elif FUNC > 50 and FUNC <= 60: # rec with big hole
+                pygame.draw.rect(window,srgb,spos)
+                draw_circle(window,[0,0,0],(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/2))
+            elif FUNC > 60 and FUNC <= 70: # rec with donat
+                pygame.draw.rect(window,srgb,spos)
+                draw_circle(window,[0,0,0],(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/2))
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/3.5))
+            elif FUNC > 70 and FUNC <= 80: # rec boarder
+                pygame.draw.rect(window,srgb,[spos[0]+1,spos[1]+1,spos[2]-2,spos[3]-2])
+            elif FUNC > 80 and FUNC <= 90: # rec big boarder
+                pygame.draw.rect(window,srgb,[spos[0]+2,spos[1]+2,spos[2]-4,spos[3]-4])
+            elif FUNC > 90 and FUNC <= 100: # rec thin line
+                pygame.draw.rect(window,srgb,spos)
+                pygame.draw.rect(window,[0,0,0],[spos[0]+1,spos[1]+1,spos[2]-2,spos[3]-2])
+            elif FUNC > 100 and FUNC <= 110: # rec big line
+                pygame.draw.rect(window,srgb,spos)
+                pygame.draw.rect(window,[0,0,0],[spos[0]+2,spos[1]+2,spos[2]-4,spos[3]-4])
+            elif FUNC > 110 and FUNC <= 120: # rec with dot
+                pygame.draw.rect(window,srgb,spos)
+                pygame.draw.rect(window,[0,0,0],[spos[0]+1,spos[1]+1,spos[2]-2,spos[3]-2])
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)),int(spos[3]/3.5))
+            elif FUNC > 120 and FUNC <= 130: # rec inline
+                pygame.draw.rect(window,srgb,[spos[0]+2,spos[1]+2,spos[2]-4,spos[3]-4])
+                pygame.draw.rect(window,[0,0,0],[spos[0]+3,spos[1]+3,spos[2]-6,spos[3]-6])
+            elif FUNC > 130 and FUNC <= 140: # 3 dot (heart)
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2)+2,spos[1]+int(spos[3]/2)),int(spos[3]/3.5))
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2)-2,spos[1]+int(spos[3]/2)),int(spos[3]/3.5))
+                draw_circle(window,srgb,(spos[0]+int(spos[2]/2),spos[1]+int(spos[3]/2)+2),int(spos[3]/3.5))
+            else:
+                pygame.draw.rect(window,srgb,spos)
+
+
+        i += 1
+
+
+def grid_label(GRID,_x=0,_y=0):
+
+    for fix in GRID:
+        #pos = fix.POS(_x,_y)
+        pos = fix.POS() #CFG_IN["x1"],CFG_IN["y1"])
+        rgb = fix.rgb
+
+        # draw row/col grid number
+        if pos[0] == 0:
+            fr = font12.render("{}".format(pos[1]+1) ,1, (200,200,200))
+            window.blit(fr,(10,pos[1]+3 ))
+        if pos[1] == 0:
+            fr = font12.render("{}".format(pos[0]+1) ,1, (200,200,200))
+            window.blit(fr,(pos[0]+2,35 ))
+
+        #pygame.draw.rect(window,rgb,pos)
+
+
+
+def grid_sub_label(GRID,_x=0,_y=0):
+    h = 1
+    v = 1
+    for fix in GRID:
+        j = 0
+        #pos = fix.POS(_x,_y)
+        pos = fix.POS() #CFG_IN["x1"],CFG_IN["y1"])
+
+        for subfix in fix.sub_fix:
+            subfix.dmx_calc(data)
+            spos = subfix.POS() #(_x,_y)
+            srgb = subfix.rgb
+
+            # draw row/col grid number
+            if subfix.pos[0] == 0:
+                fr = font12.render("{}".format(v ) ,1, (200,200,200))
+                window.blit(fr,(25,spos[1] ))
+                v += 1
+            if subfix.pos[1] == 0:
+                fr = font12.render("{}".format(1) ,1, (200,200,200))
+                fr = font12.render("{}".format(h ) ,1, (200,200,200))
+                h+=1
+                window.blit(fr,(spos[0],50 ))
+
+            if p >= 40:
+                if NR:
+                    fr = font15.render("{:02}".format(subfix._id) ,1, (250,200,5))
+                    window.blit(fr,(spos[0]+2,spos[1]+10))
+            j += 1
+
+def frame_area():
+    rgb = [255,255,0]
+    CFG = CFG_IN
+    
+    
+    p1 = CFG_IN["p1"]
+    p2 = CFG_IN["p2"]
+    draw_frame(window,rgb,p1,p2,offset=2)
+    rgb = [255,0,0]
+    #draw_frame(window,rgb,p1,p2,offset=4)
+
+
+    if CFG_OUT["on"]:
+        rgb = [255,0,0]
+        p1 = CFG_OUT["p1"]
+        p2 = CFG_OUT["p2"]
+        #pygame.draw.line(window,rgb,p1,p2)
+        draw_frame(window,rgb,p1,p2,offset=3)
+
+    if CFG_OUT2["on"]:
+        rgb = [255,0,0]
+        p1 = CFG_OUT2["p1"]
+        p2 = CFG_OUT2["p2"]
+        #pygame.draw.line(window,rgb,p1,p2)
+        draw_frame(window,rgb,p1,p2,offset=3)
+
+ips=[]
+dataA=[]
+data=[]
+
+def dmx_raw():
+    global frame
+    frame += 1
+
+    global ips,dataA,data
+    ips = read_index()
+    
+    # ----
+    ip = select_ip(ips,univ=1) # univ 1 gobo
+    dataA = read_dmx(ip)
+    # ----
+
+    data = read_dmx_data(ip,ips)
+
+
+    if options.countdown:
+        counter_dmx(COUNTER,dataA)
+    
+    if len(VIDEO) > 0:
+        video_dmx(VIDEO,dataA)
+    return ips,dataA,data
+
+
+def dmx_loop():
+    while 1:
+        dmx_raw()
+        time.sleep(1/40) # fast high cpu
+        #time.sleep(1/25)
+
+dmx_raw()
+
+thread.start_new_thread(dmx_loop,())
+
+def GRID_A1_DIM():
+    # GRID_A1 DIM
+    if options.grid_a1_idim:
+        CFG=CFG_OUT
+        grid_dim_ch = int(options.grid_a1_idim)
+        grid_dim_v = dataA[grid_dim_ch-1]
+        dim=255
+        try:
+            dim = int(grid_dim_v)
+            if dim > 255:
+                dim = 255
+            if dim <=0:
+                dim = 0
+        except:pass
+        dim_raw = dim*-1
+        s = pygame.Surface((p*8,p*8))   # the size of your rect
+        s.set_alpha(dim)                # alpha level
+        s.fill((0,0,0))                 # this fills the entire surface
+        window.blit(s, (CFG["x1"],CFG["y2"]-p*8))
+
+        fr   = font15.render("Output:GRID_A1",1, (255,255,255))
+        fr_r = fr.get_rect(center=(int(wx/2),int(0+pm_wy-p*0-10)))
+        window.blit(fr,(CFG["x1"],CFG["y2"]+5))
+
+        fr   = font15.render("inv-dim: "+str(dim_raw) ,1, (255,255,255))
+        fr_r = fr.get_rect(center=(int(wx/2),int(0+pm_wy-p*0-10)))
+        window.blit(fr,(CFG["x1"],CFG["y2"]+15))
+
+def GRID_A2_DIM():
+    # GRID_A2 DIM
+    if options.grid_a2_idim:
+        CFG=CFG_OUT2
+        grid_dim_ch = int(options.grid_a2_idim)
+        grid_dim_v = dataA[grid_dim_ch-1]
+        dim=255
+        try:
+            dim = int(grid_dim_v)
+            if dim > 255:
+                dim = 255
+            if dim <=0:
+                dim = 0
+        except:pass
+        dim_raw = dim*-1
+        s = pygame.Surface((p*8,p*8))   # the size of your rect
+        s.set_alpha(dim)                # alpha level
+        s.fill((0,0,0))                 # this fills the entire surface
+        window.blit(s, (CFG["x1"],CFG["y2"]-p*8))
+
+        fr   = font15.render("Output:GRID_A2",1, (255,255,255))
+        fr_r = fr.get_rect(center=(int(wx/2),int(0+pm_wy-p*0-10)))
+        window.blit(fr,(CFG["x1"],CFG["y2"]+5))
+
+        fr   = font15.render("inv-dim: "+str(dim_raw) ,1, (255,255,255))
+        fr_r = fr.get_rect(center=(int(wx/2),int(0+pm_wy-p*0-10)))
+        window.blit(fr,(CFG["x1"],CFG["y2"]+15))
+t1 = Timer(143)
+time.sleep(0.33)
+t2 = Timer(11)
+
+count_tilt = 0
+def main():
+    global IP
+    global GRID
+
+    global GRID_A
+    global FUNC
+    global count_tilt
+    global TEXT_BLOCK
+    global TEXT_BLOCK_TIME
+    global PLAYLIST
+    global PLAYLIST_TIME
+    global dataA
+    global frame2
+    global runnung
+    reload_grid()
+
+    s=time.time()
+    r = ""
+    IP = "xx"
+
+    while running:
+        if  TEXT_BLOCK_TIME+5 < time.time():
+            TEXT_BLOCK = open_text_block()
+            TEXT_BLOCK_TIME = time.time()
+
+        if  PLAYLIST_TIME+6 < time.time():
+            PLAYLIST = open_playlist()
+            PLAYLIST_TIME = time.time()
+
+
+        pygame.display.flip()
+        set_pos(GRID,_x=CFG_IN["x1"],_y=CFG_IN["y1"]) 
+        #set_pos(GRID,600,600)#_x=CFG_IN["x1"],_y=CFG_IN["y1"]) 
+
+        event()
+
+        window.fill((10,0,30))
+        calc_fps()
+        calc_fps2()
+        draw_overlay()
+
+
+        # GRID loop
+        try:
+            FUNC = dataA[gobo_ch-1]
+            FUNC2 = FUNC
+        except Exception as e:
+            print("EXC FUNC",e)
+
+
+
+        #if int(time.time()) % 2: # BLINK
+        #set_gobo_pos(GRID,_x=CFG_IN["x1"],_y=CFG_IN["y1"]) 
+
+        draw_gobo(GRID,data) #,_x=CFG_IN["x1"],_y=CFG_IN["y1"]) 
+        #if int(time.time()) % 2: # BLINK
+        grid_label(GRID,_x=CFG_IN["x1"],_y=CFG_IN["y1"])
+        #grid_sub_label(GRID) #,_x=CFG_IN["x1"],_y=CFG_IN["y1"])
+
+
+        if VIDEO:
+            draw_video(VIDEO)
+
+        if options.countdown:
+            draw_counter(COUNTER)
+
+        pointer.draw(0,pm_wy) #wy
+
+        pygame.draw.rect(window,[5,5,5],[0,60,MAIN_SIZE[0],p*9]) # background
+
+
+        spos = [0,0,0,0]
+        if PIXEL_MAPPING >= 1:
+            #try:
+            if options.dual_vpu:
+                GRID_X = GRID_A[8*8:]
+                xx = p*8
+                #reshape(GRID,GRID_X,CFG_OUT2["x1"],CFG_OUT2["y1"]-p*8,name="GRID_A2") #start pos
+            #except Exception as e:
+            #    print("Exception 23123",e)
+
+            reshape2(GRID,GRID_A,CFG_OUT["x1"],CFG_OUT["y1"],name="GRID_A1") #start pos
+            #reshape(GRID,GRID_A,CFG_OUT["x1"],CFG_OUT["y1"],name="GRID_A1") #start pos
+        else:
+            pass #reshape(GRID,GRID_A,spos[0]+spos[2]+20,10) #start pos
+
+        frame_area()
+
+        # OUTPUT -> MAPING
+        draw_kachel_nr()
+
+
+        GRID_A1_DIM()
+        GRID_A2_DIM()
+
+
+        pygame.display.flip()
+        clock.tick(25)
+
+        if 'SDL_VIDEO_WINDOW_POS' in os.environ:
+            del os.environ['SDL_VIDEO_WINDOW_POS'] #= '%i,%i' % (200,164)
+
+        frame2 += 1
+
+if __name__ == "__main__":
+    main()

vpu/watchdog_vpu.py

@@ -162,15 +162,54 @@ def vpu03():
     #python3 /opt/LibreLight/Xdesk/vpu/vpu_live.py -m 16,20,10 -X 12  --pixel-map=_10 --dual-vpu=1  --gobo-ch=11 --countdown=31,51,151,171 --videoplayer=181,201 --title=LIVE
     return 1
 
+def vpu04(): # pixel-perfect
+    # Ayrton VPU Offset X 235 Y 253 (Pannel 255)  7,5m-4m ... 9,5m-4m
+
+    cmd = 'screen -ls | grep "\.vpu04_out"'
+    print("CMD:",cmd)
+    r = os.popen(cmd)
+    lines = r.readlines()
 
+    if lines:
+        print(" ok")
+        return 0
+
+    cmd = 'screen -XS "vpu04_out" quit'
+    print("CMD:",cmd)
+    os.system(cmd)
+
+    cmd ="screen -m -d -S vpu04_out --"
+    cmd += " python3 /opt/LibreLight/Xdesk/vpu/vpu_live4.py"
+    cmd += " -m 16,30,10"
+    cmd += " -X 20"
+    cmd += " --pixel-map=_10"
+    cmd += " --dual-vpu=1"
+    cmd += " --gobo-ch=11"
+    #cmd += " --win-pos 430,164"
+    cmd += " --start-univ=2"
+    cmd += " --countdown=71,91,111,131"
+    cmd += " --videoplayer=221,241"
+    cmd += " --title=DUAL-8x8"
+    cmd += " --grid-a1-idim=12" 
+    cmd += " --grid-a2-idim=22"
+    print("CMD:",cmd)
+    os.system(cmd)
+    #time.sleep(1)
+    #python3 /opt/LibreLight/Xdesk/vpu/vpu_live4.py -m 16,30,10 -X 20 --pixel-map=_10 --dual-vpu=1 --gobo-ch=11 --start-univ=2 --countdown=71,91,111,131 --videoplayer=221,241 --title=DUAL-8x8 --grid-a1-idim=12 --grid-a2-idim=22  
+    return 1
 
 while 1:
+
     if "-vpu01" in sys.argv:
         r1=vpu01()
-    if "-vpu02" in sys.argv:
+    elif "-vpu02" in sys.argv:
         r2=vpu02()
-    r3=vpu03()
-
+    elif "-vpu03" in sys.argv:
+        r2=vpu03()
+    elif "-vpu04" in sys.argv:
+        r2=vpu04()
+    else:
+        r3=vpu03()
 
     if "-single" in sys.argv:
         break