void rtp_session_send_rtcp_APP(RtpSession *session, uint8_t subtype, const char *name, const uint8_t *data, int datalen){ mblk_t *h=allocb(sizeof(rtcp_app_t),0); mblk_t *d; h->b_wptr+=rtcp_app_init(session,h->b_wptr,subtype,name,datalen+sizeof(rtcp_app_t)); d=esballoc((uint8_t*)data,datalen,0,NULL); d->b_wptr+=datalen; h->b_cont=d; rtp_session_rtcp_send(session,h); }
LRESULT CALLBACK vfw_engine_stream_callback(HWND hWnd, LPVIDEOHDR lpVHdr) { VfwEngine *s; mblk_t *buf; int size; s = (VfwEngine *)capGetUserData(hWnd); if (s==NULL) return FALSE; size = lpVHdr->dwBufferLength; if (size>0 && s->cb!=NULL && s->started){ buf = esballoc(lpVHdr->lpData,size,0,dummy); buf->b_wptr+=size; s->cb(s->cb_data,buf); } return TRUE ; }
static int v4l_do_mmap(V4lState *s){ struct video_mbuf vmbuf; int err,i; memset(&vmbuf,0,sizeof(vmbuf)); /* try to get mmap properties */ err=ioctl(s->fd,VIDIOCGMBUF,&vmbuf); if (err<0){ ms_error("Could not get mmap properties: %s",strerror(errno)); return -1; }else { if (vmbuf.size>0){ /* do the mmap */ s->msize=vmbuf.size; s->frame_max=vmbuf.frames; } else { ms_error("This device cannot support mmap."); return -1; } } s->mmapdbuf=mmap(NULL,s->msize,PROT_READ,MAP_SHARED,s->fd,0); if (s->mmapdbuf==(void*)-1) { /* for non-mmu arch */ s->mmapdbuf=mmap(NULL,s->msize,PROT_READ,MAP_PRIVATE,s->fd,0); if (s->mmapdbuf==(void*)-1) { ms_error("Could not mmap: %s",strerror(errno)); s->mmapdbuf=NULL; return -1; } } /* initialize the mediastreamer buffers */ ms_message("Using %i-frames mmap'd buffer at %p, len %i", s->frame_max, s->mmapdbuf,s->msize); for(i=0;i<s->frame_max;i++){ mblk_t *buf=esballoc((uint8_t*)s->mmapdbuf+vmbuf.offsets[i],vmbuf.offsets[1],0,NULL); /* adjust to real size of picture*/ if (s->pix_fmt==MS_RGB24) buf->b_wptr+=s->vsize.width*s->vsize.height*3; else buf->b_wptr+=(s->vsize.width*s->vsize.height*3)/2; s->frames[i]=ms_yuv_buf_alloc_from_buffer(s->vsize.width, s->vsize.height, buf); } s->frame_ind=0; return 0; }
static int msv4l2_do_mmap(V4l2State *s){ struct v4l2_requestbuffers req; int i; enum v4l2_buf_type type; memset(&req,0,sizeof(req)); req.count = 4; req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.memory = V4L2_MEMORY_MMAP; if (v4l2_ioctl (s->fd, VIDIOC_REQBUFS, &req)<0) { ms_error("Error requesting info on mmap'd buffers: %s",strerror(errno)); return -1; } for (i=0; i<req.count; ++i) { struct v4l2_buffer buf; mblk_t *msg; void *start; memset(&buf,0,sizeof(buf)); buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory=V4L2_MEMORY_MMAP; buf.index=i; if (v4l2_ioctl (s->fd, VIDIOC_QUERYBUF, &buf)<0){ ms_error("Could not VIDIOC_QUERYBUF : %s",strerror(errno)); return -1; } start=v4l2_mmap (NULL /* start anywhere */, buf.length, PROT_READ | PROT_WRITE /* required */, MAP_SHARED /* recommended */, s->fd, buf.m.offset); if (start==NULL){ ms_error("Could not v4l2_mmap: %s",strerror(errno)); } msg=esballoc(start,buf.length,0,NULL); msg->b_wptr+=buf.length; s->frames[i]=ms_yuv_buf_alloc_from_buffer(s->vsize.width, s->vsize.height, msg); } s->frame_max=req.count; for (i = 0; i < s->frame_max; ++i) { struct v4l2_buffer buf; memset(&buf,0,sizeof(buf)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = i; if (-1==v4l2_ioctl (s->fd, VIDIOC_QBUF, &buf)){ ms_error("VIDIOC_QBUF failed: %s",strerror(errno)); }else { inc_ref(s->frames[i]); s->queued++; } } /*start capture immediately*/ type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (-1 ==v4l2_ioctl (s->fd, VIDIOC_STREAMON, &type)){ ms_error("VIDIOC_STREAMON failed: %s",strerror(errno)); return -1; } return 0; }
static int nd_send_data(TIUSER *tiptr, caddr_t addr, int offset, XDR *xdrp, uint32_t *xidp) { static struct rpc_msg call_msg; static uchar_t header[HDR_SIZE]; static struct t_kunitdata sudata; static uchar_t *dumpbuf; int procnum; stable_how stable = FILE_SYNC; mblk_t *mblk_p; int error; int tsize = ptob(1); uint64 offset3; if (!dumpbuf) { call_msg.rm_direction = CALL; call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; call_msg.rm_call.cb_prog = NFS_PROGRAM; call_msg.rm_call.cb_vers = nfsdump_version; if (!(dumpbuf = kmem_alloc(ptob(1), KM_NOSLEEP))) { cmn_err(CE_WARN, "\tnfs_dump: cannot allocate dump buffer"); return (ENOMEM); } } nd_log("nfs_dump: calling esballoc for header\n"); if (!(mblk_p = esballoc(header, HDR_SIZE, BPRI_HI, &frnop))) { cmn_err(CE_WARN, "\tnfs_dump: out of mblks"); return (ENOBUFS); } xdrmem_create(xdrp, (caddr_t)header, HDR_SIZE, XDR_ENCODE); call_msg.rm_xid = alloc_xid(); *xidp = call_msg.rm_xid; if (!xdr_callhdr(xdrp, &call_msg)) { cmn_err(CE_WARN, "\tnfs_dump: cannot serialize header"); return (EIO); } if (nfsdump_maxcount) { /* * Do not extend the dump file if it is also * the swap file. */ if (offset >= nfsdump_maxcount) { cmn_err(CE_WARN, "\tnfs_dump: end of file"); return (EIO); } if (offset + tsize > nfsdump_maxcount) tsize = nfsdump_maxcount - offset; } switch (nfsdump_version) { case NFS_VERSION: procnum = RFS_WRITE; if (!XDR_PUTINT32(xdrp, (int32_t *)&procnum) || !nd_auth_marshall(xdrp) || !xdr_fhandle(xdrp, &nfsdump_fhandle2) || /* * Following four values are: * beginoffset * offset * length * bytes array length */ !XDR_PUTINT32(xdrp, (int32_t *)&offset) || !XDR_PUTINT32(xdrp, (int32_t *)&offset) || !XDR_PUTINT32(xdrp, (int32_t *)&tsize) || !XDR_PUTINT32(xdrp, (int32_t *)&tsize)) { cmn_err(CE_WARN, "\tnfs_dump: serialization failed"); return (EIO); } break; case NFS_V3: procnum = NFSPROC3_WRITE; offset3 = offset; if (!XDR_PUTINT32(xdrp, (int32_t *)&procnum) || !nd_auth_marshall(xdrp) || !xdr_nfs_fh3(xdrp, &nfsdump_fhandle3) || /* * Following four values are: * offset * count * stable * bytes array length */ !xdr_u_longlong_t(xdrp, &offset3) || !XDR_PUTINT32(xdrp, (int32_t *)&tsize) || !XDR_PUTINT32(xdrp, (int32_t *)&stable) || !XDR_PUTINT32(xdrp, (int32_t *)&tsize)) { cmn_err(CE_WARN, "\tnfs_dump: serialization failed"); return (EIO); } break; default: return (EIO); } bcopy(addr, (caddr_t)dumpbuf, tsize); mblk_p->b_wptr += (int)XDR_GETPOS(xdrp); mblk_p->b_cont = esballoc((uchar_t *)dumpbuf, ptob(1), BPRI_HI, &frnop); if (!mblk_p->b_cont) { cmn_err(CE_WARN, "\tnfs_dump: out of mblks"); return (ENOBUFS); } mblk_p->b_cont->b_wptr += ptob(1); sudata.addr = nfsdump_addr; /* structure copy */ sudata.udata.buf = (char *)NULL; sudata.udata.maxlen = 0; sudata.udata.len = 1; /* needed for t_ksndudata */ sudata.udata.udata_mp = mblk_p; nd_log("nfs_dump: calling t_ksndudata\n"); if (error = t_ksndudata(tiptr, &sudata, (frtn_t *)NULL)) { nfs_perror(error, "\nnfs_dump: t_ksndudata failed: %m\n"); return (error); } return (0); }
static int v4lv2_do_mmap(V4lState *s){ struct v4l2_requestbuffers req; int i; enum v4l2_buf_type type; memset(&req,0,sizeof(req)); req.count = 4; req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.memory = V4L2_MEMORY_MMAP; if (ioctl (s->fd, VIDIOC_REQBUFS, &req)<0) { ms_error("Error requesting info on mmap'd buffers: %s",strerror(errno)); return -1; } for (i=0; i<req.count; ++i) { struct v4l2_buffer buf; mblk_t *msg; void *start; memset(&buf,0,sizeof(buf)); buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory=V4L2_MEMORY_MMAP; buf.index=i; if (ioctl (s->fd, VIDIOC_QUERYBUF, &buf)<0){ ms_error("Could not VIDIOC_QUERYBUF : %s",strerror(errno)); return -1; } start=mmap (NULL /* start anywhere */, buf.length, PROT_READ | PROT_WRITE /* required */, MAP_SHARED /* recommended */, s->fd, buf.m.offset); if (start==NULL){ ms_error("Could not mmap: %s",strerror(errno)); } msg=esballoc(start,buf.length,0,NULL); /* adjust to real size of picture*/ if (s->pix_fmt==MS_RGB24) msg->b_wptr+=s->vsize.width*s->vsize.height*3; else msg->b_wptr+=(s->vsize.width*s->vsize.height*3)/2; s->frames[i]=msg; } s->frame_max=req.count; /* for (i = 0; i < s->frame_max; ++i) { struct v4l2_buffer buf; memset(&buf,0,sizeof(buf)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = i; if (-1==ioctl (s->fd, VIDIOC_QBUF, &buf)){ ms_error("VIDIOC_QBUF failed: %s",strerror(errno)); } } */ /*start capture immediately*/ type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (-1 ==ioctl (s->fd, VIDIOC_STREAMON, &type)){ ms_error("VIDIOC_STREAMON failed: %s",strerror(errno)); return -1; } return 0; }