cpython/Demo/sgi/video/Vb.py

755 lines
17 KiB
Python
Raw Normal View History

#! /ufs/guido/bin/sgi/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')
ARROW = 0
WATCH = 1
watchcursor.defwatch(WATCH)
def main():
## fl.set_graphics_mode(0, 1)
vb = VideoBagOfTricks().init()
while 1:
dummy = fl.do_forms()
[dummy]
StopCapture = 'StopCapture'
VideoFormatLabels = ['Video off', 'rgb8', 'grey8', 'grey4', 'grey2', \
'grey2 dith', 'mono dith', 'mono thresh']
VideoFormats = ['', 'rgb8', 'grey', 'grey4', 'grey2', \
'grey2', 'mono', 'mono']
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)
class VideoBagOfTricks:
# Init/close stuff
def init(self):
formdef = flp.parse_form('VbForm', 'form')
flp.create_full_form(self, formdef)
self.g_cont.hide_object()
self.g_burst.hide_object()
self.g_single.hide_object()
self.g_vcr.hide_object()
self.setdefaults()
self.openvideo()
self.makewindow()
self.bindvideo()
self.showform()
fl.set_event_call_back(self.do_event)
return self
def close(self):
self.close_video()
self.close_audio()
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, \
'Video Bag Of Tricks')
def setdefaults(self):
self.vcr = None
self.vout = None
self.capturing = 0
# Video defaults
self.vfile = 'film.video'
self.vmode = VM_CONT
self.mono_thresh = 128
self.vformat = 'rgb8'
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')
# Audio defaults
self.aout = None
self.aport = None
self.afile = 'film.aiff'
self.aformat = A_OFF
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
def makewindow(self):
x, y = self.maxx, self.maxy
gl.foreground()
gl.maxsize(x, y)
gl.keepaspect(x, y)
gl.stepunit(8, 6)
width = 256 # XXX
if width:
height = width*3/4
x1 = 150
x2 = x1 + width-1
y2 = 768-150
y1 = y2-height+1
gl.prefposition(x1, x2, y1, y2)
self.window = gl.winopen('Vb: initializing')
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 bindvideo(self):
if not self.video: return
x, y = gl.getsize()
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_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
# 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()
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()
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()
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):
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):
self.open_if_closed()
self.init_cont()
while 1:
try:
cd, id = self.video.GetCaptureData()
break
except sv.error:
pass
sgi.nap(1)
data = cd.InterleaveFields(1)
cd.UnlockCaptureData()
self.end_cont()
t = (self.nframes+1) * (1000/25)
return self.write_frame(t, data)
def vcr_capture(self):
if not self.vcr:
import VCR
try:
self.vcr = VCR.VCR().init()
self.vcr.wait()
if not (self.vcr.fmmode('dnr') and \
self.vcr.dmcontrol('digital slow')):
self.vcr_error('digital slow failed')
return
except VCR.error, msg:
self.vcr = None
self.vcr_error(msg)
return
if not self.vcr.still():
self.vcr_error('still failed')
return
# XXX for some reason calling where() too often hangs the VCR,
# XXX so we insert sleep(0.1) before every sense() call.
self.open_if_closed()
rate = self.getint(self.in_rate_vcr, 1)
rate = max(rate, 1)
self.speed_factor = rate
addr = self.vcr.sense()
if not self.single_capture():
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(2): # one tenth speed
self.vcr_error('fwd shuttle failed')
return
cycle = 0
while count > 0:
time.sleep(0.1)
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:
if not self.single_capture():
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()
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]
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()
return
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')
self.mono = (format == 'mono')
self.grey = (format[:4] == 'grey')
self.mono_use_thresh = (label == 'mono thresh')
s = format[4:]
if 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
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 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()
vout = VFile.VoutFile().init(self.vfile)
vout.setformat(self.vformat)
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
# 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)
self.aout.writeframes('')
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.writeframesraw(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)