path: root/Demo/sgi/video/Vb.py

#! /usr/bin/env python

# Video bag of tricks: record video(+audio) in various formats and modes

# XXX To do:
# - audio
# - improve user interface
# - help button?
# - command line options to set initial settings
# - save settings in a file
# - ...?

import sys
import time
import getopt
import string
import os
sts = os.system('makemap')		# Must be before "import fl" to work
import sgi
import gl
import GL
import DEVICE
import fl
import FL
import flp
import watchcursor
import sv
import SV
import VFile
import VGrabber
import imageop
sys.path.append('/ufs/jack/src/av/vcr')
import VCR
try:
	import cl
	import CL
except ImportError:
	cl = None

ARROW = 0
WATCH = 1
watchcursor.defwatch(WATCH)

def main():
##	fl.set_graphics_mode(0, 1)
	vb = VideoBagOfTricks()
	while 1:
		dummy = fl.do_forms()
		[dummy]

StopCapture = 'StopCapture'

VideoFormatLabels = ['Video off', 'rgb8', 'grey8', 'grey4', 'grey2', \
	  'grey2 dith', 'mono dith', 'mono thresh', 'rgb24', 'rgb24-jpeg', \
	  'compress']
VideoFormats = ['', 'rgb8', 'grey', 'grey4', 'grey2', \
	  'grey2', 'mono', 'mono', 'rgb', 'jpeg', 'compress']

VideoModeLabels = ['Continuous', 'Burst', 'Single frame', 'VCR sync']
[VM_CONT, VM_BURST, VM_SINGLE, VM_VCR] = range(1, 5)

AudioFormatLabels = ['Audio off', \
	  '16 bit mono', '16 bit stereo', '8 bit mono', '8 bit stereo']
[A_OFF, A_16_MONO, A_16_STEREO, A_8_MONO, A_8_STEREO] = range(1, 6)

VcrSpeedLabels = ['normal', '1/3', '1/5', '1/10', '1/30', 'single-step']
VcrSpeeds = [None, 5, 4, 3, 2, 1, 0]

RgbSizeLabels = ['full', 'quarter', 'sixteenth']

# init file stuff:
if os.environ.has_key('HOME'):
	HOME=os.environ['HOME']
else:
	HOME='.'
VB_INIT_FILE=HOME + '/.Vb_init'

VB_INIT_KEYS=['vfile', 'vmode', 'mono_thresh', 'vformat', 'comp_scheme', \
	  'rgb24_size', 'afile', 'aformat']

