Initial revision
This commit is contained in:
Guido van Rossum
parent
baf0ebf43c
commit
e4bddeae23
|
|
@ -0,0 +1,56 @@
|
|||
This directory contains Python and C code we wrote while we had a
|
||||
framegrabber board on loan from SGI.
|
||||
|
||||
--Guido and Jack
|
||||
|
||||
cam.py network real-time tv broadcast; see tv.py
|
||||
usage: cam [packfactor [host]]
|
||||
specifying 'all' for host broadcasts
|
||||
|
||||
camcorder.py record video movies or make snapshots (in movie format)
|
||||
usage: camcorder [-c] [-a audiohost [-s]] [moviefile]
|
||||
-c color (default b/w, packfactor = 2)
|
||||
-a audiohost syncaudio is running on audiohost
|
||||
-s start syncaudio (on audiohost)
|
||||
moviefile (default film.video)
|
||||
keyboard commands:
|
||||
s stop grabbing (single step if already stopped)
|
||||
c continuous grabbing
|
||||
r start recording
|
||||
p pause recording (record single frame if paused)
|
||||
ESC quit
|
||||
|
||||
statit.py various statistics operations on movie files
|
||||
|
||||
syncaudio.py record audio synchronized with camcorder -a
|
||||
usage: syncaudio videohost soundfile
|
||||
soundfile format: 16 bits, 16khz, mono
|
||||
|
||||
tv.py receiver for transmissions from cam.py
|
||||
|
||||
video.py player for movies recorded by camcorder.py
|
||||
usage: video [moviefile [soundfile]]
|
||||
default moviefile is film.video
|
||||
default sound is no sound
|
||||
|
||||
vinfo.py print a summary of a movie file
|
||||
|
||||
vtime.py virtual time module imported by syncaudio.py and camcorder.py
|
||||
|
||||
|
||||
These are C programs, either for efficiency or because they need to
|
||||
link with a C library.
|
||||
|
||||
squash.c make a movie smaller by averaging pixels
|
||||
usage: squash factor [bits] <moviefile >newmoviefile
|
||||
factor x and y compression factor
|
||||
bits #bits left per sample in result (default 8)
|
||||
|
||||
squash2.c make a movie smaller by dropping pixels
|
||||
usage: squash2 factor <moviefile >newmoviefile
|
||||
factor x and y compression factor
|
||||
|
||||
tomono.c like squash2 but outputs a monochrome movie
|
||||
|
||||
v2i.c convert the first image of a movie file to SGI .rgb format
|
||||
link with -limage
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
import sys
|
||||
from socket import *
|
||||
from gl import *
|
||||
from GL import *
|
||||
from DEVICE import *
|
||||
from time import millitimer
|
||||
|
||||
HS = 40 # Header size (must be same as in tv.py)
|
||||
|
||||
# Rely on UDP packet (de)fragmentation for smoother images
|
||||
# (Changed for broadcast)
|
||||
MAX = 16000
|
||||
|
||||
PF = 2 # Default packfactor
|
||||
|
||||
# Default receiver station is voorn.
|
||||
# Kwik has no yellow pages, so...
|
||||
HOST = '192.16.201.121'
|
||||
PORT = 5555
|
||||
|
||||
if sys.argv[1:]:
|
||||
PF = eval(sys.argv[1])
|
||||
|
||||
if sys.argv[2:]:
|
||||
HOST = sys.argv[2]
|
||||
if HOST = 'all':
|
||||
HOST = '<broadcast>'
|
||||
MAX = 1400
|
||||
|
||||
PF2 = PF*PF
|
||||
|
||||
def main():
|
||||
centerx, centery = 400, 300
|
||||
|
||||
foreground()
|
||||
wid = winopen('cam')
|
||||
RGBmode()
|
||||
doublebuffer()
|
||||
gconfig()
|
||||
qdevice(ESCKEY)
|
||||
|
||||
w, h = getsize()
|
||||
ortho2(0, w, 0, h)
|
||||
w = w/PF*PF
|
||||
h = h/PF*PF
|
||||
|
||||
readsource(SRC_FRAMEGRABBER)
|
||||
|
||||
s = socket(AF_INET, SOCK_DGRAM)
|
||||
if HOST = '<broadcast>':
|
||||
s.allowbroadcast(1)
|
||||
addr = HOST, PORT
|
||||
|
||||
bytesperline = w/PF2
|
||||
linesperchunk = MAX/bytesperline
|
||||
linesperchunk = linesperchunk/PF*PF
|
||||
nchunks = (h+linesperchunk-1)/linesperchunk
|
||||
|
||||
print 'MAX=', MAX,
|
||||
print 'linesperchunk=', linesperchunk,
|
||||
print 'nchunks=', nchunks,
|
||||
print 'w=', w, 'h=', h
|
||||
|
||||
x1, x2 = 0, w-1
|
||||
|
||||
t1 = millitimer()
|
||||
nframes = 0
|
||||
fps = 0
|
||||
|
||||
msg = ''
|
||||
|
||||
while 1:
|
||||
while qtest():
|
||||
dev, val = qread()
|
||||
if dev = REDRAW:
|
||||
reshapeviewport()
|
||||
w, h = getsize()
|
||||
ortho2(0, w, 0, h)
|
||||
w = w/PF*PF
|
||||
h = h/PF*PF
|
||||
|
||||
bytesperline = w/PF2
|
||||
linesperchunk = MAX/bytesperline
|
||||
linesperchunk = linesperchunk/PF*PF
|
||||
nchunks = (h+linesperchunk-1)/linesperchunk
|
||||
|
||||
print 'MAX=', MAX,
|
||||
print 'linesperchunk=', linesperchunk,
|
||||
print 'nchunks=', nchunks,
|
||||
print 'w=', w, 'h=', h
|
||||
|
||||
x1, x2 = 0, w-1
|
||||
|
||||
fps = 0
|
||||
|
||||
elif dev = ESCKEY:
|
||||
winclose(wid)
|
||||
return
|
||||
|
||||
readsource(SRC_FRAMEGRABBER)
|
||||
|
||||
nframes = nframes+1
|
||||
if nframes >= fps:
|
||||
t2 = millitimer()
|
||||
if t2 <> t1:
|
||||
fps = int(10000.0*nframes/(t2-t1)) * 0.1
|
||||
msg = `fps` + ' frames/sec'
|
||||
t1 = t2
|
||||
nframes = 0
|
||||
|
||||
RGBcolor(255,255,255)
|
||||
cmov2i(9,9)
|
||||
charstr(msg)
|
||||
|
||||
swapbuffers()
|
||||
rectcopy(centerx-w/2, centery-w/2, centerx+w/2, centery+w/2, 0, 0)
|
||||
|
||||
for i in range(nchunks):
|
||||
y1 = i*linesperchunk
|
||||
y2 = y1 + linesperchunk-1
|
||||
if y2 >= h: y2 = h-1
|
||||
data = lrectread(x1, y1, x2, y2)
|
||||
data2 = packrect(x2-x1+1, y2-y1+1, PF, data)
|
||||
prefix = `w, h, PF, x1, y1, x2, y2`
|
||||
prefix = prefix + ' ' * (HS-len(prefix))
|
||||
data3 = prefix + data2
|
||||
s.sendto(data3, addr)
|
||||
|
||||
main()
|
||||
|
|
@ -0,0 +1,197 @@
|
|||
#!/ufs/guido/bin/sgi/python3.3
|
||||
from gl import *
|
||||
from GL import *
|
||||
from DEVICE import *
|
||||
import time
|
||||
import sys
|
||||
import getopt
|
||||
import socket
|
||||
import posix
|
||||
import vtime
|
||||
|
||||
SYNCPORT = 10000
|
||||
CTLPORT = 10001
|
||||
|
||||
VP_GBXORG = 0x1000001
|
||||
VP_GBYORG = 0x1000002
|
||||
VP_FBXORG = 0x1000003
|
||||
VP_FBYORG = 0x1000004
|
||||
VP_WIDTH = 0x1000005
|
||||
VP_HEIGHT = 0x1000006
|
||||
|
||||
class Struct(): pass
|
||||
epoch = Struct()
|
||||
|
||||
def getvideosize():
|
||||
w = getvideo(VP_WIDTH)
|
||||
h = getvideo(VP_HEIGHT)
|
||||
print getvideo(VP_GBXORG), getvideo(VP_GBYORG)
|
||||
print getvideo(VP_FBXORG), getvideo(VP_FBYORG)
|
||||
x = 0
|
||||
y = 0
|
||||
return x,y,w,h
|
||||
def saveframe(f,x,y,w,h,pf, notime):
|
||||
readsource(SRC_FRONT)
|
||||
if pf:
|
||||
w = w/pf*pf
|
||||
h = h/pf*pf
|
||||
data = None
|
||||
data = lrectread(x,y,x+w-1,y+h-1)
|
||||
if pf: data = packrect(w,h,pf,data)
|
||||
if notime: t = 0
|
||||
else: t = time.millitimer()-epoch.epoch
|
||||
f.write(`t` + ',' + `len(data)` + '\n')
|
||||
f.write(data)
|
||||
readsource(SRC_FRAMEGRABBER)
|
||||
def drawframe(x,y,w,h,col):
|
||||
drawmode(OVERDRAW)
|
||||
color(col)
|
||||
bgnline()
|
||||
v2i(x-1,y-1) ; v2i(x+w,y-1); v2i(x+w,y+h); v2i(x-1,y+h); v2i(x-1,y-1)
|
||||
endline()
|
||||
drawmode(NORMALDRAW)
|
||||
def main():
|
||||
foreground()
|
||||
pf = 2
|
||||
ausync = 0
|
||||
austart = 0
|
||||
optlist, args = getopt.getopt(sys.argv[1:],'ca:s')
|
||||
for opt, arg in optlist:
|
||||
if opt = '-c':
|
||||
pf = 0
|
||||
elif opt = '-a':
|
||||
ausync = 1
|
||||
aumachine = arg
|
||||
elif opt = '-s':
|
||||
austart = 1
|
||||
else:
|
||||
print 'Usage: camcorder [-c] [-a audiomachine [-s]]'
|
||||
sys.exit(1)
|
||||
if austart:
|
||||
if not ausync:
|
||||
print 'Cannot use -s without -a'
|
||||
sys.exit(1)
|
||||
print 'Starting audio recorder...'
|
||||
posix.system('rsh '+aumachine+' syncrecord '+socket.gethostname()+' &')
|
||||
if ausync:
|
||||
print 'Syncing to audio recorder...'
|
||||
globtime = vtime.VTime().init(1,aumachine,SYNCPORT)
|
||||
ctl = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
|
||||
ctl.bind((socket.gethostname(),CTLPORT))
|
||||
aua = (socket.gethostbyname(aumachine), CTLPORT)
|
||||
print 'Done.'
|
||||
vidx, vidy, w, h = getvideosize()
|
||||
prefsize(w,h)
|
||||
win = winopen('Camcorder')
|
||||
if len(args) > 1:
|
||||
f = open(args, 'w')
|
||||
else:
|
||||
f = open('film.video', 'w')
|
||||
w, h = getsize()
|
||||
realw, realh = w, h
|
||||
doublebuffer()
|
||||
RGBmode()
|
||||
gconfig()
|
||||
qdevice(LEFTMOUSE)
|
||||
qdevice(RKEY)
|
||||
qdevice(SKEY)
|
||||
qdevice(CKEY)
|
||||
qdevice(PKEY)
|
||||
qdevice(ESCKEY)
|
||||
inrunning = 1
|
||||
outrunning = 0
|
||||
stop = 'stop'
|
||||
readsource(SRC_FRAMEGRABBER)
|
||||
mousing = 0
|
||||
epoch.epoch = time.millitimer()
|
||||
stoptime = epoch.epoch
|
||||
sizewritten = 0
|
||||
x, y = realw/4, realh/4
|
||||
w, h = w/2, h/2
|
||||
drawframe(x,y,w,h,1)
|
||||
nframe = 0
|
||||
try:
|
||||
num = 0
|
||||
while 1:
|
||||
insingle = 0
|
||||
outsingle = 0
|
||||
if mousing:
|
||||
drawframe(x,y,w,h,0)
|
||||
ox, oy = getorigin()
|
||||
if sizewritten:
|
||||
x = getvaluator(MOUSEX)-ox
|
||||
y = getvaluator(MOUSEY)-oy
|
||||
else:
|
||||
w = getvaluator(MOUSEX)-x-ox
|
||||
h = getvaluator(MOUSEY)-y-oy
|
||||
drawframe(x,y,w,h,1)
|
||||
if qtest():
|
||||
ev, val = qread()
|
||||
if ev = LEFTMOUSE and val = 1:
|
||||
drawframe(x,y,w,h,0)
|
||||
mousing = 1
|
||||
ox, oy = getorigin()
|
||||
x = getvaluator(MOUSEX)-ox
|
||||
y = getvaluator(MOUSEY)-oy
|
||||
elif ev = LEFTMOUSE and val = 0:
|
||||
mousing = 0
|
||||
if not sizewritten:
|
||||
f.write('CMIF video 1.0\n')
|
||||
f.write(`w,h,pf` + '\n')
|
||||
sizewritten = 1
|
||||
if ev = RKEY and val = 1:
|
||||
if not inrunning:
|
||||
ringbell()
|
||||
else:
|
||||
outrunning = 1
|
||||
wasstopped = time.millitimer() - stoptime
|
||||
epoch.epoch = epoch.epoch + wasstopped
|
||||
nframe = 0
|
||||
starttime = time.millitimer()
|
||||
if ausync:
|
||||
ctl.sendto(`(1,starttime)`, aua)
|
||||
elif ev = PKEY and val = 1 and outrunning:
|
||||
outrunning = 0
|
||||
stoptime = time.millitimer()
|
||||
if ausync:
|
||||
ctl.sendto(`(0,stoptime)`, aua)
|
||||
nf = nframe * 1000.0 / (time.millitimer()-starttime)
|
||||
drawmode(OVERDRAW)
|
||||
color(0)
|
||||
clear()
|
||||
color(1)
|
||||
cmov2i(5,5)
|
||||
charstr('Recorded ' + `nf` + ' frames/sec')
|
||||
drawmode(NORMALDRAW)
|
||||
elif ev = PKEY and val = 1 and not outrunning:
|
||||
outsingle = 1
|
||||
elif ev = CKEY and val = 1:
|
||||
inrunning = 1
|
||||
elif ev = SKEY and val = 1:
|
||||
if outrunning:
|
||||
ringbell()
|
||||
elif inrunning:
|
||||
inrunning = 0
|
||||
else:
|
||||
insingle = 1
|
||||
elif ev = ESCKEY:
|
||||
if ausync:
|
||||
ctl.sendto(`(2,time.millitimer())`, aua)
|
||||
raise stop
|
||||
if inrunning or insingle:
|
||||
rectcopy(vidx,vidy,realw,realh,0,0)
|
||||
swapbuffers()
|
||||
if outrunning or outsingle:
|
||||
nframe = nframe + 1
|
||||
if not sizewritten:
|
||||
f.write('CMIF video 1.0\n')
|
||||
f.write(`w,h,pf` + '\n')
|
||||
sizewritten = 1
|
||||
saveframe(f, x, y, w, h, pf, outsingle)
|
||||
except stop:
|
||||
pass
|
||||
drawmode(OVERDRAW)
|
||||
color(0)
|
||||
clear()
|
||||
#
|
||||
main()
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#include <stdio.h>
|
||||
|
||||
long *bm;
|
||||
long h, w;
|
||||
long factor;
|
||||
|
||||
#define OC(x,xi) ((x)*factor+(xi))
|
||||
#define BM(x,xi,y,yi) bm[OC(y,yi)*w+OC(x,xi)]
|
||||
|
||||
#define COMP(r,g,b) ((r) | ((g)<<8) | ((b) << 16))
|
||||
|
||||
#define R(comp) ((comp) & 0xff)
|
||||
#define G(comp) (((comp)>>8) & 0xff)
|
||||
#define B(comp) (((comp)>>16) & 0xff)
|
||||
|
||||
main(argc, argv)
|
||||
char **argv;
|
||||
{
|
||||
char lbuf[100];
|
||||
int nh, nw;
|
||||
int x, y, xi, yi;
|
||||
int num;
|
||||
int r, g, b;
|
||||
long data;
|
||||
long *nbm, *nbmp;
|
||||
int i;
|
||||
int bits, mask, roundbit, addbit;
|
||||
int pf;
|
||||
int newfmt = 0;
|
||||
|
||||
if( argc != 2 && argc != 3) {
|
||||
fprintf(stderr, "Usage: squash factor [bits]\n");
|
||||
exit(1);
|
||||
}
|
||||
factor = atoi(argv[1]);
|
||||
if ( argc > 2 ) {
|
||||
bits = atoi(argv[2]);
|
||||
mask = (1 << bits) - 1;
|
||||
mask <<= (8-bits);
|
||||
roundbit = 1 << (7-bits);
|
||||
addbit = 1 << (8-bits);
|
||||
fprintf(stderr, "%x %x %x\n", mask, roundbit, addbit);
|
||||
} else {
|
||||
mask = 0xff;
|
||||
roundbit = 0;
|
||||
addbit = 0;
|
||||
}
|
||||
gets(lbuf);
|
||||
if ( strncmp( lbuf, "CMIF", 4) == 0 ) {
|
||||
newfmt = 1;
|
||||
gets(lbuf);
|
||||
if( sscanf(lbuf, "(%d,%d,%d)", &w, &h, &pf) != 3) {
|
||||
fprintf(stderr, "%s: bad size spec: %s\n", argv[0], lbuf);
|
||||
exit(1);
|
||||
}
|
||||
if ( pf != 0 ) {
|
||||
fprintf(stderr, "%s: packed file\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
} else {
|
||||
if ( sscanf(lbuf, "(%d,%d)", &w, &h) != 2) {
|
||||
fprintf(stderr, "%s: bad size spec: %s\n", argv[0], lbuf);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
nh = h / factor;
|
||||
nw = w / factor;
|
||||
if ( newfmt )
|
||||
printf("CMIF video 1.0\n(%d,%d,%d)\n", nw, nh, 0);
|
||||
else
|
||||
printf("(%d,%d)\n", nw, nh);
|
||||
if ( (bm = (long *)malloc(h*w*sizeof(long))) == 0) {
|
||||
fprintf(stderr, "%s: No memory\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
if ( (nbm = (long *)malloc(nh*nw*sizeof(long))) == 0) {
|
||||
fprintf(stderr, "%s: No memory\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
while( !feof(stdin) ) {
|
||||
gets(lbuf);
|
||||
if ( feof(stdin) ) break;
|
||||
puts(lbuf);
|
||||
fprintf(stderr, "Reading %d\n", h*w*sizeof(long));
|
||||
if ( (i=fread(bm, 1, h*w*sizeof(long), stdin)) != h*w*sizeof(long)) {
|
||||
fprintf(stderr, "%s: short read, %d wanted %d\n", argv[0],
|
||||
i, h*w*sizeof(long));
|
||||
exit(1);
|
||||
}
|
||||
nbmp = nbm;
|
||||
for( y=0; y<nh; y++) {
|
||||
for ( x=0; x<nw; x++) {
|
||||
r = g = b = 0;
|
||||
num = 0;
|
||||
for( xi=0; xi<factor; xi++ ) {
|
||||
for(yi=0; yi<factor; yi++) {
|
||||
if ( y*factor+yi < h && x*factor+xi < w ) {
|
||||
num++;
|
||||
data = BM(x,xi,y,yi);
|
||||
r += R(data);
|
||||
g += G(data);
|
||||
b += B(data);
|
||||
}
|
||||
else fprintf(stderr, "skip %d %d %d %d\n", x, xi, y, yi);
|
||||
}
|
||||
}
|
||||
r = r/num; g = g/num; b = b/num;
|
||||
if ( (r & mask) != mask && ( r & roundbit) ) r += addbit;
|
||||
if ( (g & mask) != mask && ( g & roundbit) ) g += addbit;
|
||||
if ( (b & mask) != mask && ( b & roundbit) ) b += addbit;
|
||||
data = COMP(r, g, b);
|
||||
*nbmp++ = data;
|
||||
}
|
||||
}
|
||||
if (nbmp - nbm != nh * nw ) fprintf(stderr, "%d %d\n", nbmp-nbm, nh*nw);
|
||||
fprintf(stderr, "Writing %d\n", (nbmp-nbm)*sizeof(long));
|
||||
fwrite(nbm, 1, (nbmp-nbm)*sizeof(long), stdout);
|
||||
}
|
||||
exit(0);
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include <stdio.h>
|
||||
|
||||
long *bm;
|
||||
long h, w;
|
||||
long factor;
|
||||
|
||||
#define OC(x,xi) ((x)*factor+(xi))
|
||||
#define BM(x,xi,y,yi) bm[OC(y,yi)*w+OC(x,xi)]
|
||||
|
||||
#define COMP(r,g,b) ((r) | ((g)<<8) | ((b) << 16))
|
||||
|
||||
#define R(comp) ((comp) & 0xff)
|
||||
#define G(comp) (((comp)>>8) & 0xff)
|
||||
#define B(comp) (((comp)>>16) & 0xff)
|
||||
|
||||
main(argc, argv)
|
||||
char **argv;
|
||||
{
|
||||
char lbuf[100];
|
||||
int nh, nw;
|
||||
int x, y, xi, yi;
|
||||
int num;
|
||||
int r, g, b;
|
||||
long data;
|
||||
long *nbm, *nbmp;
|
||||
int i;
|
||||
|
||||
if( argc != 2) {
|
||||
fprintf(stderr, "Usage: squash factor\n");
|
||||
exit(1);
|
||||
}
|
||||
factor = atoi(argv[1]);
|
||||
gets(lbuf);
|
||||
if ( sscanf(lbuf, "(%d,%d)", &w, &h) != 2) {
|
||||
fprintf(stderr, "%s: bad size spec: %s\n", argv[0], lbuf);
|
||||
exit(1);
|
||||
}
|
||||
nh = h / factor;
|
||||
nw = w / factor;
|
||||
printf("(%d,%d)\n", nw, nh);
|
||||
if ( (bm = (long *)malloc(h*w*sizeof(long))) == 0) {
|
||||
fprintf(stderr, "%s: No memory\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
if ( (nbm = (long *)malloc(nh*nw*sizeof(long))) == 0) {
|
||||
fprintf(stderr, "%s: No memory\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
while( !feof(stdin) ) {
|
||||
gets(lbuf);
|
||||
if ( feof(stdin) ) break;
|
||||
puts(lbuf);
|
||||
fprintf(stderr, "Reading %d\n", h*w*sizeof(long));
|
||||
if ( (i=fread(bm, 1, h*w*sizeof(long), stdin)) != h*w*sizeof(long)) {
|
||||
fprintf(stderr, "%s: short read, %d wanted %d\n", argv[0],
|
||||
i, h*w*sizeof(long));
|
||||
exit(1);
|
||||
}
|
||||
nbmp = nbm;
|
||||
for( y=0; y<nh; y++) {
|
||||
for ( x=0; x<nw; x++) {
|
||||
r = g = b = 0;
|
||||
num = 0;
|
||||
*nbmp++ = BM(x,0,y,0);
|
||||
}
|
||||
}
|
||||
if (nbmp - nbm != nh * nw ) fprintf(stderr, "%d %d\n", nbmp-nbm, nh*nw);
|
||||
fprintf(stderr, "Writing %d\n", (nbmp-nbm)*sizeof(long));
|
||||
fwrite(nbm, 1, (nbmp-nbm)*sizeof(long), stdout);
|
||||
}
|
||||
exit(0);
|
||||
}
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
import sys
|
||||
from time import millitimer
|
||||
|
||||
def main():
|
||||
filename = 'film2.video'
|
||||
if sys.argv[1:]: filename = sys.argv[1]
|
||||
f = open(filename, 'r')
|
||||
|
||||
line = f.readline()
|
||||
w, h = eval(line[:-1])
|
||||
w2, h2 = w/2, h/2
|
||||
size = w2 * h2
|
||||
|
||||
data = data2 = t = t0 = t1 = None
|
||||
nframes = 0
|
||||
t0 = millitimer()
|
||||
while 1:
|
||||
line = f.readline()
|
||||
if not line: break
|
||||
t = eval(line[:-1])
|
||||
data = None
|
||||
data = f.read(size)
|
||||
if len(data) <> size:
|
||||
raise EOFError
|
||||
dostat(w2, h2, data)
|
||||
nframes = nframes+1
|
||||
t1 = millitimer()
|
||||
|
||||
t = 0.001 * (t1-t0)
|
||||
fps = 0.1 * int(10*nframes/t)
|
||||
print nframes, 'frames in', t, 'sec. =', fps, 'frames/sec.'
|
||||
|
||||
def dostat(w, h, data):
|
||||
print
|
||||
stat3(w, h, data)
|
||||
|
||||
# Statistic op 1: frequencies of byte values
|
||||
def stat1(w, h, data):
|
||||
bins = [0]*256
|
||||
for c in data:
|
||||
i = ord(c)
|
||||
bins[i] = bins[i]+1
|
||||
prbins(bins)
|
||||
|
||||
def prbins(bins):
|
||||
import string
|
||||
s = ''
|
||||
tot = 0
|
||||
for i in range(256):
|
||||
tot = tot + bins[i]
|
||||
s = s + string.rjust(`bins[i]`, 4)
|
||||
if len(s) >= 4*16:
|
||||
print s, string.rjust(`tot`, 7)
|
||||
s = ''
|
||||
tot = 0
|
||||
|
||||
# Statistic op 2: run lengths
|
||||
def stat2(w, h, data):
|
||||
runs = []
|
||||
for y in range(h):
|
||||
count, value = 0, ord(data[y*w])
|
||||
for c in data[y*w : y*w+w]:
|
||||
i = ord(c)
|
||||
if i <> value:
|
||||
runs.append(count, value)
|
||||
count, value = 0, i
|
||||
count = count+1
|
||||
runs.append(count, value)
|
||||
print len(runs), 'runs =', 0.1 * (10*w*h/len(runs)), 'bytes/run'
|
||||
|
||||
# Statistic op 3: frequencies of byte differences
|
||||
def stat3(w, h, data):
|
||||
bins = [0]*256
|
||||
prev = 0
|
||||
for c in data:
|
||||
i = ord(c)
|
||||
delta = divmod(i-prev, 256)[1]
|
||||
prev = i
|
||||
bins[delta] = bins[delta]+1
|
||||
prbins(bins)
|
||||
|
||||
# Try packing
|
||||
def packblock(w, h, data):
|
||||
res = ''
|
||||
for y in range(h):
|
||||
res = res + packline(data[y*w : y*w+w])
|
||||
return res
|
||||
|
||||
def packline(line):
|
||||
bytes = []
|
||||
for c in line:
|
||||
bytes.append(ord(c))
|
||||
prev = bytes[0]
|
||||
i, n = 1, len(bytes)
|
||||
while i < n:
|
||||
for pack in (0, 2, 4, 8):
|
||||
if pack = 0:
|
||||
lo, hi = 0, 0
|
||||
else:
|
||||
hi = pow(2, pack-1)-1
|
||||
lo = -hi-1
|
||||
p = prev
|
||||
j = i
|
||||
count = 0
|
||||
while j < n:
|
||||
x = bytes[j]
|
||||
delta = byte(x-p)
|
||||
if not lo <= delta <= hi:
|
||||
break
|
||||
p = x
|
||||
j = j+1
|
||||
|
||||
def byte(x): return divmod(x, 256)[1]
|
||||
|
||||
main()
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
import AL
|
||||
import al
|
||||
import sys
|
||||
import vtime
|
||||
import socket
|
||||
import time
|
||||
|
||||
|
||||
SLEEPTIME = 500 # 500 ms sleeps
|
||||
SAMPLEFREQ = 16000 # 16Khz samples
|
||||
SAMPLERATE = AL.RATE_16000
|
||||
NEEDBUFFERED = SAMPLEFREQ # Buffer 1 second of sound
|
||||
BUFFERSIZE = NEEDBUFFERED*4 # setqueuesize() par for 2 second sound
|
||||
|
||||
AVSYNCPORT = 10000 # Port for time syncing
|
||||
AVCTLPORT = 10001 # Port for record start/stop
|
||||
|
||||
def main():
|
||||
if len(sys.argv) <> 3:
|
||||
print 'Usage: ', sys.argv[0], 'videohostname soundfile'
|
||||
sys.exit(1)
|
||||
#
|
||||
ofile = open(sys.argv[2], 'w')
|
||||
#
|
||||
globaltime = vtime.VTime().init(0,sys.argv[1],AVSYNCPORT)
|
||||
#
|
||||
ctl = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
|
||||
ctl.bind((socket.gethostname(),AVCTLPORT))
|
||||
#
|
||||
inp = openmic()
|
||||
#
|
||||
out = 0 # Open aiff file
|
||||
#
|
||||
while 1:
|
||||
if mainloop(None, ctl, inp, out, globaltime):
|
||||
break
|
||||
if mainloop(ofile, ctl, inp, out, globaltime):
|
||||
break
|
||||
pass # Close aiff file
|
||||
sys.exit(0)
|
||||
#
|
||||
def openmic():
|
||||
conf = al.newconfig()
|
||||
conf.setqueuesize(BUFFERSIZE)
|
||||
conf.setwidth(AL.SAMPLE_16)
|
||||
conf.setchannels(AL.MONO)
|
||||
return al.openport('micr','r',conf)
|
||||
#
|
||||
def mainloop(ofile, ctl, inp, out, globaltime):
|
||||
#
|
||||
# Wait for sync packet, keeping 1-2 seconds of sound in the
|
||||
# buffer
|
||||
#
|
||||
totsamps = 0
|
||||
totbytes = 0
|
||||
starttime = time.millitimer()
|
||||
while 1:
|
||||
time.millisleep(SLEEPTIME)
|
||||
if ctl.avail():
|
||||
break
|
||||
nsamples = inp.getfilled()-NEEDBUFFERED
|
||||
if nsamples>0:
|
||||
data = inp.readsamps(nsamples)
|
||||
totsamps = totsamps + nsamples
|
||||
totbytes = totbytes + len(data)
|
||||
if ofile <> None:
|
||||
ofile.write(data)
|
||||
#
|
||||
# Compute his starttime and the timestamp of the first byte in the
|
||||
# buffer. Discard all buffered data upto his starttime
|
||||
#
|
||||
startstop,histime = eval(ctl.recv(100))
|
||||
if (ofile = None and startstop = 0) or \
|
||||
(ofile <> None and startstop = 1):
|
||||
print 'Sync error: saving=',save,' request=',startstop
|
||||
sys.exit(1)
|
||||
filllevel = inp.getfilled()
|
||||
filltime = time.millitimer()
|
||||
filltime = filltime - filllevel / (SAMPLEFREQ/1000)
|
||||
starttime = globaltime.his2mine(histime)
|
||||
nsamples = starttime - filltime
|
||||
if nsamples < 0:
|
||||
print 'Start/stop signal came too late'
|
||||
sys.exit(1)
|
||||
nsamples = nsamples * (SAMPLEFREQ / 1000)
|
||||
data = inp.readsamps(nsamples)
|
||||
totsamps = totsamps + nsamples
|
||||
totbytes = totbytes + len(data)
|
||||
print 'Time: ', time.millitimer()-starttime, ', Bytes: ', totbytes, ', Samples: ', totsamps
|
||||
if ofile <> None:
|
||||
ofile.write(data)
|
||||
return (startstop = 2)
|
||||
|
||||
main()
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
#include <stdio.h>
|
||||
|
||||
long *bm;
|
||||
long *nbm;
|
||||
long h, w;
|
||||
int nh, nw;
|
||||
long factor;
|
||||
|
||||
#define OC(x,xi) ((x)*factor+(xi))
|
||||
#define BM(x,xi,y,yi) bm[OC(y,yi)*w+OC(x,xi)]
|
||||
|
||||
#define COMP(r,g,b) ((r) | ((g)<<8) | ((b) << 16))
|
||||
|
||||
#define R(comp) ((comp) & 0xff)
|
||||
#define G(comp) (((comp)>>8) & 0xff)
|
||||
#define B(comp) (((comp)>>16) & 0xff)
|
||||
|
||||
#define CHOICEFUNC(np1, np2) ( random() & 1 )
|
||||
|
||||
int inlevels = 3*255;
|
||||
int outlevels = 1;
|
||||
|
||||
main(argc, argv)
|
||||
char **argv;
|
||||
{
|
||||
char lbuf[100];
|
||||
int x, y, xi, yi;
|
||||
int num;
|
||||
int r, g, b;
|
||||
long data;
|
||||
int i;
|
||||
double greyness;
|
||||
int inpixels, outpixels;
|
||||
int resid;
|
||||
|
||||
setvbuf(stdout, 0, _IOFBF, 1024*128);
|
||||
if( argc != 2) {
|
||||
fprintf(stderr, "Usage: tomono factor\n");
|
||||
exit(1);
|
||||
}
|
||||
factor = atoi(argv[1]);
|
||||
gets(lbuf);
|
||||
if ( sscanf(lbuf, "(%d,%d)", &w, &h) != 2) {
|
||||
fprintf(stderr, "%s: bad size spec: %s\n", argv[0], lbuf);
|
||||
exit(1);
|
||||
}
|
||||
nh = h / factor;
|
||||
nw = w / factor;
|
||||
printf("(%d,%d)\n", nw, nh);
|
||||
if ( (bm = (long *)malloc(h*w*sizeof(long))) == 0) {
|
||||
fprintf(stderr, "%s: No memory\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
if ( (nbm = (long *)malloc(nh*nw*sizeof(long))) == 0) {
|
||||
fprintf(stderr, "%s: No memory\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
while( !feof(stdin) ) {
|
||||
gets(lbuf);
|
||||
if ( feof(stdin) ) break;
|
||||
puts(lbuf);
|
||||
fprintf(stderr, "Reading %d\n", h*w*sizeof(long));
|
||||
if ( (i=fread(bm, 1, h*w*sizeof(long), stdin)) != h*w*sizeof(long)) {
|
||||
fprintf(stderr, "%s: short read, %d wanted %d\n", argv[0],
|
||||
i, h*w*sizeof(long));
|
||||
exit(1);
|
||||
}
|
||||
/*
|
||||
** Compute picture blackness.
|
||||
*/
|
||||
inpixels = 0;
|
||||
inpixels = countpixels(0,0,w,h);
|
||||
greyness = (double)inpixels/(h*w*inlevels);
|
||||
fprintf(stderr, "%3.1f%% grey\n", 100.0*greyness);
|
||||
outpixels = (int)(greyness*outlevels*nh*nw);
|
||||
fprintf(stderr, "Inpixels: %d (%d) Outpixels %d\n", inpixels, inpixels/inlevels, outpixels);
|
||||
resid = fillpixels(0,0,nw,nh,0,0,w,h,outpixels);
|
||||
if ( resid > 1 ) fprintf(stderr, "Residue: %d pixels\n", resid);
|
||||
fprintf(stderr, "Writing %d\n", (nh*nw)*sizeof(long));
|
||||
fwrite(nbm, 1, (nh*nw)*sizeof(long), stdout);
|
||||
}
|
||||
exit(0);
|
||||
}
|
||||
|
||||
countpixels(x0,y0,x1,y1)
|
||||
{
|
||||
int x, y, tot, data;
|
||||
|
||||
tot = 0;
|
||||
for( y=y0; y<y1; y++)
|
||||
for(x=x0; x<x1; x++) {
|
||||
data = bm[y*w+x];
|
||||
tot += R(data);
|
||||
tot += G(data);
|
||||
tot += B(data);
|
||||
}
|
||||
return tot;
|
||||
}
|
||||
|
||||
fillpixels(x0,y0,x1,y1,ox0,oy0,ox1,oy1,npixels)
|
||||
{
|
||||
int m, om, p1, p2, np1, np2, rp, resid;
|
||||
|
||||
if ( npixels == 0 ) return 0;
|
||||
if ( x0+1 >= x1 && y0+1 >= y1 ) {
|
||||
if ( npixels ) {
|
||||
nbm[y0*nw+x0] = 0xffffff;
|
||||
/* fprintf(stderr, "->%d,%d\n", x0,y0); */
|
||||
return npixels - 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if ( x1-x0 < y1-y0 ) {
|
||||
if ( y1 - y0 <= 2 )
|
||||
m = y0 + 1;
|
||||
else
|
||||
m = y0+1+(random()%(y1-y0-1));
|
||||
/* fprintf(stderr,"%d,%d %d,%d Y %d\n", x0, x1, y0, y1, m); */
|
||||
/* om = (oy0+oy1)/2; */ om = m;
|
||||
p1 = countpixels(ox0,oy0,ox1,om);
|
||||
p2 = countpixels(ox0,om,ox1,oy1);
|
||||
np1 = (int)(((float)p1/(p1+p2))*npixels);
|
||||
np2 = (int)(((float)p2/(p1+p2))*npixels);
|
||||
rp = npixels - np1 - np2;
|
||||
if ( rp ) {
|
||||
np1 += rp/2;
|
||||
rp = rp - rp/2;
|
||||
np2 += rp;
|
||||
}
|
||||
resid = 0;
|
||||
if ( CHOICEFUNC(np1, np2) ) {
|
||||
resid = fillpixels(x0,y0,x1,m,ox0,oy0,ox1,om,np1+resid);
|
||||
resid = fillpixels(x0,m,x1,y1,ox0,om,ox1,oy1,np2+resid);
|
||||
} else {
|
||||
resid = fillpixels(x0,m,x1,y1,ox0,om,ox1,oy1,np2+resid);
|
||||
resid = fillpixels(x0,y0,x1,m,ox0,oy0,ox1,om,np1+resid);
|
||||
}
|
||||
} else {
|
||||
if ( x1 - x0 <= 2 )
|
||||
m = x0 + 1;
|
||||
else
|
||||
m = x0+1+(random()%(x1-x0-1));
|
||||
/* fprintf(stderr,"%d,%d %d,%d X %d\n", x0, x1, y0, y1, m); */
|
||||
/* om = (ox0+ox1)/2; */ om = m;
|
||||
p1 = countpixels(ox0,oy0,om,oy1);
|
||||
p2 = countpixels(om,oy0,ox1,oy1);
|
||||
np1 = (int)(((float)p1/(p1+p2))*npixels);
|
||||
np2 = (int)(((float)p2/(p1+p2))*npixels);
|
||||
rp = npixels - np1 - np2;
|
||||
if ( rp ) {
|
||||
np1 += rp/2;
|
||||
rp = rp - rp/2;
|
||||
np2 += rp;
|
||||
}
|
||||
resid = 0;
|
||||
if ( CHOICEFUNC(np1, np2) ) {
|
||||
resid = fillpixels(x0,y0,m,y1,ox0,oy0,om,oy1,np1+resid);
|
||||
resid = fillpixels(m,y0,x1,y1,om,oy0,ox1,oy1,np2+resid);
|
||||
} else {
|
||||
resid = fillpixels(m,y0,x1,y1,om,oy0,ox1,oy1,np2+resid);
|
||||
resid = fillpixels(x0,y0,m,y1,ox0,oy0,om,oy1,np1+resid);
|
||||
}
|
||||
}
|
||||
return resid;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
import string
|
||||
|
||||
from socket import *
|
||||
from gl import *
|
||||
from GL import *
|
||||
from DEVICE import *
|
||||
from time import millisleep, millitimer
|
||||
|
||||
PORT = 5555
|
||||
|
||||
PF = 2 # packfactor
|
||||
HS = 40 # Header size
|
||||
|
||||
def testimage():
|
||||
RGBcolor(0, 0, 0)
|
||||
clear()
|
||||
RGBcolor(0, 255, 0)
|
||||
cmov2i(10, 10)
|
||||
charstr('Waiting...')
|
||||
|
||||
def reshape():
|
||||
reshapeviewport()
|
||||
w, h = getsize()
|
||||
ortho2(0, w, 0, h)
|
||||
testimage()
|
||||
return w, h
|
||||
|
||||
def main():
|
||||
s = socket(AF_INET, SOCK_DGRAM)
|
||||
s.bind('', PORT)
|
||||
|
||||
foreground()
|
||||
wid = winopen('tv')
|
||||
RGBmode()
|
||||
gconfig()
|
||||
qdevice(ESCKEY)
|
||||
|
||||
oldw, oldh = getsize()
|
||||
ortho2(0, oldw, 0, oldh)
|
||||
testimage()
|
||||
|
||||
t1 = millitimer()
|
||||
|
||||
while 1:
|
||||
if qtest():
|
||||
dev, val = qread()
|
||||
if dev = ESCKEY:
|
||||
winclose(wid)
|
||||
return
|
||||
elif dev = REDRAW:
|
||||
oldw, oldh = reshape()
|
||||
elif s.avail():
|
||||
data = s.recv(17000)
|
||||
header = string.strip(data[:HS])
|
||||
w, h, pf, x1, y1, x2, y2 = eval(header)
|
||||
if (w, h) <> (oldw, oldh):
|
||||
x, y = getorigin()
|
||||
x, y = x-1, y+21 # TWM correction
|
||||
winposition(x, x+w-1, y+oldh-h, y+oldh-1)
|
||||
oldw, oldh = reshape()
|
||||
data2 = data[HS:]
|
||||
dx = (x2-x1+1)/pf
|
||||
dy = (y2-y1+1)/pf
|
||||
data3 = unpackrect(dx, dy, 1, data2)
|
||||
rectzoom(pf, pf)
|
||||
lrectwrite(x1, y1, x1+dx-1, y1+dy-1, data3)
|
||||
t1 = millitimer()
|
||||
else:
|
||||
t2 = millitimer()
|
||||
if t2-t1 >= 5000:
|
||||
testimage()
|
||||
t1 = t2
|
||||
else:
|
||||
millisleep(10)
|
||||
|
||||
winclose(wid)
|
||||
return data
|
||||
|
||||
main()
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#include <stdio.h>
|
||||
#include <gl/image.h>
|
||||
|
||||
long bm[1280];
|
||||
short rb[1280], gb[1280], bb[1280];
|
||||
long h, w;
|
||||
|
||||
#define R(comp) ((comp) & 0xff)
|
||||
#define G(comp) (((comp)>>8) & 0xff)
|
||||
#define B(comp) (((comp)>>16) & 0xff)
|
||||
|
||||
main(argc, argv)
|
||||
char **argv;
|
||||
{
|
||||
char lbuf[100];
|
||||
int x, y;
|
||||
int i;
|
||||
IMAGE * of;
|
||||
int pmask;
|
||||
|
||||
if( argc != 3 && argc != 4) {
|
||||
fprintf(stderr, "Usage: v2i videofile imgfile [planemask]\n");
|
||||
exit(1);
|
||||
}
|
||||
if ( argc == 4)
|
||||
pmask = atoi(argv[3]);
|
||||
else
|
||||
pmask = 7;
|
||||
if ( freopen(argv[1], "r", stdin) == NULL ) {
|
||||
perror(argv[1]);
|
||||
exit(1);
|
||||
}
|
||||
gets(lbuf);
|
||||
if ( sscanf(lbuf, "(%d,%d)", &w, &h) != 2) {
|
||||
fprintf(stderr, "%s: bad size spec: %s\n", argv[0], lbuf);
|
||||
exit(1);
|
||||
}
|
||||
gets(lbuf); /* Skip time info */
|
||||
if ( w > 1280 ) {
|
||||
fprintf(stderr, "%s: Sorry, too wide\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
if ( (of=iopen(argv[2], "w", RLE(1), 3, w, h, 3)) == 0) {
|
||||
perror(argv[2]);
|
||||
exit(1);
|
||||
}
|
||||
for( y=0; y<h; y++) {
|
||||
if( fread(bm, sizeof(long), w, stdin) != w) {
|
||||
fprintf(stderr, "%s: short read\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
for( x=0; x<w; x++) {
|
||||
if ( pmask & 1) rb[x] = R(bm[x]);
|
||||
if ( pmask & 2) gb[x] = G(bm[x]);
|
||||
if ( pmask & 4) bb[x] = B(bm[x]);
|
||||
}
|
||||
putrow(of, rb, y, 0);
|
||||
putrow(of, gb, y, 1);
|
||||
putrow(of, bb, y, 2);
|
||||
}
|
||||
iclose(of);
|
||||
exit(0);
|
||||
}
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
from gl import *
|
||||
from GL import *
|
||||
from DEVICE import *
|
||||
import time
|
||||
import sys
|
||||
import al
|
||||
import AL
|
||||
|
||||
BUFFERSIZE = 32000
|
||||
|
||||
class Struct(): pass
|
||||
epoch = Struct()
|
||||
EndOfFile = 'End of file'
|
||||
bye = 'bye'
|
||||
|
||||
def openspkr():
|
||||
conf = al.newconfig()
|
||||
conf.setqueuesize(BUFFERSIZE)
|
||||
conf.setwidth(AL.SAMPLE_16)
|
||||
conf.setchannels(AL.MONO)
|
||||
return al.openport('spkr','w',conf)
|
||||
def openvideo(name):
|
||||
f = open(name, 'r')
|
||||
line = f.readline()
|
||||
if not line: raise EndOfFile
|
||||
if line[:4] = 'CMIF': line = f.readline()
|
||||
x = eval(line[:-1])
|
||||
if len(x) = 3: w, h, pf = x
|
||||
else: w, h = x; pf = 2
|
||||
return f, w, h, pf
|
||||
def loadframe(f,w,h,pf,af,spkr):
|
||||
line = f.readline()
|
||||
if line = '':
|
||||
raise EndOfFile
|
||||
x = eval(line[:-1])
|
||||
if type(x) = type(0) or type(x) = type(0.0):
|
||||
tijd = x
|
||||
if pf = 0:
|
||||
size = w*h*4
|
||||
else:
|
||||
size = (w/pf) * (h/pf)
|
||||
else:
|
||||
tijd, size = x
|
||||
data = f.read(size)
|
||||
if len(data) <> size:
|
||||
raise EndOfFile
|
||||
if pf:
|
||||
rectzoom(pf, pf)
|
||||
w = w/pf
|
||||
h = h/pf
|
||||
data = unpackrect(w, h, 1, data)
|
||||
lrectwrite(0,0,w-1,h-1,data)
|
||||
# This is ugly here, but the only way to get the two
|
||||
# channels started in sync
|
||||
#if af <> None:
|
||||
# playsound(af,spkr)
|
||||
ct = time.millitimer() - epoch.epoch
|
||||
if tijd > 0 and ct < tijd:
|
||||
time.millisleep(tijd-ct)
|
||||
swapbuffers()
|
||||
return tijd
|
||||
def playsound(af, spkr):
|
||||
nsamp = spkr.getfillable()
|
||||
data = af.read(nsamp*2)
|
||||
spkr.writesamps(data)
|
||||
def main():
|
||||
if len(sys.argv) > 1:
|
||||
f, w, h, pf = openvideo(sys.argv[1])
|
||||
else:
|
||||
f, w, h, pf = openvideo('film.video')
|
||||
af = None
|
||||
spkr = None
|
||||
if len(sys.argv) > 2:
|
||||
af = open(sys.argv[2], 'r')
|
||||
spkr = openspkr()
|
||||
if len(sys.argv) > 3:
|
||||
data = af.read(eval(sys.argv[3]))
|
||||
del data
|
||||
foreground()
|
||||
prefsize(w,h)
|
||||
win = winopen('Video player')
|
||||
RGBmode()
|
||||
doublebuffer()
|
||||
gconfig()
|
||||
qdevice(ESCKEY)
|
||||
running = 1
|
||||
epoch.epoch = time.millitimer()
|
||||
nframe = 0
|
||||
tijd = 1
|
||||
try:
|
||||
while 1:
|
||||
if running:
|
||||
try:
|
||||
tijd = loadframe(f, w, h, pf, af, spkr)
|
||||
nframe = nframe + 1
|
||||
except EndOfFile:
|
||||
running = 0
|
||||
t = time.millitimer()
|
||||
if tijd > 0:
|
||||
print 'Recorded at ', nframe * 1000.0 / tijd,
|
||||
print 'frames/second (', tijd, 'ms total)'
|
||||
print 'Played at', nframe * 1000.0 / (t-epoch.epoch),
|
||||
print 'frames/second'
|
||||
if af <> None:
|
||||
playsound(af,spkr)
|
||||
if qtest():
|
||||
if qread() = (ESCKEY,1):
|
||||
raise bye
|
||||
except bye:
|
||||
pass
|
||||
|
||||
main()
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#!/ufs/guido/bin/sgi/python3.3
|
||||
from gl import *
|
||||
from GL import *
|
||||
from DEVICE import *
|
||||
import time
|
||||
import sys
|
||||
|
||||
class Struct(): pass
|
||||
epoch = Struct()
|
||||
EndOfFile = 'End of file'
|
||||
bye = 'bye'
|
||||
|
||||
def openvideo(name):
|
||||
f = open(name, 'r')
|
||||
w, h = eval(f.readline()[:-1])
|
||||
return f, w, h
|
||||
def loadframe(f, w, h):
|
||||
tijd = f.readline()
|
||||
if tijd = '':
|
||||
raise EndOfFile
|
||||
tijd = eval(tijd[:-1])
|
||||
f.seek(w*h*4,1)
|
||||
return tijd
|
||||
def saveframe(name, w, h, tijd, data):
|
||||
f = open(name, 'w')
|
||||
f.write(`w,h` + '\n')
|
||||
f.write(`tijd` + '\n')
|
||||
f.write(data)
|
||||
f.close()
|
||||
def main():
|
||||
if len(sys.argv) > 1:
|
||||
names = sys.argv[1:]
|
||||
else:
|
||||
names = ['film.video']
|
||||
for name in names:
|
||||
f, w, h = openvideo(name)
|
||||
print name+': '+`w`+'x'+`h`
|
||||
num = 0
|
||||
try:
|
||||
while 1:
|
||||
try:
|
||||
tijd = loadframe(f, w, h)
|
||||
print '\t', tijd,
|
||||
num = num + 1
|
||||
if num % 8 = 0:
|
||||
print
|
||||
except EndOfFile:
|
||||
raise bye
|
||||
except bye:
|
||||
pass
|
||||
if num % 8 <> 0:
|
||||
print
|
||||
f.close()
|
||||
|
||||
main()
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
#
|
||||
# Module vtime - Keep virtual time between two nodes.
|
||||
#
|
||||
# We try for synchronised clocks by sending a packet of the for
|
||||
# (1,mytime,0) to the other side, and waiting (at most) a second for
|
||||
# a reply. This reply has the form (2,mytime,histime), and we can
|
||||
# estimate the time difference by defining histime to be exactly half-way
|
||||
# between the time we sent our message and got our reply. We send a
|
||||
# final (3,mynewtime,histime) message to allow the other side to do the
|
||||
# same computations.
|
||||
#
|
||||
# Note that the protocol suffers heavily from the 2-army problem.
|
||||
# It'll have to do until I can read up on time-sync protocols, though.
|
||||
#
|
||||
from socket import *
|
||||
import time
|
||||
|
||||
MSGSIZE = 100
|
||||
MSGTIMEOUT = 1000
|
||||
|
||||
recv_timeout = 'receive timeout'
|
||||
bad_connect = 'Bad connection'
|
||||
|
||||
def timeavg(a,b):
|
||||
return int((long(a)+b)/2L)
|
||||
def tryrecv(s):
|
||||
cnt = 0
|
||||
while 1:
|
||||
if s.avail():
|
||||
return s.recvfrom(MSGSIZE)
|
||||
time.millisleep(100)
|
||||
cnt = cnt + 100
|
||||
if cnt > MSGTIMEOUT:
|
||||
raise recv_timeout
|
||||
|
||||
class VTime():
|
||||
def init(self,(client,host,port)):
|
||||
s = socket(AF_INET, SOCK_DGRAM)
|
||||
host = gethostbyname(host)
|
||||
localhost = gethostbyname(gethostname())
|
||||
raddr = (host,port)
|
||||
s.bind((localhost,port))
|
||||
if client:
|
||||
#
|
||||
# We loop here because we want the *second* measurement
|
||||
# for accuracy
|
||||
for loopct in (0,2):
|
||||
curtijd = time.millitimer()
|
||||
check = `(loopct,curtijd,0)`
|
||||
s.sendto(check,raddr)
|
||||
while 1:
|
||||
try:
|
||||
if loopct:
|
||||
data, other = s.recvfrom(MSGSIZE)
|
||||
else:
|
||||
data, other = tryrecv(s)
|
||||
newtijd = time.millitimer()
|
||||
if other <> raddr:
|
||||
print 'Someone else syncing to us: ', other
|
||||
raise bad_connect
|
||||
data = eval(data)
|
||||
if data[:2] = (loopct+1,curtijd):
|
||||
break
|
||||
if data[0] <> 2:
|
||||
print 'Illegal sync reply: ', data
|
||||
raise bad_connect
|
||||
except recv_timeout:
|
||||
curtijd = time.millitimer()
|
||||
check = `(loopct,curtijd,0)`
|
||||
s.sendto(check,raddr)
|
||||
histime = data[2]
|
||||
s.sendto(`(4,newtijd,histime)`,raddr)
|
||||
mytime = timeavg(curtijd,newtijd)
|
||||
#mytime = curtijd
|
||||
self.timediff = histime - mytime
|
||||
else:
|
||||
while 1:
|
||||
data,other = s.recvfrom(MSGSIZE)
|
||||
if other <> raddr:
|
||||
print 'Someone else syncing to us: ', other, ' Wanted ', raddr
|
||||
raise bad_connect
|
||||
data = eval(data)
|
||||
if data[0] in (0,2):
|
||||
curtijd = time.millitimer()
|
||||
s.sendto(`(data[0]+1,data[1],curtijd)`,raddr)
|
||||
elif data[0] = 4:
|
||||
newtijd = time.millitimer()
|
||||
histime = data[1]
|
||||
mytime = timeavg(curtijd,newtijd)
|
||||
#mytime = curtijd
|
||||
self.timediff = histime-mytime
|
||||
break
|
||||
else:
|
||||
print 'Funny data: ', data
|
||||
raise bad_connect
|
||||
return self
|
||||
#
|
||||
def his2mine(self,tijd):
|
||||
return tijd - self.timediff
|
||||
#
|
||||
def mine2his(self, tijd):
|
||||
return tijd + self.timediff
|
||||
|
||||
def test(clt, host, port):
|
||||
xx = VTime().init(clt,host,port)
|
||||
print 'Time diff: ', xx.his2mine(0)
|
||||
Loading…
Reference in New Issue