int C2F(db2int)(int *typ, int *n, double *dx, int *incx, int *dy, int *incy)
{
int i1;
static int i, ix, iy;
--dx;
i1 = *n;
if (i1 <= 0)
{
return 0;
}
switch (*typ)
{
case 1:
CONV(integer1);
break;
case 2:
CONV(integer2);
break;
case 4:
CONV(int) ;
break;
}
return 0;
}
void BoneNode::generateBoneLine( std::vector< Vector3 >& lineVec , Matrix4 const& trans , int frame )
{
#if 0
Matrix4 nextMat;
calcFrameTransform( nextMat , trans , frame );
Vector3 org = motionData[0].pos * trans;
for( NodeList::iterator iter ( mChildren.begin() ) , end( mChildren.end() );
iter != end ; ++iter )
{
BoneNode* bone = static_cast< BoneNode* >( CONV(iter) );
Vector3 pos = bone->motionData[0].pos * nextMat;
lineVec.push_back( org );
lineVec.push_back( pos );
}
for( NodeList::iterator iter ( mChildren.begin() ) , end( mChildren.end() );
iter != end ; ++iter )
{
castBone( CONV(iter) )->generateBoneLine( lineVec , nextMat , frame );
}
#endif
}
static void
ipclose(Chan* c)
{
Fs *f;
f = ipfs[c->dev];
switch(TYPE(c->qid)) {
default:
break;
case Qlog:
if(c->flag & COPEN)
netlogclose(f);
break;
case Qdata:
case Qctl:
case Qerr:
if(c->flag & COPEN)
closeconv(f->p[PROTO(c->qid)]->conv[CONV(c->qid)]);
break;
case Qsnoop:
if(c->flag & COPEN)
decref(&f->p[PROTO(c->qid)]->conv[CONV(c->qid)]->snoopers);
break;
}
free(((IPaux*)c->aux)->owner);
free(c->aux);
}
static void to_PCM_32bit(faacDecHandle hDecoder, real_t **input,
uint8_t channels, uint16_t frame_len,
int32_t **sample_buffer)
{
uint8_t ch, ch1;
uint16_t i;
switch (CONV(channels,hDecoder->downMatrix))
{
case CONV(1,0):
case CONV(1,1):
for(i = 0; i < frame_len; i++)
{
real_t inp = input[hDecoder->internal_channel[0]][i];
inp *= 65536.0f;
CLIP(inp, 2147483647.0f, -2147483648.0f);
(*sample_buffer)[i] = (int32_t)lrintf(inp);
}
break;
case CONV(2,0):
ch = hDecoder->internal_channel[0];
ch1 = hDecoder->internal_channel[1];
for(i = 0; i < frame_len; i++)
{
real_t inp0 = input[ch ][i];
real_t inp1 = input[ch1][i];
inp0 *= 65536.0f;
inp1 *= 65536.0f;
CLIP(inp0, 2147483647.0f, -2147483648.0f);
CLIP(inp1, 2147483647.0f, -2147483648.0f);
(*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
(*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp1);
}
break;
default:
for (ch = 0; ch < channels; ch++)
{
for(i = 0; i < frame_len; i++)
{
real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
inp *= 65536.0f;
CLIP(inp, 2147483647.0f, -2147483648.0f);
(*sample_buffer)[(i*channels)+ch] = (int32_t)lrintf(inp);
}
}
break;
}
}
static void to_PCM_double(NeAACDecHandle hDecoder, real_t **input,
uint8_t channels, uint16_t frame_len,
double **sample_buffer)
{
uint8_t ch, ch1;
uint16_t i;
switch (CONV(channels,hDecoder->downMatrix))
{
case CONV(1,0):
case CONV(1,1):
for(i = 0; i < frame_len; i++)
{
real_t inp = input[hDecoder->internal_channel[0]][i];
(*sample_buffer)[i] = (double)inp*FLOAT_SCALE;
}
break;
case CONV(2,0):
if (hDecoder->upMatrix)
{
ch = hDecoder->internal_channel[0];
for(i = 0; i < frame_len; i++)
{
real_t inp0 = input[ch][i];
(*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;
(*sample_buffer)[(i*2)+1] = (double)inp0*FLOAT_SCALE;
}
} else {
ch = hDecoder->internal_channel[0];
ch1 = hDecoder->internal_channel[1];
for(i = 0; i < frame_len; i++)
{
real_t inp0 = input[ch ][i];
real_t inp1 = input[ch1][i];
(*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;
(*sample_buffer)[(i*2)+1] = (double)inp1*FLOAT_SCALE;
}
}
break;
default:
for (ch = 0; ch < channels; ch++)
{
for(i = 0; i < frame_len; i++)
{
real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
(*sample_buffer)[(i*channels)+ch] = (double)inp*FLOAT_SCALE;
}
}
break;
}
}
static long
cmdread(Chan *ch, void *a, long n, vlong offset)
{
Conv *c;
char *p, *cmds;
int fd;
USED(offset);
p = a;
switch(TYPE(ch->qid)) {
default:
error(Eperm);
case Qcmd:
case Qtopdir:
case Qconvdir:
return devdirread(ch, a, n, 0, 0, cmdgen);
case Qctl:
sprint(up->genbuf, "%ld", CONV(ch->qid));
return readstr(offset, p, n, up->genbuf);
case Qstatus:
c = cmd.conv[CONV(ch->qid)];
cmds = "";
if(c->cmd != nil)
cmds = c->cmd->f[1];
snprint(up->genbuf, sizeof(up->genbuf), "cmd/%d %d %s %q %q\n",
c->x, c->inuse, c->state, c->dir, cmds);
return readstr(offset, p, n, up->genbuf);
case Qdata:
case Qstderr:
fd = 1;
if(TYPE(ch->qid) == Qstderr)
fd = 2;
c = cmd.conv[CONV(ch->qid)];
qlock(&c->l);
if(c->fd[fd] == -1){
qunlock(&c->l);
return 0;
}
qunlock(&c->l);
osenter();
n = read(c->fd[fd], a, n);
osleave();
if(n < 0)
oserror();
return n;
case Qwait:
c = cmd.conv[CONV(ch->qid)];
return qread(c->waitq, a, n);
}
}
long
ipread(Chan *ch, void *a, long n, vlong offset)
{
int r;
Conv *c;
Proto *x;
uchar ip[4];
char buf[128], *p;
/*print("ipread %s %lux\n", c2name(ch), (long)ch->qid.path);*/
p = a;
switch(TYPE(ch->qid)) {
default:
error(Eperm);
case Qcs:
return csread(ch, a, n, offset);
case Qprotodir:
case Qtopdir:
case Qconvdir:
return devdirread(ch, a, n, 0, 0, ipgen);
case Qctl:
sprint(buf, "%d", CONV(ch->qid));
return readstr(offset, p, n, buf);
case Qremote:
c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)];
hnputl(ip, c->raddr);
sprint(buf, "%I!%d\n", ip, c->rport);
return readstr(offset, p, n, buf);
case Qlocal:
c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)];
hnputl(ip, c->laddr);
sprint(buf, "%I!%d\n", ip, c->lport);
return readstr(offset, p, n, buf);
case Qstatus:
x = &proto[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
sprint(buf, "%s/%d %d %s \n",
c->p->name, c->x, c->r.ref, c->state);
return readstr(offset, p, n, buf);
case Qdata:
c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)];
r = so_recv(c->sfd, a, n, 0);
if(r < 0){
oserrstr();
nexterror();
}
return r;
}
}
static int
cmdwstat(Chan *c, uchar *dp, int n)
{
Dir *d;
Conv *cv;
switch(TYPE(c->qid)){
default:
error(Eperm);
case Qctl:
case Qdata:
case Qstderr:
d = malloc(sizeof(*d)+n);
if(d == nil)
error(Enomem);
if(waserror()){
free(d);
nexterror();
}
n = convM2D(dp, n, d, (char*)&d[1]);
if(n == 0)
error(Eshortstat);
cv = cmd.conv[CONV(c->qid)];
if(!iseve() && strcmp(up->env->user, cv->owner) != 0)
error(Eperm);
if(!emptystr(d->uid))
kstrdup(&cv->owner, d->uid);
if(d->mode != ~0UL)
cv->perm = d->mode & 0777;
poperror();
free(d);
break;
}
return n;
}
static int
ipwstat(Chan *c, uchar *dp, int n)
{
Dir d;
Conv *cv;
Fs *f;
Proto *p;
f = ipfs[c->dev];
switch(TYPE(c->qid)) {
default:
error(Eperm);
break;
case Qctl:
case Qdata:
break;
}
n = convM2D(dp, n, &d, nil);
if(n > 0){
p = f->p[PROTO(c->qid)];
cv = p->conv[CONV(c->qid)];
if(!iseve() && strcmp(ATTACHER(c), cv->owner) != 0)
error(Eperm);
if(d.uid[0])
kstrdup(&cv->owner, d.uid);
cv->perm = d.mode & 0777;
}
return n;
}
static long
ipbwrite(Chan* ch, Block* bp, ulong offset)
{
Conv *c;
Proto *x;
Fs *f;
int n;
switch(TYPE(ch->qid)){
case Qdata:
f = ipfs[ch->dev];
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
if(c->wq == nil)
error(Eperm);
if(bp->next)
bp = concatblock(bp);
n = BLEN(bp);
qbwrite(c->wq, bp);
return n;
default:
return devbwrite(ch, bp, offset);
}
}
void
ipclose(Chan *c)
{
Conv *cc;
switch(TYPE(c->qid)) {
case Qcs:
csclose(c);
break;
case Qdata:
case Qctl:
if((c->flag & COPEN) == 0)
break;
cc = proto[PROTO(c->qid)].conv[CONV(c->qid)];
if(decref(&cc->r) != 0)
break;
strcpy(cc->owner, "network");
cc->perm = 0666;
cc->state = "Closed";
cc->laddr = 0;
cc->raddr = 0;
cc->lport = 0;
cc->rport = 0;
close(cc->sfd);
break;
}
}
/* BAD Sheets need work */
void parse_sheet (int fd)
{
char localbuf[1000];
char filename[1000];
char filetext[1000];
int size;
int index;
int n;
int x1,y1,x2,y2;
size = read_block(fd,localbuf,15,sizeof(localbuf));
// fprintf(stderr,"Sheet %d bytes\n",size);
x1=CONVX(CONV16(localbuf,0));
y1=CONVY(CONV16(localbuf,2));
x2=CONV(CONV16(localbuf,4));
y2=CONV(CONV16(localbuf,6));
index = 8;
/* BAD 5 bytes - dunno? */
index += 5;
n = 1+read_string(filename,sizeof(filename),localbuf+index);
index += n;
n = 1+read_string(filetext,sizeof(filetext),localbuf+index);
index += n;
/* BAD Implement Hierarchy properly! */
fprintf(stderr,"Hierarchy\n");
fprintf(stderr,"xy = %d %d %d %d\n",x1,y1,x2,y2);
for (n=8; n<13; ++n) fprintf(stderr,"%02x ",localbuf[n] & 0xff);
fprintf(stderr,"\nfile = %s\n",filename);
fprintf(stderr,"text = %s\n",filetext);
/* BAD not the way to do it... */
fprintf(stdout,"C %d %d 0 0 0 include-1.sym\n",x1,y1-y2);
fprintf(stdout,"{\n");
fprintf(stdout,"B %d %d %d %d %d 0 0 0 -1 -1 0 -1 -1 -1 -1 -1\n",
x1,y1-y2,x2,y2,GRAPHIC_COLOR);
fprintf(stdout,"T %d %d %d %d 0 1 0 0\n"
"source=%s\n",x1,y1-y2,ATTRIBUTE_COLOR,TEXTSIZE,filename);
fprintf(stdout,"T %d %d %d %d 1 1 0 0\n"
"%s\n",x1,(y1-y2)-scale,ATTRIBUTE_COLOR,TEXTSIZE,filetext);
fprintf(stdout,"}\n");
}
static int
ip3gen(Chan *c, int i, Dir *dp)
{
Qid q;
Conv *cv;
char *p;
cv = ipfs[c->dev]->p[PROTO(c->qid)]->conv[CONV(c->qid)];
if(cv->owner == nil)
kstrdup(&cv->owner, eve);
mkqid(&q, QID(PROTO(c->qid), CONV(c->qid), i), 0, QTFILE);
switch(i) {
default:
return -1;
case Qctl:
devdir(c, q, "ctl", 0, cv->owner, cv->perm, dp);
return 1;
case Qdata:
devdir(c, q, "data", qlen(cv->rq), cv->owner, cv->perm, dp);
return 1;
case Qerr:
devdir(c, q, "err", qlen(cv->eq), cv->owner, cv->perm, dp);
return 1;
case Qlisten:
devdir(c, q, "listen", 0, cv->owner, cv->perm, dp);
return 1;
case Qlocal:
p = "local";
break;
case Qremote:
p = "remote";
break;
case Qsnoop:
if(strcmp(cv->p->name, "ipifc") != 0)
return -1;
devdir(c, q, "snoop", qlen(cv->sq), cv->owner, 0400, dp);
return 1;
case Qstatus:
p = "status";
break;
}
devdir(c, q, p, 0, cv->owner, 0444, dp);
return 1;
}
void convert_packet (struct rtp_packet_t *packet, enum conversion conv_dir)
{
if (conv_dir == NTOH)
{
#define CONV(var) var = ntohs ((uint16_t) var);
}
else
{
#define CONV(var) var = ntohs ((uint16_t) var);
}
CONV (packet->connection_id);
CONV (packet->type);
CONV (packet->status);
char tmp[PATH_LEN];
string_byte_order_convert (tmp, packet->buffer, PATH_LEN, conv_dir);
strcpy (packet->buffer, tmp);
}
// qemu seems to use 24-hour GWT and the values are BCD encoded
void
cmostime(struct rtcdate *r)
{
struct rtcdate t1, t2;
int sb, bcd;
sb = cmos_read(CMOS_STATB);
bcd = (sb & (1 << 2)) == 0;
// make sure CMOS doesn't modify time while we read it
for(;;) {
fill_rtcdate(&t1);
if(cmos_read(CMOS_STATA) & CMOS_UIP)
continue;
fill_rtcdate(&t2);
if(memcmp(&t1, &t2, sizeof(t1)) == 0)
break;
}
// convert
if(bcd) {
#define CONV(x) (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xf))
CONV(second);
CONV(minute);
CONV(hour );
CONV(day );
CONV(month );
CONV(year );
#undef CONV
}
*r = t1;
r->year += 2000;
}
static int
cmd3gen(Chan *c, int i, Dir *dp)
{
Qid q;
Conv *cv;
cv = cmd.conv[CONV(c->qid)];
switch(i){
default:
return -1;
case Qdata:
mkqid(&q, QID(CONV(c->qid), Qdata), 0, QTFILE);
devdir(c, q, "data", 0, cv->owner, cv->perm, dp);
return 1;
case Qstderr:
mkqid(&q, QID(CONV(c->qid), Qstderr), 0, QTFILE);
devdir(c, q, "stderr", 0, cv->owner, 0444, dp);
return 1;
case Qctl:
mkqid(&q, QID(CONV(c->qid), Qctl), 0, QTFILE);
devdir(c, q, "ctl", 0, cv->owner, cv->perm, dp);
return 1;
case Qstatus:
mkqid(&q, QID(CONV(c->qid), Qstatus), 0, QTFILE);
devdir(c, q, "status", 0, cv->owner, 0444, dp);
return 1;
case Qwait:
mkqid(&q, QID(CONV(c->qid), Qwait), 0, QTFILE);
devdir(c, q, "wait", 0, cv->owner, 0444, dp);
return 1;
}
}
static void
ipclose(Chan *c)
{
Fs *f;
f = ipfs[c->dev];
switch(TYPE(c->qid)) {
case Qdata:
case Qctl:
if(c->flag & COPEN)
closeconv(f->p[PROTO(c->qid)]->conv[CONV(c->qid)]);
break;
}
}
static Block*
ipbread(Chan* ch, long n, ulong offset)
{
Conv *c;
Proto *x;
Fs *f;
switch(TYPE(ch->qid)){
case Qdata:
f = ipfs[ch->dev];
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
return qbread(c->rq, n);
default:
return devbread(ch, n, offset);
}
}
static void
cmdclose(Chan *c)
{
Conv *cc;
int r;
if((c->flag & COPEN) == 0)
return;
switch(TYPE(c->qid)) {
case Qctl:
case Qalloc:
case Qexec:
case Qdata:
case Qstderr:
case Qwait:
cc = cmd.conv[CONV(c->qid)];
qlock(&cc->l);
if(TYPE(c->qid) == Qdata){
if(c->mode == OWRITE || c->mode == ORDWR)
cmdfdclose(cc, 0);
if(c->mode == OREAD || c->mode == ORDWR)
cmdfdclose(cc, 1);
}else if(TYPE(c->qid) == Qstderr)
cmdfdclose(cc, 2);
r = --cc->inuse;
if(cc->child != nil){
if(!cc->killed)
if(r == 0 || (cc->killonclose && TYPE(c->qid) == Qctl)){
// oscmdkill(cc->child);
cc->killed = 1;
}
}else if(r == 0)
closeconv(cc);
qunlock(&cc->l);
break;
}
}
static int
ipwstat(Chan *c, uchar *dp, int n)
{
Dir *d;
Conv *cv;
Proto *p;
Fs *f;
f = ipfs[c->dev];
switch(TYPE(c->qid)) {
default:
error(Eperm);
break;
case Qctl:
case Qdata:
break;
}
d = smalloc(sizeof(*d)+n);
if(waserror()){
free(d);
nexterror();
}
n = convM2D(dp, n, d, (char*)&d[1]);
if(n == 0)
error(Eshortstat);
p = f->p[PROTO(c->qid)];
cv = p->conv[CONV(c->qid)];
if(!iseve() && strcmp(up->env->user, cv->owner) != 0)
error(Eperm);
if(!emptystr(d->uid))
kstrdup(&cv->owner, d->uid);
if(d->mode != ~0UL)
cv->perm = d->mode & 0777;
poperror();
free(d);
return n;
}
int main(int argc, char **argv)
{
FILE *in = stdin, *out = stdout;
progname = basename(*argv);
if (*(argv+1)) {
in = fopen(*(argv+1), "rb");
if (!in) return 1;
}
if (*(argv+1) && *(argv+2)) {
out = fopen(*(argv+2), "wb");
if (!out) return 2;
}
if (0) {}
/* host to target functions */
CONV(htobe16, x16)
CONV(htole16, x16)
CONV(htobe32, x32)
CONV(htole32, x32)
CONV(htobe64, x64)
CONV(htole64, x64)
/* from target to host functions */
CONV(be16toh, x16)
CONV(le16toh, x16)
CONV(be32toh, x32)
CONV(le32toh, x32)
CONV(be64toh, x64)
CONV(le64toh, x64)
else usage();
fclose(in);
fclose(out);
return 0;
}
int find(buffer * const b, const char *pattern, const bool skip_first) {
bool recompile_string;
if (!pattern) {
pattern = b->find_string;
recompile_string = b->find_string_changed || b->last_was_regexp;
}
else recompile_string = true;
const int m = strlen(pattern);
if (!pattern || !m) return ERROR;
if (recompile_string) for(int i = 0; i < sizeof d / sizeof *d; i++) d[i] = m;
const unsigned char * const up_case = b->encoding == ENC_UTF8 ? ascii_up_case : localised_up_case;
const bool sense_case = (b->opt.case_search != 0);
line_desc *ld = b->cur_line_desc;
int64_t y = b->cur_line;
stop = false;
if (! b->opt.search_back) {
if (recompile_string) {
for(int i = 0; i < m - 1; i++) d[CONV((unsigned char)pattern[i])] = m - i-1;
b->find_string_changed = 0;
}
char * p = ld->line + b->cur_pos + m - 1 + (skip_first ? 1 : 0);
const unsigned char first_char = CONV((unsigned char)pattern[m - 1]);
while(y < b->num_lines && !stop) {
assert(ld->ld_node.next != NULL);
if (ld->line_len >= m) {
while((p - ld->line) < ld->line_len) {
const unsigned char c = CONV((unsigned char)*p);
if (c != first_char) p += d[c];
else {
int i;
for (i = 1; i < m; i++)
if (CONV((unsigned char)*(p - i)) != CONV((unsigned char)pattern[m - i-1])) {
p += d[c];
break;
}
if (i == m) {
goto_line(b, y);
goto_pos(b, (p - ld->line) - m + 1);
return OK;
}
}
}
}
ld = (line_desc *)ld->ld_node.next;
if (ld->ld_node.next) p = ld->line + m-1;
y++;
}
}
else {
if (recompile_string) {
for(int i = m - 1; i > 0; i--) d[CONV((unsigned char)pattern[i])] = i;
b->find_string_changed = 0;
}
char * p = ld->line + (b->cur_pos > ld->line_len - m ? ld->line_len - m : b->cur_pos + (skip_first ? -1 : 0));
const unsigned char first_char = CONV((unsigned char)pattern[0]);
while(y >= 0 && !stop) {
assert(ld->ld_node.prev != NULL);
if (ld->line_len >= m) {
while((p - ld->line) >= 0) {
const unsigned char c = CONV((unsigned char)*p);
if (c != first_char) p -= d[c];
else {
int i;
for (i = 1; i < m; i++)
if (CONV((unsigned char)*(p + i)) != CONV((unsigned char)pattern[i])) {
p -= d[c];
break;
}
if (i == m) {
goto_line(b, y);
goto_pos(b, p - ld->line);
return OK;
}
}
}
}
ld = (line_desc *)ld->ld_node.prev;
if (ld->ld_node.prev) p = ld->line + ld->line_len - m;
y--;
}
}
return stop ? STOPPED : NOT_FOUND;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: icvCalcOpticalFlowLK_8u32fR ( Lucas & Kanade method )
// Purpose: calculate Optical flow for 2 images using Lucas & Kanade algorithm
// Context:
// Parameters:
// imgA, // pointer to first frame ROI
// imgB, // pointer to second frame ROI
// imgStep, // width of single row of source images in bytes
// imgSize, // size of the source image ROI
// winSize, // size of the averaging window used for grouping
// velocityX, // pointer to horizontal and
// velocityY, // vertical components of optical flow ROI
// velStep // width of single row of velocity frames in bytes
//
// Returns: CV_OK - all ok
// CV_OUTOFMEM_ERR - insufficient memory for function work
// CV_NULLPTR_ERR - if one of input pointers is NULL
// CV_BADSIZE_ERR - wrong input sizes interrelation
//
// Notes: 1.Optical flow to be computed for every pixel in ROI
// 2.For calculating spatial derivatives we use 3x3 Sobel operator.
// 3.We use the following border mode.
// The last row or column is replicated for the border
// ( IPL_BORDER_REPLICATE in IPL ).
//
//
//F*/
static CvStatus CV_STDCALL
icvCalcOpticalFlowLK_8u32fR(uchar* imgA,
uchar* imgB,
int imgStep,
CvSize imgSize,
CvSize winSize,
float* velocityX,
float* velocityY, int velStep) {
/* Loops indexes */
int i, j, k;
/* Gaussian separable kernels */
float GaussX[16];
float GaussY[16];
float* KerX;
float* KerY;
/* Buffers for Sobel calculations */
float* MemX[2];
float* MemY[2];
float ConvX, ConvY;
float GradX, GradY, GradT;
int winWidth = winSize.width;
int winHeight = winSize.height;
int imageWidth = imgSize.width;
int imageHeight = imgSize.height;
int HorRadius = (winWidth - 1) >> 1;
int VerRadius = (winHeight - 1) >> 1;
int PixelLine;
int ConvLine;
int BufferAddress;
int BufferHeight = 0;
int BufferWidth;
int BufferSize;
/* buffers derivatives product */
icvDerProduct* II;
/* buffers for gaussian horisontal convolution */
icvDerProduct* WII;
/* variables for storing number of first pixel of image line */
int Line1;
int Line2;
int Line3;
/* we must have 2*2 linear system coeffs
| A1B2 B1 | {u} {C1} {0}
| | { } + { } = { }
| A2 A1B2 | {v} {C2} {0}
*/
float A1B2, A2, B1, C1, C2;
int pixNumber;
/* auxiliary */
int NoMem = 0;
velStep /= sizeof(velocityX[0]);
/* Checking bad arguments */
if (imgA == NULL) {
return CV_NULLPTR_ERR;
}
if (imgB == NULL) {
return CV_NULLPTR_ERR;
}
if (imageHeight < winHeight) {
return CV_BADSIZE_ERR;
}
if (imageWidth < winWidth) {
return CV_BADSIZE_ERR;
}
if (winHeight >= 16) {
return CV_BADSIZE_ERR;
}
if (winWidth >= 16) {
return CV_BADSIZE_ERR;
}
if (!(winHeight & 1)) {
return CV_BADSIZE_ERR;
}
if (!(winWidth & 1)) {
return CV_BADSIZE_ERR;
}
BufferHeight = winHeight;
BufferWidth = imageWidth;
/****************************************************************************************/
/* Computing Gaussian coeffs */
/****************************************************************************************/
GaussX[0] = 1;
GaussY[0] = 1;
for (i = 1; i < winWidth; i++) {
GaussX[i] = 1;
for (j = i - 1; j > 0; j--) {
GaussX[j] += GaussX[j - 1];
}
}
for (i = 1; i < winHeight; i++) {
GaussY[i] = 1;
for (j = i - 1; j > 0; j--) {
GaussY[j] += GaussY[j - 1];
}
}
KerX = &GaussX[HorRadius];
KerY = &GaussY[VerRadius];
/****************************************************************************************/
/* Allocating memory for all buffers */
/****************************************************************************************/
for (k = 0; k < 2; k++) {
MemX[k] = (float*) cvAlloc((imgSize.height) * sizeof(float));
if (MemX[k] == NULL) {
NoMem = 1;
}
MemY[k] = (float*) cvAlloc((imgSize.width) * sizeof(float));
if (MemY[k] == NULL) {
NoMem = 1;
}
}
BufferSize = BufferHeight * BufferWidth;
II = (icvDerProduct*) cvAlloc(BufferSize * sizeof(icvDerProduct));
WII = (icvDerProduct*) cvAlloc(BufferSize * sizeof(icvDerProduct));
if ((II == NULL) || (WII == NULL)) {
NoMem = 1;
}
if (NoMem) {
for (k = 0; k < 2; k++) {
if (MemX[k]) {
cvFree(&MemX[k]);
}
if (MemY[k]) {
cvFree(&MemY[k]);
}
}
if (II) {
cvFree(&II);
}
if (WII) {
cvFree(&WII);
}
return CV_OUTOFMEM_ERR;
}
/****************************************************************************************/
/* Calculate first line of memX and memY */
/****************************************************************************************/
MemY[0][0] = MemY[1][0] = CONV(imgA[0], imgA[0], imgA[1]);
MemX[0][0] = MemX[1][0] = CONV(imgA[0], imgA[0], imgA[imgStep]);
for (j = 1; j < imageWidth - 1; j++) {
MemY[0][j] = MemY[1][j] = CONV(imgA[j - 1], imgA[j], imgA[j + 1]);
}
pixNumber = imgStep;
for (i = 1; i < imageHeight - 1; i++) {
MemX[0][i] = MemX[1][i] = CONV(imgA[pixNumber - imgStep],
imgA[pixNumber], imgA[pixNumber + imgStep]);
pixNumber += imgStep;
}
MemY[0][imageWidth - 1] =
MemY[1][imageWidth - 1] = CONV(imgA[imageWidth - 2],
imgA[imageWidth - 1], imgA[imageWidth - 1]);
MemX[0][imageHeight - 1] =
MemX[1][imageHeight - 1] = CONV(imgA[pixNumber - imgStep],
imgA[pixNumber], imgA[pixNumber]);
/****************************************************************************************/
/* begin scan image, calc derivatives and solve system */
/****************************************************************************************/
PixelLine = -VerRadius;
ConvLine = 0;
BufferAddress = -BufferWidth;
while (PixelLine < imageHeight) {
if (ConvLine < imageHeight) {
/*Here we calculate derivatives for line of image */
int address;
i = ConvLine;
int L1 = i - 1;
int L2 = i;
int L3 = i + 1;
int memYline = L3 & 1;
if (L1 < 0) {
L1 = 0;
}
if (L3 >= imageHeight) {
L3 = imageHeight - 1;
}
BufferAddress += BufferWidth;
BufferAddress -= ((BufferAddress >= BufferSize) ? 0xffffffff : 0) & BufferSize;
address = BufferAddress;
Line1 = L1 * imgStep;
Line2 = L2 * imgStep;
Line3 = L3 * imgStep;
/* Process first pixel */
ConvX = CONV(imgA[Line1 + 1], imgA[Line2 + 1], imgA[Line3 + 1]);
ConvY = CONV(imgA[Line3], imgA[Line3], imgA[Line3 + 1]);
GradY = ConvY - MemY[memYline][0];
GradX = ConvX - MemX[1][L2];
MemY[memYline][0] = ConvY;
MemX[1][L2] = ConvX;
GradT = (float)(imgB[Line2] - imgA[Line2]);
II[address].xx = GradX * GradX;
II[address].xy = GradX * GradY;
II[address].yy = GradY * GradY;
II[address].xt = GradX * GradT;
II[address].yt = GradY * GradT;
address++;
/* Process middle of line */
for (j = 1; j < imageWidth - 1; j++) {
ConvX = CONV(imgA[Line1 + j + 1], imgA[Line2 + j + 1], imgA[Line3 + j + 1]);
ConvY = CONV(imgA[Line3 + j - 1], imgA[Line3 + j], imgA[Line3 + j + 1]);
GradY = ConvY - MemY[memYline][j];
GradX = ConvX - MemX[(j - 1) & 1][L2];
MemY[memYline][j] = ConvY;
MemX[(j - 1) & 1][L2] = ConvX;
GradT = (float)(imgB[Line2 + j] - imgA[Line2 + j]);
II[address].xx = GradX * GradX;
II[address].xy = GradX * GradY;
II[address].yy = GradY * GradY;
II[address].xt = GradX * GradT;
II[address].yt = GradY * GradT;
address++;
}
/* Process last pixel of line */
ConvX = CONV(imgA[Line1 + imageWidth - 1], imgA[Line2 + imageWidth - 1],
imgA[Line3 + imageWidth - 1]);
ConvY = CONV(imgA[Line3 + imageWidth - 2], imgA[Line3 + imageWidth - 1],
imgA[Line3 + imageWidth - 1]);
GradY = ConvY - MemY[memYline][imageWidth - 1];
GradX = ConvX - MemX[(imageWidth - 2) & 1][L2];
MemY[memYline][imageWidth - 1] = ConvY;
GradT = (float)(imgB[Line2 + imageWidth - 1] - imgA[Line2 + imageWidth - 1]);
II[address].xx = GradX * GradX;
II[address].xy = GradX * GradY;
II[address].yy = GradY * GradY;
II[address].xt = GradX * GradT;
II[address].yt = GradY * GradT;
address++;
/* End of derivatives for line */
/****************************************************************************************/
/* ---------Calculating horizontal convolution of processed line----------------------- */
/****************************************************************************************/
address -= BufferWidth;
/* process first HorRadius pixels */
for (j = 0; j < HorRadius; j++) {
int jj;
WII[address].xx = 0;
WII[address].xy = 0;
WII[address].yy = 0;
WII[address].xt = 0;
WII[address].yt = 0;
for (jj = -j; jj <= HorRadius; jj++) {
float Ker = KerX[jj];
WII[address].xx += II[address + jj].xx * Ker;
WII[address].xy += II[address + jj].xy * Ker;
WII[address].yy += II[address + jj].yy * Ker;
WII[address].xt += II[address + jj].xt * Ker;
WII[address].yt += II[address + jj].yt * Ker;
}
address++;
}
/* process inner part of line */
for (j = HorRadius; j < imageWidth - HorRadius; j++) {
int jj;
float Ker0 = KerX[0];
WII[address].xx = 0;
WII[address].xy = 0;
WII[address].yy = 0;
WII[address].xt = 0;
WII[address].yt = 0;
for (jj = 1; jj <= HorRadius; jj++) {
float Ker = KerX[jj];
WII[address].xx += (II[address - jj].xx + II[address + jj].xx) * Ker;
WII[address].xy += (II[address - jj].xy + II[address + jj].xy) * Ker;
WII[address].yy += (II[address - jj].yy + II[address + jj].yy) * Ker;
WII[address].xt += (II[address - jj].xt + II[address + jj].xt) * Ker;
WII[address].yt += (II[address - jj].yt + II[address + jj].yt) * Ker;
}
WII[address].xx += II[address].xx * Ker0;
WII[address].xy += II[address].xy * Ker0;
WII[address].yy += II[address].yy * Ker0;
WII[address].xt += II[address].xt * Ker0;
WII[address].yt += II[address].yt * Ker0;
address++;
}
/* process right side */
for (j = imageWidth - HorRadius; j < imageWidth; j++) {
int jj;
WII[address].xx = 0;
WII[address].xy = 0;
WII[address].yy = 0;
WII[address].xt = 0;
WII[address].yt = 0;
for (jj = -HorRadius; jj < imageWidth - j; jj++) {
float Ker = KerX[jj];
WII[address].xx += II[address + jj].xx * Ker;
WII[address].xy += II[address + jj].xy * Ker;
WII[address].yy += II[address + jj].yy * Ker;
WII[address].xt += II[address + jj].xt * Ker;
WII[address].yt += II[address + jj].yt * Ker;
}
address++;
}
}
/****************************************************************************************/
/* Calculating velocity line */
/****************************************************************************************/
if (PixelLine >= 0) {
int USpace;
int BSpace;
int address;
if (PixelLine < VerRadius) {
USpace = PixelLine;
} else {
USpace = VerRadius;
}
if (PixelLine >= imageHeight - VerRadius) {
BSpace = imageHeight - PixelLine - 1;
} else {
BSpace = VerRadius;
}
address = ((PixelLine - USpace) % BufferHeight) * BufferWidth;
for (j = 0; j < imageWidth; j++) {
int addr = address;
A1B2 = 0;
A2 = 0;
B1 = 0;
C1 = 0;
C2 = 0;
for (i = -USpace; i <= BSpace; i++) {
A2 += WII[addr + j].xx * KerY[i];
A1B2 += WII[addr + j].xy * KerY[i];
B1 += WII[addr + j].yy * KerY[i];
C2 += WII[addr + j].xt * KerY[i];
C1 += WII[addr + j].yt * KerY[i];
addr += BufferWidth;
addr -= ((addr >= BufferSize) ? 0xffffffff : 0) & BufferSize;
}
/****************************************************************************************\
* Solve Linear System *
\****************************************************************************************/
{
float delta = (A1B2 * A1B2 - A2 * B1);
if (delta) {
/* system is not singular - solving by Kramer method */
float deltaX;
float deltaY;
float Idelta = 8 / delta;
deltaX = -(C1 * A1B2 - C2 * B1);
deltaY = -(A1B2 * C2 - A2 * C1);
velocityX[j] = deltaX * Idelta;
velocityY[j] = deltaY * Idelta;
} else {
/* singular system - find optical flow in gradient direction */
float Norm = (A1B2 + A2) * (A1B2 + A2) + (B1 + A1B2) * (B1 + A1B2);
if (Norm) {
float IGradNorm = 8 / Norm;
float temp = -(C1 + C2) * IGradNorm;
velocityX[j] = (A1B2 + A2) * temp;
velocityY[j] = (B1 + A1B2) * temp;
} else {
velocityX[j] = 0;
velocityY[j] = 0;
}
}
}
/****************************************************************************************\
* End of Solving Linear System *
\****************************************************************************************/
} /*for */
velocityX += velStep;
velocityY += velStep;
} /*for */
PixelLine++;
ConvLine++;
}
/* Free memory */
for (k = 0; k < 2; k++) {
cvFree(&MemX[k]);
cvFree(&MemY[k]);
}
cvFree(&II);
cvFree(&WII);
return CV_OK;
} /*icvCalcOpticalFlowLK_8u32fR*/
static void to_PCM_16bit(NeAACDecHandle hDecoder, real_t **input,
uint8_t channels, uint16_t frame_len,
int16_t **sample_buffer)
{
uint8_t ch, ch1;
uint16_t i;
switch (CONV(channels,hDecoder->downMatrix))
{
case CONV(1,0):
case CONV(1,1):
for(i = 0; i < frame_len; i++)
{
real_t inp = input[hDecoder->internal_channel[0]][i];
CLIP(inp, 32767.0f, -32768.0f);
(*sample_buffer)[i] = (int16_t)lrintf(inp);
}
break;
case CONV(2,0):
if (hDecoder->upMatrix)
{
ch = hDecoder->internal_channel[0];
for(i = 0; i < frame_len; i++)
{
real_t inp0 = input[ch][i];
CLIP(inp0, 32767.0f, -32768.0f);
(*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);
(*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp0);
}
} else {
ch = hDecoder->internal_channel[0];
ch1 = hDecoder->internal_channel[1];
for(i = 0; i < frame_len; i++)
{
real_t inp0 = input[ch ][i];
real_t inp1 = input[ch1][i];
CLIP(inp0, 32767.0f, -32768.0f);
CLIP(inp1, 32767.0f, -32768.0f);
(*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);
(*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp1);
}
}
break;
default:
for (ch = 0; ch < channels; ch++)
{
for(i = 0; i < frame_len; i++)
{
real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
CLIP(inp, 32767.0f, -32768.0f);
(*sample_buffer)[(i*channels)+ch] = (int16_t)lrintf(inp);
}
}
break;
}
}
static Chan *
ipopen(Chan *c, int omode)
{
Conv *cv, *nc;
Proto *p;
uchar raddr[IPaddrlen];
ushort rport;
int perm, sfd;
Fs *f;
perm = m2p[omode&3];
f = ipfs[c->dev];
switch(TYPE(c->qid)) {
default:
break;
case Qtopdir:
case Qprotodir:
case Qconvdir:
case Qstatus:
case Qremote:
case Qlocal:
case Qstats:
/* case Qipselftab: */
if(omode != OREAD)
error(Eperm);
break;
case Qndb:
if(omode & (OWRITE|OTRUNC) && !iseve())
error(Eperm);
if((omode & (OWRITE|OTRUNC)) == (OWRITE|OTRUNC)){
f->ndb[0] = 0;
f->ndbvers++;
}
break;
case Qclone:
p = f->p[PROTO(c->qid)];
cv = protoclone(p, up->env->user, -1);
if(cv == 0)
error(Enodev);
mkqid(&c->qid, QID(p->x, cv->x, Qctl), 0, QTFILE);
break;
case Qdata:
case Qctl:
p = f->p[PROTO(c->qid)];
qlock(&p->l);
cv = p->conv[CONV(c->qid)];
qlock(&cv->l);
if(waserror()){
qunlock(&cv->l);
qunlock(&p->l);
nexterror();
}
if((perm & (cv->perm>>6)) != perm) {
if(strcmp(up->env->user, cv->owner) != 0)
error(Eperm);
if((perm & cv->perm) != perm)
error(Eperm);
}
cv->inuse++;
if(cv->inuse == 1) {
kstrdup(&cv->owner, up->env->user);
cv->perm = 0660;
if(cv->sfd < 0)
cv->sfd = so_socket(p->stype);
}
poperror();
qunlock(&cv->l);
qunlock(&p->l);
break;
case Qlisten:
p = f->p[PROTO(c->qid)];
cv = p->conv[CONV(c->qid)];
if((perm & (cv->perm>>6)) != perm){
if(strcmp(up->env->user, cv->owner) != 0)
error(Eperm);
if((perm & cv->perm) != perm)
error(Eperm);
}
if(cv->state != Announced)
error("not announced");
qlock(&cv->listenq);
if(waserror()){
qunlock(&cv->listenq);
nexterror();
}
sfd = so_accept(cv->sfd, raddr, &rport);
nc = protoclone(p, up->env->user, sfd);
if(nc == 0) {
so_close(sfd);
error(Enodev);
}
memmove(nc->raddr, raddr, IPaddrlen);
nc->rport = rport;
setladdr(nc);
nc->state = Connected;
mkqid(&c->qid, QID(PROTO(c->qid), nc->x, Qctl), 0, QTFILE);
poperror();
qunlock(&cv->listenq);
break;
}
c->mode = openmode(omode);
c->flag |= COPEN;
c->offset = 0;
return c;
}
static long
ipread(Chan *ch, void *a, long n, vlong off)
{
int r;
Conv *c;
Proto *x;
char *p, *s;
Fs *f;
ulong offset = off;
f = ipfs[ch->dev];
p = a;
switch(TYPE(ch->qid)) {
default:
error(Eperm);
case Qprotodir:
case Qtopdir:
case Qconvdir:
return devdirread(ch, a, n, 0, 0, ipgen);
case Qarp:
error(Eperm); /* TO DO */
case Qndb:
return readstr(off, a, n, f->ndb);
case Qctl:
sprint(up->genbuf, "%lud", CONV(ch->qid));
return readstr(offset, p, n, up->genbuf);
case Qremote:
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
sprint(up->genbuf, "%I!%d\n", c->raddr, c->rport);
return readstr(offset, p, n, up->genbuf);
case Qlocal:
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
sprint(up->genbuf, "%I!%d\n", c->laddr, c->lport);
return readstr(offset, p, n, up->genbuf);
case Qstatus:
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
s = smalloc(Statelen);
if(waserror()){
free(s);
nexterror();
}
snprint(s, Statelen, "%s\n", ipstates[c->state]);
n = readstr(offset, p, n, s);
poperror();
free(s);
return n;
case Qdata:
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
if(c->sfd < 0)
error(Ehungup);
if(c->headers) {
if(n < c->headers)
error(Ebadarg);
p = a;
r = so_recv(c->sfd, p + c->headers, n - c->headers, p, c->headers);
if(r > 0)
r += c->headers;
} else
r = so_recv(c->sfd, a, n, nil, 0);
if(r < 0)
oserror();
return r;
case Qstats:
error("stats not implemented");
return n;
}
}
static long
ipwrite(Chan *ch, void *a, long n, vlong off)
{
Conv *c;
Proto *x;
char *p;
Cmdbuf *cb;
Fs *f;
f = ipfs[ch->dev];
switch(TYPE(ch->qid)) {
default:
error(Eperm);
case Qdata:
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
if(c->sfd < 0)
error(Ehungup);
qlock(&c->wlock);
if(waserror()){
qunlock(&c->wlock);
nexterror();
}
if(c->headers) {
if(n < c->headers)
error(Eshort);
p = a;
n = so_send(c->sfd, p + c->headers, n - c->headers, p, c->headers);
if(n >= 0)
n += c->headers;
} else
n = so_send(c->sfd, a, n, nil, 0);
poperror();
qunlock(&c->wlock);
if(n < 0)
oserror();
break;
case Qarp:
return arpwrite(a, n);
case Qndb:
if(off > strlen(f->ndb))
error(Eio);
if(off+n >= sizeof(f->ndb)-1)
error(Eio);
memmove(f->ndb+off, a, n);
f->ndb[off+n] = 0;
f->ndbvers++;
f->ndbmtime = seconds();
break;
case Qctl:
x = f->p[PROTO(ch->qid)];
c = x->conv[CONV(ch->qid)];
cb = parsecmd(a, n);
qlock(&c->l);
if(waserror()){
qunlock(&c->l);
free(cb);
nexterror();
}
if(cb->nf < 1)
error("short control request");
if(strcmp(cb->f[0], "connect") == 0)
connectctlmsg(x, c, cb);
else if(strcmp(cb->f[0], "announce") == 0)
announcectlmsg(x, c, cb);
else if(strcmp(cb->f[0], "bind") == 0)
bindctlmsg(x, c, cb);
else if(strcmp(cb->f[0], "ttl") == 0){
/* ignored */
} else if(strcmp(cb->f[0], "tos") == 0){
/* ignored */
} else if(strcmp(cb->f[0], "ignoreadvice") == 0){
/* ignored */
} else if(strcmp(cb->f[0], "headers4") == 0){
if(c->p->stype != S_UDP)
error(Enoctl);
c->headers = OUdphdrlenv4;
} else if(strcmp(cb->f[0], "oldheaders") == 0){
if(c->p->stype != S_UDP)
error(Enoctl);
c->headers = OUdphdrlen;
} else if(strcmp(cb->f[0], "headers") == 0){
if(c->p->stype != S_UDP)
error(Enoctl);
c->headers = Udphdrlen;
} else if(strcmp(cb->f[0], "hangup") == 0){
if(c->p->stype != S_TCP)
error(Enoctl);
qunlock(&c->l);
if(waserror()){
qlock(&c->l);
nexterror();
}
/* TO DO: check fd status if socket close/hangup interrupted */
if(c->sfd >= 0 && so_hangup(c->sfd, 1) < 0)
oserror();
qlock(&c->l);
poperror();
c->sfd = -1;
c->state = Hungup;
} else if(strcmp(cb->f[0], "keepalive") == 0){
if(c->p->stype != S_TCP)
error(Enoctl);
if(c->sfd < 0)
error("not connected");
so_keepalive(c->sfd, cb->nf>1? atoi(cb->f[1]): 0);
} else
error(Enoctl);
poperror();
qunlock(&c->l);
free(cb);
break;
}
return n;
}
int
init (void)
{
#if defined(USE_SSE2)
const Babl *rgbaF_linear = babl_format_new (
babl_model ("RGBA"),
babl_type ("float"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgbAF_linear = babl_format_new (
babl_model ("RaGaBaA"),
babl_type ("float"),
babl_component ("Ra"),
babl_component ("Ga"),
babl_component ("Ba"),
babl_component ("A"),
NULL);
const Babl *rgba16_linear = babl_format_new (
babl_model ("RGBA"),
babl_type ("u16"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgbaF_gamma = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("float"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
const Babl *rgbAF_gamma = babl_format_new (
babl_model ("R'aG'aB'aA"),
babl_type ("float"),
babl_component ("R'a"),
babl_component ("G'a"),
babl_component ("B'a"),
babl_component ("A"),
NULL);
const Babl *rgba16_gamma = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("u16"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
#define CONV(src, dst) \
{ \
babl_conversion_new (src ## _linear, dst ## _linear, "linear", conv_ ## src ## _ ## dst, NULL); \
babl_conversion_new (src ## _gamma, dst ## _gamma, "linear", conv_ ## src ## _ ## dst, NULL); \
}
if ((babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE) &&
(babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE2))
{
CONV (rgba16, rgbaF);
CONV (rgba16, rgbAF);
}
#endif /* defined(USE_SSE2) */
return 0;
}
static Chan *
cmdopen(Chan *c, int omode)
{
int perm;
Conv *cv;
char *user;
perm = 0;
omode = openmode(omode);
switch(omode) {
case OREAD:
perm = 4;
break;
case OWRITE:
perm = 2;
break;
case ORDWR:
perm = 6;
break;
}
switch(TYPE(c->qid)) {
default:
break;
case Qtopdir:
case Qcmd:
case Qconvdir:
case Qstatus:
if(omode != OREAD)
error(Eperm);
break;
case Qclonus:
qlock(&cmd.l);
if(waserror()){
qunlock(&cmd.l);
nexterror();
}
cv = cmdclone(up->env->user);
poperror();
qunlock(&cmd.l);
if(cv == 0)
error(Enodev);
mkqid(&c->qid, QID(cv->x, Qctl), 0, QTFILE);
break;
case Qdata:
case Qstderr:
case Qctl:
case Qwait:
qlock(&cmd.l);
cv = cmd.conv[CONV(c->qid)];
qlock(&cv->l);
if(waserror()){
qunlock(&cv->l);
qunlock(&cmd.l);
nexterror();
}
user = up->env->user;
if((perm & (cv->perm>>6)) != perm) {
if(strcmp(user, cv->owner) != 0 ||
(perm & cv->perm) != perm)
error(Eperm);
}
switch(TYPE(c->qid)){
case Qdata:
if(omode == OWRITE || omode == ORDWR)
cv->count[0]++;
if(omode == OREAD || omode == ORDWR)
cv->count[1]++;
break;
case Qstderr:
if(omode != OREAD)
error(Eperm);
cv->count[2]++;
break;
case Qwait:
if(cv->waitq == nil)
cv->waitq = qopen(1024, Qmsg, nil, 0);
break;
}
cv->inuse++;
if(cv->inuse == 1) {
cv->state = "Open";
kstrdup(&cv->owner, user);
cv->perm = 0660;
cv->nice = 0;
}
poperror();
qunlock(&cv->l);
qunlock(&cmd.l);
break;
}
c->mode = omode;
c->flag |= COPEN;
c->offset = 0;
return c;
}
static long
cmdwrite(Chan *ch, void *a, long n, vlong offset)
{
int i, r;
Conv *c;
Cmdbuf *cb;
Cmdtab *ct;
USED(offset);
switch(TYPE(ch->qid)) {
default:
error(Eperm);
case Qctl:
c = cmd.conv[CONV(ch->qid)];
cb = parsecmd(a, n);
if(waserror()){
free(cb);
nexterror();
}
ct = lookupcmd(cb, cmdtab, nelem(cmdtab));
switch(ct->index){
case CMdir:
kstrdup(&c->dir, cb->f[1]);
break;
case CMexec:
poperror(); /* cb */
qlock(&c->l);
if(waserror()){
qunlock(&c->l);
free(cb);
nexterror();
}
if(c->child != nil || c->cmd != nil)
error(Einuse);
for(i = 0; i < nelem(c->fd); i++)
if(c->fd[i] != -1)
error(Einuse);
if(cb->nf < 1)
error(Etoosmall);
kproc("cmdproc", cmdproc, c, 0); /* cmdproc held back until unlock below */
free(c->cmd);
c->cmd = cb; /* don't free cb */
c->state = "Execute";
poperror();
qunlock(&c->l);
while(waserror())
;
Sleep(&c->startr, cmdstarted, c);
poperror();
if(c->error)
error(c->error);
return n; /* avoid free(cb) below */
case CMkill:
qlock(&c->l);
if(waserror()){
qunlock(&c->l);
nexterror();
}
if(c->child == nil)
error("not started");
if(oscmdkill(c->child) < 0)
oserror();
poperror();
qunlock(&c->l);
break;
case CMnice:
c->nice = cb->nf > 1? atoi(cb->f[1]): 1;
break;
case CMkillonclose:
c->killonclose = 1;
break;
}
poperror();
free(cb);
break;
case Qdata:
c = cmd.conv[CONV(ch->qid)];
qlock(&c->l);
if(c->fd[0] == -1){
qunlock(&c->l);
error(Ehungup);
}
qunlock(&c->l);
osenter();
r = write(c->fd[0], a, n);
osleave();
if(r == 0)
error(Ehungup);
if(r < 0) {
/* XXX perhaps should kill writer "write on closed pipe" here, 2nd time around? */
oserror();
}
return r;
}
return n;
}
