# Initialize an instance. Arguments:
# vw, vh: size of the video window data to be captured.
# position defaults to 0, 0 but can be set later
- def init(self, pktmax, vw, vh, type):
+ def __init__(self, pktmax, vw, vh, type):
self.pktmax = pktmax
self.realwidth, self.realheight = vw, vh
if type <> 'rgb':
self.dataoffset = 0
self.lpos = 0
self.hints = 0
- return self
# Change the size of the video being displayed.
# - data is a piece of data
# The dimensions of data are:
# - pixel depth = 1 byte
- # - scan line width = self.width (the vw argument to init())
+ # - scan line width = self.width (the vw argument to __init__())
# - number of scan lines = self.lpp (PKTMAX / vw)
def getnextpacket(self):
gl.qdevice(DEVICE.WINTHAW)
width, height = gl.getsize()
- lvo = LiveVideoOut.LiveVideoOut().init(wid, width, height, vtype)
+ lvo = LiveVideoOut.LiveVideoOut(wid, width, height, vtype)
- lvi = DisplayVideoIn.DisplayVideoIn().init(pktmax, \
- width, height, vtype)
+ lvi = DisplayVideoIn.DisplayVideoIn(pktmax, width, height, vtype)
if xpos or ypos:
lvi.positionvideo(xpos, ypos)
# Note that the data has to be cropped unless vw and vh are
# just right for the video board (vw:vh == 4:3 and vh even).
- def init(self, pktmax, vw, vh, type):
+ def __init__(self, pktmax, vw, vh, type):
if not have_video:
raise RuntimeError, 'no video available'
if vw % 4 != 0:
## if not self.justright:
## print 'Want:', self.width, 'x', self.height,
## print '; grab:', self.realwidth, 'x', self.realheight
- return self
# Change the size of the video being displayed.
def resizevideo(self, vw, vh):
self.close()
- self = self.init(self.pktmax, vw, vh, self.type)
+ self.__init__(self.pktmax, vw, vh, self.type)
# Remove an instance.
# This turns off continuous capture.
# - data is a piece of data
# The dimensions of data are:
# - pixel depth = 1 byte
- # - scan line width = self.width (the vw argument to init())
+ # - scan line width = self.width (the vw argument to __init__())
# - number of scan lines = self.lpp (PKTMAX / vw)
def getnextpacket(self):
# wid: the window id where the video is to be displayed (centered)
# vw, vh: size of the video image to be displayed
- def init(self, wid, vw, vh, type):
+ def __init__(self, wid, vw, vh, type):
##print 'Init', wid, xywh
##print 'video', vw, vw
self.vw = vw
self.vh = vh
- self.disp = Displayer().init()
+ self.disp = Displayer()
if not type in ('rgb', 'rgb8', 'grey', 'mono', 'grey2', \
'grey4'):
raise 'Incorrent live video output type', type
self.disp.initcolormap()
self.reshapewindow()
gl.winset(oldwid)
- return self
# Call this in response to every REDRAW event for the window
# or if the window size has changed for other reasons.
class LiveVideoOutSlow(LiveVideoOut):
# Reshapewindow - Realloc buffer.
- # (is also called by init() indirectly)
+ # (is also called by __init__() indirectly)
def reshapewindow(self):
LiveVideoOut.reshapewindow(self)
usage()
[ifile, ofile] = args
print 'open film ', ifile
- ifilm = VFile.VinFile().init(ifile)
+ ifilm = VFile.VinFile(ifile)
print 'open output ', ofile
- ofilm = GrabbingVoutFile().init(ofile)
+ ofilm = GrabbingVoutFile(ofile)
ofilm.setinfo(ifilm.getinfo())
DEBUG=0
class VCR:
- def init(self):
+ def __init__(self):
self.ifp, self.ofp = initline(DEVICE)
self.busy_cmd = None
self.async = 0
self.cb = None
self.cb_arg = None
- return self
def _check(self):
if self.busy_cmd:
# Set all parameters to something decent
# (except width and height are set to zero)
- def init(self):
+ def __init__(self):
# Essential parameters
self.frozen = 0 # if set, can't change parameters
self.format = 'grey' # color system used
self.chrompack = 0 # set if separate chrominance data
self.setderived()
self.decompressor = None
- return self
# Freeze the parameters (disallow changes)
# Initialize an instance.
# This does not need a current window
- def init(self):
+ def __init__(self):
if no_gl:
raise RuntimeError, \
'no gl module available, so cannot display'
- self = VideoParams.init(self)
+ VideoParams.__init__(self)
# User-settable parameters
self.magnify = 1.0 # frame magnification factor
self.xorigin = 0 # x frame offset
class BasicVinFile(VideoParams):
- def init(self, filename):
- if filename == '-':
+ def __init__(self, filename):
+ if type(filename) != type(''):
+ fp = filename
+ filename = '???'
+ elif filename == '-':
fp = sys.stdin
else:
fp = open(filename, 'r')
- return self.initfp(fp, filename)
+ self.initfp(fp, filename)
def initfp(self, fp, filename):
- self = VideoParams.init(self)
+ VideoParams.__init__(self)
self.fp = fp
self.filename = filename
self.version, values = readfileheader(fp, filename)
except IOError:
self.startpos = -1
self.canseek = 0
- return self
def _readv0frameheader(self, fp):
t, ds, cs = readv0frameheader(fp)
class RandomVinFile(BasicVinFile):
def initfp(self, fp, filename):
- self = BasicVinFile.initfp(self, fp, filename)
+ BasicVinFile.initfp(self, fp, filename)
self.index = []
- return self
def warmcache(self):
if len(self.index) == 0:
class BasicVoutFile(VideoParams):
- def init(self, filename):
- if filename == '-':
+ def __init__(self, filename):
+ if type(filename) != type(''):
+ fp = filename
+ filename = '???'
+ elif filename == '-':
fp = sys.stdout
else:
fp = open(filename, 'w')
- return self.initfp(fp, filename)
+ self.initfp(fp, filename)
def initfp(self, fp, filename):
- self = VideoParams.init(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()
class VinFile(RandomVinFile, Displayer):
def initfp(self, fp, filename):
- self = Displayer.init(self)
- return RandomVinFile.initfp(self, fp, filename)
+ Displayer.__init__(self)
+ RandomVinFile.initfp(self, fp, filename)
def shownextframe(self):
t, data, cdata = self.getnextframe()
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)
+ Displayer.__init__(self)
+## Grabber.__init__(self) # XXX not needed
+ BasicVoutFile.initfp(self, fp, filename)
# Simple test program (VinFile only)
import time
if sys.argv[1:]: filename = sys.argv[1]
else: filename = 'film.video'
- vin = VinFile().init(filename)
+ vin = VinFile(filename)
vin.printinfo()
gl.foreground()
gl.prefsize(vin.getsize())
class VGrabber(VFile.VideoParams):
- # XXX The init() method of VideoParams is just fine, for now
+ # XXX The constructor of VideoParams is just fine, for now
# Grab a frame.
# Return (data, chromdata) just like getnextframe().
def main():
## fl.set_graphics_mode(0, 1)
- vb = VideoBagOfTricks().init()
+ vb = VideoBagOfTricks()
while 1:
dummy = fl.do_forms()
[dummy]
# Init/close stuff
- def init(self):
+ def __init__(self):
self.window = None
formdef = flp.parse_form('VbForm', 'form')
flp.create_full_form(self, formdef)
self.optfullsizewindow()
self.showform()
fl.set_event_call_back(self.do_event)
- return self
def close(self):
self.close_video()
if not self.vcr:
try:
print 'Connecting to VCR ...'
- self.vcr = VCR.VCR().init()
+ self.vcr = VCR.VCR()
print 'Waiting for VCR to come online ...'
self.vcr.initvcr()
print 'Preparing VCR ...'
x, y = x/2, y/2
elif self.rgb24_size == 3:
x, y = x/4, y/4
- vout = VFile.VoutFile().init(self.vfile)
+ vout = VFile.VoutFile(self.vfile)
vout.setformat(self.vformat)
if self.vformat == 'compress':
cheader = self.init_compressor(x, y)
global newwidth, newheight, newpf
try:
- vin = VFile.BasicVinFile().init(infilename)
+ vin = VFile.BasicVinFile(infilename)
except IOError, msg:
sys.stderr.write(infilename + ': I/O error: ' + `msg` + '\n')
return 1
return 1
try:
- vout = VFile.BasicVoutFile().init(outfilename)
+ vout = VFile.BasicVoutFile(outfilename)
except IOError, msg:
sys.stderr.write(outfilename + ': I/O error: ' + `msg` + '\n')
return 1
PREV_VERSION_STRING='#!VcrIndex 1.0\n'
class VcrIndex:
- def init(self, name):
+ def __init__(self, name):
self.curmovie = None
self.curscene = None
self.modified = 0
self.editable = []
if not name:
self.movies = {}
- return self
+ return
try:
fp = open(name, 'r')
except IOError:
self.movies = {}
- return self
+ return
header = fp.readline()
if header == PREV_VERSION_STRING:
print 'Converting old-format database...'
self.movies[m] = newd
print 'Done.'
- return self
+ return
if header <> VERSION_STRING:
print 'VcrIndex: incorrect version string:', header
self.movies = {}
- return self
+ return
data = fp.read(100000)
self.movies = eval(data)
- return self
#
# Save database to given file (or same file as read from if no
# filename given).
for o, a in opts:
if o == '-q':
qsize = string.atoi(a)
- ed = Editor().init(qsize)
+ ed = Editor(qsize)
if args[0:]:
ed.open_input(args[0])
if args[1:]:
class Editor:
- def init(self, qsize):
+ def __init__(self, qsize):
self.qsize = qsize
self.vin = None
self.vout = None
flp.create_full_form(self, formdef)
self.form.show_form(FL.PLACE_SIZE, FL.TRUE, 'Vedit')
fl.set_event_call_back(self.do_event)
- return self
def do_event(self, dev, val):
if dev == DEVICE.REDRAW:
basename = os.path.split(filename)[1]
title = 'in: ' + basename
try:
- vin = Viewer.InputViewer().init(filename, title)
+ vin = Viewer.InputViewer(filename, title)
except:
self.err('Can\'t open input file', filename)
return
basename = os.path.split(filename)[1]
title = 'out: ' + basename
try:
- vout = Viewer.OutputViewer().init(filename, \
+ vout = Viewer.OutputViewer(filename, \
title, self.qsize)
except:
self.err('Can\'t open output file', filename)
def process(infilename, outfilename):
try:
- vin = VFile.BasicVinFile().init(infilename)
+ vin = VFile.BasicVinFile(infilename)
except IOError, msg:
sys.stderr.write(infilename + ': I/O error: ' + `msg` + '\n')
return 1
return 1
try:
- vout = VFile.BasicVoutFile().init(outfilename)
+ vout = VFile.BasicVoutFile(outfilename)
except IOError, msg:
sys.stderr.write(outfilename + ': I/O error: ' + `msg` + '\n')
return 1
class InputViewer:
- def init(self, filename, title, *args):
+ def __init__(self, filename, title, *args):
try:
- self.vin = VFile.VinFile().init(filename)
+ self.vin = VFile.VinFile(filename)
except (EOFError, VFile.Error):
raise IOError, 'bad video input file'
self.vin.warmcache()
gl.prefsize(self.vin.width, self.vin.height)
self.wid = -1
self.reset()
- return self
def close(self):
self.vin.close()
class OutputViewer:
- def init(self, filename, title, qsize):
+ def __init__(self, filename, title, qsize):
try:
- self.vout = VFile.VoutFile().init(filename)
+ self.vout = VFile.VoutFile(filename)
except (EOFError, VFile.Error):
raise IOError, 'bad video output file'
if not title:
gl.foreground()
self.wid = -1
self.reset()
- return self
def close(self):
while self.queue:
def rewind(self):
info = self.vout.getinfo()
self.vout.close()
- self.vout = VFile.VoutFile().init(self.filename)
+ self.vout = VFile.VoutFile(self.filename)
self.vout.setinfo(info)
self.reset()
def test():
import sys
- a = InputViewer().init(sys.argv[1], '')
- b = OutputViewer().init(sys.argv[2], '')
+ a = InputViewer(sys.argv[1], '')
+ b = OutputViewer(sys.argv[2], '')
b.setinfo(a.getinfo())
while 1:
def process(filename):
try:
- vin = VFile.RandomVinFile().init(filename)
+ vin = VFile.RandomVinFile(filename)
except IOError, msg:
sys.stderr.write(filename + ': I/O error: ' + `msg` + '\n')
return 1
def process(infilename, outfilename):
try:
- vin = VFile.BasicVinFile().init(infilename)
+ vin = VFile.BasicVinFile(infilename)
except IOError, msg:
sys.stderr.write(infilename + ': I/O error: ' + `msg` + '\n')
return 1
return 1
try:
- vout = VFile.BasicVoutFile().init(outfilename)
+ vout = VFile.BasicVoutFile(outfilename)
except IOError, msg:
sys.stderr.write(outfilename + ': I/O error: ' + `msg` + '\n')
return 1
def process(filename):
try:
- vin = VFile.VinFile().init(filename)
+ vin = VFile.VinFile(filename)
except IOError, msg:
sys.stderr.write(filename + ': I/O error: ' + `msg` + '\n')
return 1
MAXSIZE = 20 # Don't read ahead too much
import thread
import Queue
- queue = Queue.Queue().init(MAXSIZE)
+ queue = Queue.Queue(MAXSIZE)
stop = []
thread.start_new_thread(read_ahead, (vin, queue, stop))
# Get the read-ahead thread going
# XXX (Strange: need fps of Indigo monitor, not of PAL or NTSC!)
tpf = 1000.0 / fps # Time per field in msec
if filename:
- vout = VFile.VoutFile().init(filename)
+ vout = VFile.VoutFile(filename)
if mono:
format = 'mono'
elif grey and greybits == 8:
print 'done.'
MAXSIZE = 20 # XXX should be a user option
import Queue
- queue = Queue.Queue().init(MAXSIZE)
+ queue = Queue.Queue(MAXSIZE)
done = thread.allocate_lock()
done.acquire_lock()
convertor = None
AQSIZE = 8000 # XXX should be a user option
def initaudio(filename, stop, done):
- import thread, aiff
- afile = aiff.Aiff().init(filename, 'w')
+ import thread, aifc
+ afile = aifc.open(filename, 'w')
afile.nchannels = AL.MONO
afile.sampwidth = AL.SAMPLE_8
params = [AL.INPUT_RATE, 0]
# Construct header and write it
#
try:
- vout = VFile.VoutFile().init(filename)
+ vout = VFile.VoutFile(filename)
except IOError, msg:
print filename, ':', msg
sys.exit(1)
AQSIZE = 8*8000 # XXX should be a user option
def initaudio(filename, stop, start, done):
- import thread, aiff
- afile = aiff.Aiff().init(filename, 'w')
+ import thread, aifc
+ afile = aifc.open(filename, 'w')
afile.nchannels = AL.MONO
afile.sampwidth = AL.SAMPLE_8
params = [AL.INPUT_RATE, 0]
gl.qdevice(DEVICE.WINSHUT)
gl.qdevice(DEVICE.WINQUIT)
- lvo = LiveVideoOut.LiveVideoOut().init(wid, width, height, vtype)
+ lvo = LiveVideoOut.LiveVideoOut(wid, width, height, vtype)
ifdlist = [gl.qgetfd(), s.fileno()]
ofdlist = []
gl.qdevice(DEVICE.WINTHAW)
width, height = gl.getsize()
- lvo = LiveVideoOut.LiveVideoOut().init(wid, width, height, vtype)
+ lvo = LiveVideoOut.LiveVideoOut(wid, width, height, vtype)
- lvi = LiveVideoIn.LiveVideoIn().init(pktmax, width, height, vtype)
+ lvi = LiveVideoIn.LiveVideoIn(pktmax, width, height, vtype)
s = socket(AF_INET, SOCK_DGRAM)
s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
def process(infilename, outfilename):
try:
- vin = VFile.BasicVinFile().init(infilename)
+ vin = VFile.BasicVinFile(infilename)
except IOError, msg:
sys.stderr.write(infilename + ': I/O error: ' + `msg` + '\n')
return 1
return 1
try:
- vout = VFile.BasicVoutFile().init(outfilename)
+ vout = VFile.BasicVoutFile(outfilename)
except IOError, msg:
sys.stderr.write(outfilename + ': I/O error: ' + `msg` + '\n')
return 1
def process(infilename, outfilename):
try:
- vin = VFile.BasicVinFile().init(infilename)
+ vin = VFile.BasicVinFile(infilename)
except IOError, msg:
sys.stderr.write(infilename + ': I/O error: ' + `msg` + '\n')
return 1
return 1
try:
- vout = VFile.BasicVoutFile().init(outfilename)
+ vout = VFile.BasicVoutFile(outfilename)
except IOError, msg:
sys.stderr.write(outfilename + ': I/O error: ' + `msg` + '\n')
return 1
videofile = videofile + '.video'
print 'Opening video input file..'
- vin = VFile.VinFile().init(videofile)
+ vin = VFile.VinFile(videofile)
print 'Opening audio input file..'
ain = aifc.open(audiofile, 'r')
def instantiate_converter(args):
list = args[2]
- cl = RtConverters().init(list)
+ cl = RtConverters(list)
args.append(cl.convert)
return args
class RtConverters:
- def init(self, list):
+ def __init__(self, list):
self.list = list
- return self
def convert(self, img, w, h):
for cv in self.list:
format = oformat
cfunc = imgconv.getconverter(oformat, format)
- vout = VFile.VoutFile().init(outfile)
+ vout = VFile.VoutFile(outfile)
vout.format = format
vout.width = nxsize
vout.height = ysize
def process(filename):
try:
- vin = VFile.VinFile().init(filename)
+ vin = VFile.VinFile(filename)
except IOError, msg:
sys.stderr.write(filename + ': I/O error: ' + `msg` + '\n')
return 1
projects / thirdparty / Python / cpython.git / commitdiff
