#! /usr/bin/env python
#! /ufs/guido/bin/sgi/python-405
# Capture a CMIF movie using the Indigo video library and board
# The CMIF video file format is documented in cmif-film.ms.
# Audio data is recorded in AIFF format, using the input sampling
# rate, source and volume set by the audio panel, in mono, 8
# bits/sample.
# Usage and help functions (keep this up-to-date if you change the program!)
def usage():
print 'Usage: Vrec [options] [moviefile [audiofile]]'
print
print 'Options:'
print '-a : record audio as well'
print '-q queuesize : set the capture queue size (default 2)'
print '-r rate : capture 1 out of every "rate" frames', \
'(default and min 2)'
print '-w width : initial window width', \
'(default 256, use 0 for interactive placement)'
print '-n : Don\'t write to file, only timing info'
print '-d : drop fields if needed'
print '-g bits : greyscale (2, 4 or 8 bits)'
print '-G : 2-bit greyscale dithered'
print '-m : monochrome dithered'
print '-M value : monochrome tresholded with value'
print '-f : Capture fields (in stead of frames)'
print '-P frames : preallocate space for "frames" frames'
print 'moviefile : here goes the movie data (default film.video)'
print 'audiofile : with -a, here goes the audio data', \
'(default film.aiff)'
def help():
print 'Press the left mouse button to start recording, release it to'
print 'end recording. You can record as many times as you wish, but'
print 'each recording overwrites the output file(s) -- only the last'
print 'recording is kept.'
print
print 'Press ESC or use the window manager Quit or Close window option'
print 'to quit. If you quit before recording anything, the output'
print 'file(s) are not touched.'
# Imported modules
import sys
sys.path.append('/ufs/guido/src/video')
import sv, SV
import VFile
import gl, GL, DEVICE
import al, AL
import time
import posix
import getopt
import string
import imageop
import sgi
# Main program
def main():
format = SV.RGB8_FRAMES
qsize = 2
audio = 0
rate = 2
width = 0
norecord = 0
drop = 0
mono = 0
grey = 0
greybits = 0
monotreshold = -1
fields = 0
preallocspace = 0
# Parse command line
try:
opts, args = getopt.getopt(sys.argv[1:], 'aq:r:w:ndg:mM:GfP:')
except getopt.error, msg:
sys.stdout = sys.stderr
print 'Error:', msg, '\n'
usage()
sys.exit(2)
# Interpret options
try:
for opt, arg in opts:
if opt == '-a':
audio = 1
elif opt == '-q':
qsize = string.atoi(arg)
elif opt == '-r':
rate = string.atoi(arg)
if rate < 2:
sys.stderr.write( \
'-r rate must be >= 2\n')
sys.exit(2)
elif opt == '-w':
width = string.atoi(arg)
elif opt == '-n':
norecord = 1
elif opt == '-d':
drop = 1
elif opt == '-g':
grey = 1
greybits = string.atoi(arg)
if not greybits in (2, 4, 8):
sys.stderr.write( \
'Only 2, 4 or 8 bit greyscale supported\n')
sys.exit(2)
elif opt == '-G':
grey = 1
greybits = -2
elif opt == '-m':
mono = 1
elif opt == '-M':
mono = 1
monotreshold = string.atoi(arg)
elif opt == '-f':
fields = 1
elif opt == '-P':
preallocspace = string.atoi(arg)
except string.atoi_error:
sys.stdout = sys.stderr
print 'Option', opt, 'requires integer argument'
sys.exit(2)
# Check excess arguments
# If norecord is on, refuse filename arguments
if norecord:
if args:
sys.stdout = sys.stderr
print 'With -n, no filename arguments are used\n'
usage()
sys.exit(2)
elif args[2:]:
sys.stdout = sys.stderr
print 'Too many filename arguments\n'
usage()
sys.exit(2)
# Process file arguments
if args:
filename = args[0]
else:
filename = 'film.video'
if args[1:] and not audio:
sys.stderr.write('-a turned on by appearance of 2nd file\n')
audio = 1
if audio:
if args[1:]:
audiofilename = args[1]
else:
audiofilename = 'film.aiff'
else:
audiofilename = None
if norecord:
filename = audiofilename = ''
# Open video
v = sv.OpenVideo()
# Determine maximum window size based on signal standard
param = [SV.BROADCAST, 0]
v.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)
gl.foreground()
gl.maxsize(x, y)
gl.keepaspect(x, y)
gl.stepunit(8, 6)
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)
win = gl.winopen(filename)
if width:
gl.maxsize(x, y)
gl.keepaspect(x, y)
gl.stepunit(8, 6)
gl.winconstraints()
x, y = gl.getsize()
print x, 'x', y
v.SetSize(x, y)
if drop:
param = [SV.FIELDDROP, 1, SV.GENLOCK, SV.GENLOCK_OFF]
else:
param = [SV.FIELDDROP, 0, SV.GENLOCK, SV.GENLOCK_ON]
if mono or grey:
param = param+[SV.COLOR, SV.MONO, SV.DITHER, 0, \
SV.INPUT_BYPASS, 1]
else:
param = param+[SV.COLOR, SV.DEFAULT_COLOR, SV.INPUT_BYPASS, 0]
v.BindGLWindow(win, SV.IN_REPLACE)
v.SetParam(param)
gl.qdevice(DEVICE.LEFTMOUSE)
gl.qdevice(DEVICE.WINQUIT)
gl.qdevice(DEVICE.WINSHUT)
gl.qdevice(DEVICE.ESCKEY)
help()
while 1:
dev, val = gl.qread()
if dev == DEVICE.LEFTMOUSE:
if val == 1:
info = format, x, y, qsize, rate
record(v, info, filename, audiofilename,\
mono, grey, greybits, monotreshold, \
fields, preallocspace)
elif dev == DEVICE.REDRAW:
# Window resize (or move)
x, y = gl.getsize()
print x, 'x', y
v.SetSize(x, y)
v.BindGLWindow(win, SV.IN_REPLACE)
elif dev in (DEVICE.ESCKEY, DEVICE.WINQUIT, DEVICE.WINSHUT):
# Quit
v.CloseVideo()
gl.winclose(win)
break
# Record until the mouse is released (or any other GL event)
# XXX audio not yet supported
def record(v, info, filename, audiofilename, mono, grey, greybits, \
monotreshold, fields, preallocspace):
import thread
format, x, y, qsize, rate = info
fps = 59.64 # Fields per second
# 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(filename)
if mono:
format = 'mono'
elif grey and greybits == 8:
format = 'grey'
elif grey:
format = 'grey'+`abs(greybits)`
else:
format = 'rgb8'
vout.setformat(format)
vout.setsize(x, y)
if fields:
vout.setpf((1, -2))
vout.writeheader()
if preallocspace:
print 'Preallocating space...'
vout.prealloc(preallocspace)
print 'done.'
MAXSIZE = 20 # XXX should be a user option
import Queue
queue = Queue.Queue(MAXSIZE)
done = thread.allocate_lock()
done.acquire_lock()
convertor = None
if grey:
if greybits == 2:
convertor = imageop.grey2grey2
elif greybits == 4:
convertor = imageop.grey2grey4
elif greybits == -2:
convertor = imageop.dither2grey2
thread.start_new_thread(saveframes, \
(vout, queue, done, mono, monotreshold, convertor))
if audiofilename:
audiodone = thread.allocate_lock()
audiodone.acquire_lock()
audiostop = []
initaudio(audiofilename, audiostop, audiodone)
gl.wintitle('(rec) ' + filename)
lastid = 0
t0 = time.time()
count = 0
ids = []
v.InitContinuousCapture(info)
while not gl.qtest():
try:
cd, id = v.GetCaptureData()
except sv.error:
#time.sleep(0.010) # XXX is this necessary?
sgi.nap(1) # XXX Try by Jack
continue
ids.append(id)
id = id + 2*rate
## if id <> lastid + 2*rate:
## print lastid, id
lastid = id
count = count+1
if fields:
data1, data2 = cd.GetFields()
cd.UnlockCaptureData()
if filename:
queue.put((data1, int(id*tpf)))
queue.put((data2, int((id+1)*tpf)))
else:
data = cd.InterleaveFields(1)
cd.UnlockCaptureData()
if filename:
queue.put((data, int(id*tpf)))
t1 = time.time()
gl.wintitle('(busy) ' + filename)
print lastid, 'fields in', round(t1-t0, 3), 'sec',
print '--', round(lastid/(t1-t0), 1), 'fields/sec'
print 'Captured',count*2, 'fields,',
print round(count*2/(t1-t0), 1), 'f/s',
if lastid:
print '(',
print round(count*200.0/lastid), '%, or',
print round(count*rate*200.0/lastid), '% of wanted rate )',
print
if ids:
print 'Ids:',
t0 = ids[0]
del ids[0]
for t1 in ids:
print t1-t0,
t0 = t1
print
if filename and audiofilename:
audiostop.append(None)
audiodone.acquire_lock()
v.EndContinuousCapture()
if filename:
queue.put(None) # Sentinel
done.acquire_lock()
gl.wintitle('(done) ' + filename)
# Thread to save the frames to the file
def saveframes(vout, queue, done, mono, monotreshold, convertor):
while 1:
x = queue.get()
if not x:
break
data, t = x
if convertor:
data = convertor(data, len(data), 1)
elif mono and monotreshold >= 0:
data = imageop.grey2mono(data, len(data), 1,\
monotreshold)
elif mono:
data = imageop.dither2mono(data, len(data), 1)
vout.writeframe(t, data, None)
sys.stderr.write('Done writing video\n')
vout.close()
done.release_lock()
# Initialize audio recording
AQSIZE = 8000 # XXX should be a user option
def initaudio(filename, stop, done):
import thread, aifc
afile = aifc.open(filename, 'w')
afile.setnchannels(AL.MONO)
afile.setsampwidth(AL.SAMPLE_8)
params = [AL.INPUT_RATE, 0]
al.getparams(AL.DEFAULT_DEVICE, params)
print 'audio sampling rate =', params[1]
afile.setframerate(params[1])
c = al.newconfig()
c.setchannels(AL.MONO)
c.setqueuesize(AQSIZE)
c.setwidth(AL.SAMPLE_8)
aport = al.openport(filename, 'r', c)
thread.start_new_thread(audiorecord, (afile, aport, stop, done))
# Thread to record audio samples
def audiorecord(afile, aport, stop, done):
while not stop:
data = aport.readsamps(AQSIZE/2)
afile.writesampsraw(data)
del data
afile.close()
print 'Done writing audio'
done.release_lock()
# Don't forget to call the main program
try:
main()
except KeyboardInterrupt:
print '[Interrupt]'
|