diff options
Diffstat (limited to 'Demo/sgi/video/VFile.py')
| -rwxr-xr-x | Demo/sgi/video/VFile.py | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/Demo/sgi/video/VFile.py b/Demo/sgi/video/VFile.py new file mode 100755 index 0000000..0bab8fa --- /dev/null +++ b/Demo/sgi/video/VFile.py @@ -0,0 +1,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 |