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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
# VFile -- two classes for Video Files.
# VinFile -- for video input.
# VoutFile -- for video output.
import sys
import gl
import GL
Error = 'VFile.Error' # Exception
# Class VinFile represents a video file used for input.
#
# It has the following methods:
# init(filename)
# initfp(fp, filename)
# rewind()
# getframe()
# skipframe()
#
# The following read-only data members provide public information:
# version
# filename
# width, height
# packfactor
# ybits, ibits, qbits, chrompack
#
# These writable data members provide additional parametrization:
# xorigin, yorigin
class VinFile():
# init() and initfp() raise Error if the header is bad.
# init() raises whatever open() raises if the file can't be opened.
def init(self, filename):
if filename = '-':
return self.initfp(sys.stdin, filename)
return self.initfp(open(filename, 'r'), filename)
def initfp(self, (fp, filename)):
self.colormapinited = 0
self.magnify = 1.0
self.xorigin = self.yorigin = 0
self.fp = fp
self.filename = filename
#
line = self.fp.readline()
if line = 'CMIF video 1.0\n':
self.version = 1.0
elif line = 'CMIF video 2.0\n':
self.version = 2.0
else:
raise Error, self.filename + ': bad video format'
#
if self.version < 2.0:
self.ybits, self.ibits, self.qbits = 8, 0, 0
self.chrompack = 0
else:
line = self.fp.readline()
try:
self.ybits, self.ibits, self.qbits, \
self.chrompack = eval(line[:-1])
except:
raise Error, self.filename + ': bad color info'
#
line = self.fp.readline()
try:
x = eval(line[:-1])
if self.version > 1.0 or len(x) = 3:
self.width, self.height, self.packfactor = x
else:
sef.width, self.height = x
self.packfactor = 2
except:
raise Error, self.filename + ': bad (w,h,pf) info'
#
return self
# rewind() raises Error if the header is bad (which can only
# happen if the file was written to since opened).
def rewind(self):
self.fp.seek(0)
x = self.initfp(self.fp, self.filename)
# getnextframe() raises EOFError (built-in) if there is no next frame,
# or if the next frame is broken.
# So to getnextframeheader(), getnextframedata() and skipnextframe().
def getnextframe(self):
time, size, chromsize = self.getnextframeheader()
data, chromdata = self.getnextframedata(size, chromsize)
return time, data, chromdata
def getnextframedata(self, (size, chromsize)):
data = self.fp.read(size)
if len(data) <> size: raise EOFError
if chromsize:
chromdata = self.fp.read(chromsize)
if len(chromdata) <> chromsize: raise EOFError
else:
chromdata = None
#
return data, chromdata
def skipnextframe(self):
time, size, chromsize = self.getnextframeheader()
self.skipnextframedata(size, chromsize)
return time
def skipnextframedata(self, (size, chromsize)):
# Note that this won't raise EOFError for a partial frame.
try:
self.fp.seek(size + chromsize, 1) # Relative seek
except:
# Assume it's a pipe -- read the data to discard it
dummy = self.fp.read(size)
dummy = self.fp.read(chromsize)
def getnextframeheader(self):
line = self.fp.readline()
if not line:
raise EOFError
#
w, h, pf = self.width, self.height, self.packfactor
try:
x = eval(line[:-1])
if type(x) in (type(0), type(0.0)):
time = x
if pf = 0:
size = w * h * 4
else:
size = (w/pf) * (h/pf)
elif len(x) = 2:
time, size = x
cp = self.chrompack
if cp:
cw = (w + cp - 1) / cp
ch = (h + cp - 1) / cp
chromsize = 2 * cw * ch
else:
chromsize = 0
else:
time, size, chromsize = x
except:
raise Error, self.filename + ': bad frame header'
return time, size, chromsize
def shownextframe(self):
time, data, chromdata = self.getnextframe()
self.showframe(data, chromdata)
return time
def showframe(self, (data, chromdata)):
w, h, pf = self.width, self.height, self.packfactor
factor = self.magnify
if pf: factor = factor * pf
if chromdata:
cp = self.chrompack
cw = (w+cp-1)/cp
ch = (h+cp-1)/cp
gl.rectzoom(factor*cp, factor*cp)
gl.pixmode(GL.PM_SIZE, 16)
gl.writemask(0x7ff - ((1 << self.ybits) - 1))
gl.lrectwrite(self.xorigin, self.yorigin, \
self.xorigin + cw - 1, self.yorigin + ch - 1, \
chromdata)
#
if pf:
if not self.colormapinited:
self.initcolormap()
gl.writemask((1 << self.ybits) - 1)
gl.pixmode(GL.PM_SIZE, 8)
gl.rectzoom(factor, factor)
w = w/pf
h = h/pf
gl.lrectwrite(self.xorigin, self.yorigin, \
self.xorigin + w - 1, self.yorigin + h - 1, data)
def initcolormap(self):
initcmap(self.ybits, self.ibits, self.qbits, self.chrompack)
gl.color(0x800)
gl.clear()
self.colormapinited = 1
def initcmap(ybits, ibits, qbits, chrompack):
if ybits+ibits+qbits > 11:
raise Error, 'Sorry, 11 bits max'
import colorsys
maxy = 1 << ybits
maxi = 1 << ibits
maxq = 1 << qbits
for i in range(2048, 4096-256):
gl.mapcolor(i, 0, 255, 0)
for y in range(maxy):
yv = y/float(maxy-1)
for i in range(maxi):
if maxi = 1:
iv = 0
else:
iv = (i/float(maxi-1))-0.5
for q in range(maxq):
if maxq = 1:
qv = 0
else:
qv = (q/float(maxq-1))-0.5
index = 2048 + y + \
(i << ybits) + (q << (ybits+ibits))
rv, gv, bv = colorsys.yiq_to_rgb(yv, iv, qv)
r, g, b = \
int(rv*255.0), int(gv*255.0), int(bv*255.0)
if index < 4096 - 256:
gl.mapcolor(index, r, g, b)
def test():
import sys
filename = 'film.video'
if sys.argv[1:]: filename = sys.argv[1]
vin = VinFile().init(filename)
gl.foreground()
gl.prefsize(vin.width, vin.height)
wid = gl.winopen('VFile.test: ' + filename)
try:
while 1:
t = vin.shownextframe()
except EOFError:
pass
|
