mirror of
https://github.com/python/cpython.git
synced 2025-09-26 18:29:57 +00:00
Remove the SGI demos. These were all ancient and nobody cared enough.
This commit is contained in:
Guido van Rossum
parent
4cb2204851
commit
b0c87b956c
24 changed files with 0 additions and 1117 deletions
|
|
@ -1,22 +0,0 @@
|
||||||
Demonstrations of Python that use various features of the Silicon
|
|
||||||
Graphics IRIS machines.
|
|
||||||
|
|
||||||
al Demonstrations of the audio capabilities of the
|
|
||||||
Indigo. Require the built-in module 'al'. One program
|
|
||||||
also needs the build-in module 'fl' (the FORMS
|
|
||||||
library by Mark Overmars.)
|
|
||||||
|
|
||||||
cd Demonstrations of the CD-ROM player's audio interface,
|
|
||||||
built-in module 'cd'.
|
|
||||||
|
|
||||||
flp Demonstrations of using the 'flp' standard module,
|
|
||||||
which enables you to quickly create forms using the
|
|
||||||
'fl' built-in module (available if you use the FORMS
|
|
||||||
library by Mark Overmars).
|
|
||||||
|
|
||||||
gl Demonstrations of the Graphics Library (GL).
|
|
||||||
Require the built-in module 'gl'.
|
|
||||||
|
|
||||||
sv Demonstrations of the Indigo Video module.
|
|
||||||
Requires the built-in module 'sv'. See also the
|
|
||||||
following directory.
|
|
||||||
|
|
@ -1,15 +0,0 @@
|
||||||
This directory contains programs using the "al" interface, which gives
|
|
||||||
access to the most important parts of the SGI Audio Library for the
|
|
||||||
Indigo and 4D/35.
|
|
||||||
|
|
||||||
alwatch.py Watch changes in device settings
|
|
||||||
broadcast.py Broadcast audio using UDP packets
|
|
||||||
cmpaf.py Compare different audio compression schemes (uses fl)
|
|
||||||
intercom.py 2-way communication with another host (uses fl)
|
|
||||||
playaiff.py Play an AIFF file (as output by recordaiff)
|
|
||||||
playback.py Play raw audio data read from stdin
|
|
||||||
playold.py Play an audio file recorded by the old 4D/25 audio
|
|
||||||
radio.py Listen to UDP packets sent by broadcast.py
|
|
||||||
rec_play.py Repeatedly record and play back a sample
|
|
||||||
record.py Record raw audio data to stdout
|
|
||||||
unicast.py Like broadcast but sends to one host
|
|
||||||
|
|
@ -1,33 +0,0 @@
|
||||||
import time
|
|
||||||
import al, AL
|
|
||||||
import string
|
|
||||||
|
|
||||||
dev = AL.DEFAULT_DEVICE
|
|
||||||
|
|
||||||
source_name = ['line', 'microphone', 'digital']
|
|
||||||
|
|
||||||
params = al.queryparams(dev)
|
|
||||||
for i in range(1, len(params), 2):
|
|
||||||
params[i] = -1
|
|
||||||
while 1:
|
|
||||||
time.sleep(0.1)
|
|
||||||
old = params[:]
|
|
||||||
al.getparams(dev, params)
|
|
||||||
if params <> old:
|
|
||||||
for i in range(0, len(params), 2):
|
|
||||||
if params[i+1] <> old[i+1]:
|
|
||||||
name = al.getname(dev, params[i])
|
|
||||||
if params[i] == AL.INPUT_SOURCE:
|
|
||||||
if 0 <= old[i+1] < len(source_name):
|
|
||||||
oldval = source_name[old[i+1]]
|
|
||||||
else:
|
|
||||||
oldval = ''
|
|
||||||
newval = source_name[params[i+1]]
|
|
||||||
else:
|
|
||||||
oldval = `old[i+1]`
|
|
||||||
newval = `params[i+1]`
|
|
||||||
print string.ljust(name, 25),
|
|
||||||
print '(' + string.rjust(oldval, 10) + ')',
|
|
||||||
print '-->',
|
|
||||||
print string.rjust(newval, 10)
|
|
||||||
print
|
|
||||||
|
|
@ -1,27 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# broadcast [port]
|
|
||||||
#
|
|
||||||
# Broadcast audio input on the network as UDP packets;
|
|
||||||
# they can be received on any SGI machine with "radio.py".
|
|
||||||
# This uses the input sampling rate, input source etc. set by apanel.
|
|
||||||
# It uses the default sample width and #channels (16 bit/sample stereo).
|
|
||||||
# (This is 192,000 Bytes at a sampling speed of 48 kHz, or ~137
|
|
||||||
# packets/second -- use with caution!!!)
|
|
||||||
|
|
||||||
import sys, al
|
|
||||||
from socket import *
|
|
||||||
|
|
||||||
port = 5555
|
|
||||||
if sys.argv[1:]: port = eval(sys.argv[1])
|
|
||||||
|
|
||||||
s = socket(AF_INET, SOCK_DGRAM)
|
|
||||||
s.allowbroadcast(1)
|
|
||||||
|
|
||||||
p = al.openport('broadcast', 'r')
|
|
||||||
|
|
||||||
address = '<broadcast>', port
|
|
||||||
while 1:
|
|
||||||
# 700 samples equals 1400 bytes, or about the max packet size!
|
|
||||||
data = p.readsamps(700)
|
|
||||||
s.sendto(data, address)
|
|
||||||
|
|
@ -1,64 +0,0 @@
|
||||||
# Compare different audio compression schemes.
|
|
||||||
#
|
|
||||||
# This copies mono audio data from the input port to the output port,
|
|
||||||
# and puts up a window with 4 toggle buttons:
|
|
||||||
#
|
|
||||||
# uLAW : convert the data to uLAW and back
|
|
||||||
# ADPCM : convert the data to ADPCM and back
|
|
||||||
# Difference : make only the difference between the converted and the
|
|
||||||
# original data audible
|
|
||||||
# Exit : quit from the program
|
|
||||||
|
|
||||||
import fl
|
|
||||||
import FL
|
|
||||||
import flp
|
|
||||||
import al
|
|
||||||
import AL
|
|
||||||
import audioop
|
|
||||||
import sys
|
|
||||||
|
|
||||||
class Cmpaf:
|
|
||||||
def __init__(self):
|
|
||||||
parsetree = flp.parse_form('cmpaf_form','form')
|
|
||||||
flp.create_full_form(self, parsetree)
|
|
||||||
c = al.newconfig()
|
|
||||||
c.setchannels(AL.MONO)
|
|
||||||
c.setqueuesize(1800)
|
|
||||||
self.iport = al.openport('cmpaf','r', c)
|
|
||||||
self.oport = al.openport('cmpaf','w', c)
|
|
||||||
self.do_adpcm = self.do_ulaw = self.do_diff = 0
|
|
||||||
self.acstate = None
|
|
||||||
self.form.show_form(FL.PLACE_SIZE, 1, 'compare audio formats')
|
|
||||||
|
|
||||||
def run(self):
|
|
||||||
while 1:
|
|
||||||
olddata = data = self.iport.readsamps(600)
|
|
||||||
if self.do_ulaw:
|
|
||||||
data = audioop.lin2ulaw(data, 2)
|
|
||||||
data = audioop.ulaw2lin(data, 2)
|
|
||||||
if self.do_adpcm:
|
|
||||||
data, nacstate = audioop.lin2adpcm(data, 2, \
|
|
||||||
self.acstate)
|
|
||||||
data, dummy = audioop.adpcm2lin(data, 2, \
|
|
||||||
self.acstate)
|
|
||||||
self.acstate = nacstate
|
|
||||||
if self.do_diff:
|
|
||||||
olddata = audioop.mul(olddata, 2, -1)
|
|
||||||
data = audioop.add(olddata, data, 2)
|
|
||||||
self.oport.writesamps(data)
|
|
||||||
fl.check_forms()
|
|
||||||
|
|
||||||
def cb_exit(self, *args):
|
|
||||||
sys.exit(0)
|
|
||||||
|
|
||||||
def cb_adpcm(self, obj, val):
|
|
||||||
self.do_adpcm = obj.get_button()
|
|
||||||
|
|
||||||
def cb_ulaw(self, obj, val):
|
|
||||||
self.do_ulaw = obj.get_button()
|
|
||||||
|
|
||||||
def cb_diff(self, obj, val):
|
|
||||||
self.do_diff = obj.get_button()
|
|
||||||
|
|
||||||
cmpaf = Cmpaf()
|
|
||||||
cmpaf.run()
|
|
||||||
|
|
@ -1,90 +0,0 @@
|
||||||
Magic: 12321
|
|
||||||
|
|
||||||
Internal Form Definition File
|
|
||||||
(do not change)
|
|
||||||
|
|
||||||
Number of forms: 1
|
|
||||||
|
|
||||||
=============== FORM ===============
|
|
||||||
Name: form
|
|
||||||
Width: 230.000000
|
|
||||||
Height: 80.000000
|
|
||||||
Number of Objects: 5
|
|
||||||
|
|
||||||
--------------------
|
|
||||||
class: 1
|
|
||||||
type: 1
|
|
||||||
box: 0.000000 0.000000 230.000000 80.000000
|
|
||||||
boxtype: 1
|
|
||||||
colors: 47 47
|
|
||||||
alignment: 4
|
|
||||||
style: 0
|
|
||||||
size: 11.000000
|
|
||||||
lcol: 0
|
|
||||||
label:
|
|
||||||
name:
|
|
||||||
callback:
|
|
||||||
argument:
|
|
||||||
|
|
||||||
--------------------
|
|
||||||
class: 12
|
|
||||||
type: 1
|
|
||||||
box: 10.000000 40.000000 100.000000 30.000000
|
|
||||||
boxtype: 1
|
|
||||||
colors: 39 3
|
|
||||||
alignment: 4
|
|
||||||
style: 0
|
|
||||||
size: 11.000000
|
|
||||||
lcol: 0
|
|
||||||
label: uLAW
|
|
||||||
name: ulawbutton
|
|
||||||
callback: cb_ulaw
|
|
||||||
argument: 0
|
|
||||||
|
|
||||||
--------------------
|
|
||||||
class: 12
|
|
||||||
type: 1
|
|
||||||
box: 10.000000 10.000000 100.000000 30.000000
|
|
||||||
boxtype: 1
|
|
||||||
colors: 39 3
|
|
||||||
alignment: 4
|
|
||||||
style: 0
|
|
||||||
size: 11.000000
|
|
||||||
lcol: 0
|
|
||||||
label: ADPCM
|
|
||||||
name: adpcm_button
|
|
||||||
callback: cb_adpcm
|
|
||||||
argument: 0
|
|
||||||
|
|
||||||
--------------------
|
|
||||||
class: 11
|
|
||||||
type: 0
|
|
||||||
box: 170.000000 10.000000 50.000000 20.000000
|
|
||||||
boxtype: 1
|
|
||||||
colors: 47 47
|
|
||||||
alignment: 4
|
|
||||||
style: 0
|
|
||||||
size: 11.000000
|
|
||||||
lcol: 0
|
|
||||||
label: EXIT
|
|
||||||
name: exit_button
|
|
||||||
callback: cb_exit
|
|
||||||
argument: 0
|
|
||||||
|
|
||||||
--------------------
|
|
||||||
class: 12
|
|
||||||
type: 1
|
|
||||||
box: 120.000000 40.000000 100.000000 30.000000
|
|
||||||
boxtype: 1
|
|
||||||
colors: 39 3
|
|
||||||
alignment: 4
|
|
||||||
style: 0
|
|
||||||
size: 11.000000
|
|
||||||
lcol: 0
|
|
||||||
label: Difference
|
|
||||||
name: diffbutton
|
|
||||||
callback: cb_diff
|
|
||||||
argument: 0
|
|
||||||
|
|
||||||
==============================
|
|
||||||
create_the_forms
|
|
||||||
|
|
@ -1,212 +0,0 @@
|
||||||
# intercom -- use mike and headset to *talk* to a person on another host.
|
|
||||||
# For SGI 4D/35 or Indigo running IRIX 4.0.
|
|
||||||
# Uses 16 bit sampling at 16000 samples/sec, or 32000 bytes/sec,
|
|
||||||
# tranmitted in 32 1000-byte UDP packets. (In each direction!)
|
|
||||||
#
|
|
||||||
# usage:
|
|
||||||
# intercom hostname - start talking to person on other host
|
|
||||||
# intercom -r hostname - called remotely to do the setup
|
|
||||||
|
|
||||||
from names import *
|
|
||||||
import sys, time, posix, gl, fl, FL, al, AL, getopt, rand
|
|
||||||
from socket import *
|
|
||||||
|
|
||||||
# UDP port numbers used (one for each direction!)
|
|
||||||
PORT1 = 51042
|
|
||||||
PORT2 = PORT1+1
|
|
||||||
|
|
||||||
# Figure out the user name
|
|
||||||
try:
|
|
||||||
user = posix.environ['LOGNAME']
|
|
||||||
except:
|
|
||||||
user = posix.environ['USER']
|
|
||||||
|
|
||||||
# Debug flags (Implemented as a list; non-empty means debugging is on)
|
|
||||||
debug = []
|
|
||||||
|
|
||||||
def main():
|
|
||||||
remote = 0
|
|
||||||
opts, args = getopt.getopt(sys.argv[1:], 'rd')
|
|
||||||
for opt, arg in opts:
|
|
||||||
if opt == '-r': remote = 1
|
|
||||||
elif opt == '-d': debug.append(opt)
|
|
||||||
if len(args) <> 1:
|
|
||||||
msg = 'usage: intercom [-d] [-r] hostname'
|
|
||||||
msg = msg + ' (-r is for internal use only!)\n'
|
|
||||||
sys.stderr.write(msg)
|
|
||||||
sys.exit(2)
|
|
||||||
if remote:
|
|
||||||
server(args[0])
|
|
||||||
else:
|
|
||||||
client(args[0])
|
|
||||||
|
|
||||||
def client(hostname):
|
|
||||||
print 'client starting'
|
|
||||||
cmd = 'rsh ' + hostname + ' "cd ' + AUDIODIR
|
|
||||||
cmd = cmd + '; DISPLAY=:0; export DISPLAY'
|
|
||||||
cmd = cmd + '; ' + PYTHON + ' intercom.py -r '
|
|
||||||
for flag in debug: cmd = cmd + flag + ' '
|
|
||||||
cmd = cmd + gethostname()
|
|
||||||
cmd = cmd + '"'
|
|
||||||
if debug: print cmd
|
|
||||||
pipe = posix.popen(cmd, 'r')
|
|
||||||
ack = 0
|
|
||||||
nak = 0
|
|
||||||
while 1:
|
|
||||||
line = pipe.readline()
|
|
||||||
if not line: break
|
|
||||||
sys.stdout.write('remote: ' + line)
|
|
||||||
if line == 'NAK\n':
|
|
||||||
nak = 1
|
|
||||||
break
|
|
||||||
elif line == 'ACK\n':
|
|
||||||
ack = 1
|
|
||||||
break
|
|
||||||
if nak:
|
|
||||||
print 'Remote user doesn\'t want to talk to you.'
|
|
||||||
return
|
|
||||||
if not ack:
|
|
||||||
print 'No acknowledgement (remote side crashed?).'
|
|
||||||
return
|
|
||||||
#
|
|
||||||
print 'Ready...'
|
|
||||||
#
|
|
||||||
s = socket(AF_INET, SOCK_DGRAM)
|
|
||||||
s.bind('', PORT2)
|
|
||||||
#
|
|
||||||
otheraddr = gethostbyname(hostname), PORT1
|
|
||||||
try:
|
|
||||||
try:
|
|
||||||
ioloop(s, otheraddr)
|
|
||||||
except KeyboardInterrupt:
|
|
||||||
log('client got intr')
|
|
||||||
except error:
|
|
||||||
log('client got error')
|
|
||||||
finally:
|
|
||||||
s.sendto('', otheraddr)
|
|
||||||
log('client finished sending empty packet to server')
|
|
||||||
#
|
|
||||||
log('client exit')
|
|
||||||
print 'Done.'
|
|
||||||
|
|
||||||
def server(hostname):
|
|
||||||
print 'server starting'
|
|
||||||
sys.stdout.flush()
|
|
||||||
#
|
|
||||||
if not remotedialog():
|
|
||||||
print 'NAK'
|
|
||||||
return
|
|
||||||
#
|
|
||||||
print 'ACK'
|
|
||||||
#
|
|
||||||
s = socket(AF_INET, SOCK_DGRAM)
|
|
||||||
s.bind('', PORT1)
|
|
||||||
#
|
|
||||||
# Close std{in,out,err} so rsh will exit; reopen them as dummies
|
|
||||||
#
|
|
||||||
sys.stdin.close()
|
|
||||||
sys.stdin = open('/dev/null', 'r')
|
|
||||||
sys.stdout.close()
|
|
||||||
sys.stdout = open('/dev/null', 'w')
|
|
||||||
sys.stderr.close()
|
|
||||||
if debug:
|
|
||||||
sys.stderr = open('/tmp/intercom.err', 'a')
|
|
||||||
else:
|
|
||||||
sys.stderr = open('/dev/null', 'w')
|
|
||||||
#
|
|
||||||
ioloop(s, (gethostbyname(hostname), PORT2))
|
|
||||||
log('server exit')
|
|
||||||
sys.exit(0)
|
|
||||||
|
|
||||||
def remotedialog():
|
|
||||||
gl.foreground()
|
|
||||||
gl.ringbell()
|
|
||||||
m1 = user + ' wants to talk to you over the audio channel.'
|
|
||||||
m2 = 'If it\'s OK, put on your headset and click Yes.'
|
|
||||||
m3 = 'If you\'re too busy, click No.'
|
|
||||||
return fl.show_question(m1, m2, m3)
|
|
||||||
|
|
||||||
def ioloop(s, otheraddr):
|
|
||||||
#
|
|
||||||
dev = AL.DEFAULT_DEVICE
|
|
||||||
params = al.queryparams(dev)
|
|
||||||
al.getparams(dev, params)
|
|
||||||
time.sleep(1)
|
|
||||||
saveparams = params[:]
|
|
||||||
for i in range(0, len(params), 2):
|
|
||||||
if params[i] in (AL.INPUT_RATE, AL.OUTPUT_RATE):
|
|
||||||
params[i+1] = AL.RATE_16000
|
|
||||||
elif params[i] == AL.INPUT_SOURCE:
|
|
||||||
params[i+1] = AL.INPUT_MIC
|
|
||||||
try:
|
|
||||||
al.setparams(dev, params)
|
|
||||||
ioloop1(s, otheraddr)
|
|
||||||
finally:
|
|
||||||
al.setparams(dev, saveparams)
|
|
||||||
|
|
||||||
def ioloop1(s, otheraddr):
|
|
||||||
#
|
|
||||||
# Watch out! data is in bytes, but the port counts in samples,
|
|
||||||
# which are two bytes each (for 16-bit samples).
|
|
||||||
# Luckily, we use mono, else it would be worse (2 samples/frame...)
|
|
||||||
#
|
|
||||||
SAMPSPERBUF = 500
|
|
||||||
BYTESPERSAMP = 2 # AL.SAMPLE_16
|
|
||||||
BUFSIZE = BYTESPERSAMP*SAMPSPERBUF
|
|
||||||
QSIZE = 4*SAMPSPERBUF
|
|
||||||
#
|
|
||||||
config = al.newconfig()
|
|
||||||
config.setqueuesize(QSIZE)
|
|
||||||
config.setwidth(AL.SAMPLE_16)
|
|
||||||
config.setchannels(AL.MONO)
|
|
||||||
#
|
|
||||||
pid = posix.fork()
|
|
||||||
if pid:
|
|
||||||
# Parent -- speaker/headphones handler
|
|
||||||
log('parent started')
|
|
||||||
spkr = al.openport('spkr', 'w', config)
|
|
||||||
while 1:
|
|
||||||
data = s.recv(BUFSIZE)
|
|
||||||
if len(data) == 0:
|
|
||||||
# EOF packet
|
|
||||||
log('parent got empty packet; killing child')
|
|
||||||
posix.kill(pid, 15)
|
|
||||||
return
|
|
||||||
# Discard whole packet if we are too much behind
|
|
||||||
if spkr.getfillable() > len(data) / BYTESPERSAMP:
|
|
||||||
if len(debug) >= 2:
|
|
||||||
log('parent Q full; dropping packet')
|
|
||||||
spkr.writesamps(data)
|
|
||||||
else:
|
|
||||||
# Child -- microphone handler
|
|
||||||
log('child started')
|
|
||||||
try:
|
|
||||||
try:
|
|
||||||
mike = al.openport('mike', 'r', config)
|
|
||||||
# Sleep a while to let the other side get started
|
|
||||||
time.sleep(1)
|
|
||||||
# Drain the queue before starting to read
|
|
||||||
data = mike.readsamps(mike.getfilled())
|
|
||||||
# Loop, sending packets from the mike to the net
|
|
||||||
while 1:
|
|
||||||
data = mike.readsamps(SAMPSPERBUF)
|
|
||||||
s.sendto(data, otheraddr)
|
|
||||||
except KeyboardInterrupt:
|
|
||||||
log('child got interrupt; exiting')
|
|
||||||
posix._exit(0)
|
|
||||||
except error:
|
|
||||||
log('child got error; exiting')
|
|
||||||
posix._exit(1)
|
|
||||||
finally:
|
|
||||||
log('child got unexpected error; leaving w/ traceback')
|
|
||||||
|
|
||||||
def log(msg):
|
|
||||||
if not debug: return
|
|
||||||
if type(msg) <> type(''):
|
|
||||||
msg = `msg`
|
|
||||||
|
|
||||||
f = open('/tmp/intercom.log', 'a')
|
|
||||||
f.write(`sys.argv` + ' ' + `posix.getpid()` + ': ' + msg + '\n')
|
|
||||||
f.close()
|
|
||||||
|
|
||||||
main()
|
|
||||||
|
|
@ -1,34 +0,0 @@
|
||||||
# Listen to the input on host argv[1].
|
|
||||||
|
|
||||||
import sys, al, AL, posix
|
|
||||||
|
|
||||||
BUFSIZE = 2000
|
|
||||||
QSIZE = 4000
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) <> 2:
|
|
||||||
sys.stderr.write('usage: ' + sys.argv[0] + ' hostname\n')
|
|
||||||
sys.exit(2)
|
|
||||||
hostname = sys.argv[1]
|
|
||||||
cmd = 'exec rsh </dev/null ' + hostname + \
|
|
||||||
' "cd /ufs/guido/mm/demo/audio; ' + \
|
|
||||||
'exec /ufs/guido/bin/sgi/python record.py"'
|
|
||||||
pipe = posix.popen(cmd, 'r')
|
|
||||||
config = al.newconfig()
|
|
||||||
config.setchannels(AL.MONO)
|
|
||||||
config.setqueuesize(QSIZE)
|
|
||||||
port = al.openport('', 'w', config)
|
|
||||||
while 1:
|
|
||||||
data = pipe.read(BUFSIZE)
|
|
||||||
if not data:
|
|
||||||
sts = pipe.close()
|
|
||||||
sys.stderr.write(sys.argv[0] + ': end of data\n')
|
|
||||||
if sts: sys.stderr.write('rsh exit status '+`sts`+'\n')
|
|
||||||
sys.exit(1)
|
|
||||||
port.writesamps(data)
|
|
||||||
del data
|
|
||||||
|
|
||||||
try:
|
|
||||||
main()
|
|
||||||
except KeyboardInterrupt:
|
|
||||||
sys.exit(1)
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
import sys
|
|
||||||
|
|
||||||
# My home directory/
|
|
||||||
GUIDO = '/ufs/guido/'
|
|
||||||
|
|
||||||
# Hack sys.path so AL can be found
|
|
||||||
LIB = GUIDO + 'lib/python'
|
|
||||||
if LIB not in sys.path: sys.path.insert(0, LIB)
|
|
||||||
|
|
||||||
# Python binary to be used on remote machine
|
|
||||||
PYTHON = GUIDO + 'bin/sgi/python'
|
|
||||||
|
|
||||||
# Directory where the programs live
|
|
||||||
AUDIODIR = GUIDO + 'src/python/demo/sgi/al'
|
|
||||||
|
|
@ -1,54 +0,0 @@
|
||||||
import aiff
|
|
||||||
import al
|
|
||||||
import sys
|
|
||||||
import time
|
|
||||||
|
|
||||||
def main():
|
|
||||||
v = 1
|
|
||||||
c = al.newconfig()
|
|
||||||
nchannels = c.getchannels()
|
|
||||||
nsampframes = 0 # ???
|
|
||||||
sampwidth = c.getwidth()
|
|
||||||
samprate = 0.0 # unknown
|
|
||||||
filename = sys.argv[1]
|
|
||||||
f = open(filename, 'r')
|
|
||||||
type, totalsize = aiff.read_chunk_header(f)
|
|
||||||
if type <> 'FORM':
|
|
||||||
raise aiff.Error, 'FORM chunk expected at start of file'
|
|
||||||
aiff.read_form_chunk(f)
|
|
||||||
while 1:
|
|
||||||
try:
|
|
||||||
type, size = aiff.read_chunk_header(f)
|
|
||||||
except EOFError:
|
|
||||||
break
|
|
||||||
if v: print 'header:', `type`, size
|
|
||||||
if type == 'COMM':
|
|
||||||
nchannels, nsampframes, sampwidth, samprate = \
|
|
||||||
aiff.read_comm_chunk(f)
|
|
||||||
if v: print nchannels, nsampframes, sampwidth, samprate
|
|
||||||
elif type == 'SSND':
|
|
||||||
offset, blocksize = aiff.read_ssnd_chunk(f)
|
|
||||||
if v: print offset, blocksize
|
|
||||||
data = f.read(size-8)
|
|
||||||
if size%2: void = f.read(1)
|
|
||||||
p = makeport(nchannels, sampwidth, samprate)
|
|
||||||
play(p, data, offset, blocksize)
|
|
||||||
elif type in aiff.skiplist:
|
|
||||||
aiff.skip_chunk(f, size)
|
|
||||||
else:
|
|
||||||
raise aiff.Error, 'bad chunk type ' + type
|
|
||||||
|
|
||||||
def makeport(nchannels, sampwidth, samprate):
|
|
||||||
c = al.newconfig()
|
|
||||||
c.setchannels(nchannels)
|
|
||||||
c.setwidth(sampwidth/8)
|
|
||||||
# can't set the rate...
|
|
||||||
p = al.openport('', 'w', c)
|
|
||||||
return p
|
|
||||||
|
|
||||||
def play(p, data, offset, blocksize):
|
|
||||||
data = data[offset:]
|
|
||||||
p.writesamps(data)
|
|
||||||
while p.getfilled() > 0: time.sleep(0.01)
|
|
||||||
|
|
||||||
main()
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
# Read mono 16bit samples from stdin and write them to the audio device.
|
|
||||||
# Assume the sampling rate is compatible.
|
|
||||||
# Use a small queue size to minimize delays.
|
|
||||||
|
|
||||||
import al, sys
|
|
||||||
import AL
|
|
||||||
|
|
||||||
BUFSIZE = 2000
|
|
||||||
QSIZE = 4000
|
|
||||||
|
|
||||||
def main():
|
|
||||||
c = al.newconfig()
|
|
||||||
c.setchannels(AL.MONO)
|
|
||||||
c.setqueuesize(QSIZE)
|
|
||||||
p = al.openport('', 'w', c)
|
|
||||||
while 1:
|
|
||||||
data = sys.stdin.read(BUFSIZE)
|
|
||||||
p.writesamps(data)
|
|
||||||
|
|
||||||
try:
|
|
||||||
main()
|
|
||||||
except KeyboardInterrupt:
|
|
||||||
sys.exit(1)
|
|
||||||
|
|
@ -1,51 +0,0 @@
|
||||||
# Play old style sound files (Guido's private format)
|
|
||||||
|
|
||||||
import al, sys, time
|
|
||||||
import AL
|
|
||||||
|
|
||||||
BUFSIZE = 8000
|
|
||||||
|
|
||||||
def main():
|
|
||||||
if len(sys.argv) < 2:
|
|
||||||
f = sys.stdin
|
|
||||||
filename = sys.argv[0]
|
|
||||||
else:
|
|
||||||
if len(sys.argv) <> 2:
|
|
||||||
sys.stderr.write('usage: ' + \
|
|
||||||
sys.argv[0] + ' filename\n')
|
|
||||||
sys.exit(2)
|
|
||||||
filename = sys.argv[1]
|
|
||||||
f = open(filename, 'r')
|
|
||||||
#
|
|
||||||
magic = f.read(4)
|
|
||||||
extra = ''
|
|
||||||
if magic == '0008':
|
|
||||||
rate = 8000
|
|
||||||
elif magic == '0016':
|
|
||||||
rate = 16000
|
|
||||||
elif magic == '0032':
|
|
||||||
rate = 32000
|
|
||||||
else:
|
|
||||||
sys.stderr.write('no magic header; assuming 8k samples/sec.\n')
|
|
||||||
rate = 8000
|
|
||||||
extra = magic
|
|
||||||
#
|
|
||||||
pv = [AL.OUTPUT_RATE, rate]
|
|
||||||
al.setparams(AL.DEFAULT_DEVICE, pv)
|
|
||||||
c = al.newconfig()
|
|
||||||
c.setchannels(AL.MONO)
|
|
||||||
c.setwidth(AL.SAMPLE_8)
|
|
||||||
port = al.openport(filename, 'w', c)
|
|
||||||
if extra:
|
|
||||||
port.writesamps(extra)
|
|
||||||
while 1:
|
|
||||||
buf = f.read(BUFSIZE)
|
|
||||||
if not buf: break
|
|
||||||
port.writesamps(buf)
|
|
||||||
while port.getfilled() > 0:
|
|
||||||
time.sleep(0.1)
|
|
||||||
|
|
||||||
try:
|
|
||||||
main()
|
|
||||||
except KeyboardInterrupt:
|
|
||||||
sys.exit(1)
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# radio [port]
|
|
||||||
#
|
|
||||||
# Receive audio packets broadcast by "broadcast.py" on another SGI machine.
|
|
||||||
# Use apanel to set the output sampling rate to match that of the broadcast.
|
|
||||||
|
|
||||||
import sys, al
|
|
||||||
from socket import *
|
|
||||||
|
|
||||||
port = 5555
|
|
||||||
if sys.argv[1:]: port = eval(sys.argv[1])
|
|
||||||
|
|
||||||
s = socket(AF_INET, SOCK_DGRAM)
|
|
||||||
s.bind('', port)
|
|
||||||
|
|
||||||
p = al.openport('radio', 'w')
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
data = s.recv(1400)
|
|
||||||
p.writesamps(data)
|
|
||||||
|
|
@ -1,28 +0,0 @@
|
||||||
#
|
|
||||||
# records an AIFF sample and plays it
|
|
||||||
# infinity number of times.
|
|
||||||
#
|
|
||||||
|
|
||||||
import time
|
|
||||||
import al
|
|
||||||
|
|
||||||
def recordit () :
|
|
||||||
p = al.openport('hello', 'r')
|
|
||||||
print 'recording...'
|
|
||||||
buf = p.readsamps(500000)
|
|
||||||
print 'done.'
|
|
||||||
p.closeport()
|
|
||||||
|
|
||||||
return buf
|
|
||||||
|
|
||||||
def playit (buf) :
|
|
||||||
p = al.openport('hello', 'w')
|
|
||||||
print 'playing...'
|
|
||||||
p.writesamps(buf)
|
|
||||||
while p.getfilled() > 0:
|
|
||||||
time.sleep(0.01)
|
|
||||||
print 'done.'
|
|
||||||
p.closeport()
|
|
||||||
|
|
||||||
while 1 :
|
|
||||||
playit (recordit ())
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
# Record mono 16bits samples from the audio device and send them to stdout.
|
|
||||||
# Assume the sampling rate is compatible.
|
|
||||||
# Use a small queue size to minimize delays.
|
|
||||||
|
|
||||||
import al, sys
|
|
||||||
import AL
|
|
||||||
|
|
||||||
BUFSIZE = 2000
|
|
||||||
QSIZE = 4000
|
|
||||||
|
|
||||||
def main():
|
|
||||||
c = al.newconfig()
|
|
||||||
c.setchannels(AL.MONO)
|
|
||||||
c.setqueuesize(QSIZE)
|
|
||||||
p = al.openport('', 'r', c)
|
|
||||||
while 1:
|
|
||||||
data = p.readsamps(BUFSIZE)
|
|
||||||
sys.stdout.write(data)
|
|
||||||
|
|
||||||
try:
|
|
||||||
main()
|
|
||||||
except KeyboardInterrupt:
|
|
||||||
sys.exit(1)
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
# unicast host [port]
|
|
||||||
#
|
|
||||||
# Similar to "broadcast.py" but sends to a specific host only;
|
|
||||||
# use "radio.py" on the designated host to receive.
|
|
||||||
# This is less stressful on other hosts on the same ethernet segment
|
|
||||||
# if you need to send to one host only.
|
|
||||||
|
|
||||||
import sys, al
|
|
||||||
from socket import *
|
|
||||||
|
|
||||||
host = sys.argv[1]
|
|
||||||
|
|
||||||
port = 5555
|
|
||||||
if sys.argv[2:]: port = eval(sys.argv[1])
|
|
||||||
|
|
||||||
s = socket(AF_INET, SOCK_DGRAM)
|
|
||||||
|
|
||||||
p = al.openport('unicast', 'r')
|
|
||||||
|
|
||||||
address = host, port
|
|
||||||
while 1:
|
|
||||||
# 700 samples equals 1400 bytes, or about the max packet size!
|
|
||||||
data = p.readsamps(700)
|
|
||||||
s.sendto(data, address)
|
|
||||||
|
|
@ -1,12 +0,0 @@
|
||||||
# Demonstrate that rsh exits when the remote end closes std{in,out,err}.
|
|
||||||
# rsh voorn exec /ufs/guido/bin/sgi/python /ufs/guido/mm/demo/audio/x.py
|
|
||||||
|
|
||||||
print 'hoi!'
|
|
||||||
import sys
|
|
||||||
sys.stdin.close()
|
|
||||||
sys.stdout.close()
|
|
||||||
sys.stderr.close()
|
|
||||||
import time
|
|
||||||
time.sleep(5)
|
|
||||||
sys.stdout = open('@', 'w')
|
|
||||||
sys.stdout.write('Hello\n')
|
|
||||||
|
|
@ -1,8 +0,0 @@
|
||||||
Programs that demonstrate the use of the audio device on the SGI 4D/25.
|
|
||||||
These require the built-in module 'audio'.
|
|
||||||
|
|
||||||
XXX This hardware is already obsolete; see ../al for examples of audio
|
|
||||||
XXX on the Indigo and 4D/35.
|
|
||||||
|
|
||||||
play Read a sound sample from a file and play it through the
|
|
||||||
speaker. Options to set volume, sampling rate etc.
|
|
||||||
|
|
@ -1,75 +0,0 @@
|
||||||
#! /usr/bin/env python
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import audio
|
|
||||||
|
|
||||||
import string
|
|
||||||
import getopt
|
|
||||||
import auds
|
|
||||||
|
|
||||||
debug = []
|
|
||||||
|
|
||||||
DEF_RATE = 3
|
|
||||||
|
|
||||||
def main():
|
|
||||||
#
|
|
||||||
gain = 100
|
|
||||||
rate = 0
|
|
||||||
starter = audio.write
|
|
||||||
stopper = 0
|
|
||||||
#
|
|
||||||
optlist, args = getopt.getopt(sys.argv[1:], 'adg:r:')
|
|
||||||
#
|
|
||||||
for optname, optarg in optlist:
|
|
||||||
if 0:
|
|
||||||
pass
|
|
||||||
elif optname == '-d':
|
|
||||||
debug.append(1)
|
|
||||||
elif optname == '-g':
|
|
||||||
gain = string.atoi(optarg)
|
|
||||||
if not (0 < gain < 256):
|
|
||||||
raise optarg.error, '-g gain out of range'
|
|
||||||
elif optname == '-r':
|
|
||||||
rate = string.atoi(optarg)
|
|
||||||
if not (1 <= rate <= 3):
|
|
||||||
raise optarg.error, '-r rate out of range'
|
|
||||||
elif optname == '-a':
|
|
||||||
starter = audio.start_playing
|
|
||||||
stopper = audio.wait_playing
|
|
||||||
#
|
|
||||||
audio.setoutgain(gain)
|
|
||||||
audio.setrate(rate)
|
|
||||||
#
|
|
||||||
if not args:
|
|
||||||
play(starter, rate, auds.loadfp(sys.stdin))
|
|
||||||
else:
|
|
||||||
real_stopper = 0
|
|
||||||
for file in args:
|
|
||||||
if real_stopper:
|
|
||||||
real_stopper()
|
|
||||||
play(starter, rate, auds.load(file))
|
|
||||||
real_stopper = stopper
|
|
||||||
|
|
||||||
def play(starter, rate, data):
|
|
||||||
magic = data[:4]
|
|
||||||
if magic == '0008':
|
|
||||||
mrate = 3
|
|
||||||
elif magic == '0016':
|
|
||||||
mrate = 2
|
|
||||||
elif magic == '0032':
|
|
||||||
mrate = 1
|
|
||||||
else:
|
|
||||||
mrate = 0
|
|
||||||
if mrate:
|
|
||||||
data = data[4:]
|
|
||||||
else:
|
|
||||||
mrate = DEF_RATE
|
|
||||||
if not rate: rate = mrate
|
|
||||||
audio.setrate(rate)
|
|
||||||
starter(data)
|
|
||||||
|
|
||||||
try:
|
|
||||||
main()
|
|
||||||
finally:
|
|
||||||
audio.setoutgain(0)
|
|
||||||
audio.done()
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
Demo programs for the SGI Video library for the Indigo (IRIX 4.0.5).
|
|
||||||
|
|
||||||
These are more-or-less literal translations of the C programs from the
|
|
||||||
Indigo Video Programming Guide, by Sjoerd Mullender, with some changes
|
|
||||||
by Guido.
|
|
||||||
|
|
||||||
Note that none of the example programs save any data to a file,
|
|
||||||
although this would be easy to do (e.g. individual grabbed frames
|
|
||||||
could be written as SGI image files using the imgfile module).
|
|
||||||
|
|
||||||
We have written a Python program to record live video to file (within
|
|
||||||
the limits of the Indigo video board), and a suite of programs to
|
|
||||||
manipulate and display such files. At the moment we don't distribute
|
|
||||||
these programs, since the file format is, eh..., weird, to say the
|
|
||||||
least. However, if you are really interested we can mail you the
|
|
||||||
source.
|
|
||||||
|
|
||||||
Also note that we haven't tried using video *output* yet.
|
|
||||||
|
|
||||||
simpleinput.py Live video in a resizable window
|
|
||||||
rgbgrab.py Grab still frames
|
|
||||||
contcapt.py Continuous capturing
|
|
||||||
burstcapt.py Burst capturing
|
|
||||||
|
|
@ -1,52 +0,0 @@
|
||||||
import sys
|
|
||||||
import sv, SV
|
|
||||||
import gl, GL, DEVICE
|
|
||||||
|
|
||||||
def main():
|
|
||||||
format = SV.RGB8_FRAMES
|
|
||||||
requestedwidth = SV.PAL_XMAX
|
|
||||||
queuesize = 30
|
|
||||||
if sys.argv[1:]:
|
|
||||||
queuesize = eval(sys.argv[1])
|
|
||||||
|
|
||||||
v = sv.OpenVideo()
|
|
||||||
svci = (format, requestedwidth, 0, queuesize, 0)
|
|
||||||
|
|
||||||
go = raw_input('Press return to capture ' + `queuesize` + ' frames: ')
|
|
||||||
result = v.CaptureBurst(svci)
|
|
||||||
svci, buffer, bitvec = result
|
|
||||||
## svci, buffer = result # XXX If bit vector not yet implemented
|
|
||||||
|
|
||||||
print 'Captured', svci[3], 'frames, i.e.', len(buffer)/1024, 'K bytes'
|
|
||||||
|
|
||||||
w, h = svci[1:3]
|
|
||||||
framesize = w * h
|
|
||||||
|
|
||||||
gl.prefposition(300, 300+w-1, 100, 100+h-1)
|
|
||||||
gl.foreground()
|
|
||||||
win = gl.winopen('Burst Capture')
|
|
||||||
gl.RGBmode()
|
|
||||||
gl.gconfig()
|
|
||||||
gl.qdevice(DEVICE.LEFTMOUSE)
|
|
||||||
gl.qdevice(DEVICE.ESCKEY)
|
|
||||||
|
|
||||||
print 'Click left mouse for next frame'
|
|
||||||
|
|
||||||
for i in range(svci[3]):
|
|
||||||
inverted_frame = sv.RGB8toRGB32(1, \
|
|
||||||
buffer[i*framesize:(i+1)*framesize], w, h)
|
|
||||||
gl.lrectwrite(0, 0, w-1, h-1, inverted_frame)
|
|
||||||
while 1:
|
|
||||||
dev, val = gl.qread()
|
|
||||||
if dev == DEVICE.LEFTMOUSE and val == 1:
|
|
||||||
break
|
|
||||||
if dev == DEVICE.REDRAW:
|
|
||||||
gl.lrectwrite(0, 0, w-1, h-1, inverted_frame)
|
|
||||||
if dev == DEVICE.ESCKEY:
|
|
||||||
v.CloseVideo()
|
|
||||||
gl.winclose(win)
|
|
||||||
return
|
|
||||||
v.CloseVideo()
|
|
||||||
gl.winclose(win)
|
|
||||||
|
|
||||||
main()
|
|
||||||
|
|
@ -1,107 +0,0 @@
|
||||||
import sys
|
|
||||||
import sv, SV
|
|
||||||
import gl, GL, DEVICE
|
|
||||||
|
|
||||||
def main():
|
|
||||||
format = SV.RGB8_FRAMES
|
|
||||||
framerate = 25
|
|
||||||
queuesize = 16
|
|
||||||
samplingrate = 2
|
|
||||||
|
|
||||||
v = sv.OpenVideo()
|
|
||||||
# Determine maximum window size based on signal standard
|
|
||||||
param = [SV.BROADCAST, 0]
|
|
||||||
v.GetParam(param)
|
|
||||||
if param[1] == SV.PAL:
|
|
||||||
width = SV.PAL_XMAX
|
|
||||||
height = SV.PAL_YMAX
|
|
||||||
framefreq = 25
|
|
||||||
else:
|
|
||||||
width = SV.NTSC_XMAX
|
|
||||||
height = SV.NTSC_YMAX
|
|
||||||
framefreq = 30
|
|
||||||
|
|
||||||
# Allow resizing window if capturing RGB frames, which can be scaled
|
|
||||||
if format == SV.RGB8_FRAMES:
|
|
||||||
gl.keepaspect(width, height)
|
|
||||||
gl.maxsize(width, height)
|
|
||||||
gl.stepunit(8, 6)
|
|
||||||
gl.minsize(120, 90)
|
|
||||||
else:
|
|
||||||
if format == SV.YUV411_FRAMES_AND_BLANKING_BUFFER:
|
|
||||||
height = height + SV.BLANKING_BUFFER_SIZE
|
|
||||||
gl.prefposition(300, 300+width-1, 100, 100+height-1)
|
|
||||||
|
|
||||||
# Open the window
|
|
||||||
gl.foreground()
|
|
||||||
win = gl.winopen('Continuous Capture')
|
|
||||||
gl.RGBmode()
|
|
||||||
gl.gconfig()
|
|
||||||
if format == SV.RGB8_FRAMES:
|
|
||||||
width, height = gl.getsize()
|
|
||||||
gl.pixmode(GL.PM_SIZE, 8)
|
|
||||||
else:
|
|
||||||
gl.pixmode(GL.PM_SIZE, 32)
|
|
||||||
|
|
||||||
svci = (format, width, height, queuesize, samplingrate)
|
|
||||||
[svci]
|
|
||||||
|
|
||||||
svci = v.InitContinuousCapture(svci)
|
|
||||||
width, height = svci[1:3]
|
|
||||||
[svci]
|
|
||||||
|
|
||||||
hz = gl.getgdesc(GL.GD_TIMERHZ)
|
|
||||||
gl.noise(DEVICE.TIMER0, hz / framerate)
|
|
||||||
gl.qdevice(DEVICE.TIMER0)
|
|
||||||
gl.qdevice(DEVICE.WINQUIT)
|
|
||||||
gl.qdevice(DEVICE.WINSHUT)
|
|
||||||
gl.qdevice(DEVICE.ESCKEY)
|
|
||||||
|
|
||||||
ndisplayed = 0
|
|
||||||
lastfieldID = 0
|
|
||||||
|
|
||||||
while 1:
|
|
||||||
dev, val = gl.qread()
|
|
||||||
if dev == DEVICE.REDRAW:
|
|
||||||
oldw = width
|
|
||||||
oldh = height
|
|
||||||
width, height = gl.getsize()
|
|
||||||
if oldw != width or oldh != height:
|
|
||||||
v.EndContinuousCapture()
|
|
||||||
gl.viewport(0, width-1, 0, height-1)
|
|
||||||
svci = (svci[0], width, height) + svci[3:]
|
|
||||||
svci = v.InitContinuousCapture(svci)
|
|
||||||
width, height = svci[1:3]
|
|
||||||
[svci]
|
|
||||||
if ndisplayed:
|
|
||||||
print 'lost',
|
|
||||||
print fieldID/(svci[4]*2) - ndisplayed,
|
|
||||||
print 'frames'
|
|
||||||
ndisplayed = 0
|
|
||||||
elif dev == DEVICE.TIMER0:
|
|
||||||
try:
|
|
||||||
captureData, fieldID = v.GetCaptureData()
|
|
||||||
except sv.error, val:
|
|
||||||
if val <> 'no data available':
|
|
||||||
print val
|
|
||||||
continue
|
|
||||||
if fieldID - lastfieldID <> 2*samplingrate:
|
|
||||||
print lastfieldID, fieldID
|
|
||||||
lastfieldID = fieldID
|
|
||||||
if svci[0] == SV.RGB8_FRAMES:
|
|
||||||
rgbbuf = captureData.InterleaveFields(1)
|
|
||||||
else:
|
|
||||||
rgbbuf = captureData.YUVtoRGB(1)
|
|
||||||
captureData.UnlockCaptureData()
|
|
||||||
gl.lrectwrite(0, 0, width-1, height-1, rgbbuf)
|
|
||||||
ndisplayed = ndisplayed + 1
|
|
||||||
elif dev in (DEVICE.ESCKEY, DEVICE.WINQUIT, DEVICE.WINSHUT):
|
|
||||||
v.EndContinuousCapture()
|
|
||||||
v.CloseVideo()
|
|
||||||
gl.winclose(win)
|
|
||||||
print fieldID, ndisplayed, svci[4]
|
|
||||||
print 'lost', fieldID/(svci[4]*2) - ndisplayed,
|
|
||||||
print 'frames'
|
|
||||||
return
|
|
||||||
|
|
||||||
main()
|
|
||||||
|
|
@ -1,81 +0,0 @@
|
||||||
import sys
|
|
||||||
import sv, SV
|
|
||||||
import gl, GL, DEVICE
|
|
||||||
import time
|
|
||||||
|
|
||||||
def main():
|
|
||||||
v = sv.OpenVideo()
|
|
||||||
# Determine maximum window size based on signal standard
|
|
||||||
param = [SV.BROADCAST, 0]
|
|
||||||
v.GetParam(param)
|
|
||||||
if param[1] == SV.PAL:
|
|
||||||
width = SV.PAL_XMAX
|
|
||||||
height = SV.PAL_YMAX
|
|
||||||
elif param[1] == SV.NTSC:
|
|
||||||
width = SV.NTSC_XMAX
|
|
||||||
height = SV.NTSC_YMAX
|
|
||||||
else:
|
|
||||||
print 'Unknown video standard', param[1]
|
|
||||||
sys.exit(1)
|
|
||||||
|
|
||||||
# Initially all windows are half size
|
|
||||||
grabwidth, grabheight = width/2, height/2
|
|
||||||
|
|
||||||
# Open still window
|
|
||||||
gl.foreground()
|
|
||||||
gl.prefsize(grabwidth, grabheight)
|
|
||||||
still_win = gl.winopen('Grabbed frame')
|
|
||||||
gl.keepaspect(width, height)
|
|
||||||
gl.maxsize(width, height)
|
|
||||||
gl.winconstraints()
|
|
||||||
gl.RGBmode()
|
|
||||||
gl.gconfig()
|
|
||||||
gl.clear()
|
|
||||||
gl.pixmode(GL.PM_SIZE, 8)
|
|
||||||
|
|
||||||
# Open live window
|
|
||||||
gl.foreground()
|
|
||||||
gl.prefsize(grabwidth, grabheight)
|
|
||||||
live_win = gl.winopen('Live video')
|
|
||||||
gl.keepaspect(width, height)
|
|
||||||
gl.maxsize(width, height)
|
|
||||||
gl.winconstraints()
|
|
||||||
|
|
||||||
# Bind live video
|
|
||||||
v.SetSize(gl.getsize())
|
|
||||||
v.BindGLWindow(live_win, SV.IN_REPLACE)
|
|
||||||
|
|
||||||
print 'Use leftmouse to grab frame'
|
|
||||||
|
|
||||||
gl.qdevice(DEVICE.LEFTMOUSE)
|
|
||||||
gl.qdevice(DEVICE.WINQUIT)
|
|
||||||
gl.qdevice(DEVICE.WINSHUT)
|
|
||||||
gl.qdevice(DEVICE.ESCKEY)
|
|
||||||
frame = None
|
|
||||||
while 1:
|
|
||||||
dev, val = gl.qread()
|
|
||||||
if dev == DEVICE.LEFTMOUSE and val == 0:
|
|
||||||
w, h, fields = v.CaptureOneFrame(SV.RGB8_FRAMES, \
|
|
||||||
grabwidth, grabheight)
|
|
||||||
frame = sv.InterleaveFields(1, fields, w, h)
|
|
||||||
gl.winset(still_win)
|
|
||||||
gl.lrectwrite(0, 0, w - 1, h - 1, frame)
|
|
||||||
gl.winset(live_win)
|
|
||||||
if dev in (DEVICE.ESCKEY, DEVICE.WINQUIT, DEVICE.WINSHUT):
|
|
||||||
v.CloseVideo()
|
|
||||||
gl.winclose(live_win)
|
|
||||||
gl.winclose(still_win)
|
|
||||||
break
|
|
||||||
if dev == DEVICE.REDRAW and val == still_win:
|
|
||||||
gl.winset(still_win)
|
|
||||||
gl.reshapeviewport()
|
|
||||||
gl.clear()
|
|
||||||
grabwidth, grabheight = gl.getsize()
|
|
||||||
if frame:
|
|
||||||
gl.lrectwrite(0, 0, w - 1, h - 1, frame)
|
|
||||||
gl.winset(live_win)
|
|
||||||
if dev == DEVICE.REDRAW and val == live_win:
|
|
||||||
v.SetSize(gl.getsize())
|
|
||||||
v.BindGLWindow(live_win, SV.IN_REPLACE)
|
|
||||||
|
|
||||||
main()
|
|
||||||
|
|
@ -1,22 +0,0 @@
|
||||||
import sv, SV
|
|
||||||
import gl, DEVICE
|
|
||||||
|
|
||||||
def main():
|
|
||||||
gl.foreground()
|
|
||||||
gl.prefsize(SV.PAL_XMAX, SV.PAL_YMAX)
|
|
||||||
win = gl.winopen('video test')
|
|
||||||
v = sv.OpenVideo()
|
|
||||||
params = [SV.VIDEO_MODE, SV.COMP, SV.BROADCAST, SV.PAL]
|
|
||||||
v.SetParam(params)
|
|
||||||
v.BindGLWindow(win, SV.IN_REPLACE)
|
|
||||||
gl.qdevice(DEVICE.ESCKEY)
|
|
||||||
gl.qdevice(DEVICE.WINQUIT)
|
|
||||||
gl.qdevice(DEVICE.WINSHUT)
|
|
||||||
while 1:
|
|
||||||
dev, val = gl.qread()
|
|
||||||
if dev in (DEVICE.ESCKEY, DEVICE.WINSHUT, DEVICE.WINQUIT):
|
|
||||||
v.CloseVideo()
|
|
||||||
gl.winclose(win)
|
|
||||||
return
|
|
||||||
|
|
||||||
main()
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue