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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
backpred.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：11k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

backpred.c：源码内容
  1. /*
  2.  * FAAC - Freeware Advanced Audio Coder
  3.  * Copyright (C) 2001 Menno Bakker
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Lesser General Public
  7.  * License as published by the Free Software Foundation; either
  8.  * version 2.1 of the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Lesser General Public License for more details.
  15.  * You should have received a copy of the GNU Lesser General Public
  16.  * License along with this library; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  * $Id: backpred.c,v 1.3 2001/06/04 23:02:24 wmay Exp $
  20.  */
  22. #include <math.h>
  23. #include "frame.h"
  24. #include "coder.h"
  25. #include "channels.h"
  26. #include "backpred.h"
  29. void PredInit(faacEncHandle hEncoder)
  30. {
  31. unsigned int channel;
  33. for (channel = 0; channel < hEncoder->numChannels; channel++) {
  34. BwpInfo *bwpInfo = &(hEncoder->coderInfo[channel].bwpInfo);
  36. bwpInfo->psy_init_mc = 0;
  37. bwpInfo->reset_count_mc = 0;
  38. }
  39. }
  40.  
  41. void PredCalcPrediction(double *act_spec, double *last_spec, int btype, 
  42. int nsfb, 
  43. int *isfb_width, 
  44. CoderInfo *coderInfo,
  45. ChannelInfo *channelInfo,
  46. int chanNum) 
  47. {
  48. int i, k, j, cb_long;
  49. int leftChanNum;
  50. int isRightWithCommonWindow;
  51. double num_bit, snr[SBMAX_L];
  52. double energy[BLOCK_LEN_LONG], snr_p[BLOCK_LEN_LONG], temp1, temp2;
  53. ChannelInfo *thisChannel;
  55. /* Set pointers for specified channel number */
  56. /* int psy_init; */
  57. int *psy_init;
  58. double (*dr)[BLOCK_LEN_LONG],(*e)[BLOCK_LEN_LONG];
  59. double (*K)[BLOCK_LEN_LONG], (*R)[BLOCK_LEN_LONG];
  60. double (*VAR)[BLOCK_LEN_LONG], (*KOR)[BLOCK_LEN_LONG];
  61. double *sb_samples_pred;
  62. int *thisLineNeedsResetting;
  63. /* int reset_count; */
  64. int *reset_count;
  65. int *pred_global_flag;
  66. int *pred_sfb_flag;
  67. int *reset_group;
  69. /* Set pointers for this chanNum */
  70. pred_global_flag = &(coderInfo[chanNum].pred_global_flag);
  71. pred_sfb_flag = coderInfo[chanNum].pred_sfb_flag;
  72. reset_group = &(coderInfo[chanNum].reset_group_number);
  73. psy_init = &coderInfo[chanNum].bwpInfo.psy_init_mc;
  74. dr = &coderInfo[chanNum].bwpInfo.dr_mc[0];
  75. e = &coderInfo[chanNum].bwpInfo.e_mc[0];
  76. K = &coderInfo[chanNum].bwpInfo.K_mc[0]; 
  77. R = &coderInfo[chanNum].bwpInfo.R_mc[0];
  78. VAR = &coderInfo[chanNum].bwpInfo.VAR_mc[0];
  79. KOR = &coderInfo[chanNum].bwpInfo.KOR_mc[0];
  80. sb_samples_pred = &coderInfo[chanNum].bwpInfo.sb_samples_pred_mc[0];
  81. thisLineNeedsResetting = &coderInfo[chanNum].bwpInfo.thisLineNeedsResetting_mc[0];
  82. reset_count = &coderInfo[chanNum].bwpInfo.reset_count_mc;
  84. thisChannel = &(channelInfo[chanNum]);
  85. *psy_init = (*psy_init && (btype!=2));
  87. if((*psy_init) == 0) {
  88. for (j=0; j<BLOCK_LEN_LONG; j++) {
  89. thisLineNeedsResetting[j]=1;
  90. }
  91. *psy_init = 1;
  92. }
  94. if (btype==2) {
  95. pred_global_flag[0]=0;
  96. /* SHORT WINDOWS reset all the co-efficients    */
  97. if (thisChannel->ch_is_left) {
  98. (*reset_count)++;
  99. if (*reset_count >= 31 * RESET_FRAME)
  100. *reset_count = RESET_FRAME;
  101. }
  102. return;
  103. }
  106. /**************************************************/
  107. /*  Compute state using last_spec                 */
  108. /**************************************************/
  109. for (i=0;i<BLOCK_LEN_LONG;i++) 
  110.     {
  111. /* e[0][i]=last_spec[i]; */ 
  112. e[0][i]=last_spec[i]+sb_samples_pred[i];
  114. for(j=1;j<=LPC;j++)
  115. e[j][i] = e[j-1][i]-K[j][i]*R[j-1][i];
  117. for(j=1;j<LPC;j++) 
  118. dr[j][i] = K[j][i]*e[j-1][i];
  120. for(j=1;j<=LPC;j++) {
  121. VAR[j][i] = ALPHA*VAR[j][i]+.5*(R[j-1][i]*R[j-1][i]+e[j-1][i]*e[j-1][i]);
  122. KOR[j][i] = ALPHA*KOR[j][i]+R[j-1][i]*e[j-1][i];
  123. }
  125. for(j=LPC-1;j>=1;j--) 
  126. R[j][i] = A*(R[j-1][i]-dr[j][i]);
  127. R[0][i] = A*e[0][i];
  128.     }
  131. /**************************************************/
  132. /* Reset state here if resets were sent           */
  133. /**************************************************/
  134. for (i=0;i<BLOCK_LEN_LONG;i++) {
  135. if (thisLineNeedsResetting[i]) {
  136. for (j = 0; j <= LPC; j++)
  137. {
  138. K[j][i] = 0.0;
  139. e[j][i] = 0.0;
  140. R[j][i] = 0.0;
  141. VAR[j][i] = 1.0;
  142. KOR[j][i] = 0.0;
  143. dr[j][i] = 0.0;
  144. }
  145. }
  146. }
  150. /**************************************************/
  151. /* Compute predictor coefficients, predicted data */
  152. /**************************************************/
  153. for (i=0;i<BLOCK_LEN_LONG;i++) 
  154.     {
  155. for(j=1;j<=LPC;j++) {
  156. if(VAR[j][i]>MINVAR)
  157. K[j][i] = KOR[j][i]/VAR[j][i]*B;
  158. else
  159. K[j][i] = 0;
  160. }
  161.     }
  164. for (k=0; k<BLOCK_LEN_LONG; k++)
  165.     {
  166. sb_samples_pred[k]=0.0;
  167. for (i=1; i<=LPC; i++)
  168. sb_samples_pred[k]+=K[i][k]*R[i-1][k];
  169.     }
  172. /***********************************************************/
  173. /* If this is the right channel of a channel_pair_element, */
  174. /* AND common_window is 1 in this channel_pair_element,    */
  175. /* THEN copy predictor data to use from the left channel.  */
  176. /* ELSE determine independent predictor data and resets.   */
  177. /***********************************************************/
  178. /* BE CAREFUL HERE, this assumes that predictor data has   */
  179. /* already been determined for the left channel!!          */
  180. /***********************************************************/
  181. isRightWithCommonWindow = 0;     /* Is this a right channel with common_window?*/
  182. if ((thisChannel->cpe)&&( !(thisChannel->ch_is_left))) {
  183. leftChanNum = thisChannel->paired_ch;
  184. if (channelInfo[leftChanNum].common_window) {
  185. isRightWithCommonWindow = 1;
  186. }
  187. }
  189. if (isRightWithCommonWindow) {
  191. /**************************************************/
  192. /* Use predictor data from the left channel.      */
  193. /**************************************************/
  194. CopyPredInfo(&(coderInfo[chanNum]),&(coderInfo[leftChanNum]));
  196. /* Make sure to turn off bands with intensity stereo */
  197. #if 0
  198. if (thisChannel->is_info.is_present) {
  199. for (i=0; i<nsfb; i++) {
  200. if (thisChannel->is_info.is_used[i]) {
  201. pred_sfb_flag[i] = 0;
  202. }
  203. }
  204. }
  205. #endif
  207. cb_long=0;
  208. for (i=0; i<nsfb; i++)
  209. {
  210. if (!pred_sfb_flag[i]) {
  211. for (j=cb_long; j<cb_long+isfb_width[i]; j++)
  212. sb_samples_pred[j]=0.0; 
  213. }
  214. cb_long+=isfb_width[i];
  215. }
  217. /* Disable prediction for bands nsfb through SBMAX_L */ 
  218. for (i=j;i<BLOCK_LEN_LONG;i++) {
  219. sb_samples_pred[i]=0.0;
  220. }
  221. for (i=nsfb;i<SBMAX_L;i++) {
  222. pred_sfb_flag[i]=0;
  223. }
  225. /* Is global enable set, if not enabled predicted samples are zeroed */
  226. if(!pred_global_flag[0]) {
  227. for (j=0; j<BLOCK_LEN_LONG; j++)
  228. sb_samples_pred[j]=0.0; 
  229. }
  230. for (j=0; j<BLOCK_LEN_LONG; j++)
  231. act_spec[j]-=sb_samples_pred[j];
  233. } else {
  235. /**************************************************/
  236. /* Determine whether to enable/disable prediction */
  237. /**************************************************/
  239. for (k=0; k<BLOCK_LEN_LONG; k++) {
  240. energy[k]=act_spec[k]*act_spec[k];
  241. snr_p[k]=(act_spec[k]-sb_samples_pred[k])*(act_spec[k]-sb_samples_pred[k]);
  242. }
  244. cb_long=0;
  245. for (i=0; i<nsfb; i++) {
  246. pred_sfb_flag[i]=1;
  247. temp1=0.0;
  248. temp2=0.0;
  249. for (j=cb_long; j<cb_long+isfb_width[i]; j++) {
  250. temp1+=energy[j];
  251. temp2+=snr_p[j];
  252. }
  253. if(temp2<1.e-20)
  254. temp2=1.e-20;
  255. if(temp1!=0.0)
  256. snr[i]=-10.*log10((double ) temp2/temp1);
  257. else
  258. snr[i]=0.0;
  260. if(snr[i]<=0.0) {
  261. pred_sfb_flag[i]=0; 
  262. for (j=cb_long; j<cb_long+isfb_width[i]; j++)
  263. sb_samples_pred[j]=0.0;
  264. }
  265. cb_long+=isfb_width[i];
  266. }
  268. /* Disable prediction for bands nsfb through SBMAX_L */ 
  269. for (i=j;i<BLOCK_LEN_LONG;i++) {
  270. sb_samples_pred[i]=0.0;
  271. }
  272. for (i=nsfb;i<SBMAX_L;i++) {
  273. pred_sfb_flag[i]=0;
  274. }
  276. num_bit=0.0;
  277. for (i=0; i<nsfb; i++)
  278. if(snr[i]>0.0)
  279. num_bit+=snr[i]/6.*isfb_width[i];
  281. /* Determine global enable, if not enabled predicted samples are zeroed */
  282. pred_global_flag[0]=1;
  283. if(num_bit<50) {
  284. pred_global_flag[0]=0; num_bit=0.0; 
  285. for (j=0; j<BLOCK_LEN_LONG; j++)
  286. sb_samples_pred[j]=0.0; 
  287. }
  288. for (j=0; j<BLOCK_LEN_LONG; j++)
  289. act_spec[j]-=sb_samples_pred[j];
  291. }
  293. /**********************************************************/
  294. /* If this is a left channel, determine pred resets.      */
  295. /* If this is a right channel, using pred reset data from */
  296. /* left channel.  Keep left and right resets in sync.     */
  297. /**********************************************************/
  298. if ((thisChannel->cpe)&&( !(thisChannel->ch_is_left))) {
  299. /*  if (!thisChannel->ch_is_left) {*/
  300. /**********************************************************/
  301. /* Using predictor reset data from the left channel.      */
  302. /**********************************************************/
  303. reset_count = &coderInfo[leftChanNum].bwpInfo.reset_count_mc;
  304. /* Reset the frame counter */
  305. for (i=0;i<BLOCK_LEN_LONG;i++) {
  306. thisLineNeedsResetting[i]=0;
  307. }
  308. reset_group = &(coderInfo[chanNum].reset_group_number);
  309. if (*reset_count % RESET_FRAME == 0)
  310. { /* Send a reset in this frame */
  311. *reset_group = *reset_count / 8;
  312. for (i = *reset_group - 1; i < BLOCK_LEN_LONG; i += 30)
  313. {
  314. thisLineNeedsResetting[i]=1;
  315. }
  316. }
  317. else
  318. *reset_group = -1;
  319. } else {
  320. /******************************************************************/
  321. /* Determine whether a prediction reset is required - if so, then */
  322. /* set reset flag for the appropriate group.                      */
  323. /******************************************************************/
  325. /* Increase counter on left channel, keep left and right resets in sync */
  326. (*reset_count)++;
  328. /* Reset the frame counter */
  329. for (i=0;i<BLOCK_LEN_LONG;i++) {
  330. thisLineNeedsResetting[i]=0;
  331. }
  332. if (*reset_count >= 31 * RESET_FRAME)
  333. *reset_count = RESET_FRAME;
  334. if (*reset_count % RESET_FRAME == 0)
  335. { /* Send a reset in this frame */
  336. *reset_group = *reset_count / 8;
  337. for (i = *reset_group - 1; i < BLOCK_LEN_LONG; i += 30)
  338. {
  339. thisLineNeedsResetting[i]=1;
  340. }
  341. }
  342. else
  343. *reset_group = -1;
  344. }
  347. /* Ensure that prediction data is sent when there is a prediction
  348. * reset.
  349. */
  350. if (*reset_group != -1 && pred_global_flag[0] == 0)
  351.     {
  352. pred_global_flag[0] = 1;
  353. for (i = 0; i < nsfb; i++)
  354. pred_sfb_flag[i] = 0;
  355.     }
  356. }
  359. void CopyPredInfo(CoderInfo *right, CoderInfo *left)
  360. {
  361. int band;
  363. right->pred_global_flag = left->pred_global_flag;
  364. right->reset_group_number = left->reset_group_number;
  366. for (band = 0; band<MAX_SCFAC_BANDS; band++) {
  367. right->pred_sfb_flag[band] = left->pred_sfb_flag[band];
  368. }
  369. }