mirror of https://github.com/python/cpython
1121 lines
28 KiB
Python
Executable File
1121 lines
28 KiB
Python
Executable File
# Classes to read and write CMIF video files.
|
|
# (For a description of the CMIF video format, see cmif-file.ms.)
|
|
|
|
|
|
# Layers of functionality:
|
|
#
|
|
# VideoParams: maintain essential parameters of a video file
|
|
# Displayer: display a frame in a window (with some extra parameters)
|
|
# BasicVinFile: read a CMIF video file
|
|
# BasicVoutFile: write a CMIF video file
|
|
# VinFile: BasicVinFile + Displayer
|
|
# VoutFile: BasicVoutFile + Displayer
|
|
#
|
|
# XXX Future extension:
|
|
# BasicVinoutFile: supports overwriting of individual frames
|
|
|
|
|
|
# Imported modules
|
|
|
|
import sys
|
|
import gl
|
|
import GL
|
|
import GET
|
|
import colorsys
|
|
import imageop
|
|
|
|
|
|
# Exception raised for various occasions
|
|
|
|
Error = 'VFile.Error' # file format errors
|
|
CallError = 'VFile.CallError' # bad call
|
|
AssertError = 'VFile.AssertError' # internal malfunction
|
|
|
|
|
|
# Max nr. of colormap entries to use
|
|
|
|
MAXMAP = 4096 - 256
|
|
|
|
|
|
# Parametrizations of colormap handling based on color system.
|
|
# (These functions are used via eval with a constructed argument!)
|
|
|
|
def conv_grey(l, x, y):
|
|
return colorsys.yiq_to_rgb(l, 0, 0)
|
|
|
|
def conv_grey4(l, x, y):
|
|
return colorsys.yiq_to_rgb(l*17, 0, 0)
|
|
|
|
def conv_mono(l, x, y):
|
|
return colorsys.yiq_to_rgb(l*255, 0, 0)
|
|
|
|
def conv_yiq(y, i, q):
|
|
return colorsys.yiq_to_rgb(y, (i-0.5)*1.2, q-0.5)
|
|
|
|
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)
|
|
|
|
def conv_jpeg(r, g, b):
|
|
raise Error, 'Attempt to make RGB colormap (jpeg)'
|
|
|
|
conv_jpeggrey = conv_grey
|
|
conv_grey2 = conv_grey
|
|
|
|
|
|
# Choose one of the above based upon a color system name
|
|
|
|
def choose_conversion(format):
|
|
try:
|
|
return eval('conv_' + format)
|
|
except:
|
|
raise Error, 'Unknown color system: ' + `format`
|
|
|
|
|
|
# Inverses of the above
|
|
|
|
def inv_grey(r, g, b):
|
|
y, i, q = colorsys.rgb_to_yiq(r, g, b)
|
|
return y, 0, 0
|
|
|
|
def inv_yiq(r, g, b):
|
|
y, i, q = colorsys.rgb_to_yiq(r, g, b)
|
|
return y, i/1.2 + 0.5, q + 0.5
|
|
|
|
def inv_hls(r, g, b):
|
|
h, l, s = colorsys.rgb_to_hls(r, g, b)
|
|
return l, h, s
|
|
|
|
def inv_hsv(r, g, b):
|
|
h, s, v = colorsys.rgb_to_hsv(r, g, b)
|
|
return v, h, s
|
|
|
|
def inv_rgb(r, g, b):
|
|
raise Error, 'Attempt to invert RGB colormap'
|
|
|
|
def inv_rgb8(r, g, b):
|
|
r = int(r*7.0)
|
|
g = int(g*7.0)
|
|
b = int(b*7.0)
|
|
rgb = ((r&7) << 5) | ((b&3) << 3) | (g&7)
|
|
return rgb / 255.0, 0, 0
|
|
|
|
def inv_jpeg(r, g, b):
|
|
raise Error, 'Attempt to invert RGB colormap (jpeg)'
|
|
|
|
inv_jpeggrey = inv_grey
|
|
|
|
|
|
# Choose one of the above based upon a color system name
|
|
|
|
def choose_inverse(format):
|
|
try:
|
|
return eval('inv_' + format)
|
|
except:
|
|
raise Error, 'Unknown color system: ' + `format`
|
|
|
|
|
|
# Predicate to see whether this is an entry level (non-XS) Indigo.
|
|
# If so we can lrectwrite 8-bit wide pixels into a window in RGB mode
|
|
|
|
def is_entry_indigo():
|
|
# XXX hack, hack. We should call gl.gversion() but that doesn't
|
|
# exist in earlier Python versions. Therefore we check the number
|
|
# of bitplanes *and* the size of the monitor.
|
|
xmax = gl.getgdesc(GL.GD_XPMAX)
|
|
if xmax <> 1024: return 0
|
|
ymax = gl.getgdesc(GL.GD_YPMAX)
|
|
if ymax != 768: return 0
|
|
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)
|
|
return (r, g, b) == (3, 3, 2)
|
|
|
|
|
|
# Predicate to see whether this machine supports pixmode(PM_SIZE) with
|
|
# values 1 or 4.
|
|
#
|
|
# XXX Temporarily disabled, since it is unclear which machines support
|
|
# XXX which pixelsizes.
|
|
#
|
|
# XXX The XS appears to support 4 bit pixels, but (looking at osview) it
|
|
# XXX seems as if the conversion is done by the kernel (unpacking ourselves
|
|
# XXX is faster than using PM_SIZE=4)
|
|
|
|
def support_packed_pixels():
|
|
return 0 # To be architecture-dependent
|
|
|
|
|
|
|
|
# Tables listing bits per pixel for some formats
|
|
|
|
bitsperpixel = { \
|
|
'rgb': 32, \
|
|
'rgb8': 8, \
|
|
'grey': 8, \
|
|
'grey4': 4, \
|
|
'grey2': 2, \
|
|
'mono': 1, \
|
|
'compress': 32, \
|
|
}
|
|
|
|
bppafterdecomp = {'jpeg': 32, 'jpeggrey': 8}
|
|
|
|
|
|
# Base class to manage video format parameters
|
|
|
|
class VideoParams:
|
|
|
|
# Initialize an instance.
|
|
# Set all parameters to something decent
|
|
# (except width and height are set to zero)
|
|
|
|
def init(self):
|
|
# Essential parameters
|
|
self.frozen = 0 # if set, can't change parameters
|
|
self.format = 'grey' # color system used
|
|
# Choose from: grey, rgb, rgb8, hsv, yiq, hls, jpeg, jpeggrey,
|
|
# mono, grey2, grey4
|
|
self.width = 0 # width of frame
|
|
self.height = 0 # height of frame
|
|
self.packfactor = 1, 1 # expansion using rectzoom
|
|
# Colormap info
|
|
self.c0bits = 8 # bits in first color dimension
|
|
self.c1bits = 0 # bits in second color dimension
|
|
self.c2bits = 0 # bits in third color dimension
|
|
self.offset = 0 # colormap index offset (XXX ???)
|
|
self.chrompack = 0 # set if separate chrominance data
|
|
self.setderived()
|
|
return self
|
|
|
|
# Freeze the parameters (disallow changes)
|
|
|
|
def freeze(self):
|
|
self.frozen = 1
|
|
|
|
# Unfreeze the parameters (allow changes)
|
|
|
|
def unfreeze(self):
|
|
self.frozen = 0
|
|
|
|
# Set some values derived from the standard info values
|
|
|
|
def setderived(self):
|
|
if self.frozen: raise AssertError
|
|
if bitsperpixel.has_key(self.format):
|
|
self.bpp = bitsperpixel[self.format]
|
|
else:
|
|
self.bpp = 0
|
|
xpf, ypf = self.packfactor
|
|
self.xpf = abs(xpf)
|
|
self.ypf = abs(ypf)
|
|
self.mirror_image = (xpf < 0)
|
|
self.upside_down = (ypf < 0)
|
|
self.realwidth = self.width / self.xpf
|
|
self.realheight = self.height / self.ypf
|
|
|
|
# Set colormap info
|
|
|
|
def setcmapinfo(self):
|
|
stuff = 0, 0, 0, 0, 0
|
|
if self.format in ('rgb8', 'grey'):
|
|
stuff = 8, 0, 0, 0, 0
|
|
if self.format == 'grey4':
|
|
stuff = 4, 0, 0, 0, 0
|
|
if self.format == 'grey2':
|
|
stuff = 2, 0, 0, 0, 0
|
|
if self.format == 'mono':
|
|
stuff = 1, 0, 0, 0, 0
|
|
self.c0bits, self.c1bits, self.c2bits, \
|
|
self.offset, self.chrompack = stuff
|
|
|
|
# Set the frame width and height (e.g. from gl.getsize())
|
|
|
|
def setsize(self, width, height):
|
|
if self.frozen: raise CallError
|
|
width = (width/self.xpf)*self.xpf
|
|
height = (height/self.ypf)*self.ypf
|
|
self.width, self.height = width, height
|
|
self.setderived()
|
|
|
|
# Retrieve the frame width and height (e.g. for gl.prefsize())
|
|
|
|
def getsize(self):
|
|
return (self.width, self.height)
|
|
|
|
# Set the format
|
|
|
|
def setformat(self, format):
|
|
if self.frozen: raise CallError
|
|
self.format = format
|
|
self.setderived()
|
|
self.setcmapinfo()
|
|
|
|
# Get the format
|
|
|
|
def getformat(self):
|
|
return self.format
|
|
|
|
# Set the packfactor
|
|
|
|
def setpf(self, pf):
|
|
if self.frozen: raise CallError
|
|
if type(pf) is not type(()) or len(pf) <> 2: raise CallError
|
|
self.packfactor = pf
|
|
self.setderived()
|
|
|
|
# Get the packfactor
|
|
|
|
def getpf(self):
|
|
return self.packfactor
|
|
|
|
# Set all parameters
|
|
|
|
def setinfo(self, values):
|
|
if self.frozen: raise CallError
|
|
self.setformat(values[0])
|
|
self.setpf(values[3])
|
|
self.setsize(values[1], values[2])
|
|
(self.c0bits, self.c1bits, self.c2bits, \
|
|
self.offset, self.chrompack) = values[4:9]
|
|
if self.format == 'compress':
|
|
self.compressheader = values[9]
|
|
self.setderived()
|
|
|
|
# Retrieve all parameters in a format suitable for a subsequent
|
|
# call to setinfo()
|
|
|
|
def getinfo(self):
|
|
return (self.format, self.width, self.height, self.packfactor,\
|
|
self.c0bits, self.c1bits, self.c2bits, self.offset, \
|
|
self.chrompack)
|
|
|
|
# Write the relevant bits to stdout
|
|
|
|
def printinfo(self):
|
|
print 'Format: ', self.format
|
|
print 'Size: ', self.width, 'x', self.height
|
|
print 'Pack: ', self.packfactor, '; chrom:', self.chrompack
|
|
print 'Bpp: ', self.bpp
|
|
print 'Bits: ', self.c0bits, self.c1bits, self.c2bits
|
|
print 'Offset: ', self.offset
|
|
|
|
# Calculate data size, if possible
|
|
# (Not counting frame header or cdata size)
|
|
|
|
def calcframesize(self):
|
|
if not self.bpp: raise CallError
|
|
size = self.width/self.xpf * self.height/self.ypf
|
|
size = (size * self.bpp + 7) / 8
|
|
return size
|
|
|
|
|
|
# Class to display video frames in a window.
|
|
# It is the caller's responsibility to ensure that the correct window
|
|
# is current when using showframe(), initcolormap(), clear() and clearto()
|
|
|
|
class Displayer(VideoParams):
|
|
|
|
# Initialize an instance.
|
|
# This does not need a current window
|
|
|
|
def init(self):
|
|
self = VideoParams.init(self)
|
|
# User-settable parameters
|
|
self.magnify = 1.0 # frame magnification factor
|
|
self.xorigin = 0 # x frame offset
|
|
self.yorigin = 0 # y frame offset (from bottom)
|
|
self.quiet = 0 # if set, don't print messages
|
|
self.fallback = 1 # allow fallback to grey
|
|
# Internal flags
|
|
self.colormapinited = 0 # must initialize window
|
|
self.skipchrom = 0 # don't skip chrominance data
|
|
self.color0 = None # magic, used by clearto()
|
|
self.fixcolor0 = 0 # don't need to fix color0
|
|
self.mustunpack = (not support_packed_pixels())
|
|
self.decompressor = None
|
|
return self
|
|
|
|
# setinfo() must reset some internal flags
|
|
|
|
def setinfo(self, values):
|
|
VideoParams.setinfo(self, values)
|
|
self.colormapinited = 0
|
|
self.skipchrom = 0
|
|
self.color0 = None
|
|
self.fixcolor0 = 0
|
|
|
|
# Show one frame, initializing the window if necessary
|
|
|
|
def showframe(self, data, chromdata):
|
|
self.showpartframe(data, chromdata, \
|
|
(0,0,self.width,self.height))
|
|
|
|
def showpartframe(self, data, chromdata, (x,y,w,h)):
|
|
pmsize = self.bpp
|
|
xpf, ypf = self.xpf, self.ypf
|
|
if self.upside_down:
|
|
gl.pixmode(GL.PM_TTOB, 1)
|
|
if self.mirror_image:
|
|
gp.pixmode(GL.PM_RTOL, 1)
|
|
if self.format in ('jpeg', 'jpeggrey'):
|
|
import jpeg
|
|
data, width, height, bytes = jpeg.decompress(data)
|
|
pmsize = bytes*8
|
|
elif self.format == 'compress':
|
|
if not self.decompressor:
|
|
import cl, CL
|
|
scheme = cl.QueryScheme(self.compressheader)
|
|
self.decompressor = cl.OpenDecompressor(scheme)
|
|
headersize = self.decompressor.ReadHeader(self.compressheader)
|
|
width = self.decompressor.GetParam(CL.IMAGE_WIDTH)
|
|
height = self.decompressor.GetParam(CL.IMAGE_HEIGHT)
|
|
params = [CL.ORIGINAL_FORMAT, CL.RGBX, \
|
|
CL.ORIENTATION, CL.BOTTOM_UP, \
|
|
CL.FRAME_BUFFER_SIZE, width*height*CL.BytesPerPixel(CL.RGBX)]
|
|
self.decompressor.SetParams(params)
|
|
data = self.decompressor.Decompress(1, data)
|
|
elif self.format in ('mono', 'grey4'):
|
|
if self.mustunpack:
|
|
if self.format == 'mono':
|
|
data = imageop.mono2grey(data, \
|
|
w/xpf, h/ypf, 0x20, 0xdf)
|
|
elif self.format == 'grey4':
|
|
data = imageop.grey42grey(data, \
|
|
w/xpf, h/ypf)
|
|
pmsize = 8
|
|
elif self.format == 'grey2':
|
|
data = imageop.grey22grey(data, w/xpf, h/ypf)
|
|
pmsize = 8
|
|
if not self.colormapinited:
|
|
self.initcolormap()
|
|
if self.fixcolor0:
|
|
gl.mapcolor(self.color0)
|
|
self.fixcolor0 = 0
|
|
xfactor = yfactor = self.magnify
|
|
xfactor = xfactor * xpf
|
|
yfactor = yfactor * ypf
|
|
if chromdata and not self.skipchrom:
|
|
cp = self.chrompack
|
|
cx = int(x*xfactor*cp) + self.xorigin
|
|
cy = int(y*yfactor*cp) + self.yorigin
|
|
cw = (w+cp-1)/cp
|
|
ch = (h+cp-1)/cp
|
|
gl.rectzoom(xfactor*cp, yfactor*cp)
|
|
gl.pixmode(GL.PM_SIZE, 16)
|
|
gl.writemask(self.mask - ((1 << self.c0bits) - 1))
|
|
gl.lrectwrite(cx, cy, cx + cw - 1, cy + ch - 1, \
|
|
chromdata)
|
|
#
|
|
if pmsize < 32:
|
|
gl.writemask((1 << self.c0bits) - 1)
|
|
gl.pixmode(GL.PM_SIZE, pmsize)
|
|
w = w/xpf
|
|
h = h/ypf
|
|
x = x/xpf
|
|
y = y/ypf
|
|
gl.rectzoom(xfactor, yfactor)
|
|
x = int(x*xfactor)+self.xorigin
|
|
y = int(y*yfactor)+self.yorigin
|
|
gl.lrectwrite(x, y, x + w - 1, y + h - 1, data)
|
|
gl.gflush()
|
|
|
|
# Initialize the window: set RGB or colormap mode as required,
|
|
# fill in the colormap, and clear the window
|
|
|
|
def initcolormap(self):
|
|
self.colormapinited = 1
|
|
self.color0 = None
|
|
self.fixcolor0 = 0
|
|
if self.format in ('rgb', 'jpeg', 'compress'):
|
|
gl.RGBmode()
|
|
gl.gconfig()
|
|
gl.RGBcolor(200, 200, 200) # XXX rather light grey
|
|
gl.clear()
|
|
return
|
|
# This only works on an Entry-level Indigo from IRIX 4.0.5
|
|
if self.format == 'rgb8' and is_entry_indigo() and \
|
|
gl.gversion() == 'GL4DLG-4.0.': # Note trailing '.'!
|
|
gl.RGBmode()
|
|
gl.gconfig()
|
|
gl.RGBcolor(200, 200, 200) # XXX rather light grey
|
|
gl.clear()
|
|
gl.pixmode(GL.PM_SIZE, 8)
|
|
return
|
|
gl.cmode()
|
|
gl.gconfig()
|
|
self.skipchrom = 0
|
|
if self.offset == 0:
|
|
self.mask = 0x7ff
|
|
else:
|
|
self.mask = 0xfff
|
|
if not self.quiet:
|
|
sys.stderr.write('Initializing color map...')
|
|
self._initcmap()
|
|
gl.clear()
|
|
if not self.quiet:
|
|
sys.stderr.write(' Done.\n')
|
|
|
|
# Clear the window to a default color
|
|
|
|
def clear(self):
|
|
if not self.colormapinited: raise CallError
|
|
if gl.getdisplaymode() in (GET.DMRGB, GET.DMRGBDOUBLE):
|
|
gl.RGBcolor(200, 200, 200) # XXX rather light grey
|
|
gl.clear()
|
|
return
|
|
gl.writemask(0xffffffff)
|
|
gl.clear()
|
|
|
|
# Clear the window to a given RGB color.
|
|
# This may steal the first color index used; the next call to
|
|
# showframe() will restore the intended mapping for that index
|
|
|
|
def clearto(self, r, g, b):
|
|
if not self.colormapinited: raise CallError
|
|
if gl.getdisplaymode() in (GET.DMRGB, GET.DMRGBDOUBLE):
|
|
gl.RGBcolor(r, g, b)
|
|
gl.clear()
|
|
return
|
|
index = self.color0[0]
|
|
self.fixcolor0 = 1
|
|
gl.mapcolor(index, r, g, b)
|
|
gl.writemask(0xffffffff)
|
|
gl.clear()
|
|
gl.gflush()
|
|
|
|
# Do the hard work for initializing the colormap (internal).
|
|
# This also sets the current color to the first color index
|
|
# used -- the caller should never change this since it is used
|
|
# by clear() and clearto()
|
|
|
|
def _initcmap(self):
|
|
if self.format in ('mono', 'grey4') and self.mustunpack:
|
|
convcolor = conv_grey
|
|
else:
|
|
convcolor = choose_conversion(self.format)
|
|
maxbits = gl.getgdesc(GL.GD_BITS_NORM_SNG_CMODE)
|
|
if maxbits > 11:
|
|
maxbits = 11
|
|
c0bits = self.c0bits
|
|
c1bits = self.c1bits
|
|
c2bits = self.c2bits
|
|
if c0bits+c1bits+c2bits > maxbits:
|
|
if self.fallback and c0bits < maxbits:
|
|
# Cannot display frames in this mode, use grey
|
|
self.skipchrom = 1
|
|
c1bits = c2bits = 0
|
|
convcolor = choose_conversion('grey')
|
|
else:
|
|
raise Error, 'Sorry, '+`maxbits`+ \
|
|
' bits max on this machine'
|
|
maxc0 = 1 << c0bits
|
|
maxc1 = 1 << c1bits
|
|
maxc2 = 1 << c2bits
|
|
if self.offset == 0 and maxbits == 11:
|
|
offset = 2048
|
|
else:
|
|
offset = self.offset
|
|
if maxbits <> 11:
|
|
offset = offset & ((1<<maxbits)-1)
|
|
self.color0 = None
|
|
self.fixcolor0 = 0
|
|
for c0 in range(maxc0):
|
|
c0v = c0/float(maxc0-1)
|
|
for c1 in range(maxc1):
|
|
if maxc1 == 1:
|
|
c1v = 0
|
|
else:
|
|
c1v = c1/float(maxc1-1)
|
|
for c2 in range(maxc2):
|
|
if maxc2 == 1:
|
|
c2v = 0
|
|
else:
|
|
c2v = c2/float(maxc2-1)
|
|
index = offset + c0 + (c1<<c0bits) + \
|
|
(c2 << (c0bits+c1bits))
|
|
if index < MAXMAP:
|
|
rv, gv, bv = \
|
|
convcolor(c0v, c1v, c2v)
|
|
r, g, b = int(rv*255.0), \
|
|
int(gv*255.0), \
|
|
int(bv*255.0)
|
|
gl.mapcolor(index, r, g, b)
|
|
if self.color0 == None:
|
|
self.color0 = \
|
|
index, r, g, b
|
|
# Permanently make the first color index current
|
|
gl.color(self.color0[0])
|
|
gl.gflush() # send the colormap changes to the X server
|
|
|
|
|
|
# Read a CMIF video file header.
|
|
# Return (version, values) where version is 0.0, 1.0, 2.0 or 3.[01],
|
|
# and values is ready for setinfo().
|
|
# Raise Error if there is an error in the info
|
|
|
|
def readfileheader(fp, filename):
|
|
#
|
|
# Get identifying header
|
|
#
|
|
line = fp.readline(20)
|
|
if line == 'CMIF video 0.0\n':
|
|
version = 0.0
|
|
elif line == 'CMIF video 1.0\n':
|
|
version = 1.0
|
|
elif line == 'CMIF video 2.0\n':
|
|
version = 2.0
|
|
elif line == 'CMIF video 3.0\n':
|
|
version = 3.0
|
|
elif line == 'CMIF video 3.1\n':
|
|
version = 3.1
|
|
else:
|
|
# XXX Could be version 0.0 without identifying header
|
|
raise Error, \
|
|
filename + ': Unrecognized file header: ' + `line`[:20]
|
|
compressheader = None
|
|
#
|
|
# Get color encoding info
|
|
# (The format may change to 'rgb' later when packfactor == 0)
|
|
#
|
|
if version <= 1.0:
|
|
format = 'grey'
|
|
c0bits, c1bits, c2bits = 8, 0, 0
|
|
chrompack = 0
|
|
offset = 0
|
|
elif version == 2.0:
|
|
line = fp.readline()
|
|
try:
|
|
c0bits, c1bits, c2bits, chrompack = eval(line[:-1])
|
|
except:
|
|
raise Error, filename + ': Bad 2.0 color info'
|
|
if c1bits or c2bits:
|
|
format = 'yiq'
|
|
else:
|
|
format = 'grey'
|
|
offset = 0
|
|
elif version in (3.0, 3.1):
|
|
line = fp.readline()
|
|
try:
|
|
format, rest = eval(line[:-1])
|
|
except:
|
|
raise Error, filename + ': Bad 3.[01] color info'
|
|
if format in ('rgb', 'jpeg'):
|
|
c0bits = c1bits = c2bits = 0
|
|
chrompack = 0
|
|
offset = 0
|
|
elif format == 'compress':
|
|
c0bits = c1bits = c2bits = 0
|
|
chrompack = 0
|
|
offset = 0
|
|
compressheader = rest
|
|
elif format in ('grey', 'jpeggrey', 'mono', 'grey2', 'grey4'):
|
|
c0bits = rest
|
|
c1bits = c2bits = 0
|
|
chrompack = 0
|
|
offset = 0
|
|
else:
|
|
# XXX ought to check that the format is valid
|
|
try:
|
|
c0bits, c1bits, c2bits, chrompack, offset = rest
|
|
except:
|
|
raise Error, filename + ': Bad 3.[01] color info'
|
|
if format == 'xrgb8':
|
|
format = 'rgb8' # rgb8 upside-down, for X
|
|
upside_down = 1
|
|
else:
|
|
upside_down = 0
|
|
#
|
|
# Get frame geometry info
|
|
#
|
|
line = fp.readline()
|
|
try:
|
|
x = eval(line[:-1])
|
|
except:
|
|
raise Error, filename + ': Bad (w,h,pf) info'
|
|
if type(x) <> type(()):
|
|
raise Error, filename + ': Bad (w,h,pf) info'
|
|
if len(x) == 3:
|
|
width, height, packfactor = x
|
|
if packfactor == 0 and version < 3.0:
|
|
format = 'rgb'
|
|
c0bits = 0
|
|
elif len(x) == 2 and version <= 1.0:
|
|
width, height = x
|
|
packfactor = 2
|
|
else:
|
|
raise Error, filename + ': Bad (w,h,pf) info'
|
|
if type(packfactor) is type(0):
|
|
if packfactor == 0: packfactor = 1
|
|
xpf = ypf = packfactor
|
|
else:
|
|
xpf, ypf = packfactor
|
|
if upside_down:
|
|
ypf = -ypf
|
|
packfactor = (xpf, ypf)
|
|
xpf = abs(xpf)
|
|
ypf = abs(ypf)
|
|
width = (width/xpf) * xpf
|
|
height = (height/ypf) * ypf
|
|
#
|
|
# Return (version, values)
|
|
#
|
|
values = (format, width, height, packfactor, \
|
|
c0bits, c1bits, c2bits, offset, chrompack, compressheader)
|
|
return (version, values)
|
|
|
|
|
|
# Read a *frame* header -- separate functions per version.
|
|
# Return (timecode, datasize, chromdatasize).
|
|
# Raise EOFError if end of data is reached.
|
|
# Raise Error if data is bad.
|
|
|
|
def readv0frameheader(fp):
|
|
line = fp.readline()
|
|
if not line or line == '\n': raise EOFError
|
|
try:
|
|
t = eval(line[:-1])
|
|
except:
|
|
raise Error, 'Bad 0.0 frame header'
|
|
return (t, 0, 0)
|
|
|
|
def readv1frameheader(fp):
|
|
line = fp.readline()
|
|
if not line or line == '\n': raise EOFError
|
|
try:
|
|
t, datasize = eval(line[:-1])
|
|
except:
|
|
raise Error, 'Bad 1.0 frame header'
|
|
return (t, datasize, 0)
|
|
|
|
def readv2frameheader(fp):
|
|
line = fp.readline()
|
|
if not line or line == '\n': raise EOFError
|
|
try:
|
|
t, datasize = eval(line[:-1])
|
|
except:
|
|
raise Error, 'Bad 2.0 frame header'
|
|
return (t, datasize, 0)
|
|
|
|
def readv3frameheader(fp):
|
|
line = fp.readline()
|
|
if not line or line == '\n': raise EOFError
|
|
try:
|
|
t, datasize, chromdatasize = x = eval(line[:-1])
|
|
except:
|
|
raise Error, 'Bad 3.[01] frame header'
|
|
return x
|
|
|
|
|
|
# Write a CMIF video file header (always version 3.1)
|
|
|
|
def writefileheader(fp, values):
|
|
(format, width, height, packfactor, \
|
|
c0bits, c1bits, c2bits, offset, chrompack) = values
|
|
#
|
|
# Write identifying header
|
|
#
|
|
fp.write('CMIF video 3.1\n')
|
|
#
|
|
# Write color encoding info
|
|
#
|
|
if format in ('rgb', 'jpeg'):
|
|
data = (format, 0)
|
|
elif format in ('grey', 'jpeggrey', 'mono', 'grey2', 'grey4'):
|
|
data = (format, c0bits)
|
|
else:
|
|
data = (format, (c0bits, c1bits, c2bits, chrompack, offset))
|
|
fp.write(`data`+'\n')
|
|
#
|
|
# Write frame geometry info
|
|
#
|
|
data = (width, height, packfactor)
|
|
fp.write(`data`+'\n')
|
|
|
|
|
|
# Basic class for reading CMIF video files
|
|
|
|
class BasicVinFile(VideoParams):
|
|
|
|
def init(self, filename):
|
|
if filename == '-':
|
|
fp = sys.stdin
|
|
else:
|
|
fp = open(filename, 'r')
|
|
return self.initfp(fp, filename)
|
|
|
|
def initfp(self, fp, filename):
|
|
self = VideoParams.init(self)
|
|
self.fp = fp
|
|
self.filename = filename
|
|
self.version, values = readfileheader(fp, filename)
|
|
self.setinfo(values)
|
|
self.freeze()
|
|
if self.version == 0.0:
|
|
w, h, pf = self.width, self.height, self.packfactor
|
|
if pf == 0:
|
|
self._datasize = w*h*4
|
|
else:
|
|
self._datasize = (w/pf) * (h/pf)
|
|
self._readframeheader = self._readv0frameheader
|
|
elif self.version == 1.0:
|
|
self._readframeheader = readv1frameheader
|
|
elif self.version == 2.0:
|
|
self._readframeheader = readv2frameheader
|
|
elif self.version in (3.0, 3.1):
|
|
self._readframeheader = readv3frameheader
|
|
else:
|
|
raise Error, \
|
|
filename + ': Bad version: ' + `self.version`
|
|
self.framecount = 0
|
|
self.atframeheader = 1
|
|
self.eofseen = 0
|
|
self.errorseen = 0
|
|
try:
|
|
self.startpos = self.fp.tell()
|
|
self.canseek = 1
|
|
except IOError:
|
|
self.startpos = -1
|
|
self.canseek = 0
|
|
return self
|
|
|
|
def _readv0frameheader(self, fp):
|
|
t, ds, cs = readv0frameheader(fp)
|
|
ds = self._datasize
|
|
return (t, ds, cs)
|
|
|
|
def close(self):
|
|
self.fp.close()
|
|
del self.fp
|
|
del self._readframeheader
|
|
|
|
def rewind(self):
|
|
if not self.canseek:
|
|
raise Error, self.filename + ': can\'t seek'
|
|
self.fp.seek(self.startpos)
|
|
self.framecount = 0
|
|
self.atframeheader = 1
|
|
self.eofseen = 0
|
|
self.errorseen = 0
|
|
|
|
def warmcache(self):
|
|
print '[BasicVinFile.warmcache() not implemented]'
|
|
|
|
def printinfo(self):
|
|
print 'File: ', self.filename
|
|
print 'Size: ', getfilesize(self.filename)
|
|
print 'Version: ', self.version
|
|
VideoParams.printinfo(self)
|
|
|
|
def getnextframe(self):
|
|
t, ds, cs = self.getnextframeheader()
|
|
data, cdata = self.getnextframedata(ds, cs)
|
|
return (t, data, cdata)
|
|
|
|
def skipnextframe(self):
|
|
t, ds, cs = self.getnextframeheader()
|
|
self.skipnextframedata(ds, cs)
|
|
return t
|
|
|
|
def getnextframeheader(self):
|
|
if self.eofseen: raise EOFError
|
|
if self.errorseen: raise CallError
|
|
if not self.atframeheader: raise CallError
|
|
self.atframeheader = 0
|
|
try:
|
|
return self._readframeheader(self.fp)
|
|
except Error, msg:
|
|
self.errorseen = 1
|
|
# Patch up the error message
|
|
raise Error, self.filename + ': ' + msg
|
|
except EOFError:
|
|
self.eofseen = 1
|
|
raise EOFError
|
|
|
|
def getnextframedata(self, ds, cs):
|
|
if self.eofseen: raise EOFError
|
|
if self.errorseen: raise CallError
|
|
if self.atframeheader: raise CallError
|
|
if ds:
|
|
data = self.fp.read(ds)
|
|
if len(data) < ds:
|
|
self.eofseen = 1
|
|
raise EOFError
|
|
else:
|
|
data = ''
|
|
if cs:
|
|
cdata = self.fp.read(cs)
|
|
if len(cdata) < cs:
|
|
self.eofseen = 1
|
|
raise EOFError
|
|
else:
|
|
cdata = ''
|
|
self.atframeheader = 1
|
|
self.framecount = self.framecount + 1
|
|
return (data, cdata)
|
|
|
|
def skipnextframedata(self, ds, cs):
|
|
if self.eofseen: raise EOFError
|
|
if self.errorseen: raise CallError
|
|
if self.atframeheader: raise CallError
|
|
# Note that this won't raise EOFError for a partial frame
|
|
# since there is no easy way to tell whether a seek
|
|
# ended up beyond the end of the file
|
|
if self.canseek:
|
|
self.fp.seek(ds + cs, 1) # Relative seek
|
|
else:
|
|
dummy = self.fp.read(ds + cs)
|
|
del dummy
|
|
self.atframeheader = 1
|
|
self.framecount = self.framecount + 1
|
|
|
|
|
|
# Subroutine to return a file's size in bytes
|
|
|
|
def getfilesize(filename):
|
|
import os, stat
|
|
try:
|
|
st = os.stat(filename)
|
|
return st[stat.ST_SIZE]
|
|
except os.error:
|
|
return 0
|
|
|
|
|
|
# Derived class implementing random access and index cached in the file
|
|
|
|
class RandomVinFile(BasicVinFile):
|
|
|
|
def initfp(self, fp, filename):
|
|
self = BasicVinFile.initfp(self, fp, filename)
|
|
self.index = []
|
|
return self
|
|
|
|
def warmcache(self):
|
|
if len(self.index) == 0:
|
|
try:
|
|
self.readcache()
|
|
except Error:
|
|
self.buildcache()
|
|
else:
|
|
print '[RandomVinFile.warmcache(): too late]'
|
|
self.rewind()
|
|
|
|
def buildcache(self):
|
|
self.index = []
|
|
self.rewind()
|
|
while 1:
|
|
try: dummy = self.skipnextframe()
|
|
except EOFError: break
|
|
self.rewind()
|
|
|
|
def writecache(self):
|
|
# Raises IOerror if the file is not seekable & writable!
|
|
import marshal
|
|
if len(self.index) == 0:
|
|
self.buildcache()
|
|
if len(self.index) == 0:
|
|
raise Error, self.filename + ': No frames'
|
|
self.fp.seek(0, 2)
|
|
self.fp.write('\n/////CMIF/////\n')
|
|
pos = self.fp.tell()
|
|
data = `pos`
|
|
data = '\n-*-*-CMIF-*-*-\n' + data + ' '*(15-len(data)) + '\n'
|
|
try:
|
|
marshal.dump(self.index, self.fp)
|
|
self.fp.write(data)
|
|
self.fp.flush()
|
|
finally:
|
|
self.rewind()
|
|
|
|
def readcache(self):
|
|
# Raises Error if there is no cache in the file
|
|
import marshal
|
|
if len(self.index) <> 0:
|
|
raise CallError
|
|
self.fp.seek(-32, 2)
|
|
data = self.fp.read()
|
|
if data[:16] <> '\n-*-*-CMIF-*-*-\n' or data[-1:] <> '\n':
|
|
self.rewind()
|
|
raise Error, self.filename + ': No cache'
|
|
pos = eval(data[16:-1])
|
|
self.fp.seek(pos)
|
|
try:
|
|
self.index = marshal.load(self.fp)
|
|
except TypeError:
|
|
self.rewind()
|
|
raise Error, self.filename + ': Bad cache'
|
|
self.rewind()
|
|
|
|
def getnextframeheader(self):
|
|
if self.framecount < len(self.index):
|
|
return self._getindexframeheader(self.framecount)
|
|
if self.framecount > len(self.index):
|
|
raise AssertError, \
|
|
'managed to bypass index?!?'
|
|
rv = BasicVinFile.getnextframeheader(self)
|
|
if self.canseek:
|
|
pos = self.fp.tell()
|
|
self.index.append(rv, pos)
|
|
return rv
|
|
|
|
def getrandomframe(self, i):
|
|
t, ds, cs = self.getrandomframeheader(i)
|
|
data, cdata = self.getnextframedata(ds, cs)
|
|
return t, data, cdata
|
|
|
|
def getrandomframeheader(self, i):
|
|
if i < 0: raise ValueError, 'negative frame index'
|
|
if not self.canseek:
|
|
raise Error, self.filename + ': can\'t seek'
|
|
if i < len(self.index):
|
|
return self._getindexframeheader(i)
|
|
if len(self.index) > 0:
|
|
rv = self.getrandomframeheader(len(self.index)-1)
|
|
else:
|
|
self.rewind()
|
|
rv = self.getnextframeheader()
|
|
while i > self.framecount:
|
|
self.skipnextframedata()
|
|
rv = self.getnextframeheader()
|
|
return rv
|
|
|
|
def _getindexframeheader(self, i):
|
|
(rv, pos) = self.index[i]
|
|
self.fp.seek(pos)
|
|
self.framecount = i
|
|
self.atframeheader = 0
|
|
self.eofseen = 0
|
|
self.errorseen = 0
|
|
return rv
|
|
|
|
|
|
# Basic class for writing CMIF video files
|
|
|
|
class BasicVoutFile(VideoParams):
|
|
|
|
def init(self, filename):
|
|
if filename == '-':
|
|
fp = sys.stdout
|
|
else:
|
|
fp = open(filename, 'w')
|
|
return self.initfp(fp, filename)
|
|
|
|
def initfp(self, fp, filename):
|
|
self = VideoParams.init(self)
|
|
self.fp = fp
|
|
self.filename = filename
|
|
self.version = 3.1 # In case anyone inquries
|
|
return self
|
|
|
|
def flush(self):
|
|
self.fp.flush()
|
|
|
|
def close(self):
|
|
self.fp.close()
|
|
del self.fp
|
|
|
|
def prealloc(self, nframes):
|
|
if not self.frozen: raise CallError
|
|
data = '\xff' * (self.calcframesize() + 64)
|
|
pos = self.fp.tell()
|
|
for i in range(nframes):
|
|
self.fp.write(data)
|
|
self.fp.seek(pos)
|
|
|
|
def writeheader(self):
|
|
if self.frozen: raise CallError
|
|
writefileheader(self.fp, self.getinfo())
|
|
self.freeze()
|
|
self.atheader = 1
|
|
self.framecount = 0
|
|
|
|
def rewind(self):
|
|
self.fp.seek(0)
|
|
self.unfreeze()
|
|
self.atheader = 1
|
|
self.framecount = 0
|
|
|
|
def printinfo(self):
|
|
print 'File: ', self.filename
|
|
VideoParams.printinfo(self)
|
|
|
|
def writeframe(self, t, data, cdata):
|
|
if data: ds = len(data)
|
|
else: ds = 0
|
|
if cdata: cs = len(cdata)
|
|
else: cs = 0
|
|
self.writeframeheader(t, ds, cs)
|
|
self.writeframedata(data, cdata)
|
|
|
|
def writeframeheader(self, t, ds, cs):
|
|
if not self.frozen: self.writeheader()
|
|
if not self.atheader: raise CallError
|
|
data = `(t, ds, cs)`
|
|
n = len(data)
|
|
if n < 63: data = data + ' '*(63-n)
|
|
self.fp.write(data + '\n')
|
|
self.atheader = 0
|
|
|
|
def writeframedata(self, data, cdata):
|
|
if not self.frozen or self.atheader: raise CallError
|
|
if data: self.fp.write(data)
|
|
if cdata: self.fp.write(cdata)
|
|
self.atheader = 1
|
|
self.framecount = self.framecount + 1
|
|
|
|
|
|
# Classes that combine files with displayers:
|
|
|
|
class VinFile(RandomVinFile, Displayer):
|
|
|
|
def initfp(self, fp, filename):
|
|
self = Displayer.init(self)
|
|
return RandomVinFile.initfp(self, fp, filename)
|
|
|
|
def shownextframe(self):
|
|
t, data, cdata = self.getnextframe()
|
|
self.showframe(data, cdata)
|
|
return t
|
|
|
|
|
|
class VoutFile(BasicVoutFile, Displayer):
|
|
|
|
def initfp(self, fp, filename):
|
|
self = Displayer.init(self)
|
|
## self = Grabber.init(self) # XXX not needed
|
|
return BasicVoutFile.initfp(self, fp, filename)
|
|
|
|
|
|
# Simple test program (VinFile only)
|
|
|
|
def test():
|
|
import time
|
|
if sys.argv[1:]: filename = sys.argv[1]
|
|
else: filename = 'film.video'
|
|
vin = VinFile().init(filename)
|
|
vin.printinfo()
|
|
gl.foreground()
|
|
gl.prefsize(vin.getsize())
|
|
wid = gl.winopen(filename)
|
|
vin.initcolormap()
|
|
t0 = time.millitimer()
|
|
while 1:
|
|
try: t, data, cdata = vin.getnextframe()
|
|
except EOFError: break
|
|
dt = t0 + t - time.millitimer()
|
|
if dt > 0: time.millisleep(dt)
|
|
vin.showframe(data, cdata)
|
|
time.sleep(2)
|