cpython/Demo/sgi/video/VFile.py

1195 lines
30 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
try:
import gl
import GL
no_gl = 0
except ImportError:
no_gl = 1
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()
self.decompressor = None
# 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) == type(1):
pf = (pf, pf)
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' and len(values) > 9:
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)
def getcompressheader(self):
return self.compressheader
def setcompressheader(self, ch):
self.compressheader = ch
# 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
# Decompress a possibly compressed frame. This method is here
# since you sometimes want to use it on a VFile instance and sometimes
# on a Displayer instance.
#
# XXXX This should also handle jpeg. Actually, the whole mechanism
# should be much more of 'ihave/iwant' style, also allowing you to
# read, say, greyscale images from a color movie.
def decompress(self, data):
if self.format <> 'compress':
return data
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)
return data
# 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):
if no_gl:
raise RuntimeError, \
'no gl module available, so cannot display'
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())
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:
gl.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':
data = self.decompress(data)
pmsize = 32
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'):
self.set_rgbmode()
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 '.'!
self.set_rgbmode()
gl.RGBcolor(200, 200, 200) # XXX rather light grey
gl.clear()
gl.pixmode(GL.PM_SIZE, 8)
return
self.set_cmode()
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')
# Set the window in RGB mode (may be overridden for Glx window)
def set_rgbmode(self):
gl.RGBmode()
gl.gconfig()
# Set the window in colormap mode (may be overridden for Glx window)
def set_cmode(self):
gl.cmode()
gl.gconfig()
# 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):
map = []
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)
map.append(index, r, g, b)
if self.color0 == None:
self.color0 = \
index, r, g, b
self.install_colormap(map)
# Permanently make the first color index current
gl.color(self.color0[0])
# Install the colormap in the window (may be overridden for Glx window)
def install_colormap(self, map):
if not self.quiet:
sys.stderr.write(' Installing ' + `len(map)` + \
' entries...')
for irgb in map:
gl.mapcolor(irgb)
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')
def writecompressfileheader(fp, cheader, 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
#
data = (format, cheader)
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 type(filename) != type(''):
fp = filename
filename = '???'
elif filename == '-':
fp = sys.stdin
else:
fp = open(filename, 'r')
self.initfp(fp, filename)
def initfp(self, fp, filename):
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
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):
BasicVinFile.initfp(self, fp, filename)
self.index = []
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 type(filename) != type(''):
fp = filename
filename = '???'
elif filename == '-':
fp = sys.stdout
else:
fp = open(filename, 'w')
self.initfp(fp, filename)
def initfp(self, fp, filename):
VideoParams.__init__(self)
self.fp = fp
self.filename = filename
self.version = 3.1 # In case anyone inquries
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
if self.format == 'compress':
writecompressfileheader(self.fp, self.compressheader, \
self.getinfo())
else:
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):
Displayer.__init__(self)
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):
Displayer.__init__(self)
## Grabber.__init__(self) # XXX not needed
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(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)