Add sdl version of pixelvloed server
This commit is contained in:
Jan Klopper
parent
9cfae29dc7
commit
4e22d0187e
1 changed files with 348 additions and 0 deletions
348
sdlvloed.py
Executable file
348
sdlvloed.py
Executable file
|
|
@ -0,0 +1,348 @@
|
|||
#!/usr/bin/python
|
||||
"""This is a udp / binary version of PixelFlut
|
||||
|
||||
Inspired by the PixelFlut projector on eth0:winter 2016 and
|
||||
code from https://github.com/defnull/pixelflut/
|
||||
|
||||
This version runs without PyGame but uses SDL instead
|
||||
"""
|
||||
|
||||
__version__ = 0.4
|
||||
__author__ = "Jan Klopper <jan@underdark.nl>"
|
||||
|
||||
# import gevent monkeypatching and perform patch_all before anything else to
|
||||
# avoid nasty eception on python closing time
|
||||
from gevent import spawn, monkey
|
||||
monkey.patch_all()
|
||||
|
||||
import sdl2.ext
|
||||
from pygame import locals as pygamelocals
|
||||
import struct
|
||||
import time
|
||||
import socket
|
||||
|
||||
from gevent.server import DatagramServer
|
||||
from gevent.queue import Queue
|
||||
|
||||
UDP_IP = "127.0.0.1"
|
||||
UDP_PORT = 5005
|
||||
DISCOVER_PORT = 5006
|
||||
PROTOCOL_VERSION = 1
|
||||
MAX_PROTOCOL_VERSION = 1
|
||||
PROTOCOL_PREAMBLE = "pixelvloed"
|
||||
MAX_PIXELS = 140
|
||||
DEFAULT_WIDTH = 786
|
||||
DEFAULT_HEIGHT = 1366
|
||||
|
||||
class Canvas(object):
|
||||
"""PixelVloed display class"""
|
||||
|
||||
def __init__(self, queue, options):
|
||||
"""Init the pixelVloed server"""
|
||||
self.debug = options.debug if options.debug else False
|
||||
self.pixeloffset = 2
|
||||
self.fps = 30
|
||||
self.screen = None
|
||||
self.udp_ip = UDP_IP
|
||||
self.udp_port = UDP_PORT
|
||||
self.factor = options.factor if options.factor else 1
|
||||
self.width = options.width if options.width else DEFAULT_WIDTH
|
||||
self.height = options.height if options.height else DEFAULT_HEIGHT
|
||||
self.canvas()
|
||||
|
||||
self.queue = queue
|
||||
self.limit = options.maxpixels if options.maxpixels else MAX_PIXELS
|
||||
self.pixels = None
|
||||
self.broadcastsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
self.broadcastsocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||
self.broadcastsocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
|
||||
@staticmethod
|
||||
def set_title(text=None):
|
||||
"""Sets the window title"""
|
||||
title = 'PixelVloed %0.02f' % __version__
|
||||
if text:
|
||||
title += ' ' + text
|
||||
return title
|
||||
|
||||
def canvas(self):
|
||||
"""Init the pygame canvas"""
|
||||
sdl2.ext.init()
|
||||
self.screen = sdl2.ext.Window(self.set_title(),
|
||||
size=(self.width, self.height))
|
||||
self.screen.show()
|
||||
self.surface = self.screen.get_surface()
|
||||
|
||||
def Pixel(self, x, y, r, g, b, a=255): # pylint: disable=C0103
|
||||
"""Print a pixel to the screen"""
|
||||
try:
|
||||
if a == 255:
|
||||
color = (r*256*256) + (g*256) + b
|
||||
if self.factor>1:
|
||||
for w in xrange(0, self.factor):
|
||||
for h in xrange(0, self.factor):
|
||||
self.pixels[(x*self.factor) + w][(y*self.factor) + h] = color
|
||||
else:
|
||||
self.pixels[x][y] = color
|
||||
else:
|
||||
old = self.pixels[x][y]
|
||||
oldr = old >> 16
|
||||
oldg = (old & 0x00ff00) / 256
|
||||
oldb = old & 0x0000ff
|
||||
red = (r * a) + (oldr * (1.0 - a))
|
||||
green = (g * a) + (oldg * (1.0 - a))
|
||||
blue = (b * a) + (oldb * (1.0 - a))
|
||||
self.pixels[x][y] = (red*256*256) + (green*256) + blue
|
||||
except IndexError:
|
||||
pass
|
||||
|
||||
def CanvasUpdate(self):
|
||||
"""Updates the screen according to self.fps"""
|
||||
lasttime = lastbroadcast = time.time()
|
||||
changed = False
|
||||
while True:
|
||||
changed = self.Draw() or changed
|
||||
#events = sdl2.ext.get_events()
|
||||
#for event in events:
|
||||
# if event.type == sdl2.SDL_QUIT:
|
||||
# sys.exit()
|
||||
# break
|
||||
if time.time() - lastbroadcast > 2:
|
||||
lastbroadcast = time.time()
|
||||
self.SendDiscoveryPacket()
|
||||
|
||||
if time.time() - lasttime >= 1.0 / self.fps and changed:
|
||||
self.pixels = None # release the lock on these pixels so we can flip
|
||||
self.screen.refresh()
|
||||
changed = False
|
||||
lasttime = time.time()
|
||||
else:
|
||||
time.sleep(1.0 / self.fps)
|
||||
|
||||
def Draw(self):
|
||||
"""Draws pixels specified in the received packages in the queue"""
|
||||
if self.queue.empty():
|
||||
# indicate that nothing was done, and we can skip flipping the screen
|
||||
return False
|
||||
#access the pixel array and lock it
|
||||
self.pixels = sdl2.ext.pixels2d(self.surface)
|
||||
returntime = time.time() + (1.0 / self.fps)
|
||||
# while we have stuff in the queue, and its not our next time to draw a
|
||||
# frame, lets process packets from the queue
|
||||
while time.time() < returntime and not self.queue.empty():
|
||||
try:
|
||||
data = self.queue.get()
|
||||
preamble = struct.unpack_from("<?", data)[0]
|
||||
protocol = struct.unpack_from("<B", data, 1)[0]
|
||||
packetformat = ("<2H4B" if preamble else "<2H3B")
|
||||
pixellength = (8 #xx,yy,r,g,b,a
|
||||
if preamble else
|
||||
7 #xx,yy,r,g,b
|
||||
)
|
||||
pixelcount = min(((len(data)-1) / pixellength),
|
||||
self.limit)
|
||||
if self.debug:
|
||||
print '%d pixels received, protocol V %d' % (pixelcount, protocol)
|
||||
for i in xrange(0, pixelcount):
|
||||
pixel = struct.unpack_from(
|
||||
packetformat,
|
||||
data,
|
||||
self.pixeloffset + (i*pixellength))
|
||||
if self.debug:
|
||||
print pixel
|
||||
self.Pixel(*pixel)
|
||||
except Exception as error:
|
||||
if self.debug:
|
||||
# All exceptions will be printed, but won't result in a crash.
|
||||
print error
|
||||
# indicate that we have been drawing stuff
|
||||
return True
|
||||
|
||||
def SendDiscoveryPacket(self):
|
||||
"""Lets send out our ip/port/resolution to any listening clients"""
|
||||
try:
|
||||
self.broadcastsocket.sendto(
|
||||
'%s:%f %s:%d %d*%d' % (
|
||||
PROTOCOL_PREAMBLE, PROTOCOL_VERSION,
|
||||
UDP_IP, UDP_PORT,
|
||||
self.width/self.factor, self.height/self.factor),
|
||||
('<broadcast>', DISCOVER_PORT))
|
||||
if self.debug:
|
||||
print 'sending discovery packet'
|
||||
except Exception as error:
|
||||
if self.debug:
|
||||
print error
|
||||
|
||||
def __del__(self):
|
||||
"""Clean up any sockets we created"""
|
||||
self.broadcastsocket.close()
|
||||
|
||||
class PixelVloedServer(DatagramServer):
|
||||
"""PixelVloed server class"""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
"""Set up some vars for this instance"""
|
||||
self.queue = Queue()
|
||||
pixelcanvas = Canvas(self.queue, kwargs['options'])
|
||||
__request_processing_greenlet = spawn(pixelcanvas.CanvasUpdate)
|
||||
del (kwargs['options'])
|
||||
DatagramServer.__init__(self, *args, **kwargs)
|
||||
|
||||
def handle(self, data, _address):
|
||||
"""Is called by the DataGramServer whenever an udp package is received"""
|
||||
self.queue.put(data)
|
||||
|
||||
class PixelVloedClient(object):
|
||||
"""Sets up a client
|
||||
|
||||
Arguments:
|
||||
firstserver: (bool) False, select the first server immediately
|
||||
debug: (bool) False
|
||||
ip: (str) None
|
||||
port: (int) None
|
||||
width: (int) 640
|
||||
height: (int) 480
|
||||
|
||||
Listens for servers if no ip is given
|
||||
"""
|
||||
|
||||
def __init__(self, firstserver=False, debug=False,
|
||||
ip=None, port=None,
|
||||
width=640, height=480):
|
||||
self.sleep = 0.01
|
||||
self.debug = debug
|
||||
if not ip:
|
||||
servers = False
|
||||
while servers == False:
|
||||
servers = self.DiscoverServers(firstserver)
|
||||
self.ipaddress = servers[0]['ip']
|
||||
self.port = servers[0]['port']
|
||||
self.width = servers[0]['width']
|
||||
self.height = servers[0]['height']
|
||||
|
||||
if self.debug:
|
||||
print ('displaying on %(ip)s:%(port)d, %(width)d*%(height)dpx' %
|
||||
servers[0])
|
||||
else:
|
||||
self.ipaddress = ip
|
||||
self.port = port if port else UDP_PORT
|
||||
self.width = width
|
||||
self.height = height
|
||||
if self.debug:
|
||||
print ('displaying on %(ip)s:%(port)d, %(width)d*%(height)dpx' %
|
||||
self)
|
||||
self.sock = socket.socket(socket.AF_INET, # Internet
|
||||
socket.SOCK_DGRAM) # UDP
|
||||
|
||||
def Sleep(self, duration=None):
|
||||
"""Sleeps the designated amount of time"""
|
||||
time.sleep(duration if duration else self.sleep)
|
||||
|
||||
def SendPacket(self, message, sleep=True):
|
||||
"""Sends the message to the udp server
|
||||
|
||||
Arguments:
|
||||
message: (str, 140)
|
||||
sleep: (bool) True, should the client sleep for a while?
|
||||
"""
|
||||
self.sock.sendto(message, (self.ipaddress, self.port))
|
||||
if sleep:
|
||||
self.Sleep()
|
||||
|
||||
@staticmethod
|
||||
def DiscoverServers(returnfirst=False, timeout=5):
|
||||
"""Discover servers that send out the pixelvloed preample"""
|
||||
discoverysock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
discoverysock.bind(('', DISCOVER_PORT))
|
||||
starttime = time.time()
|
||||
servers = []
|
||||
foundhash = {}
|
||||
while (time.time() - timeout) < starttime:
|
||||
data, _addr = discoverysock.recvfrom(1024)
|
||||
try:
|
||||
if data.startswith(PROTOCOL_PREAMBLE):
|
||||
dataset = data.split(' ')
|
||||
if float(dataset[0].split(':')[1]) <= MAX_PROTOCOL_VERSION:
|
||||
ipaddress = dataset[1].split(':')[0]
|
||||
port = int(dataset[1].split(':')[1])
|
||||
width = int(dataset[2].split('*')[0])
|
||||
height = int(dataset[2].split('*')[1])
|
||||
if data not in foundhash:
|
||||
newserver = {'ip': ipaddress,
|
||||
'port': port,
|
||||
'width': width,
|
||||
'height': height}
|
||||
foundhash[data] = True
|
||||
print 'New pixelvloed screen found: %r' % newserver
|
||||
servers.append(newserver)
|
||||
if returnfirst:
|
||||
return servers
|
||||
except:
|
||||
pass
|
||||
if servers:
|
||||
return servers
|
||||
return False
|
||||
|
||||
def NewMessage():
|
||||
"""Creates a new message with the correct max size, rgb mode and version"""
|
||||
message = MaxSizeList(MAX_PIXELS+2)
|
||||
message.append(SetRGBAMode(False))
|
||||
message.append(SetVersionBit())
|
||||
return message
|
||||
|
||||
def RGBPixel(x, y, r, g, b, a=None): # pylint: disable=C0103
|
||||
"""Generates the packed data for a pixel"""
|
||||
if a is not None:
|
||||
return struct.pack("<2H4B", x, y, r, g, b, a)
|
||||
return struct.pack("<2H3B", x, y, r, g, b)
|
||||
|
||||
def SetRGBAMode(mode):
|
||||
"""Generate the rgb/rgba bit"""
|
||||
return struct.pack("<?", mode)
|
||||
|
||||
def SetVersionBit(protocol=1):
|
||||
"""Generate the Version bit"""
|
||||
return struct.pack("<B", protocol)
|
||||
|
||||
class MaxSizeList(list):
|
||||
"""A list that raises an indexError when it reaches the designated max size"""
|
||||
def __init__(self, maxcount=100):
|
||||
"""Inits a list with a maxcount
|
||||
|
||||
Arguments:
|
||||
maxcount: (int) 100
|
||||
"""
|
||||
self.maxsize = maxcount
|
||||
super(MaxSizeList, self).__init__()
|
||||
|
||||
def append(self, item):
|
||||
"""Appends an item to the list"""
|
||||
if self.__len__() == self.maxsize:
|
||||
raise IndexError('max size reached')
|
||||
super(MaxSizeList, self).append(item)
|
||||
|
||||
def RunServer(options):
|
||||
"""Runs a pixelvloed server"""
|
||||
PixelVloedServer('%s:%d' %(options.ip, options.port),
|
||||
options=options).serve_forever()
|
||||
|
||||
if __name__ == '__main__':
|
||||
import optparse
|
||||
parser = optparse.OptionParser()
|
||||
parser.add_option('-v', action="store_true", dest="debug", default=False)
|
||||
parser.add_option('-i', action="store", dest="ip", default=UDP_IP)
|
||||
parser.add_option('-p', action="store", dest="port", default=UDP_PORT,
|
||||
type="int")
|
||||
parser.add_option('-x', action="store", dest="width", default=DEFAULT_WIDTH,
|
||||
type="int")
|
||||
parser.add_option('-y', action="store", dest="height", default=DEFAULT_HEIGHT,
|
||||
type="int")
|
||||
parser.add_option('-m', action="store", dest="maxpixels", default=MAX_PIXELS,
|
||||
type="int")
|
||||
parser.add_option('-f', action="store", dest="factor", default=1,
|
||||
type="int")
|
||||
options, remainder = parser.parse_args()
|
||||
try:
|
||||
RunServer(options)
|
||||
except KeyboardInterrupt:
|
||||
print 'Closing server'
|
||||
Loading…
Add table
Add a link
Reference in a new issue