payload.c

Radvision rtpRtcp协议栈 4.5.0.18 版本

/***********************************************************************
        Copyright (c) 2002 RADVISION Ltd.
************************************************************************
NOTICE:
This document contains information that is confidential and proprietary
to RADVISION Ltd.. No part of this document may be reproduced in any
form whatsoever without written prior approval by RADVISION Ltd..

RADVISION Ltd. reserve the right to revise this publication and make
changes without obligation to notify any person of such revisions or
changes.
***********************************************************************/

#include "rvtypes.h"
#include "rverror.h"
#include "bitfield.h"
#include "rtp.h"
#include "rtputil.h"
#include "payload.h"

RVAPI
RvInt32 RVCALLCONV rtpPCMUPack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);

    p->payload=PCMU;
    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpPCMUUnpack(
                                OUT void*buf,
                                IN  RvInt32 len,
                                OUT rtpParam*p,
                                OUT void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);
    RV_UNUSED_ARG(p);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpPCMUGetHeaderLength(void)
{
    return rtpGetHeaderLength();
}

RVAPI
RvInt32 RVCALLCONV rtpPCMAPack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);

    p->payload=PCMA;
    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpPCMAUnpack(
                                OUT     void*buf,
                                IN  RvInt32 len,
                                OUT     rtpParam*p,
                                OUT void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);
    RV_UNUSED_ARG(p);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpPCMAGetHeaderLength(void)
{
    return rtpGetHeaderLength();
}

RVAPI
RvInt32 RVCALLCONV rtpG722Pack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);

    p->payload=G722;
    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG722Unpack(
                                OUT     void*buf,
                                IN  RvInt32 len,
                                OUT rtpParam*p,
                                OUT void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);
    RV_UNUSED_ARG(p);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG722GetHeaderLength(void)
{
    return rtpGetHeaderLength();
}

RVAPI
RvInt32 RVCALLCONV rtpG728Pack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);

    p->payload=G728;
    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG728Unpack(
                                OUT void*buf,
                                IN  RvInt32 len,
                                OUT rtpParam*p,
                                OUT void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);
    RV_UNUSED_ARG(p);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG728GetHeaderLength(void)
{
    return rtpGetHeaderLength();
}

RVAPI
RvInt32 RVCALLCONV rtpG729Pack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);

    p->payload=G729;
    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG729Unpack(
                                OUT void*buf,
                                IN  RvInt32 len,
                                OUT rtpParam*p,
                                OUT void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);
    RV_UNUSED_ARG(p);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG729GetHeaderLength(void)
{
    return rtpGetHeaderLength();
}

