mirror of https://github.com/python/cpython
Added class VoutFile.
Added rgb8 support. Added cache of frame offsets to VinFile. Misc hacks to grab rgb8 data.
This commit is contained in:
Guido van Rossum
parent
444db07d3c
commit
2080b347f4
|
|
@ -9,6 +9,9 @@ import colorsys
|
|||
|
||||
Error = 'VFile.Error' # Exception
|
||||
|
||||
# Missing from GL.py:
|
||||
DMRGB = 0
|
||||
|
||||
MAXMAP = 4096 - 256
|
||||
|
||||
def conv_grey(l,x,y): return colorsys.yiq_to_rgb(l,0,0)
|
||||
|
|
@ -17,6 +20,12 @@ def conv_hls (l,h,s): return colorsys.hls_to_rgb(h,l,s)
|
|||
def conv_hsv (v,h,s): return colorsys.hsv_to_rgb(h,s,v)
|
||||
def conv_rgb (r,g,b):
|
||||
raise Error, 'Attempt to make RGB colormap'
|
||||
def conv_rgb8(rgb,d1,d2):
|
||||
rgb = int(rgb*255.0)
|
||||
r = (rgb >> 5) & 0x07
|
||||
g = (rgb ) & 0x07
|
||||
b = (rgb >> 3) & 0x03
|
||||
return (r/7.0, g/7.0, b/3.0)
|
||||
|
||||
# Class VinFile represents a video file used for input.
|
||||
#
|
||||
|
|
@ -39,6 +48,7 @@ def conv_rgb (r,g,b):
|
|||
# These writable data members provide additional parametrization:
|
||||
# magnify
|
||||
# xorigin, yorigin
|
||||
# fallback
|
||||
|
||||
class VinFile():
|
||||
|
||||
|
|
@ -54,6 +64,8 @@ class VinFile():
|
|||
self.colormapinited = 0
|
||||
self.magnify = 1.0
|
||||
self.xorigin = self.yorigin = 0
|
||||
self.fallback = 1
|
||||
self.skipchrom = 0
|
||||
self.fp = fp
|
||||
self.filename = filename
|
||||
#
|
||||
|
|
@ -90,7 +102,11 @@ class VinFile():
|
|||
try:
|
||||
self.format, rest = eval(line[:-1])
|
||||
if self.format == 'rgb':
|
||||
pass
|
||||
self.offset = 0
|
||||
self.c0bits = 0
|
||||
self.c1bits = 0
|
||||
self.c2bits = 0
|
||||
self.chrompack = 0
|
||||
elif self.format == 'grey':
|
||||
self.offset = 0
|
||||
self.c0bits = rest
|
||||
|
|
@ -121,9 +137,34 @@ class VinFile():
|
|||
self.packfactor = 2
|
||||
except:
|
||||
raise Error, self.filename + ': bad (w,h,pf) info'
|
||||
self.frameno = 0
|
||||
self.framecache = []
|
||||
self.hascache = 0
|
||||
#
|
||||
return self
|
||||
|
||||
def warmcache(self):
|
||||
if self.hascache: return
|
||||
n = 0
|
||||
try:
|
||||
while 1:
|
||||
void = self.skipnextframe()
|
||||
n = n + 1
|
||||
except EOFError:
|
||||
pass
|
||||
if not self.hascache:
|
||||
raise Error, 'Cannot warm cache'
|
||||
|
||||
|
||||
#
|
||||
# getinfo returns all info pertaining to a film. The returned tuple
|
||||
# can be passed to VoutFile.setinfo()
|
||||
#
|
||||
def getinfo(self):
|
||||
return (self.format, self.width, self.height, self.packfactor,\
|
||||
self.c0bits, self.c1bits, self.c2bits, self.offset, \
|
||||
self.chrompack)
|
||||
|
||||
# rewind() raises Error if the header is bad (which can only
|
||||
# happen if the file was written to since opened).
|
||||
|
||||
|
|
@ -131,6 +172,11 @@ class VinFile():
|
|||
self.fp.seek(0)
|
||||
x = self.initfp(self.fp, self.filename)
|
||||
|
||||
def position(self):
|
||||
if self.frameno >= len(self.framecache):
|
||||
raise EOFError
|
||||
self.fp.seek(self.framecache[self.frameno][0])
|
||||
|
||||
# getnextframe() raises EOFError (built-in) if there is no next frame,
|
||||
# or if the next frame is broken.
|
||||
# So to getnextframeheader(), getnextframedata() and skipnextframe().
|
||||
|
|
@ -141,6 +187,9 @@ class VinFile():
|
|||
return time, data, chromdata
|
||||
|
||||
def getnextframedata(self, (size, chromsize)):
|
||||
if self.hascache:
|
||||
self.position()
|
||||
self.frameno = self.frameno + 1
|
||||
data = self.fp.read(size)
|
||||
if len(data) <> size: raise EOFError
|
||||
if chromsize:
|
||||
|
|
@ -157,6 +206,9 @@ class VinFile():
|
|||
return time
|
||||
|
||||
def skipnextframedata(self, (size, chromsize)):
|
||||
if self.hascache:
|
||||
self.frameno = self.frameno + 1
|
||||
return
|
||||
# Note that this won't raise EOFError for a partial frame.
|
||||
try:
|
||||
self.fp.seek(size + chromsize, 1) # Relative seek
|
||||
|
|
@ -165,8 +217,13 @@ class VinFile():
|
|||
dummy = self.fp.read(size + chromsize)
|
||||
|
||||
def getnextframeheader(self):
|
||||
if self.hascache:
|
||||
if self.frameno >= len(self.framecache):
|
||||
raise EOFError
|
||||
return self.framecache[self.frameno][1]
|
||||
line = self.fp.readline()
|
||||
if not line:
|
||||
self.hascache = 1
|
||||
raise EOFError
|
||||
#
|
||||
w, h, pf = self.width, self.height, self.packfactor
|
||||
|
|
@ -191,6 +248,8 @@ class VinFile():
|
|||
time, size, chromsize = x
|
||||
except:
|
||||
raise Error, self.filename + ': bad frame header'
|
||||
cdata = (self.fp.tell(), (time, size, chromsize))
|
||||
self.framecache.append(cdata)
|
||||
return time, size, chromsize
|
||||
|
||||
def shownextframe(self):
|
||||
|
|
@ -204,7 +263,7 @@ class VinFile():
|
|||
self.initcolormap()
|
||||
factor = self.magnify
|
||||
if pf: factor = factor * pf
|
||||
if chromdata:
|
||||
if chromdata and not self.skipchrom:
|
||||
cp = self.chrompack
|
||||
cw = (w+cp-1)/cp
|
||||
ch = (h+cp-1)/cp
|
||||
|
|
@ -232,28 +291,45 @@ class VinFile():
|
|||
return
|
||||
gl.cmode()
|
||||
gl.gconfig()
|
||||
self.skipchrom = 0
|
||||
sys.stderr.write('Initializing color map...')
|
||||
initcmap(self.convcolor, self.c0bits, self.c1bits, \
|
||||
self.c2bits, self.chrompack, self.offset)
|
||||
self.initcmap()
|
||||
sys.stderr.write(' Done.\n')
|
||||
if self.offset == 0:
|
||||
gl.color(0x800)
|
||||
gl.clear()
|
||||
self.mask = 0x7ff
|
||||
else:
|
||||
self.mask = 0xfff
|
||||
gl.clear()
|
||||
|
||||
|
||||
def initcmap(convcolor, c0bits, c1bits, c2bits, chrompack, offset):
|
||||
if c0bits+c1bits+c2bits > 11:
|
||||
raise Error, 'Sorry, 11 bits max'
|
||||
def initcmap(self):
|
||||
maxbits = gl.getgdesc(GL.GD_BITS_NORM_SNG_CMODE)
|
||||
if maxbits > 11:
|
||||
maxbits = 11
|
||||
c0bits, c1bits, c2bits = self.c0bits, self.c1bits, self.c2bits
|
||||
if c0bits+c1bits+c2bits > maxbits:
|
||||
if self.fallback and c0bits < maxbits:
|
||||
# Cannot display film in this mode, use mono
|
||||
self.skipchrom = 1
|
||||
c1bits = c2bits = 0
|
||||
self.convcolor = conv_grey
|
||||
else:
|
||||
raise Error, 'Sorry, '+`maxbits`+ \
|
||||
' bits max on this machine'
|
||||
maxc0 = 1 << c0bits
|
||||
maxc1 = 1 << c1bits
|
||||
maxc2 = 1 << c2bits
|
||||
if offset == 0:
|
||||
if self.offset == 0 and maxbits == 11:
|
||||
offset = 2048
|
||||
for i in range(offset, MAXMAP):
|
||||
gl.mapcolor(i, 0, 255, 0)
|
||||
else:
|
||||
offset = self.offset
|
||||
if maxbits <> 11:
|
||||
offset = offset & ((1<<maxbits)-1)
|
||||
#for i in range(512, MAXMAP):
|
||||
# gl.mapcolor(i, 0, 0, 0)
|
||||
#void = gl.qtest() # Should be gl.gflush()
|
||||
for c0 in range(maxc0):
|
||||
c0v = c0/float(maxc0-1)
|
||||
for c1 in range(maxc1):
|
||||
|
|
@ -266,14 +342,136 @@ def initcmap(convcolor, c0bits, c1bits, c2bits, chrompack, offset):
|
|||
c2v = 0
|
||||
else:
|
||||
c2v = c2/float(maxc2-1)
|
||||
index = offset + c0 + \
|
||||
(c1<<c0bits) + (c2 << (c0bits+c1bits))
|
||||
rv, gv, bv = convcolor(c0v, c1v, c2v)
|
||||
r, g, b = \
|
||||
int(rv*255.0), int(gv*255.0), int(bv*255.0)
|
||||
index = offset + c0 + (c1<<c0bits) + \
|
||||
(c2 << (c0bits+c1bits))
|
||||
rv, gv, bv = self.convcolor( \
|
||||
c0v, c1v, c2v)
|
||||
r, g, b = int(rv*255.0), \
|
||||
int(gv*255.0), int(bv*255.0)
|
||||
if index < MAXMAP:
|
||||
gl.mapcolor(index, r, g, b)
|
||||
void = gl.gflush()
|
||||
|
||||
#
|
||||
# A set of routines to grab images from windows
|
||||
#
|
||||
def grab_rgb(w, h, pf):
|
||||
if gl.getdisplaymode() <> DMRGB:
|
||||
raise Error, 'Sorry, can only grab rgb in single-buf rgbmode'
|
||||
if pf <> 1 and pf <> 0:
|
||||
raise Error, 'Sorry, only grab with packfactor=1'
|
||||
return gl.lrectread(0, 0, w-1, h-1), None
|
||||
|
||||
def grab_rgb8(w, h, pf):
|
||||
if gl.getdisplaymode() <> DMRGB:
|
||||
raise Error, 'Sorry, can only grab rgb in single-buf rgbmode'
|
||||
if pf <> 1 and pf <> 0:
|
||||
raise Error, 'Sorry, can only grab with packfactor=1'
|
||||
r = gl.getgdesc(GL.GD_BITS_NORM_SNG_RED)
|
||||
g = gl.getgdesc(GL.GD_BITS_NORM_SNG_GREEN)
|
||||
b = gl.getgdesc(GL.GD_BITS_NORM_SNG_BLUE)
|
||||
if (r,g,b) <> (3,3,2):
|
||||
raise Error, 'Sorry, can only grab rgb8 on 8-bit Indigo'
|
||||
# Dirty Dirty here. Set buffer to cmap mode, grab image and set it back
|
||||
gl.cmode()
|
||||
gl.gconfig()
|
||||
gl.pixmode(GL.PM_SIZE, 8)
|
||||
data = gl.lrectread(0, 0, w-1, h-1)
|
||||
data = data[:w*h] # BUG FIX for python lrectread
|
||||
gl.RGBmode()
|
||||
gl.gconfig()
|
||||
gl.pixmode(GL.PM_SIZE, 32)
|
||||
return data, None
|
||||
|
||||
def grab_grey(w, h, pf):
|
||||
raise Error, 'Sorry, grabbing grey not implemented'
|
||||
|
||||
def grab_yiq(w, h, pf):
|
||||
raise Error, 'Sorry, grabbing yiq not implemented'
|
||||
|
||||
def grab_hls(w, h, pf):
|
||||
raise Error, 'Sorry, grabbing hls not implemented'
|
||||
|
||||
def grab_hsv(w, h, pf):
|
||||
raise Error, 'Sorry, grabbing hsv not implemented'
|
||||
|
||||
#
|
||||
# The class VoutFile is not as well-designed (and tested) as VinFile.
|
||||
# Notably it will accept almost any garbage and write it to the video
|
||||
# output file
|
||||
#
|
||||
class VoutFile():
|
||||
def init(self, filename):
|
||||
if filename == '-':
|
||||
return self.initfp(sys.stdout, filename)
|
||||
else:
|
||||
return self.initfp(open(filename,'w'), filename)
|
||||
|
||||
def initfp(self, fp, filename):
|
||||
self.fp = fp
|
||||
self.format = 'grey'
|
||||
self.width = self.height = 0
|
||||
self.packfactor = 1
|
||||
self.c0bits = 8
|
||||
self.c1bits = self.c2bits = 0
|
||||
self.offset = 0
|
||||
self.chrompack = 0
|
||||
self.headerwritten = 0
|
||||
return self
|
||||
|
||||
def close(self):
|
||||
self.fp.close()
|
||||
self.initfp(None, None)
|
||||
|
||||
def setinfo(self, values):
|
||||
self.format, self.width, self.height, self.packfactor,\
|
||||
self.c0bits, self.c1bits, self.c2bits, self.offset, \
|
||||
self.chrompack = values
|
||||
|
||||
def writeheader(self):
|
||||
self.headerwritten = 1
|
||||
if self.format == 'rgb':
|
||||
self.packfactor = 0
|
||||
elif self.packfactor == 0:
|
||||
self.packfactor = 1
|
||||
self.fp.write('CMIF video 3.0\n')
|
||||
if self.format == 'rgb':
|
||||
data = ('rgb', 0)
|
||||
elif self.format == 'grey':
|
||||
data = ('grey', 0)
|
||||
else:
|
||||
data = (self.format, (self.c0bits, self.c1bits, \
|
||||
self.c2bits, self.chrompack, self.offset))
|
||||
self.fp.write(`data`+'\n')
|
||||
data = (self.width, self.height, self.packfactor)
|
||||
self.fp.write(`data`+'\n')
|
||||
try:
|
||||
self._grabber = eval('grab_' + self.format)
|
||||
except:
|
||||
raise Error, 'unknown colorsys: ' + self.format
|
||||
|
||||
def writeframeheader(self, data):
|
||||
if not self.headerwritten:
|
||||
raise Error, 'Writing frame data before header'
|
||||
# XXXX Should we sanity check here?
|
||||
self.fp.write(`data`+'\n')
|
||||
|
||||
def writeframedata(self, data, chromdata):
|
||||
# XXXX Check sizes here
|
||||
self.fp.write(data)
|
||||
if chromdata:
|
||||
self.fp.write(chromdata)
|
||||
|
||||
def writeframe(self, time, data, chromdata):
|
||||
if chromdata:
|
||||
clen = len(chromdata)
|
||||
else:
|
||||
clen = 0
|
||||
self.writeframeheader((time, len(data), clen))
|
||||
self.writeframedata(data, chromdata)
|
||||
|
||||
def grabframe(self):
|
||||
return self._grabber(self.width, self.height, self.packfactor)
|
||||
|
||||
def test():
|
||||
import sys, time
|
||||
|
|
@ -303,3 +501,4 @@ def test():
|
|||
vin.showframe(data, chromdata)
|
||||
print 'Done.'
|
||||
time.sleep(2)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue