rtp.c

h.248协议源码

        IN  HRTPSESSION  hRTP)
{
    rtpSession *s = (rtpSession *)hRTP;

    return (s->hRTCP);
}


RVVXDAPI
RvInt32 VXDCALLCONV rtpSetRTCPSession(
        IN  HRTPSESSION   hRTP,
        IN  HRTCPSESSION  hRTCP)
{
    rtpSession *s = (rtpSession *)hRTP;

    s->hRTCP = hRTCP;

    return 0;
}


RVVXDAPI
RvInt32 VXDCALLCONV rtpGetHeaderLength(void)
{
    return 12;
}

RVVXDAPI
RvUint32 VXDCALLCONV rtpRegenSSRC(
        IN  HRTPSESSION  hRTP)
{
    rtpSession *s = (rtpSession *)hRTP;

	rvMutexLock(&s->mutex);

	s->sSrc = rvTimeGetEpochTime(NULL);
#ifdef _MTS_
    s->sSrc *= rand_r(&seed);
#else
    s->sSrc *= rand();
#endif
    s->sSrc &= ~s->sSrcMask;
    s->sSrc |= s->sSrcPattern;
    
	rvMutexUnlock(&s->mutex);
    return s->sSrc;
}

RVVXDAPI
RvInt32 VXDCALLCONV rtpSetGroupAddress(
        IN HRTPSESSION hRTP,	/* RTP Session Opaque Handle */
        IN RvUint32       ip)
{
    rtpSession *s = (rtpSession *)hRTP;
    rvMutexLock(&s->mutex);
    rvSocketJoinMulticastGroup(&s->socket, ip, RV_INET_ADDRANY);
    rvMutexUnlock(&s->mutex);
    return 0;
}


RVVXDAPI
RvInt32 VXDCALLCONV rtpResume(
        IN	HRTPSESSION hRTP)
{
    rtpSession *s = (rtpSession *)hRTP;
	RvHost h;
	RvSocketAddr toAddr;

	rvMutexLock(&s->mutex);
	rvHostConstruct(&h, "127.0.0.1");
	rvSocketAddrConstructInet(&toAddr, &h, 0, rvSocketGetPort(&s->socket));
    rvSocketSendTo(&s->socket, (RvUint8*)"", 1, &toAddr);
	rvMutexUnlock(&s->mutex);
    return 0;
}

RVVXDAPI 
RvInt32 VXDCALLCONV rtpUseSequenceNumber(
                IN HRTPSESSION  hRTP)
{
    rtpSession *s = (rtpSession *)hRTP;

    s->useSequenceNumber = 1;

    return 0;
}

RVVXDAPI 
RvInt32 VXDCALLCONV rtpSetReceiveBufferSize(
                IN HRTPSESSION  hRTP,
		IN int size)
{
    rtpSession *s = (rtpSession *)hRTP;

	rvMutexLock(&s->mutex);
    rvSocketSetRecvBufferSize(&s->socket, size);
	rvMutexUnlock(&s->mutex);

    return 0;
}

RVVXDAPI 
RvInt32 VXDCALLCONV rtpSetTransmitBufferSize(
                IN HRTPSESSION  hRTP,
		IN int size)
{
    rtpSession *s = (rtpSession *)hRTP;

	rvMutexLock(&s->mutex);
    rvSocketSetRecvBufferSize(&s->socket, size);
	rvMutexUnlock(&s->mutex);

    return 0;
}

RVVXDAPI 
RvInt32 VXDCALLCONV rtpGetAvailableBytes(
                IN HRTPSESSION  hRTP)
{
    rtpSession *s = (rtpSession *)hRTP;
    int bytes=(-1);
	rvMutexUnlock(&s->mutex);
    /* ????liBytesAvailable(s->socket, &bytes); */
	rvMutexLock(&s->mutex);
    return bytes;
}
                  /* == ENDS: Accessory RTP Functions == */

#ifdef _ATM_
                        /* == RTP ATM Functions == */

RvInt32 VXDCALLCONV rtpatmInit(RvBool bListen, RvUint8 atmSelector, RvUint16 port)
{
    int res = rtpInit();
    liatmInit();
    return res;
}

RVVXDAPI
void VXDCALLCONV rtpatmEnd(void)
{
    rtpEnd();
    liatmEnd();
}


RVVXDAPI
HRTPSESSION VXDCALLCONV rtpatmOpenFrom(
        IN  RvUint8               atmSelector,
        IN  RvUint16              port,
        IN  RTPATMDIRECTION     Direction,
        IN  RvUint32              ssrcPattern,
        IN  RvUint32              ssrcMask,
	    IN  void*               buffer,
	    IN  int	                bufferSize)
{
    rtpSession * s  = (rtpSession *)buffer;

    if (bufferSize < rtpGetAllocationSize())
	    return NULL;
    
    memset(buffer, 0 , rtpGetAllocationSize());

    s->bUseATM        = TRUE;    
    s->isAllocated    = FALSE;
    s->sSrcPattern    = ssrcPattern;
    s->sSrcMask       = ssrcMask;
    s->sequenceNumber = (RvUint16)
#ifdef _MTS_
      rand_r(&seed);
#else
    rand();
#endif
    s->socket = liatmCreateSocket((Direction==ATMLISTEN),atmSelector,port);

    rtpRegenSSRC((HRTPSESSION)s); 
    liBlock(s->socket);
	
    return (HRTPSESSION)s;
}


