1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
#!/usr/bin/env python
from socketserver import *
import socket
import struct
import zlib
from time import time, strftime, sleep
from collections import namedtuple, deque
import itertools
import threading
import random
import os
from ctypes import *
from matelight import sendframe, DISPLAY_WIDTH, DISPLAY_HEIGHT, FRAME_SIZE
UDP_TIMEOUT = 3.0
class COLOR(Structure):
_fields_ = [('r', c_uint8), ('g', c_uint8), ('b', c_uint8), ('a', c_uint8)]
class FRAMEBUFFER(Structure):
_fields_ = [('data', POINTER(COLOR)), ('w', c_size_t), ('h', c_size_t)]
bdf = CDLL('./libbdf.so')
bdf.read_bdf_file.restype = c_void_p
bdf.framebuffer_render_text.restype = POINTER(FRAMEBUFFER)
bdf.framebuffer_render_text.argtypes= [c_char_p, c_void_p, c_void_p, c_size_t, c_size_t, c_size_t]
unifont = bdf.read_bdf_file('unifont.bdf')
def compute_text_bounds(text):
assert unifont
textbytes = bytes(str(text), 'UTF-8')
textw, texth = c_size_t(0), c_size_t(0)
res = bdf.framebuffer_get_text_bounds(textbytes, unifont, byref(textw), byref(texth))
if res:
raise ValueError('Invalid text')
return textw.value, texth.value
cbuf = create_string_buffer(FRAME_SIZE*sizeof(COLOR))
cbuflock = threading.Lock()
def render_text(text, offset):
global cbuf
cbuflock.acquire()
textbytes = bytes(str(text), 'UTF-8')
res = bdf.framebuffer_render_text(textbytes, unifont, cbuf, DISPLAY_WIDTH, DISPLAY_HEIGHT, offset)
if res:
raise ValueError('Invalid text')
cbuflock.release()
return cbuf
printlock = threading.Lock()
def printframe(fb):
printlock.acquire()
print('\0337\033[H', end='')
print('Rendering frame @{}'.format(time()))
bdf.console_render_buffer(fb, DISPLAY_WIDTH, DISPLAY_HEIGHT)
#print('\033[0m\033[KCurrently rendering', current_entry.entrytype, 'from', current_entry.remote, ':', current_entry.text, '\0338', end='')
printlock.release()
def log(*args):
printlock.acquire()
print(strftime('\x1B[93m[%m-%d %H:%M:%S]\x1B[0m'), ' '.join(str(arg) for arg in args), '\x1B[0m')
printlock.release()
class TextRenderer:
def __init__(self, text):
self.text = text
self.width, _ = compute_text_bounds(text)
def __iter__(self):
for i in range(-DISPLAY_WIDTH, self.width):
yield render_text(self.text, i)
class MateLightUDPServer:
def __init__(self, port=1337, ip=''):
self.current_client = None
self.last_timestamp = 0
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind((ip, port))
self.thread = threading.Thread(target = self.udp_receive)
self.thread.daemon = True
self.start = self.thread.start
self.frame_condition = threading.Condition()
self.frame = None
def frame_da(self):
return self.frame is not None
def __iter__(self):
while True:
with self.frame_condition:
if not self.frame_condition.wait_for(self.frame_da, timeout=UDP_TIMEOUT):
raise StopIteration()
frame, self.frame = self.frame, None
yield frame
def udp_receive(self):
while True:
try:
data, (addr, sport) = self.socket.recvfrom(FRAME_SIZE*3+4)
timestamp = time()
if timestamp - self.last_timestamp > UDP_TIMEOUT:
self.current_client = addr
log('\x1B[91mAccepting UDP data from\x1B[0m', addr)
if addr == self.current_client:
if len(data) == FRAME_SIZE*3+4:
frame = data[:-4]
crc1, = struct.unpack('!I', data[-4:])
if crc1:
crc2, = zlib.crc32(frame, 0),
if crc1 != crc2:
raise ValueError('Invalid frame CRC checksum: Expected {}, got {}'.format(crc2, crc1))
elif len(data) == FRAME_SIZE*3:
frame = data
else:
raise ValueError('Invalid frame size: {}'.format(len(data)))
self.last_timestamp = timestamp
with self.frame_condition:
self.frame = frame
self.frame_condition.notify()
except Exception as e:
log('Error receiving UDP frame:', e)
renderqueue = deque()
class MateLightTCPTextHandler(BaseRequestHandler):
def handle(self):
global render_deque
data = str(self.request.recv(1024).strip(), 'UTF-8')
addr = self.client_address[0]
if len(data) > 140:
self.request.sendall('TOO MUCH INFORMATION!\n')
return
log('\x1B[95mText from\x1B[0m {}: {}\x1B[0m'.format(addr, data))
renderqueue.append(TextRenderer(data))
self.request.sendall(b'KTHXBYE!\n')
TCPServer.allow_reuse_address = True
tserver = TCPServer(('', 1337), MateLightTCPTextHandler)
t = threading.Thread(target=tserver.serve_forever)
t.daemon = True
t.start()
userver = MateLightUDPServer()
userver.start()
defaultlines = [ TextRenderer(l[:-1].replace('\\x1B', '\x1B')) for l in open('default.lines').readlines() ]
random.shuffle(defaultlines)
defaulttexts = itertools.cycle(itertools.chain(*defaultlines))
if __name__ == '__main__':
#print('\033[?1049h'+'\n'*9)
while True:
if renderqueue:
renderer = renderqueue.popleft()
elif userver.frame_da():
renderer = userver
else:
static_noise = time() % 300 < 60
if static_noise:
foo = os.urandom(640)
frame = bytes([v for c in zip(list(foo), list(foo), list(foo)) for v in c ])
else:
frame = next(defaulttexts)
sendframe(frame)
#printframe(next(defaulttexts))
continue
for frame in renderer:
sendframe(frame)
#printframe(frame)
|
