ref: 01338076d1a3610858f41fcbcdc7e46fb1109b77
dir: /appl/wm/avi.b/
implement WmAVI;
include "sys.m";
sys: Sys;
include "draw.m";
draw: Draw;
Rect, Display, Image: import draw;
include "tk.m";
tk: Tk;
Toplevel: import tk;
include "tkclient.m";
tkclient: Tkclient;
ctxt: ref Draw->Context;
include "selectfile.m";
selectfile: Selectfile;
include "dialog.m";
dialog: Dialog;
include "riff.m";
avi: Riff;
AVIhdr, AVIstream, RD: import avi;
video: ref AVIstream;
WmAVI: module
{
init: fn(ctxt: ref Draw->Context, argv: list of string);
};
Stopped, Playing, Paused: con iota;
state := Stopped;
cmap: array of byte;
codedbuf: array of byte;
pixelbuf: array of byte;
pixelrec: Draw->Rect;
task_cfg := array[] of {
"canvas .c",
"frame .b",
"button .b.File -text File -command {send cmd file}",
"button .b.Stop -text Stop -command {send cmd stop}",
"button .b.Pause -text Pause -command {send cmd pause}",
"button .b.Play -text Play -command {send cmd play}",
"frame .f",
"label .f.file -text {File:}",
"label .f.name",
"pack .f.file .f.name -side left",
"pack .b.File .b.Stop .b.Pause .b.Play -side left",
"pack .f -fill x",
"pack .b -anchor w",
"pack .c -side bottom -fill both -expand 1",
"pack propagate . 0",
};
init(xctxt: ref Draw->Context, nil: list of string)
{
sys = load Sys Sys->PATH;
draw = load Draw Draw->PATH;
tk = load Tk Tk->PATH;
tkclient= load Tkclient Tkclient->PATH;
dialog = load Dialog Dialog->PATH;
selectfile = load Selectfile Selectfile->PATH;
ctxt = xctxt;
sys->pctl(Sys->NEWPGRP, nil);
tkclient->init();
dialog->init();
selectfile->init();
(t, wmctl) := tkclient->toplevel(ctxt, "", "AVI Player", 0);
cmd := chan of string;
tk->namechan(t, cmd, "cmd");
for (c:=0; c<len task_cfg; c++)
tk->cmd(t, task_cfg[c]);
tk->cmd(t, "bind . <Configure> {send cmd resize}");
tk->cmd(t, "update");
tkclient->onscreen(t, nil);
tkclient->startinput(t, "kbd"::"ptr"::nil);
avi = load Riff Riff->PATH;
if(avi == nil) {
dialog->prompt(ctxt, t.image, "error -fg red", "Loading Interfaces",
"Failed to load the RIFF/AVI\ninterface:"+sys->sprint("%r"),
0, "Exit"::nil);
return;
}
avi->init();
fname := "";
state = Stopped;
for(;;) alt {
s := <-t.ctxt.kbd =>
tk->keyboard(t, s);
s := <-t.ctxt.ptr =>
tk->pointer(t, *s);
s := <-t.ctxt.ctl or
s = <-t.wreq or
s = <-wmctl =>
if(s == "exit") {
state = Stopped;
return;
}
tkclient->wmctl(t, s);
press := <-cmd =>
case press {
"file" =>
state = Stopped;
patterns := list of {
"*.avi (Microsoft movie files)",
"* (All Files)"
};
fname = selectfile->filename(ctxt, t.image, "Locate AVI files",
patterns, nil);
if(fname != nil) {
tk->cmd(t, ".f.name configure -text {"+fname+"}");
tk->cmd(t, "update");
}
"play" =>
if (state != Stopped) {
state = Playing;
continue;
}
if(fname != nil) {
state = Playing;
spawn play(t, fname);
}
"pause" =>
if(state == Playing)
state = Paused;
"stop" =>
state = Stopped;
}
}
}
play(t: ref Toplevel, file: string)
{
sp := list of { "Stop Play" };
(r, err) := avi->open(file);
if(err != nil) {
dialog->prompt(ctxt, t.image, "error -fg red", "Open AVI file", err, 0, sp);
return;
}
err = avi->r.check4("AVI ");
if(err != nil) {
dialog->prompt(ctxt, t.image, "error -fg red", "Read AVI format", err, 0, sp);
return;
}
(code, l) := avi->r.gethdr();
if(code != "LIST") {
dialog->prompt(ctxt, t.image, "error -fg red", "Parse AVI headers",
"no list under AVI section header", 0, sp);
return;
}
err = avi->r.check4("hdrl");
if(err != nil) {
dialog->prompt(ctxt, t.image, "error -fg red", "Read AVI header", err, 0, sp);
return;
}
avihdr: ref AVIhdr;
(avihdr, err) = avi->r.avihdr();
if(err != nil) {
dialog->prompt(ctxt, t.image, "error -fg red", "Read AVI header", err, 0, sp);
return;
}
#
# read the stream info & format structures
#
stream := array[avihdr.streams] of ref AVIstream;
for(i := 0; i < avihdr.streams; i++) {
(stream[i], err) = avi->r.streaminfo();
if(err != nil) {
dialog->prompt(ctxt, t.image, "error -fg red", "Parse AVI headers",
"Failed to parse stream headers\n"+err, 0, sp);
return;
}
if(stream[i].stype == "vids") {
video = stream[i];
err = video.fmt2binfo();
if(err != nil) {
dialog->prompt(ctxt, t.image, "error -fg red",
"Parse AVI Video format",
"Invalid stream headers\n"+err, 0, sp);
return;
}
}
}
img: ref Draw->Image;
if(video != nil) {
case video.binfo.compression {
* =>
dialog->prompt(ctxt, t.image, "error -fg red",
"Parse AVI Compression method",
"unknown compression/encoding method", 0, sp);
return;
avi->BI_RLE8 =>
cmap = array[len video.binfo.cmap] of byte;
for(i = 0; i < len video.binfo.cmap; i++) {
e := video.binfo.cmap[i];
cmap[i] = byte ctxt.display.rgb2cmap(e.r, e.g, e.b);
}
break;
}
chans: draw->Chans;
case video.binfo.bitcount {
* =>
dialog->prompt(ctxt, t.image, "error -fg red",
"Check AVI Video format",
string video.binfo.bitcount+
" bits per pixel not supported", 0, sp);
return;
8 =>
chans = Draw->CMAP8;
mem := video.binfo.width*video.binfo.height;
pixelbuf = array[mem] of byte;
};
pixelrec.min = (0, 0);
pixelrec.max = (video.binfo.width, video.binfo.height);
img = ctxt.display.newimage(pixelrec, chans, 0, Draw->White);
if (img == nil) {
sys->fprint(sys->fildes(2), "coffee: failed to allocate image\n");
exit;
}
}
#
# Parse out the junk headers we don't understand
#
parse: for(;;) {
(code, l) = avi->r.gethdr();
if(l < 0)
break;
case code {
* =>
# sys->print("%s %d\n", code, l);
avi->r.skip(l);
"LIST" =>
err = avi->r.check4("movi");
if(err != nil) {
dialog->prompt(ctxt, t.image, "error -fg red",
"Strip AVI headers",
"no movi chunk", 0, sp);
return;
}
break parse;
}
}
canvr := canvsize(t);
p := (Draw->Point)(0, 0);
dx := canvr.dx();
if(dx > video.binfo.width)
p.x = (dx - video.binfo.width)/2;
dy := canvr.dy();
if(dy > video.binfo.height)
p.y = (dy - video.binfo.height)/2;
canvr = canvr.addpt(p);
chunk: for(;;) {
while(state == Paused)
sys->sleep(0);
if(state == Stopped)
break chunk;
(code, l) = avi->r.gethdr();
if(l <= 0)
break;
if(l & 1)
l++;
case code {
* =>
avi->r.skip(l);
"00db" => # Stream 0 Video DIB
dib(r, img, l);
"00dc" => # Stream 0 Video DIB compressed
dibc(r, img, l);
t.image.draw(canvr, img, nil, img.r.min);
"idx1" =>
break chunk;
}
}
state = Stopped;
}
dib(r: ref RD, i: ref Draw->Image, l: int): int
{
if(len codedbuf < l)
codedbuf = array[l] of byte;
if(r.readn(codedbuf, l) != l)
return -1;
case video.binfo.bitcount {
8 =>
for(k := 0; k < l; k++)
codedbuf[k] = cmap[int codedbuf[k]];
i.writepixels(pixelrec, codedbuf);
}
return 0;
}
dibc(r: ref RD, i: ref Draw->Image, l: int): int
{
if(len codedbuf < l)
codedbuf = array[l] of byte;
if(r.readn(codedbuf, l) != l)
return -1;
case video.binfo.compression {
avi->BI_RLE8 =>
p := 0;
posn := 0;
x := 0;
y := video.binfo.height-1;
w := video.binfo.width;
decomp: while(p < l) {
n := int codedbuf[p++];
if(n == 0) {
esc := int codedbuf[p++];
case esc {
0 => # end of line
x = 0;
y--;
1 => # end of image
break decomp;
2 => # Delta dx,dy
x += int codedbuf[p++];
y -= int codedbuf[p++];
* =>
posn = x+y*w;
for(k := 0; k < esc; k++)
pixelbuf[posn++] = cmap[int codedbuf[p++]];
x += esc;
if(p & 1)
p++;
};
}
else {
posn = x+y*w;
v := cmap[int codedbuf[p++]];
for(k := 0; k < n; k++)
pixelbuf[posn++] = v;
x += n;
}
}
i.writepixels(pixelrec, pixelbuf);
}
return 0;
}
canvsize(t: ref Toplevel): Rect
{
r: Rect;
r.min.x = int tk->cmd(t, ".c cget -actx");
r.min.y = int tk->cmd(t, ".c cget -acty");
r.max.x = r.min.x + int tk->cmd(t, ".c cget -width");
r.max.y = r.min.y + int tk->cmd(t, ".c cget -height");
return r;
}