RVVXDAPI
HRTPSESSION VXDCALLCONV rtpatmOpenEx(
        IN  RvUint8               atmSelector,
        IN  RvUint16              port,
        IN  RTPATMDIRECTION     Direction,
        IN  RvUint32              ssrcPattern,
        IN  RvUint32              ssrcMask,
        IN  char *              cname)
{
    rtpSession *s  = (rtpSession*)rvMemAlloc(rtpGetAllocationSize());

    if (s==NULL) 
	    return NULL;
	memset(s, 0, rtpGetAllocationSize());
    
    if (rtpatmOpenFrom(atmSelector, port, Direction, ssrcPattern, ssrcMask, (void*)s, rtpGetAllocationSize())==NULL)
    {
	    rvMemFree(s);
	    return NULL;
    }
    s->isAllocated=TRUE;

    if (cname)
        s->hRTCP = rtcpOpen(s->sSrc, ++port, cname);

    return (HRTPSESSION) s;
}


RVVXDAPI
HRTPSESSION VXDCALLCONV rtpatmOpen(
        IN  RvUint8               atmSelector,
        IN  RvUint16              port,
        IN  RTPATMDIRECTION     Direction,
        IN  RvUint32              ssrcPattern,
        IN  RvUint32              ssrcMask)
{
    return rtpatmOpenEx(atmSelector, port, Direction, ssrcPattern, ssrcMask, NULL);
}


RVVXDAPI
RvUint32 VXDCALLCONV rtpatmClose(IN  HRTPSESSION  hRTP)
{
    rtpSession * s     = (rtpSession *)hRTP;
    RvUint8        bzero = 0;
    
    if (s->hRTCP)
        rtcpClose(s->hRTCP);
    
    liatmCallOn       (s->socket, 0, NULL, NULL);
    liatmSendData     (s->socket, &bzero, 1);
    liatmDeleteSocket (s->socket);

    if (s->isAllocated)
	    rvMemFree(s);
    
    return 0;
} 

RVVXDAPI
void VXDCALLCONV rtpatmSetEventHandler(
        IN  HRTPSESSION        hRTP,
        IN  LPRTPEVENTHANDLER  eventHandler,
        IN  void *             context)
{
    if (hRTP)
    {
        ATMSOCKET socket = ((rtpSession *)hRTP)->socket;

        ((rtpSession *)hRTP)->eventHandler  = eventHandler;
        ((rtpSession *)hRTP)->context       = context;
        
        liUnblock   (((rtpSession*)hRTP)->socket);
        liatmCallOn (((rtpSession*)hRTP)->socket, liEvRead, (eventHandler) ? rtpEvent:NULL, (void*)hRTP);
    }
}


RVVXDAPI
void VXDCALLCONV rtpSetATMRemoteAddress(
	IN HRTPSESSION 	hRTP,	/* RTP Session Opaque Handle */
	IN RvUint8	*atmAddr,
	IN RvUint32	addrLength,
	IN RvUint16	selector)
{
    rtpSession *s = (rtpSession *)hRTP;

    if (atmAddr)
    {
        s->atmAddr     = atmAddr;
        s->addrLength  = addrLength;
    }

    if (selector)
        s->selector = selector;
    else 
        s->selector = s->atmAddr[s->addrLength-1];
}


RVVXDAPI
RvInt32 VXDCALLCONV rtpatmConnect(IN HRTPSESSION hRTP)
{
    rtpSession * s = (rtpSession*) hRTP;
    int          res;

    res = liatmConnect(s->socket, s->atmAddr, s->addrLength,TRUE,0,(int*)&s->selector);

    /*if (res != (-1))
        liatmCallOn (s->socket, liEvRead, (s->eventHandler) ? rtpEvent:NULL, (void*)hRTP);*/
        
    return res;
}

RVVXDAPI
RvInt32 VXDCALLCONV rtpatmWrite(
        IN  HRTPSESSION  hRTP,
        IN  void *       buf,
        IN  RvInt32        len,
        IN  rtpParam *   p)
{
    int     retVal;
    RvUint32 *header;

    rtpSession *s = (rtpSession *)hRTP;

    if (s->socket==INVALID_SOCKET)
        return (-1);

    header = (RvUint32*)((char*)buf+p->sByte-12);

    if (s->useSequenceNumber)
        s->sequenceNumber=p->sequenceNumber;
    p->sequenceNumber=s->sequenceNumber;

    header[0]=0;
    header[0]=bitfieldSet(header[0],2,30,2);	
    header[0]=bitfieldSet(header[0],p->marker,23,1);	
    header[0]=bitfieldSet(header[0],p->payload,16,7);	
    header[0]=bitfieldSet(header[0],s->sequenceNumber++,0,16);	
    header[1]=p->timestamp;
    header[2]=s->sSrc;
    p->len=len-p->sByte;
	       
	ConvertToNetwork(header,0,3);
	retVal = liatmSendData(s->socket,(RvUint8*)header,len-((char*)header-(char*)buf));
	
    if (s->hRTCP  &&  retVal >= 0)
    {
        rtcpRTPPacketSent(s->hRTCP, p->len, p->timestamp);
    }

    return retVal;
}


