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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
rpe.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：11k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

rpe.c：源码内容
  1. /*
  2.  * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
  3.  * Universitaet Berlin.  See the accompanying file "COPYRIGHT" for
  4.  * details.  THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
  5.  */
  7. /* $Header: /cvsroot/vocal.modules/contrib/libsndfile-0.0.22/src/GSM610/rpe.c,v 1.2 2001/02/27 19:23:18 deepalir Exp $ */
  9. #include <stdio.h>
  10. #include <assert.h>
  12. #include "private.h"
  14. #include "gsm.h"
  15. #include "proto.h"
  17. /*  4.2.13 .. 4.2.17  RPE ENCODING SECTION
  18.  */
  20. /* 4.2.13 */
  22. static void Weighting_filter P2((e, x),
  23. register word * e, /* signal [-5..0.39.44] IN  */
  24. word * x /* signal [0..39] OUT */
  25. )
  26. /*
  27.  *  The coefficients of the weighting filter are stored in a table
  28.  *  (see table 4.4).  The following scaling is used:
  29.  *
  30.  * H[0..10] = integer( real_H[ 0..10] * 8192 ); 
  31.  */
  32. {
  33. /* word wt[ 50 ]; */
  35. register longword L_result;
  36. register int k /* , i */ ;
  38. /*  Initialization of a temporary working array wt[0...49]
  39.  */
  41. /* for (k =  0; k <=  4; k++) wt[k] = 0;
  42.  * for (k =  5; k <= 44; k++) wt[k] = *e++;
  43.  * for (k = 45; k <= 49; k++) wt[k] = 0;
  44.  *
  45.  *  (e[-5..-1] and e[40..44] are allocated by the caller,
  46.  *  are initially zero and are not written anywhere.)
  47.  */
  48. e -= 5;
  50. /*  Compute the signal x[0..39]
  51.  */ 
  52. for (k = 0; k <= 39; k++) {
  54. L_result = 8192 >> 1;
  56. /* for (i = 0; i <= 10; i++) {
  57.  * L_temp   = GSM_L_MULT( wt[k+i], gsm_H[i] );
  58.  * L_result = GSM_L_ADD( L_result, L_temp );
  59.  * }
  60.  */
  62. #undef STEP
  63. #define STEP( i, H ) (e[ k + i ] * (longword)H)
  65. /*  Every one of these multiplications is done twice --
  66.  *  but I don't see an elegant way to optimize this. 
  67.  *  Do you?
  68.  */
  70. #ifdef STUPID_COMPILER
  71. L_result += STEP( 0,  -134 ) ;
  72. L_result += STEP( 1,  -374 )  ;
  73.                /* + STEP( 2,  0    )  */
  74. L_result += STEP( 3,  2054 ) ;
  75. L_result += STEP( 4,  5741 ) ;
  76. L_result += STEP( 5,  8192 ) ;
  77. L_result += STEP( 6,  5741 ) ;
  78. L_result += STEP( 7,  2054 ) ;
  79.          /* + STEP( 8,  0    )  */
  80. L_result += STEP( 9,  -374 ) ;
  81. L_result += STEP( 10,  -134 ) ;
  82. #else
  83. L_result +=
  84.   STEP( 0,  -134 ) 
  85. + STEP( 1,  -374 ) 
  86.      /* + STEP( 2,  0    )  */
  87. + STEP( 3,  2054 ) 
  88. + STEP( 4,  5741 ) 
  89. + STEP( 5,  8192 ) 
  90. + STEP( 6,  5741 ) 
  91. + STEP( 7,  2054 ) 
  92.      /* + STEP( 8,  0    )  */
  93. + STEP( 9,  -374 ) 
  94. + STEP(10,  -134 )
  95. ;
  96. #endif
  98. /* L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x2) *)
  99.  * L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x4) *)
  100.  *
  101.  * x[k] = SASR( L_result, 16 );
  102.  */
  104. /* 2 adds vs. >>16 => 14, minus one shift to compensate for
  105.  * those we lost when replacing L_MULT by '*'.
  106.  */
  108. L_result = SASR( L_result, 13 );
  109. x[k] =  (  L_result < MIN_WORD ? MIN_WORD
  110. : (L_result > MAX_WORD ? MAX_WORD : L_result ));
  111. }
  112. }
  114. /* 4.2.14 */
  116. static void RPE_grid_selection P3((x,xM,Mc_out),
  117. word * x, /* [0..39] IN  */ 
  118. word * xM, /* [0..12] OUT */
  119. word * Mc_out /* OUT */
  120. )
  121. /*
  122.  *  The signal x[0..39] is used to select the RPE grid which is
  123.  *  represented by Mc.
  124.  */
  125. {
  126. /* register word temp1; */
  127. register int /* m, */  i;
  128. register longword L_result, L_temp;
  129. longword EM; /* xxx should be L_EM? */
  130. word Mc;
  132. longword L_common_0_3;
  134. EM = 0;
  135. Mc = 0;
  137. /* for (m = 0; m <= 3; m++) {
  138.  * L_result = 0;
  139.  *
  140.  *
  141.  * for (i = 0; i <= 12; i++) {
  142.  *
  143.  * temp1    = SASR( x[m + 3*i], 2 );
  144.  *
  145.  * assert(temp1 != MIN_WORD);
  146.  *
  147.  * L_temp   = GSM_L_MULT( temp1, temp1 );
  148.  * L_result = GSM_L_ADD( L_temp, L_result );
  149.  * }
  150.  * 
  151.  * if (L_result > EM) {
  152.  * Mc = m;
  153.  * EM = L_result;
  154.  * }
  155.  * }
  156.  */
  158. #undef STEP
  159. #define STEP( m, i ) L_temp = SASR( x[m + 3 * i], 2 );
  160. L_result += L_temp * L_temp;
  162. /* common part of 0 and 3 */
  164. L_result = 0;
  165. STEP( 0, 1 ); STEP( 0, 2 ); STEP( 0, 3 ); STEP( 0, 4 );
  166. STEP( 0, 5 ); STEP( 0, 6 ); STEP( 0, 7 ); STEP( 0, 8 );
  167. STEP( 0, 9 ); STEP( 0, 10); STEP( 0, 11); STEP( 0, 12);
  168. L_common_0_3 = L_result;
  170. /* i = 0 */
  172. STEP( 0, 0 );
  173. L_result <<= 1; /* implicit in L_MULT */
  174. EM = L_result;
  176. /* i = 1 */
  178. L_result = 0;
  179. STEP( 1, 0 );
  180. STEP( 1, 1 ); STEP( 1, 2 ); STEP( 1, 3 ); STEP( 1, 4 );
  181. STEP( 1, 5 ); STEP( 1, 6 ); STEP( 1, 7 ); STEP( 1, 8 );
  182. STEP( 1, 9 ); STEP( 1, 10); STEP( 1, 11); STEP( 1, 12);
  183. L_result <<= 1;
  184. if (L_result > EM) {
  185. Mc = 1;
  186.   EM = L_result;
  187. }
  189. /* i = 2 */
  191. L_result = 0;
  192. STEP( 2, 0 );
  193. STEP( 2, 1 ); STEP( 2, 2 ); STEP( 2, 3 ); STEP( 2, 4 );
  194. STEP( 2, 5 ); STEP( 2, 6 ); STEP( 2, 7 ); STEP( 2, 8 );
  195. STEP( 2, 9 ); STEP( 2, 10); STEP( 2, 11); STEP( 2, 12);
  196. L_result <<= 1;
  197. if (L_result > EM) {
  198. Mc = 2;
  199.   EM = L_result;
  200. }
  202. /* i = 3 */
  204. L_result = L_common_0_3;
  205. STEP( 3, 12 );
  206. L_result <<= 1;
  207. if (L_result > EM) {
  208. Mc = 3;
  209.   EM = L_result;
  210. }
  212. /**/
  214. /*  Down-sampling by a factor 3 to get the selected xM[0..12]
  215.  *  RPE sequence.
  216.  */
  217. for (i = 0; i <= 12; i ++) xM[i] = x[Mc + 3*i];
  218. *Mc_out = Mc;
  219. }
  221. /* 4.12.15 */
  223. static void APCM_quantization_xmaxc_to_exp_mant P3((xmaxc,exp_out,mant_out),
  224. word xmaxc, /* IN  */
  225. word * exp_out, /* OUT */
  226. word * mant_out ) /* OUT  */
  227. {
  228. word exp, mant;
  230. /* Compute exponent and mantissa of the decoded version of xmaxc
  231.  */
  233. exp = 0;
  234. if (xmaxc > 15) exp = SASR(xmaxc, 3) - 1;
  235. mant = xmaxc - (exp << 3);
  237. if (mant == 0) {
  238. exp  = -4;
  239. mant = 7;
  240. }
  241. else {
  242. while (mant <= 7) {
  243. mant = mant << 1 | 1;
  244. exp--;
  245. }
  246. mant -= 8;
  247. }
  249. assert( exp  >= -4 && exp <= 6 );
  250. assert( mant >= 0 && mant <= 7 );
  252. *exp_out  = exp;
  253. *mant_out = mant;
  254. }
  256. static void APCM_quantization P5((xM,xMc,mant_out,exp_out,xmaxc_out),
  257. word * xM, /* [0..12] IN */
  259. word * xMc, /* [0..12] OUT */
  260. word * mant_out, /*  OUT */
  261. word * exp_out, /* OUT */
  262. word * xmaxc_out /* OUT */
  263. )
  264. {
  265. int i, itest;
  267. word xmax, xmaxc, temp, temp1, temp2;
  268. word exp, mant;
  271. /*  Find the maximum absolute value xmax of xM[0..12].
  272.  */
  274. xmax = 0;
  275. for (i = 0; i <= 12; i++) {
  276. temp = xM[i];
  277. temp = GSM_ABS(temp);
  278. if (temp > xmax) xmax = temp;
  279. }
  281. /*  Qantizing and coding of xmax to get xmaxc.
  282.  */
  284. exp   = 0;
  285. temp  = SASR( xmax, 9 );
  286. itest = 0;
  288. for (i = 0; i <= 5; i++) {
  290. itest |= (temp <= 0);
  291. temp = SASR( temp, 1 );
  293. assert(exp <= 5);
  294. if (itest == 0) exp++; /* exp = add (exp, 1) */
  295. }
  297. assert(exp <= 6 && exp >= 0);
  298. temp = exp + 5;
  300. assert(temp <= 11 && temp >= 0);
  301. xmaxc = gsm_add( SASR(xmax, temp), exp << 3 );
  303. /*   Quantizing and coding of the xM[0..12] RPE sequence
  304.  *   to get the xMc[0..12]
  305.  */
  307. APCM_quantization_xmaxc_to_exp_mant( xmaxc, &exp, &mant );
  309. /*  This computation uses the fact that the decoded version of xmaxc
  310.  *  can be calculated by using the exponent and the mantissa part of
  311.  *  xmaxc (logarithmic table).
  312.  *  So, this method avoids any division and uses only a scaling
  313.  *  of the RPE samples by a function of the exponent.  A direct 
  314.  *  multiplication by the inverse of the mantissa (NRFAC[0..7]
  315.  *  found in table 4.5) gives the 3 bit coded version xMc[0..12]
  316.  *  of the RPE samples.
  317.  */
  320. /* Direct computation of xMc[0..12] using table 4.5
  321.  */
  323. assert( exp <= 4096 && exp >= -4096);
  324. assert( mant >= 0 && mant <= 7 ); 
  326. temp1 = 6 - exp; /* normalization by the exponent */
  327. temp2 = gsm_NRFAC[ mant ];   /* inverse mantissa   */
  329. for (i = 0; i <= 12; i++) {
  331. assert(temp1 >= 0 && temp1 < 16);
  333. temp = xM[i] << temp1;
  334. temp = GSM_MULT( temp, temp2 );
  335. temp = SASR(temp, 12);
  336. xMc[i] = temp + 4; /* see note below */
  337. }
  339. /*  NOTE: This equation is used to make all the xMc[i] positive.
  340.  */
  342. *mant_out  = mant;
  343. *exp_out   = exp;
  344. *xmaxc_out = xmaxc;
  345. }
  347. /* 4.2.16 */
  349. static void APCM_inverse_quantization P4((xMc,mant,exp,xMp),
  350. register word * xMc, /* [0..12] IN  */
  351. word mant,
  352. word exp,
  353. register word * xMp) /* [0..12] OUT  */
  354. /* 
  355.  *  This part is for decoding the RPE sequence of coded xMc[0..12]
  356.  *  samples to obtain the xMp[0..12] array.  Table 4.6 is used to get
  357.  *  the mantissa of xmaxc (FAC[0..7]).
  358.  */
  359. {
  360. int i;
  361. word temp, temp1, temp2, temp3;
  362. longword ltmp;
  364. assert( mant >= 0 && mant <= 7 ); 
  366. temp1 = gsm_FAC[ mant ]; /* see 4.2-15 for mant */
  367. temp2 = gsm_sub( 6, exp ); /* see 4.2-15 for exp  */
  368. temp3 = gsm_asl( 1, gsm_sub( temp2, 1 ));
  370. for (i = 13; i--;) {
  372. assert( *xMc <= 7 && *xMc >= 0 );  /* 3 bit unsigned */
  374. /* temp = gsm_sub( *xMc++ << 1, 7 ); */
  375. temp = (*xMc++ << 1) - 7;         /* restore sign   */
  376. assert( temp <= 7 && temp >= -7 );  /* 4 bit signed   */
  378. temp <<= 12; /* 16 bit signed  */
  379. temp = GSM_MULT_R( temp1, temp );
  380. temp = GSM_ADD( temp, temp3 );
  381. *xMp++ = gsm_asr( temp, temp2 );
  382. }
  383. }
  385. /* 4.2.17 */
  387. static void RPE_grid_positioning P3((Mc,xMp,ep),
  388. word Mc, /* grid position IN */
  389. register word * xMp, /* [0..12] IN */
  390. register word * ep /* [0..39] OUT */
  391. )
  392. /*
  393.  *  This procedure computes the reconstructed long term residual signal
  394.  *  ep[0..39] for the LTP analysis filter.  The inputs are the Mc
  395.  *  which is the grid position selection and the xMp[0..12] decoded
  396.  *  RPE samples which are upsampled by a factor of 3 by inserting zero
  397.  *  values.
  398.  */
  399. {
  400. int i = 13;
  402. assert(0 <= Mc && Mc <= 3);
  404.         switch (Mc) {
  405.                 case 3: *ep++ = 0;
  406.                 case 2:  do {
  407.                                 *ep++ = 0;
  408.                 case 1:         *ep++ = 0;
  409.                 case 0:         *ep++ = *xMp++;
  410.                          } while (--i);
  411.         }
  412.         while (++Mc < 4) *ep++ = 0;
  414. /*
  416. int i, k;
  417. for (k = 0; k <= 39; k++) ep[k] = 0;
  418. for (i = 0; i <= 12; i++) {
  419. ep[ Mc + (3*i) ] = xMp[i];
  420. }
  421. */
  422. }
  424. /* 4.2.18 */
  426. /*  This procedure adds the reconstructed long term residual signal
  427.  *  ep[0..39] to the estimated signal dpp[0..39] from the long term
  428.  *  analysis filter to compute the reconstructed short term residual
  429.  *  signal dp[-40..-1]; also the reconstructed short term residual
  430.  *  array dp[-120..-41] is updated.
  431.  */
  433. #if 0 /* Has been inlined in code.c */
  434. void Gsm_Update_of_reconstructed_short_time_residual_signal P3((dpp, ep, dp),
  435. word * dpp, /* [0...39] IN */
  436. word * ep, /* [0...39] IN */
  437. word * dp) /* [-120...-1]  IN/OUT  */
  438. {
  439. int  k;
  441. for (k = 0; k <= 79; k++) 
  442. dp[ -120 + k ] = dp[ -80 + k ];
  444. for (k = 0; k <= 39; k++)
  445. dp[ -40 + k ] = gsm_add( ep[k], dpp[k] );
  446. }
  447. #endif /* Has been inlined in code.c */
  449. void Gsm_RPE_Encoding P5((S,e,xmaxc,Mc,xMc),
  451. struct gsm_state * S,
  453. word * e, /* -5..-1][0..39][40..44 IN/OUT  */
  454. word * xmaxc, /*  OUT */
  455. word * Mc, /*     OUT */
  456. word * xMc) /* [0..12] OUT */
  457. {
  458. word x[40];
  459. word xM[13], xMp[13];
  460. word mant, exp;
  462. Weighting_filter(e, x);
  463. RPE_grid_selection(x, xM, Mc);
  465. APCM_quantization( xM, xMc, &mant, &exp, xmaxc);
  466. APCM_inverse_quantization(  xMc,  mant,  exp, xMp);
  468. RPE_grid_positioning( *Mc, xMp, e );
  470. }
  472. void Gsm_RPE_Decoding P5((S, xmaxcr, Mcr, xMcr, erp),
  473. struct gsm_state * S,
  475. word  xmaxcr,
  476. word Mcr,
  477. word * xMcr,  /* [0..12], 3 bits  IN */
  478. word * erp  /* [0..39] OUT  */
  479. )
  480. {
  481. word exp, mant;
  482. word xMp[ 13 ];
  484. APCM_quantization_xmaxc_to_exp_mant( xmaxcr, &exp, &mant );
  485. APCM_inverse_quantization( xMcr, mant, exp, xMp );
  486. RPE_grid_positioning( Mcr, xMp, erp );
  488. }