class VideoBagOfTricks:

	# Init/close stuff

	def __init__(self):
		self.window = None
		formdef = flp.parse_form('VbForm', 'form')
		flp.create_full_form(self, formdef)
		self.setdefaults()
		if self.vmode <> VM_CONT:
			self.g_cont.hide_object()
		if self.vmode <> VM_BURST:
			self.g_burst.hide_object()
		if self.vmode <> VM_SINGLE:
			self.g_single.hide_object()
		if self.vmode <> VM_VCR:
			self.g_vcr.hide_object()
		if self.vformat <> 'compress':
			self.g_compress.hide_object()

		self.openvideo()
		self.makewindow()
		self.bindvideo()
		if self.use_24:
			self.optfullsizewindow()
		self.showform()
		fl.set_event_call_back(self.do_event)

	def close(self):
		self.close_video()
		self.close_audio()
		self.savedefaults()
		raise SystemExit, 0

	def showform(self):
		# Get position of video window
		gl.winset(self.window)
		x, y = gl.getorigin()
		width, height = gl.getsize()
		# Calculate position of form window
		x1 = x + width + 10
		x2 = x1 + int(self.form.w) - 1
		y2 = y + height - 1
		y1 = y2 - int(self.form.h) + 1
		# Position and show form window
		gl.prefposition(x1, x2, y1, y2)
		self.form.show_form(FL.PLACE_FREE, FL.TRUE, 'Vb Control')

	def getdefaultdefaults(self):
		# Video defaults
		self.vfile = 'film.video'
		self.vmode = VM_CONT
		self.mono_thresh = 128
		self.vformat = 'rgb8'
		self.comp_scheme = 'Uncompressed'
		self.rgb24_size = 1
		# Missing: drop, rate, maxmem, nframes, rate, vcrspeed
		# Audio defaults:
		self.afile = 'film.aiff'
		self.aformat = A_OFF

	def getdefaults(self):
		self.getdefaultdefaults()
		# XXXX Read defaults file and override.
		try:
			fp = open(VB_INIT_FILE, 'r')
		except IOError:
			print 'Vb: no init file'
			self.initcont = {}
			return
		data = fp.read(1000000)
		try:
			self.initcont = eval(data)
		except:
			print 'Vb: Ill-formatted init file'
			self.initcont = {}
		for k in self.initcont.keys():
			if hasattr(self, k):
				setattr(self, k, self.initcont[k])

	def savedefaults(self):
		newdb = {}
		for k in VB_INIT_KEYS:
			newdb[k] = getattr(self, k)
		if newdb <> self.initcont:
			try:
				fp = open(VB_INIT_FILE, 'w')
			except IOError:
				print 'Vb: Cannot create', VB_INIT_FILE
				return
			fp.write(`newdb`)
			fp.close()
			
	def setdefaults(self):
		self.getdefaults()
		self.vcr = None
		self.vout = None
		self.capturing = 0
		self.c_vformat.clear_choice()
		for label in VideoFormatLabels:
			self.c_vformat.addto_choice(label)
		self.c_vformat.set_choice(1 + VideoFormats.index(self.vformat))
		self.c_vmode.clear_choice()
		for label in VideoModeLabels:
			self.c_vmode.addto_choice(label)
		self.c_vmode.set_choice(self.vmode)
		self.get_vformat()
		self.b_drop.set_button(1)
		self.in_rate.set_input('2')
		self.in_maxmem.set_input('1.0')
		self.in_nframes.set_input('0')
		self.in_nframes_vcr.set_input('1')
		self.in_rate_vcr.set_input('1')
		self.c_vcrspeed.clear_choice()
		for label in VcrSpeedLabels:
			self.c_vcrspeed.addto_choice(label)
		self.c_vcrspeed.set_choice(4)
		self.c_rgb24_size.clear_choice()
		for label in RgbSizeLabels:
			self.c_rgb24_size.addto_choice(label)
		self.c_rgb24_size.set_choice(self.rgb24_size)
		if cl:
			algs = cl.QueryAlgorithms(CL.VIDEO)
			self.all_comp_schemes = []
			for i in range(0, len(algs), 2):
				if algs[i+1] in (CL.COMPRESSOR, CL.CODEC):
					self.all_comp_schemes.append(algs[i])
			self.c_cformat.clear_choice()
			for label in self.all_comp_schemes:
				self.c_cformat.addto_choice(label)
			i = self.all_comp_schemes.index(self.comp_scheme)
			self.c_cformat.set_choice(i+1)
		# Audio defaults
		self.aout = None
		self.aport = None
		self.c_aformat.clear_choice()
		for label in AudioFormatLabels:
			self.c_aformat.addto_choice(label)
		self.c_aformat.set_choice(self.aformat)
		self.get_aformat()

	def openvideo(self):
		try:
			self.video = sv.OpenVideo()
		except sv.error, msg:
			print 'Error opening video:', msg
			self.video = None
		param = [SV.BROADCAST, SV.PAL]
		if self.video: self.video.GetParam(param)
		if param[1] == SV.PAL:
			x = SV.PAL_XMAX
			y = SV.PAL_YMAX
		elif param[1] == SV.NTSC:
			x = SV.NTSC_XMAX
			y = SV.NTSC_YMAX
		else:
			print 'Unknown video standard:', param[1]
			sys.exit(1)
		self.maxx, self.maxy = x, y
		self.curx = 256
		self.cury = 256*3/4

	def makewindow(self):
		x, y = self.maxx, self.maxy
		gl.foreground()
		gl.maxsize(x, y)
		gl.keepaspect(x, y)
		gl.stepunit(8, 6)
		width = self.curx
		height = self.cury
		if width and height:
			# Place the window at (150, 150) from top left
			# (the video board likes this location...)
			x1 = 150
			x2 = x1+width-1
			SCRHEIGHT = 768
			y2 = SCRHEIGHT-1-150
			y1 = y2-height+1
			gl.prefposition(x1, x2, y1, y2)
		self.window = gl.winopen('Vb video')
		self.settitle()
		if width:
			gl.maxsize(x, y)
			gl.keepaspect(x, y)
			gl.stepunit(8, 6)
			gl.winconstraints()
		gl.qdevice(DEVICE.LEFTMOUSE)
		gl.qdevice(DEVICE.WINQUIT)
		gl.qdevice(DEVICE.WINSHUT)

	def optfullsizewindow(self):
		if not self.window:
			return
		gl.winset(self.window)
		if self.use_24:
			x, y = self.maxx, self.maxy
		else:
			x, y = self.curx, self.cury
		left, bottom = gl.getorigin()
		width, height = gl.getsize()
		bottom = bottom+height-y
		gl.prefposition(left, left+x-1, bottom, bottom+y-1)
		gl.winconstraints()
		if not self.use_24:
			gl.keepaspect(x, y)
			gl.stepunit(8, 6)
			gl.maxsize(self.maxx, self.maxy)
			gl.winconstraints()
		self.bindvideo()

	def bindvideo(self):
		if not self.video: return
		x, y = gl.getsize()
		if not self.use_24:
			self.curx, self.cury = x, y
		self.video.SetSize(x, y)
		drop = self.b_drop.get_button()
		if drop:
			param = [SV.FIELDDROP, 1, SV.GENLOCK, SV.GENLOCK_OFF]
		else:
			param = [SV.FIELDDROP, 0, SV.GENLOCK, SV.GENLOCK_ON]
		if self.rgb:
			param = param+[SV.COLOR, SV.DEFAULT_COLOR, \
				       SV.DITHER, 1, \
				       SV.INPUT_BYPASS, 0]
		else:
			param = param+[SV.COLOR, SV.MONO, SV.DITHER, 0, \
				       SV.INPUT_BYPASS, 1]
		self.video.BindGLWindow(self.window, SV.IN_REPLACE)
		self.video.SetParam(param)

	def rebindvideo(self):
		gl.winset(self.window)
		self.bindvideo()

	def reset(self):
		self.close_video()
		self.close_audio()
		if self.vcr:
			try:
				ok = self.vcr.still()
			except VCR.error:
				pass
			self.vcr = None
		self.b_capture.set_button(0)

	# Event handler (catches resize of video window)

	def do_event(self, dev, val):
		#print 'Event:', dev, val
		if dev in (DEVICE.WINSHUT, DEVICE.WINQUIT):
			self.close()
		if dev == DEVICE.REDRAW and val == self.window:
			self.rebindvideo()
			self.settitle()

	# Video controls: format, mode, file

	def cb_vformat(self, *args):
		self.reset()
		self.get_vformat()
		if self.mono_use_thresh:
			s = `self.mono_thresh`
			s = fl.show_input('Please enter mono threshold', s)
			if s:
				try:
					self.mono_thresh = string.atoi(s)
				except string.atoi_error:
					fl.show_message('Bad input, using', \
						  `self.mono_thresh`, '')
		self.rebindvideo()

	def cb_cformat(self, *args):
		i = self.c_cformat.get_choice()
		self.comp_scheme = self.all_comp_schemes[i-1]

		
	def cb_vmode(self, *args):
		if self.vcr:
			self.vcr = None
		self.vmode = self.c_vmode.get_choice()
		self.form.freeze_form()
		self.g_cont.hide_object()
		self.g_burst.hide_object()
		self.g_single.hide_object()
		self.g_vcr.hide_object()
		if self.vmode == VM_CONT:
			self.g_cont.show_object()
		elif self.vmode == VM_BURST:
			self.g_burst.show_object()
		elif self.vmode == VM_SINGLE:
			self.g_single.show_object()
		elif self.vmode == VM_VCR:
			self.g_vcr.show_object()
		self.form.unfreeze_form()

	def cb_vfile(self, *args):
		filename = self.vfile
		hd, tl = os.path.split(filename)
		filename = fl.file_selector('Video save file:', hd, '', tl)
		if filename:
			self.reset()
			hd, tl = os.path.split(filename)
			if hd == os.getcwd():
				filename = tl
			self.vfile = filename

	# Video mode specific video controls

	def cb_rate(self, *args):
		pass

	def cb_drop(self, *args):
		self.rebindvideo()

	def cb_maxmem(self, *args):
		pass

	def cb_nframes(self, *args):
		pass

	def cb_fps(self, *args):
		pass

	def cb_nframes_vcr(self, *args):
		pass

	def cb_rate_vcr(self, *args):
		pass

	def cb_vcrspeed(self, *args):
		pass

	def cb_rgb24_size(self, *args):
		i = self.c_rgb24_size.get_choice()
		if i:
			self.rgb24_size = i

	# Audio controls: format, file

	def cb_aformat(self, *args):
		self.get_aformat()

	def cb_afile(self, *args):
		filename = self.afile
		hd, tl = os.path.split(filename)
		filename = fl.file_selector('Audio save file:', hd, '', tl)
		if filename:
			self.reset()
			hd, tl = os.path.split(filename)
			if hd == os.getcwd():
				filename = tl
			self.afile = filename

	# General controls: capture, reset, play, quit

	def cb_capture(self, *args):
		if self.capturing:
			raise StopCapture
		if not self.b_capture.get_button():
			return
		if not self.video or not self.vformat:
			gl.ringbell()
			return
		if self.vmode == VM_CONT:
			self.cont_capture()
		elif self.vmode == VM_BURST:
			self.burst_capture()
		elif self.vmode == VM_SINGLE:
			self.single_capture(None, None)
		elif self.vmode == VM_VCR:
			self.vcr_capture()

	def cb_reset(self, *args):
		self.reset()

	def cb_play(self, *args):
		self.reset()
		sts = os.system('Vplay -q ' + self.vfile + ' &')

	def cb_quit(self, *args):
		self.close()

	# Capture routines

	def burst_capture(self):
		self.setwatch()
		gl.winset(self.window)
		x, y = gl.getsize()
		if self.use_24:
			fl.show_message('Sorry, no 24 bit continuous capture yet', '', '')
			return
		vformat = SV.RGB8_FRAMES
		nframes = self.getint(self.in_nframes, 0)
		if nframes == 0:
			maxmem = self.getint(self.in_maxmem, 1.0)
			memsize = int(maxmem * 1024 * 1024)
			nframes = self.calcnframes(memsize)
		info = (vformat, x, y, nframes, 1)
		try:
			info2, data, bitvec = self.video.CaptureBurst(info)
		except sv.error, msg:
			self.b_capture.set_button(0)
			self.setarrow()
			fl.show_message('Capture error:', str(msg), '')
			return
		if info <> info2: print info, '<>', info2
		self.save_burst(info2, data, bitvec)
		self.setarrow()

	def calcnframes(self, memsize):
		gl.winset(self.window)
		x, y = gl.getsize()
		pixels = x*y
		pixels = pixels/2	# XXX always assume fields
		if self.mono or self.grey:
			n = memsize/pixels
		else:
			n = memsize/(4*pixels)
		return max(1, n)

	def save_burst(self, info, data, bitvec):
		(vformat, x, y, nframes, rate) = info
		self.open_if_closed()
		fieldsize = x*y/2
		nskipped = 0
		realframeno = 0
		tpf = 1000 / 50.0     # XXX
		for frameno in range(0, nframes*2):
			if frameno <> 0 and \
				  bitvec[frameno] == bitvec[frameno-1]:
				nskipped = nskipped + 1
				continue
			#
			# Save field.
			# XXX Works only for fields and top-to-bottom
			#
			start = frameno*fieldsize
			field = data[start:start+fieldsize]
			realframeno = realframeno + 1
			fn = int(realframeno*tpf)
			if not self.write_frame(fn, field):
				break

	def cont_capture(self):
		saved_label = self.b_capture.label
		self.b_capture.label = 'Stop\n' + saved_label
		self.open_if_closed()
		self.init_cont()
		fps = 59.64		# Fields per second
		# XXX (fps of Indigo monitor, not of PAL or NTSC!)
		tpf = 1000.0 / fps	# Time per field in msec
		self.capturing = 1
		self.start_audio()
		while 1:
			try:
				void = fl.check_forms()
			except StopCapture:
				break
			try:
				cd, id = self.video.GetCaptureData()
			except sv.error:
				sgi.nap(1)
				continue
			id = id + 2*self.rate
			data = cd.InterleaveFields(1)
			cd.UnlockCaptureData()
			t = id*tpf
			if not self.write_frame(t, data):
				break
		self.stop_audio()
		self.capturing = 0
		self.end_cont()
		if self.aout:
			# If recording audio, can't capture multiple sequences
			self.reset()
		self.b_capture.label = saved_label

	def single_capture(self, stepfunc, timecode):
		self.open_if_closed()
		self.init_cont()
		while 1:
			try:
				cd, id = self.video.GetCaptureData()
				break
			except sv.error:
				pass
			sgi.nap(1)
			if stepfunc:		# This might step the video
				d=stepfunc()	# to the next frame
		if not self.use_24:
			data = cd.InterleaveFields(1)
		else:
			x, y = self.vout.getsize()
			if self.use_compress:
				if self.rgb24_size == 1:
					data = cd.YUVtoYUV422DC(0)
				elif self.rgb24_size == 2:
					data = cd.YUVtoYUV422DC_quarter(1)
					x = x/2
					y = y/2
				elif self.rgb24_size == 3:
					data = cd.YUVtoYUV422DC_sixteenth(1)
					x = x/4
					y = y/4
			else:
				data = cd.YUVtoRGB(1)
				if self.maxx*self.maxy*4 <> len(data):
					print 'maxx,maxy,exp,got=', self.maxx,
					print self.maxy,self.maxx*self.maxy*4,
					print len(data)
					fl.showmessage('Wrong sized data')
					return 0
				if self.rgb24_size <> 1:
					data = imageop.scale(data, 4, \
						  self.maxx, self.maxy, x, y)
			if self.use_jpeg:
				import jpeg
				data = jpeg.compress(data, x, y, 4)
			if self.use_compress:
				data = self.compressor.Compress(1, data)
		cd.UnlockCaptureData()
		self.end_cont()
		if timecode == None:
			timecode = (self.nframes+1) * (1000/25)
		return self.write_frame(timecode, data)

	def vcr_capture(self):
		if not self.vcr:
			try:
				print 'Connecting to VCR ...'
				self.vcr = VCR.VCR()
				print 'Waiting for VCR to come online ...'
				self.vcr.initvcr()
				print 'Preparing VCR ...'
				if not (self.vcr.fmmode('dnr') and \
					  self.vcr.dmcontrol('digital slow')):
					self.vcr_error('digital slow failed')
					return
				print 'VCR OK.'
			except VCR.error, msg:
				self.vcr = None
				self.vcr_error(msg)
				return
		if not self.vcr.still():
			self.vcr_error('still failed')
			return
		self.open_if_closed()
		rate = self.getint(self.in_rate_vcr, 1)
		rate = max(rate, 1)
		vcrspeed = self.c_vcrspeed.get_choice()
		vcrspeed = VcrSpeeds[vcrspeed]
		if vcrspeed == 0:
			stepfunc = self.vcr.step
		else:
			stepfunc = None
		self.speed_factor = rate
		addr = start_addr = self.vcr.sense()
		if not self.single_capture(None, 0):
			return
		print 'captured %02d:%02d:%02d:%02d' % self.vcr.addr2tc(addr)
		count = self.getint(self.in_nframes_vcr, 1) - 1
		if count <= 0:
			while rate > 0:
				if not self.vcr.step():
					self.vcr_error('step failed')
				here = self.vcr.sense()
				if here > addr:
					rate = rate - (here - addr)
				addr = here
			return
		if not self.vcr.fwdshuttle(vcrspeed):
			self.vcr_error('fwd shuttle failed')
			return
		cycle = 0
		while count > 0:
			try:
				here = self.vcr.sense()
			except VCR.error, msg:
				self.vcr_error(msg)
				break
			if here <> addr:
				if here <> addr+1:
					print 'Missed', here-addr-1,
					print 'frame' + 's'*(here-addr-1 <> 1)
				cycle = (cycle+1) % rate
				if cycle == 0:
					tc = (here-start_addr)*40
					if not self.single_capture(stepfunc, \
						  tc):
						break
					print 'captured %02d:%02d:%02d:%02d' \
						  % self.vcr.addr2tc(here)
					count = count -1
				addr = here
		if self.vcr and not self.vcr.still():
			self.vcr_error('still failed')

	def vcr_error(self, msg):
		self.reset()
		fl.show_message('VCR error:', str(msg), '')

	# Init/end continuous capture mode

	def init_cont(self):
		qsize = 1
		if self.vmode == VM_CONT:
			self.rate = self.getint(self.in_rate, 2)
		else:
			self.rate = 2
		x, y = self.vout.getsize()
		if self.use_24:
			info = (SV.YUV411_FRAMES, x, y, qsize, self.rate)
		else:
			info = (SV.RGB8_FRAMES, x, y, qsize, self.rate)
		info2 = self.video.InitContinuousCapture(info)
		if info2 <> info:
			# XXX This is really only debug info
			print 'Info mismatch: requested', info, 'got', info2

	def end_cont(self):
		self.video.EndContinuousCapture()

	# Misc stuff

	def settitle(self):
		gl.winset(self.window)
		x, y = gl.getsize()
		title = 'Vb ' + self.vfile + ' (%dx%d)' % (x, y)
		gl.wintitle(title)

	def get_vformat(self):
		i = self.c_vformat.get_choice()
		label = VideoFormatLabels[i-1]
		format = VideoFormats[i-1]
		if format == 'compress' and cl == None:
			fl.show_message('Sorry, no compression library support')
			format = ''
			label = 'Video off'
		self.vformat = format
		if self.vformat == '':
			self.form.freeze_form()
			self.g_video.hide_object()
			self.g_cont.hide_object()
			self.g_burst.hide_object()
			self.g_single.hide_object()
			self.form.unfreeze_form()
		else:
			self.g_video.show_object()
			if self.vmode == VM_CONT:
				self.g_cont.show_object()
			elif self.vmode == VM_BURST:
				self.g_burst.show_object()
			elif self.vmode == VM_SINGLE:
				self.g_single.show_object()
		#
		self.rgb = (format[:3] == 'rgb' or format == 'compress')
		self.mono = (format == 'mono')
		self.grey = (format[:4] == 'grey')
		self.use_24 = (format in ('rgb', 'jpeg', 'compress'))
		if self.use_24:
			self.g_rgb24.show_object()
		else:
			self.g_rgb24.hide_object()
		self.use_jpeg = (format == 'jpeg')
		self.mono_use_thresh = (label == 'mono thresh')
		self.use_compress = (format == 'compress')
		if self.use_compress:
			self.g_compress.show_object()
		else:
			self.g_compress.hide_object()
		s = format[4:]
		if self.grey and s:
			self.greybits = string.atoi(s)
		else:
			self.greybits = 8
		if label == 'grey2 dith':
			self.greybits = -2
		#
		convertor = None
		if self.grey:
			if self.greybits == 2:
				convertor = imageop.grey2grey2
			elif self.greybits == 4:
				convertor = imageop.grey2grey4
			elif self.greybits == -2:
				convertor = imageop.dither2grey2
		self.convertor = convertor
		self.optfullsizewindow()

	def get_aformat(self):
		self.reset()
		self.aformat = self.c_aformat.get_choice()
		if self.aformat == A_OFF:
			self.g_audio.hide_object()
		else:
			self.g_audio.show_object()

	def init_compressor(self, w, h):
		self.compressor = None
		scheme = cl.QuerySchemeFromName(CL.VIDEO, self.comp_scheme)
		self.compressor = cl.OpenCompressor(scheme)
		parambuf = [CL.IMAGE_WIDTH, w, \
			  CL.IMAGE_HEIGHT, h, \
			  CL.ORIGINAL_FORMAT, CL.YUV422DC]
		self.compressor.SetParams(parambuf)
		return self.compressor.Compress(0, '')

	def open_if_closed(self):
		if not self.vout:
			self.open_video()
		if not self.aout:
			self.open_audio()

	# File I/O handling

	def open_video(self):
		self.close_video()
		gl.winset(self.window)
		x, y = gl.getsize()
		if self.use_24:
			if self.rgb24_size == 2:
				x, y = x/2, y/2
			elif self.rgb24_size == 3:
				x, y = x/4, y/4
		vout = VFile.VoutFile(self.vfile)
		vout.setformat(self.vformat)
		if self.vformat == 'compress':
			cheader = self.init_compressor(x, y)
			vout.setcompressheader(cheader)
		vout.setsize(x, y)
		if self.vmode == VM_BURST:
			vout.setpf((1, -2))
		vout.writeheader()
		self.vout = vout
		self.nframes = 0
		self.speed_factor = 1
		self.t_nframes.label = `self.nframes`

	def write_frame(self, t, data):
		t = t * self.speed_factor
		if not self.vout:
			gl.ringbell()
			return 0
		if self.convertor:
			data = self.convertor(data, len(data), 1)
		elif self.mono:
			if self.mono_use_thresh:
				data = imageop.grey2mono(data, \
					  len(data), 1,\
					  self.mono_thresh)
			else:
				data = imageop.dither2mono(data, \
					  len(data), 1)
		try:
			self.vout.writeframe(int(t), data, None)
		except IOError, msg:
			self.reset()
			if msg == (0, 'Error 0'):
				msg = 'disk full??'
			fl.show_message('IOError', str(msg), '')
			return 0
		self.nframes = self.nframes + 1
		self.t_nframes.label = `self.nframes`
		return 1

	def close_video(self):
		if not self.vout:
			return
		self.nframes = 0
		self.t_nframes.label = ''
		try:
			self.vout.close()
		except IOError, msg:
			if msg == (0, 'Error 0'):
				msg = 'disk full??'
			fl.show_message('IOError', str(msg), '')
		self.vout = None
		self.compressor = None

	# Watch cursor handling

	def setwatch(self):
		gl.winset(self.form.window)
		gl.setcursor(WATCH, 0, 0)
		gl.winset(self.window)
		gl.setcursor(WATCH, 0, 0)

	def setarrow(self):
		gl.winset(self.form.window)
		gl.setcursor(ARROW, 0, 0)
		gl.winset(self.window)
		gl.setcursor(ARROW, 0, 0)

	# Numeric field handling

	def getint(self, field, default):
		try:
			value = string.atoi(field.get_input())
		except string.atoi_error:
			value = default
		field.set_input(`value`)
		return value

	def getfloat(self, field, default):
		try:
			value = float(eval(field.get_input()))
		except:
			value = float(default)
		field.set_input(`value`)
		return value

	# Audio stuff

	def open_audio(self):
		if self.aformat == A_OFF:
			return
		import aifc
		import al
		import AL
		import thread
		self.close_audio()
		params = [AL.INPUT_RATE, 0]
		al.getparams(AL.DEFAULT_DEVICE, params)
		rate = params[1]
		self.aout = aifc.open(self.afile, 'w')
		if self.aformat in (A_16_STEREO, A_8_STEREO):
			nch = AL.STEREO
		else:
			nch = AL.MONO
		if self.aformat in (A_16_STEREO, A_16_MONO):
			width = AL.SAMPLE_16
		else:
			width = AL.SAMPLE_8
		self.aout.setnchannels(nch)
		self.aout.setsampwidth(width)
		self.aout.setframerate(rate)
		c = al.newconfig()
		c.setqueuesize(8000)
		c.setchannels(nch)
		c.setwidth(width)
		self.aport = al.openport('Vb audio record', 'r', c)
		self.audio_stop = 0
		self.audio_ok = 0
		self.audio_busy = 1
		thread.start_new_thread(self.record_audio, ())

	def start_audio(self):
		if self.aformat == A_OFF:
			return
		self.audio_ok = 1

	def record_audio(self, *args):
		# This function runs in a separate thread
		# Currently no semaphores are used
		while not self.audio_stop:
			data = self.aport.readsamps(4000)
			if self.audio_ok:
				self.aout.writeframes(data)
			data = None
		self.audio_busy = 0

	def stop_audio(self):
		self.audio_ok = 0

	def close_audio(self):
		if self.aout:
			self.audio_ok = 0
			self.audio_stop = 1
			while self.audio_busy:
				time.sleep(0.1)
			self.aout.close()
			self.aout = None
		if self.aport:
			self.aport.closeport()
			self.aport = None


try:
	main()
except KeyboardInterrupt:
	print '[Interrupt]'
	sys.exit(1)