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
|
# Live video output (display video on the screen, presumably from the net)
import gl
from VFile import Displayer
# Video output (displayer) class.
class LiveVideoOut:
# Call this to initialize things. Arguments:
# wid: the window id where the video is to be displayed (centered)
# vw, vh: size of the video image to be displayed
def __init__(self, wid, vw, vh, type):
##print 'Init', wid, xywh
##print 'video', vw, vw
self.vw = vw
self.vh = vh
self.disp = Displayer()
if not type in ('rgb', 'rgb8', 'grey', 'mono', 'grey2', \
'grey4'):
raise 'Incorrent live video output type', type
if type == 'rgb':
info = (type, vw, vh, 0, 32, 0, 0, 0, 0)
else:
info = (type, vw, vh, 1, 8, 0, 0, 0, 0)
self.disp.setinfo(info)
self.wid = wid
oldwid = gl.winget()
gl.winset(wid)
self.disp.initcolormap()
self.reshapewindow()
gl.winset(oldwid)
# Call this in response to every REDRAW event for the window
# or if the window size has changed for other reasons.
def reshapewindow(self):
oldwid = gl.winget()
gl.winset(self.wid)
gl.reshapeviewport()
w, h = gl.getsize()
self.disp.xorigin = (w-self.vw)/2
self.disp.yorigin = (h-self.vh)/2
self.disp.clear()
gl.winset(oldwid)
# Call this to change the size of the video images being displayed.
# Implies reshapewindow().
def resizevideo(self, vw, vh):
self.vw, self.vh = vw, vh
self.disp.setsize(vw, vh)
self.reshapewindow()
# Return the number of bytes in one video line
def linewidth(self):
if self.disp.format == 'rgb':
return self.vw*4
if self.disp.format == 'mono':
return (self.vw+7)/8
elif self.disp.format == 'grey2':
return (self.vw+3)/4
elif self.disp.format == 'grey4':
return (self.vw+1)/2
else:
return self.vw
# Call this to display the next video packet. Arguments:
# pos: line number where the packet begins
# data: image data of the packet
# (these correspond directly to the return values from
# LiveVideoIn.getnextpacket()).
def putnextpacket(self, pos, data):
nline = len(data)/self.linewidth()
if nline*self.linewidth() <> len(data):
print 'Incorrect-sized video fragment ignored'
return
oldwid = gl.winget()
gl.winset(self.wid)
self.disp.showpartframe(data, None, (0, pos, self.vw, nline))
gl.winset(oldwid)
# Call this to close the window.
def close(self):
pass
# Call this to set optional mirroring of video
def setmirror(self, mirrored):
f, w, h, pf, c0, c1, c2, o, cp = self.disp.getinfo()
if type(pf) == type(()):
xpf, ypf = pf
else:
xpf = ypf = pf
xpf = abs(xpf)
if mirrored:
xpf = -xpf
info = (f, w, h, (xpf, ypf), c0, c1, c2, o, cp)
self.disp.setinfo(info)
self.disp.initcolormap()
self.disp.clear()
#
# This derived class has one difference with the base class: the video is
# not displayed until an entire image has been gotten
#
class LiveVideoOutSlow(LiveVideoOut):
# Reshapewindow - Realloc buffer.
# (is also called by __init__() indirectly)
def reshapewindow(self):
LiveVideoOut.reshapewindow(self)
self.buffer = '\0'*self.linewidth()*self.vh
self.isbuffered = []
# putnextpacket - buffer incoming data until a complete
# image has been received
def putnextpacket(self, pos, data):
if pos in self.isbuffered or pos == 0:
LiveVideoOut.putnextpacket(self, 0, self.buffer)
self.isbuffered = []
self.isbuffered.append(pos)
bpos = pos * self.linewidth()
epos = bpos + len(data)
self.buffer = self.buffer[:bpos] + data + self.buffer[epos:]
|
