Initial revision
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