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; }