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