开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
payload.c
资源名称：rtp11.rar　[点击查看]
上传用户：biaoge6808
上传日期：2007-08-15
资源大小：42k
文件大小：13k
源码类别：

多媒体

开发平台：

C/C++

payload.c：源码内容
  1. #ifdef __cplusplus
  2. extern "C" {
  3. #endif
  7. /*
  9.   NOTICE:
  10.   This document contains information that is proprietary to RADVISION LTD..
  11.   No part of this publication may be reproduced in any form whatsoever without
  12.   written prior approval by RADVISION LTD..
  14.     RADVISION LTD. reserves the right to revise this publication and make changes
  15.     without obligation to notify any person of such revisions or changes.
  17. */
  19. #include <rvcommon.h>
  20. #include "bitfield.h"
  21. #include <li.h>
  23. #include "rtp.h"
  24. #include "payload.h"
  26. RVAPI
  27. INT32 RVCALLCONV rtpPCMUPack(
  28.                               IN    void*buf,
  29.                               IN    INT32 len,
  30.                               IN    rtpParam*p,
  31.                               IN    void*param)
  32. {
  33.   if(buf || len || param);
  34.     p->payload=PCMU;
  35.     return 0;
  36. }
  38. RVAPI
  39. INT32 RVCALLCONV rtpPCMUUnpack(
  40.                                 OUT void*buf,
  41.                                 IN  INT32 len,
  42.                                 OUT rtpParam*p,
  43.                                 OUT void*param)
  44. {
  45.   if(buf || len || p || param);
  47.     return 0;
  48. }
  50. RVAPI
  51. INT32 RVCALLCONV rtpPCMUGetHeaderLength(void)
  52. {
  53.     return rtpGetHeaderLength();
  54. }
  56. RVAPI
  57. INT32 RVCALLCONV rtpPCMAPack(
  58.                               IN    void*buf,
  59.                               IN    INT32 len,
  60.                               IN    rtpParam*p,
  61.                               IN    void*param)
  62. {
  63.   if(buf || len || param);
  65.     p->payload=PCMA;
  66.     return 0;
  67. }
  69. RVAPI
  70. INT32 RVCALLCONV rtpPCMAUnpack(
  71.                                 OUT     void*buf,
  72.                                 IN  INT32 len,
  73.                                 OUT     rtpParam*p,
  74.                                 OUT void*param)
  75. {
  76.   if(buf || len || p || param);
  77.     return 0;
  78. }
  80. RVAPI
  81. INT32 RVCALLCONV rtpPCMAGetHeaderLength(void)
  82. {
  83.     return rtpGetHeaderLength();
  84. }
  86. RVAPI
  87. INT32 RVCALLCONV rtpG722Pack(
  88.                               IN    void*buf,
  89.                               IN    INT32 len,
  90.                               IN    rtpParam*p,
  91.                               IN    void*param)
  92. {
  93.   if(buf || len || param);
  95.     p->payload=G722;
  96.     return 0;
  97. }
  99. RVAPI
  100. INT32 RVCALLCONV rtpG722Unpack(
  101.                                 OUT     void*buf,
  102.                                 IN  INT32 len,
  103.                                 OUT rtpParam*p,
  104.                                 OUT void*param)
  105. {
  106.   if(buf || len || p || param);
  108.     return 0;
  109. }
  111. RVAPI
  112. INT32 RVCALLCONV rtpG722GetHeaderLength(void)
  113. {
  114.     return rtpGetHeaderLength();
  115. }
  117. RVAPI
  118. INT32 RVCALLCONV rtpG728Pack(
  119.                               IN    void*buf,
  120.                               IN    INT32 len,
  121.                               IN    rtpParam*p,
  122.                               IN    void*param)
  123. {
  124.   if(buf || len || param);
  126.     p->payload=G728;
  127.     return 0;
  128. }
  130. RVAPI
  131. INT32 RVCALLCONV rtpG728Unpack(
  132.                                 OUT     void*buf,
  133.                                 IN  INT32 len,
  134.                                 OUT rtpParam*p,
  135.                                 OUT void*param)
  136. {
  137.   if(buf || len || p || param);
  139.     return 0;
  140. }
  142. RVAPI
  143. INT32 RVCALLCONV rtpG728GetHeaderLength(void)
  144. {
  145.     return rtpGetHeaderLength();
  146. }
  148. RVAPI
  149. INT32 RVCALLCONV rtpG729Pack(
  150.                               IN    void*buf,
  151.                               IN    INT32 len,
  152.                               IN    rtpParam*p,
  153.                               IN    void*param)
  154. {
  155.   if(buf || len || param);
  157.     p->payload=G729;
  158.     return 0;
  159. }
  161. RVAPI
  162. INT32 RVCALLCONV rtpG729Unpack(
  163.                                 OUT     void*buf,
  164.                                 IN  INT32 len,
  165.                                 OUT rtpParam*p,
  166.                                 OUT void*param)
  167. {
  168.   if(buf || len || p || param);
  170.     return 0;
  171. }
  173. RVAPI
  174. INT32 RVCALLCONV rtpG729GetHeaderLength(void)
  175. {
  176.     return rtpGetHeaderLength();
  177. }
  179. RVAPI
  180. INT32 RVCALLCONV rtpG7231Pack(
  181.                               IN    void*buf,
  182.                               IN    INT32 len,
  183.                               IN    rtpParam*p,
  184.                               IN    void*param)
  185. {
  186.   if(buf || len || param);
  188.     p->payload=G7231;
  189.     return 0;
  190. }
  192. RVAPI
  193. INT32 RVCALLCONV rtpG7231Unpack(
  194.                                 OUT     void*buf,
  195.                                 IN  INT32 len,
  196.                                 OUT rtpParam*p,
  197.                                 OUT void*param)
  198. {
  199.  if(buf || len || param || p);
  200.     return 0;
  201. }
  203. RVAPI
  204. INT32 RVCALLCONV rtpG7231GetHeaderLength(void)
  205. {
  206.     return rtpGetHeaderLength();
  207. }
  210. RVAPI
  211. INT32 RVCALLCONV rtpH261Pack(
  212.                               IN    void*buf,
  213.                               IN    INT32 len,
  214.                               IN    rtpParam*p,
  215.                               IN    void*param)
  216. {
  217.     H261param*h261=(H261param*)param;
  218.     UINT32*hPtr;
  219.     p->sByte-=4;
  220.     hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  221.     hPtr[0]=bitfieldSet(0,h261->v,24,1);
  222.     hPtr[0]=bitfieldSet(hPtr[0],h261->i,25,1);
  223.     if(len);
  225.     if (h261->gobN)
  226.     {
  227.         hPtr[0]=bitfieldSet(hPtr[0],h261->vMvd,0,5);
  228.         hPtr[0]=bitfieldSet(hPtr[0],h261->hMvd,5,5);
  229.         hPtr[0]=bitfieldSet(hPtr[0],h261->quant,10,5);
  230.         hPtr[0]=bitfieldSet(hPtr[0],h261->mbaP,15,5);
  231.         hPtr[0]=bitfieldSet(hPtr[0],h261->gobN,20,4);
  232.     }
  233.     hPtr[0]=bitfieldSet(hPtr[0],h261->eBit,26,3);
  234.     hPtr[0]=bitfieldSet(hPtr[0],h261->sBit,29,3);
  235.     p->payload=H261;
  236.     liConvertHeader2l((BYTE*)hPtr,0,1);
  237.     return 0;
  238. }
  240. RVAPI
  241. INT32 RVCALLCONV rtpH261Unpack(
  242.                                 OUT void*buf,
  243.                                 IN  INT32 len,
  244.                                 OUT rtpParam*p,
  245.                                 OUT void*param)
  246. {
  247.     H261param*h261=(H261param*)param;
  248.     UINT32*hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  249.     if(len);
  251.     p->sByte+=4;
  252.     liConvertHeader2h((BYTE*)hPtr,0,1);
  253.     h261->vMvd=bitfieldGet(hPtr[0],0,5);
  254.     h261->hMvd=bitfieldGet(hPtr[0],5,5);
  255.     h261->quant=bitfieldGet(hPtr[0],10,5);
  256.     h261->mbaP=bitfieldGet(hPtr[0],15,5);
  257.     h261->gobN=bitfieldGet(hPtr[0],20,4);
  258.     h261->v=bitfieldGet(hPtr[0],24,1);
  259.     h261->i=bitfieldGet(hPtr[0],25,1);
  260.     h261->eBit=bitfieldGet(hPtr[0],26,3);
  261.     h261->sBit=bitfieldGet(hPtr[0],29,3);
  262.     return 0;
  263. }
  265. RVAPI
  266. INT32 RVCALLCONV rtpH261GetHeaderLength()
  267. {
  268.     return rtpGetHeaderLength()+4;
  269. }
  272. INT32 RVCALLCONV rtpH263Pack(
  273.                               IN    void*buf,
  274.                               IN    INT32 len,
  275.                               IN    rtpParam*p,
  276.                               IN    void*param)
  277. {
  278.     H263param*h263=(H263param*)param;
  279.     UINT32*hPtr=NULL;
  280.     int dwords=0;
  281.     if(len);
  283.     if (h263->p)
  284.     {
  285.         dwords=1;
  286.         p->sByte-=4;
  287.         hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  289.         hPtr[0]=bitfieldSet(0,h263->dbq,11,2);
  290.         hPtr[0]=bitfieldSet(hPtr[0],h263->trb,8,3);
  291.         hPtr[0]=bitfieldSet(hPtr[0],h263->tr,0,8);
  292.     }
  294.     if (h263->f)
  295.     {
  296.         dwords+=2;
  297.         p->sByte-=8;
  298.         hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  299.         hPtr[0]=bitfieldSet(0,h263->mbaP,0,8);
  300.         hPtr[0]=bitfieldSet(hPtr[0],h263->gobN,8,5);
  301.         hPtr[0]=bitfieldSet(hPtr[0],h263->quant,16,5);
  304.         hPtr[1]=bitfieldSet(      0,h263->vMv2, 0,8);
  305.         hPtr[1]=bitfieldSet(hPtr[1],h263->hMv2, 8,8);
  306.         hPtr[1]=bitfieldSet(hPtr[1],h263->vMv1,16,8);
  307.         hPtr[1]=bitfieldSet(hPtr[1],h263->hMv1,24,8);
  308.     }
  310.     if (!h263->f && !h263->p)
  311.     {
  312.         dwords=1;
  313.         p->sByte-=4;
  314.         hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  315.         hPtr[0]=0;
  316.     }
  318.     hPtr[0]=bitfieldSet(hPtr[0],h263->f,31,1);
  319.     hPtr[0]=bitfieldSet(hPtr[0],h263->p,30,1);
  320.     hPtr[0]=bitfieldSet(hPtr[0],h263->sBit,27,3);
  321.     hPtr[0]=bitfieldSet(hPtr[0],h263->eBit,24,3);
  322.     hPtr[0]=bitfieldSet(hPtr[0],h263->src,21,3);
  323.     hPtr[0]=bitfieldSet(hPtr[0],h263->i,15,1);
  324.     hPtr[0]=bitfieldSet(hPtr[0],h263->a,14,1);
  325.     hPtr[0]=bitfieldSet(hPtr[0],h263->s,13,1);
  326.     p->payload=H263;
  327.     liConvertHeader2l((BYTE*)hPtr,0,dwords);
  328.     return 0;
  329. }
  331. INT32 RVCALLCONV rtpH263Unpack(
  332.                                 OUT     void*buf,
  333.                                 IN  INT32 len,
  334.                                 OUT     rtpParam*p,
  335.                                 OUT void*param)
  336. {
  337.     H263param*h263=(H263param*)param;
  338.     UINT32*hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  339.     if(len);
  341.     p->sByte+=4;
  343.     liConvertHeader2h((BYTE*)hPtr,0,1);
  344.     h263->f=bitfieldGet(hPtr[0],31,1);
  345.     h263->p=bitfieldGet(hPtr[0],30,1);
  347.     h263->sBit=bitfieldGet(hPtr[0],27,3);
  348.     h263->eBit=bitfieldGet(hPtr[0],24,3);
  349.     h263->src=bitfieldGet(hPtr[0],21,3);
  350.     h263->i=bitfieldGet(hPtr[0],15,1);
  351.     h263->a=bitfieldGet(hPtr[0],14,1);
  352.     h263->s=bitfieldGet(hPtr[0],13,1);
  354.     if (h263->f)
  355.     {
  356.         int aDwords=h263->p+1;
  357.         liConvertHeader2h((BYTE*)hPtr,1,aDwords);
  358.         p->sByte+=4*aDwords;
  359.         h263->mbaP=bitfieldGet(hPtr[0],0,8);
  360.         h263->gobN=bitfieldGet(hPtr[0],8,5);
  361.         h263->quant=bitfieldGet(hPtr[0],16,5);
  364.         h263->vMv2=bitfieldGet(hPtr[1],0,8);
  365.         h263->hMv2=bitfieldGet(hPtr[1],8,8);
  366.         h263->vMv1=bitfieldGet(hPtr[1],16,8);
  367.         h263->hMv1=bitfieldGet(hPtr[1],24,8);
  368.         hPtr=(UINT32*)((BYTE*)buf+p->sByte-4);
  369.     }
  371.     if (h263->p)
  372.     {
  374.         h263->dbq=bitfieldGet(hPtr[0],11,2);
  375.         h263->trb=bitfieldGet(hPtr[0],8,3);
  376.         h263->tr=bitfieldGet(hPtr[0],0,8);
  377.     }
  380.     return 0;
  381. }
  383. INT32 RVCALLCONV rtpH263GetHeaderLength()
  384. {
  385.     return rtpGetHeaderLength()+12;
  386. }
  388. INT32 RVCALLCONV rtpH263aPack(
  389.                               IN    void*buf,
  390.                               IN    INT32 len,
  391.                               IN    rtpParam*p,
  392.                               IN    void*param)
  393. {
  394.     H263aparam*h263a=(H263aparam*)param;
  395.     UINT32*hPtr=NULL;
  396.     int dwords=0;
  397.     if(len);
  399.     if (h263a->p)
  400.     {
  401.         dwords=1;
  402.         p->sByte-=4;
  403.         hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  405.         hPtr[0]=bitfieldSet(0,h263a->dbq,11,2);
  406.         hPtr[0]=bitfieldSet(hPtr[0],h263a->trb,8,3);
  407.         hPtr[0]=bitfieldSet(hPtr[0],h263a->tr,0,8);
  408.     }
  410.     if (h263a->f)
  411.     {
  412.         dwords+=2;
  413.         p->sByte-=8;
  414.         hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  415.         hPtr[0]=bitfieldSet(0,h263a->mbaP,2,9);
  416.         hPtr[0]=bitfieldSet(hPtr[0],h263a->gobN,11,5);
  417.         hPtr[0]=bitfieldSet(hPtr[0],h263a->quant,16,5);
  420.         hPtr[1]=bitfieldSet(      0,h263a->vMv2, 0,7);
  421.         hPtr[1]=bitfieldSet(hPtr[1],h263a->hMv2, 7,7);
  422.         hPtr[1]=bitfieldSet(hPtr[1],h263a->vMv1,14,7);
  423.         hPtr[1]=bitfieldSet(hPtr[1],h263a->hMv1,21,7);
  425.     hPtr[1]=bitfieldSet(hPtr[1],h263a->a,28,1);
  426.         hPtr[1]=bitfieldSet(hPtr[1],h263a->s,29,1);
  427.         hPtr[1]=bitfieldSet(hPtr[1],h263a->u,30,1);
  428.         hPtr[1]=bitfieldSet(hPtr[1],h263a->i,31,1);
  429.     }
  431.     if (!h263a->f && !h263a->p)
  432.     {
  433.         dwords=1;
  434.         p->sByte-=4;
  435.         hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  436.         hPtr[0]=bitfieldSet(      0,h263a->a,17,1);
  437.         hPtr[0]=bitfieldSet(hPtr[0],h263a->s,18,1);
  438.         hPtr[0]=bitfieldSet(hPtr[0],h263a->u,19,1);
  439.         hPtr[0]=bitfieldSet(hPtr[0],h263a->i,20,1); ;
  440.     }
  442.     hPtr[0]=bitfieldSet(hPtr[0],h263a->f,31,1);
  443.     hPtr[0]=bitfieldSet(hPtr[0],h263a->p,30,1);
  444.     hPtr[0]=bitfieldSet(hPtr[0],h263a->sBit,27,3);
  445.     hPtr[0]=bitfieldSet(hPtr[0],h263a->eBit,24,3);
  446.     hPtr[0]=bitfieldSet(hPtr[0],h263a->src,21,3);
  448.     p->payload=H263;
  449.     liConvertHeader2l((BYTE*)hPtr,0,dwords);
  450.     return 0;
  451. }
  453. INT32 RVCALLCONV rtpH263aUnpack(
  454.                                 OUT     void*buf,
  455.                                 IN  INT32 len,
  456.                                 OUT     rtpParam*p,
  457.                                 OUT void*param)
  458. {
  459.     H263aparam*h263a=(H263aparam*)param;
  460.     UINT32*hPtr=(UINT32*)((BYTE*)buf+p->sByte);
  461.     if(len);
  463.     p->sByte+=4;
  465.     liConvertHeader2h((BYTE*)hPtr,0,1);
  466.     h263a->f=bitfieldGet(hPtr[0],31,1);
  467.     h263a->p=bitfieldGet(hPtr[0],30,1);
  469.     h263a->sBit=bitfieldGet(hPtr[0],27,3);
  470.     h263a->eBit=bitfieldGet(hPtr[0],24,3);
  471.     h263a->src=bitfieldGet(hPtr[0],21,3);
  474.     if (h263a->f)
  475.     {
  476.         int aDwords=h263a->p+1;
  477.         liConvertHeader2h((BYTE*)hPtr,1,aDwords);
  478.         p->sByte+=4*aDwords;
  479.         h263a->mbaP=bitfieldGet(hPtr[0],2,9);
  480.         h263a->gobN=bitfieldGet(hPtr[0],11,5);
  481.         h263a->quant=bitfieldGet(hPtr[0],16,5);
  484.         h263a->vMv2=bitfieldGet(hPtr[1],0,7);
  485.         h263a->hMv2=bitfieldGet(hPtr[1],7,7);
  486.         h263a->vMv1=bitfieldGet(hPtr[1],14,7);
  487.         h263a->hMv1=bitfieldGet(hPtr[1],21,7);
  489.     h263a->i=bitfieldGet(hPtr[1],31,1);
  490.     h263a->u=bitfieldGet(hPtr[1],30,1);
  491.     h263a->s=bitfieldGet(hPtr[1],29,1);
  492.     h263a->a=bitfieldGet(hPtr[1],28,1);
  494.         hPtr=(UINT32*)((BYTE*)buf+p->sByte-4);
  495.     }
  497.     if (h263a->p)
  498.     {
  500.         h263a->dbq=bitfieldGet(hPtr[0],11,2);
  501.         h263a->trb=bitfieldGet(hPtr[0],8,3);
  502.         h263a->tr=bitfieldGet(hPtr[0],0,8);
  503.     }
  505.     if (!h263a->f && !h263a->p)
  506.     {
  507.       h263a->i=bitfieldGet(hPtr[0],20,1);
  508.       h263a->u=bitfieldGet(hPtr[0],19,1);
  509.       h263a->s=bitfieldGet(hPtr[0],18,1);
  510.       h263a->a=bitfieldGet(hPtr[0],17,1);
  512.     }
  515.     return 0;
  516. }
  518. INT32 RVCALLCONV rtpH263aGetHeaderLength()
  519. {
  520.     return rtpGetHeaderLength()+12;
  521. }
  528. #ifdef __cplusplus
  529. }
  530. #endif