RVVXDAPI
RvInt32 VXDCALLCONV rtpatmWriteFirst(
        IN  HRTPSESSION  hRTP,
        IN  void *       buf,
        IN  RvInt32        len)
{
    int retVal;
    rtpParam p;
    rtpSession *s;
    RvUint32 *header;

    memset (&p,0,sizeof(rtpParam));
    p.timestamp = 0;
    p.marker    = TRUE;
    p.payload   = 0; //PCMU;
    //OUT     RvUint32  sSrc;
    //OUT     RvUint16  sequenceNumber;
    p.sByte     = 12;
    //OUT     int     len;

    s = (rtpSession *)hRTP;

    header=(RvUint32*)((char*)buf+p.sByte-12);

    if (s->useSequenceNumber)
        s->sequenceNumber=p.sequenceNumber;
    p.sequenceNumber=s->sequenceNumber;

    header[0]=0;
    header[0]=bitfieldSet(header[0],2,30,2);	
    header[0]=bitfieldSet(header[0],p.marker,23,1);	
    header[0]=bitfieldSet(header[0],p.payload,16,7);	
    header[0]=bitfieldSet(header[0],s->sequenceNumber++,0,16);	
    header[1]=p.timestamp;
    header[2]=s->sSrc;
    p.len=len-p.sByte;
	       
	ConvertToNetwork(header,0,3);
	
    if (retVal=liatmSendData(s->socket, (RvUint8*)header, len-((char*)header-(char*)buf))<0)
	    retVal=0;

    if (s->hRTCP  &&  retVal >= 0)
    {
        rtcpRTPPacketSent(s->hRTCP, p.len, p.timestamp);
    }

    return retVal;
}

RVVXDAPI
RvInt32 VXDCALLCONV rtpatmRead(
        IN  HRTPSESSION  hRTP,
        IN  void        *buf,
        IN  RvInt32        len,
        OUT rtpParam    *p)
{
    rtpSession * s      = (rtpSession *)hRTP;
    RvUint32     * header = buf;


    if (s->socket==INVALID_SOCKET)
        return (-1);

    p->len = liatmRecvData(s->socket,(char*)buf,len);  
    
    ConvertFromNetwork(buf,0,3);
    
    //if (isMyIP(ip) && s->sSrc==((RvUint32*)buf)[2]) return (-1);
    if (p->len==(-1) || p->len<12) 
        return (-1);
    
	ConvertFromNetwork(buf,3,bitfieldGet(header[0],24,4));

    p->timestamp        = header[1];
    p->sequenceNumber   = (RvUint16)bitfieldGet(header[0],0,16);
    p->sSrc             = header[2];
    p->marker           = bitfieldGet(header[0],23,1);
    p->payload          = (unsigned char)bitfieldGet(header[0],16,7);
    p->sByte            = 12 + bitfieldGet(header[0],24,4) * sizeof(RvUint32);
    
    if (bitfieldGet(header[0],28,1))
    {
        int xStart = p->sByte/sizeof(RvUint32);

        ConvertFromNetwork(buf,xStart,1);
        ConvertFromNetwork(buf,xStart+1,bitfieldGet(header[xStart],0,16));
        p->sByte += bitfieldGet(header[xStart],0,16)*sizeof(RvUint32);
    }

    return 0;
}


RVVXDAPI
RvInt32 VXDCALLCONV rtpatmReadEx(
        IN  HRTPSESSION  hRTP,
        IN  void *       buf,
        IN  RvInt32        len,
        IN  RvUint32       timestamp,
        OUT rtpParam *   p)
{
    rtpSession *s = (rtpSession *)hRTP;
    int retVal;

    retVal = rtpatmRead(hRTP, buf, len, p);

    if (s->hRTCP  &&  retVal >= 0)
    {
        rtcpRTPPacketRecv(s->hRTCP, p->sSrc, timestamp,  p->timestamp, p->sequenceNumber);
    }

    return retVal;
}


RVVXDAPI 
RvInt32 rtpatmGetATMAddr(IN HRTPSESSION  hRTP, RvUint8 Addr[ATM_ADDR_SIZE], RvUint32 *NumofDigits)
{
    return liatmGetLocalAddr(((rtpSession*)hRTP)->socket,Addr,NumofDigits);
}

RVVXDAPI
RvBool VXDCALLCONV rtpatmIsATM(IN HRTPSESSION hRTP)
{
    return ((rtpSession*)hRTP)->bUseATM;
}

                 /* == ENDS: RTP ATM Functions == */
#endif



#ifdef __cplusplus
}              
#endif