RVAPI
RvInt32 RVCALLCONV rtpG7231Pack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);

    p->payload=G7231;
    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG7231Unpack(
                                OUT void*buf,
                                IN  RvInt32 len,
                                OUT rtpParam*p,
                                OUT void*param)
{
    RV_UNUSED_ARG(buf);
    RV_UNUSED_ARG(len);
    RV_UNUSED_ARG(param);
    RV_UNUSED_ARG(p);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpG7231GetHeaderLength(void)
{
    return rtpGetHeaderLength();
}


RVAPI
RvInt32 RVCALLCONV rtpH261Pack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    H261param*h261=(H261param*)param;
    RvUint32*hPtr;
    p->sByte-=4;
    hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);
    hPtr[0]=bitfieldSet(0,h261->v,24,1);
    hPtr[0]=bitfieldSet(hPtr[0],h261->i,25,1);

    RV_UNUSED_ARG(len);

    if (h261->gobN)
    {
        hPtr[0]=bitfieldSet(hPtr[0],h261->vMvd,0,5);
        hPtr[0]=bitfieldSet(hPtr[0],h261->hMvd,5,5);
        hPtr[0]=bitfieldSet(hPtr[0],h261->quant,10,5);
        hPtr[0]=bitfieldSet(hPtr[0],h261->mbaP,15,5);
        hPtr[0]=bitfieldSet(hPtr[0],h261->gobN,20,4);
    }
    hPtr[0]=bitfieldSet(hPtr[0],h261->eBit,26,3);
    hPtr[0]=bitfieldSet(hPtr[0],h261->sBit,29,3);
    p->payload=H261;

    ConvertToNetwork(hPtr, 0, 1);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpH261Unpack(
                                OUT void*buf,
                                IN  RvInt32 len,
                                OUT rtpParam*p,
                                OUT void*param)
{
    H261param*h261=(H261param*)param;
    RvUint32*hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);

    RV_UNUSED_ARG(len);

    p->sByte += 4;
    ConvertFromNetwork(hPtr, 0, 1);

    h261->vMvd=bitfieldGet(hPtr[0],0,5);
    h261->hMvd=bitfieldGet(hPtr[0],5,5);
    h261->quant=bitfieldGet(hPtr[0],10,5);
    h261->mbaP=bitfieldGet(hPtr[0],15,5);
    h261->gobN=bitfieldGet(hPtr[0],20,4);
    h261->v=bitfieldGet(hPtr[0],24,1);
    h261->i=bitfieldGet(hPtr[0],25,1);
    h261->eBit=bitfieldGet(hPtr[0],26,3);
    h261->sBit=bitfieldGet(hPtr[0],29,3);

    return RV_OK;
}

RVAPI
RvInt32 RVCALLCONV rtpH261GetHeaderLength()
{
    return rtpGetHeaderLength()+4;
}


RvInt32 RVCALLCONV rtpH263Pack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    H263param*h263=(H263param*)param;
    RvUint32*hPtr=NULL;
    int dwords=0;

    RV_UNUSED_ARG(len);

    if (h263->p)
    {
        dwords=1;
        p->sByte-=4;
        hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);

        hPtr[0]=bitfieldSet(0,h263->dbq,11,2);
        hPtr[0]=bitfieldSet(hPtr[0],h263->trb,8,3);
        hPtr[0]=bitfieldSet(hPtr[0],h263->tr,0,8);
    }

    if (h263->f)
    {
        dwords+=2;
        p->sByte-=8;
        hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);
        hPtr[0]=bitfieldSet(0,h263->mbaP,0,8);
        hPtr[0]=bitfieldSet(hPtr[0],h263->gobN,8,5);
        hPtr[0]=bitfieldSet(hPtr[0],h263->quant,16,5);


        hPtr[1]=bitfieldSet(      0,h263->vMv2, 0,8);
        hPtr[1]=bitfieldSet(hPtr[1],h263->hMv2, 8,8);
        hPtr[1]=bitfieldSet(hPtr[1],h263->vMv1,16,8);
        hPtr[1]=bitfieldSet(hPtr[1],h263->hMv1,24,8);
    }

    if (!h263->f && !h263->p)
    {
        dwords=1;
        p->sByte-=4;
        hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);
        hPtr[0]=0;
    }

	/*lint -e613*/
    hPtr[0]=bitfieldSet(hPtr[0],h263->f,31,1);
    hPtr[0]=bitfieldSet(hPtr[0],h263->p,30,1);
    hPtr[0]=bitfieldSet(hPtr[0],h263->sBit,27,3);
    hPtr[0]=bitfieldSet(hPtr[0],h263->eBit,24,3);
    hPtr[0]=bitfieldSet(hPtr[0],h263->src,21,3);
    hPtr[0]=bitfieldSet(hPtr[0],h263->i,15,1);
    hPtr[0]=bitfieldSet(hPtr[0],h263->a,14,1);
    hPtr[0]=bitfieldSet(hPtr[0],h263->s,13,1);
    p->payload=H263;

    ConvertToNetwork(hPtr, 0, dwords);

    return RV_OK;
}

RvInt32 RVCALLCONV rtpH263Unpack(
                                OUT     void*buf,
                                IN  RvInt32 len,
                                OUT     rtpParam*p,
                                OUT void*param)
{
    H263param*h263=(H263param*)param;
    RvUint32*hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);

    RV_UNUSED_ARG(len);

    p->sByte+=4;

    ConvertFromNetwork(hPtr, 0, 1);

    h263->f=bitfieldGet(hPtr[0],31,1);
    h263->p=bitfieldGet(hPtr[0],30,1);

    h263->sBit=bitfieldGet(hPtr[0],27,3);
    h263->eBit=bitfieldGet(hPtr[0],24,3);
    h263->src=bitfieldGet(hPtr[0],21,3);
    h263->i=bitfieldGet(hPtr[0],15,1);
    h263->a=bitfieldGet(hPtr[0],14,1);
    h263->s=bitfieldGet(hPtr[0],13,1);

    if (h263->f)
    {
        int aDwords=h263->p+1;

        ConvertFromNetwork(hPtr, 1, aDwords);

        p->sByte+=4*aDwords;
        h263->mbaP=bitfieldGet(hPtr[0],0,8);
        h263->gobN=bitfieldGet(hPtr[0],8,5);
        h263->quant=bitfieldGet(hPtr[0],16,5);


        h263->vMv2=bitfieldGet(hPtr[1],0,8);
        h263->hMv2=bitfieldGet(hPtr[1],8,8);
        h263->vMv1=bitfieldGet(hPtr[1],16,8);
        h263->hMv1=bitfieldGet(hPtr[1],24,8);
        hPtr=(RvUint32*)((RvUint8*)buf+p->sByte-4);
    }

    if (h263->p)
    {

        h263->dbq=bitfieldGet(hPtr[0],11,2);
        h263->trb=bitfieldGet(hPtr[0],8,3);
        h263->tr=bitfieldGet(hPtr[0],0,8);
    }

    return RV_OK;
}

RvInt32 RVCALLCONV rtpH263GetHeaderLength()
{
    return rtpGetHeaderLength()+12;
}

RvInt32 RVCALLCONV rtpH263aPack(
                              IN    void*buf,
                              IN    RvInt32 len,
                              IN    rtpParam*p,
                              IN    void*param)
{
    H263aparam*h263a=(H263aparam*)param;
    RvUint32*hPtr=NULL;
    int dwords=0;

    RV_UNUSED_ARG(len);

    if (h263a->p)
    {
        dwords=1;
        p->sByte-=4;
        hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);

        hPtr[0]=bitfieldSet(0,h263a->dbq,11,2);
        hPtr[0]=bitfieldSet(hPtr[0],h263a->trb,8,3);
        hPtr[0]=bitfieldSet(hPtr[0],h263a->tr,0,8);
    }

    if (h263a->f)
    {
        dwords+=2;
        p->sByte-=8;
        hPtr=(RvUint32*)((RvUint8*)buf+p->sByte);
        hPtr[0]=bitfieldSet(0,h263a->mbaP,2,9);
        hPtr[0]=bitfieldSet(hPtr[0],h263a->gobN,11,5);
        hPtr[0]=bitfieldSet(hPtr[0],h263a->quant,16,5);


        hPtr[1]=bitfieldSet(      0,h263a->vMv2, 0,7);
        hPtr[1]=bitfieldSet(hPtr[1],h263a->hMv2, 7,7);
        hPtr[1]=bitfieldSet(hPtr[1],h263a->vMv1,14,7);
        hPtr[1]=bitfieldSet(hPtr[1],h263a->hMv1,21,7);

        hPtr[1]=bitfieldSet(hPtr[1],h263a->a,28,1);
        hPtr[1]=bitfieldSet(hPtr[1],h263a->s,29,1);
        hPtr[1]=bitfieldSet(hPtr[1],h263a->u,30,1);
        hPtr[1]=bitfieldSet(hPtr[1],h263a->i,31,1);
    }

    if (!h263a->f && !h263a->p)
    {
        dwords=1;