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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

pan_lspqtz2_dd.c：源码内容
  1. /*
  2. This software module was originally developed by
  3. Naoya Tanaka (Matsushita Communication Industrial Co., Ltd.)
  4. and edited by
  6. in the course of development of the
  7. MPEG-2 NBC/MPEG-4 Audio standard ISO/IEC 13818-7, 14496-1,2 and 3.
  8. This software module is an implementation of a part of one or more
  9. MPEG-2 NBC/MPEG-4 Audio tools as specified by the MPEG-2 NBC/MPEG-4 Audio
  10. standard. ISO/IEC  gives users of the MPEG-2 NBC/MPEG-4 Audio standards
  11. free license to this software module or modifications thereof for use in
  12. hardware or software products claiming conformance to the MPEG-2 NBC/
  13. MPEG-4 Audio  standards. Those intending to use this software module in
  14. hardware or software products are advised that this use may infringe
  15. existing patents. The original developer of this software module and
  16. his/her company, the subsequent editors and their companies, and ISO/IEC
  17. have no liability for use of this software module or modifications
  18. thereof in an implementation. Copyright is not released for non
  19. MPEG-2 NBC/MPEG-4 Audio conforming products. The original developer
  20. retains full right to use the code for his/her  own purpose, assign or
  21. donate the code to a third party and to inhibit third party from using
  22. the code for non MPEG-2 NBC/MPEG-4 Audio conforming products.
  23. This copyright notice must be included in all copies or derivative works.
  24. Copyright (c)1996.
  25. */
  26. /*----------------------------------------------------------------------*
  27.  *  Panasonic                                                           *
  28.  *    MPEG-4 Audio Verification Model (VM)                              * 
  29.  *                                                                      *
  30.  * CELP based coder                                                *
  31.  *    Module: pan_lspqtz2_dd.c                                      *
  32.  *                                                                      *
  33.  *  Last modified: Jan. 06, 1998                                        *
  34.  *----------------------------------------------------------------------*/
  36. /* 2-mode, 2-stage LSP vector quantizer w/ delayed decision */
  37. /*  - This module supports (1+2) and (2+2) structures only! */
  39. #include <stdio.h>
  40. #include <stdlib.h>
  42. #include "buffersHandle.h"       /* handler, defines, enums */
  44. #include "bitstream.h"
  45. #include "pan_celp_proto.h"
  46. #include "pan_celp_const.h"
  48. void pan_lspqtz2_dd(
  49.     float in[], /* in: input LSPs */
  50.     float out_p[], /* in: previous output LSPs */
  51.     float out[], /* out: output LSPs */
  52.     float weight[], /* in: weighting factor */
  53.     float p_factor, /* in: prediction coefficient */
  54.     float min_gap, /* in: minimum gap between adjacent LSPs */
  55.     long lpc_order, /* in: LPC order */
  56.     long num_dc, /* in: number of delayed candidates for DD */
  57.     long idx[],  /* out: LSP indicies */
  58.     float tbl[], /* in: VQ table */
  59.     float d_tbl[], /* in: DVQ table */
  60.     float rd_tbl[], /* in: PVQ table */
  61.     long dim_1[], /* in: dimensions of the 1st VQ vectors */
  62.     long ncd_1[], /* in: numbers of the 1st VQ codes */
  63.     long dim_2[], /* in: dimensions of the 2nd VQ vectors */
  64.     long ncd_2[], /* in: numbers of the 2nd VQ codes */
  65.     long flagStab /* in: 0 - stabilization OFF, 1 - stabilization ON */
  66.     )
  67. {
  68.     float out_v[PAN_DIM_MAX*PAN_N_DC_LSP_MAX];
  69.     float qv_rd[PAN_DIM_MAX*PAN_N_DC_LSP_MAX];
  70.     float qv_d[PAN_DIM_MAX*PAN_N_DC_LSP_MAX];
  71.     float dist_rd1, dist_d1;
  72.     float dist_rd2, dist_d2;
  73.     float dist_rd_min1, dist_d_min1;
  74.     float dist_rd_min2, dist_d_min2;
  75.     long i, j;
  76.     long d_idx[2*PAN_N_DC_LSP_MAX];
  77.     long rd_idx[2*PAN_N_DC_LSP_MAX];
  78.     long d_idx_tmp1, rd_idx_tmp1;
  79.     long d_idx_tmp2, rd_idx_tmp2;
  81.     long idx_tmp[2*PAN_N_DC_LSP_MAX];
  82.     long i_tmp[PAN_N_DC_LSP_MAX];
  84.     if(lpc_order>PAN_DIM_MAX) {
  85.         printf("n LSP quantizer: LPC order exceeds the limitn");
  86.         exit(1);
  87.     }
  88.     if(num_dc>PAN_N_DC_LSP_MAX) {
  89.         printf("n LSP quantizer: number of delayed candidates exceeds the limitn");
  90.         exit(1);
  91.     }
  93. /* 1st stage vector quantization */
  94. pan_v_qtz_w_dd(&in[0], i_tmp, ncd_1[0], &tbl[0], dim_1[0], 
  95. &weight[0], num_dc);
  96. for(i=0;i<num_dc;i++) idx_tmp[2*i] = i_tmp[i];
  98. pan_v_qtz_w_dd(&in[dim_1[0]], i_tmp, ncd_1[1], 
  99. &tbl[dim_1[0]*ncd_1[0]], dim_1[1], &weight[dim_1[0]], num_dc);
  100. for(i=0;i<num_dc;i++) idx_tmp[2*i+1] = i_tmp[i];
  101.  
  102. /* quantized value */
  103. for(j=0;j<num_dc;j++) {
  104. for(i=0;i<dim_1[0];i++) {
  105. out_v[lpc_order*j+i] = tbl[dim_1[0]*idx_tmp[2*j]+i];
  106. }
  108. for(i=0;i<dim_1[1];i++) {
  109. out_v[lpc_order*j+dim_1[0]+i] 
  110. = tbl[dim_1[0]*ncd_1[0]+dim_1[1]*idx_tmp[2*j+1]+i];
  111. }
  112. }
  114. /* ------------------------------------------------------------------ */
  115. /* 2nd stage vector quantization */
  117. for(j=0;j<num_dc;j++) {
  118. pan_d_qtz_w(&in[0], &out_v[lpc_order*j], &d_idx[2*j], ncd_2[0], 
  119. &d_tbl[0], dim_2[0], &weight[0]);
  121. pan_d_qtz_w(&in[dim_2[0]], &out_v[lpc_order*j+dim_2[0]], &d_idx[2*j+1], 
  122. ncd_2[1], &d_tbl[dim_2[0]*ncd_2[0]], 
  123. dim_2[1], &weight[dim_2[0]]);
  125. /* quantized value */
  127. if(d_idx[2*j]<ncd_2[0]) {
  128.     for(i=0;i<dim_2[0];i++) {
  129. qv_d[lpc_order*j+i] = out_v[lpc_order*j+i]+d_tbl[d_idx[2*j]*dim_2[0]+i];
  130.     }
  131. }else {
  132.     for(i=0;i<dim_2[0];i++) {
  133. qv_d[lpc_order*j+i] = out_v[lpc_order*j+i]-d_tbl[(d_idx[2*j]-ncd_2[0])*dim_2[0]+i];
  134.     }
  135. }
  136. if(d_idx[2*j+1]<ncd_2[1]) {
  137.     for(i=0;i<dim_2[1];i++) {
  138. qv_d[lpc_order*j+dim_2[0]+i] = out_v[lpc_order*j+dim_2[0]+i]
  139. + d_tbl[dim_2[0]*ncd_2[0]+d_idx[2*j+1]*dim_2[1]+i];
  140.     }
  141. }else {
  142.     for(i=0;i<dim_2[1];i++) {
  143. qv_d[lpc_order*j+dim_2[0]+i] = out_v[lpc_order*j+dim_2[0]+i]
  144. - d_tbl[dim_2[0]*ncd_2[0]
  145. + (d_idx[2*j+1]-ncd_2[1])*dim_2[1]+i];
  146.     }
  147. }
  149. }
  150. /* ------------------------------------------------------------------ */
  151. /* 2nd stage predictive vector quantization */
  152. for(j=0;j<num_dc;j++) {
  154. pan_rd_qtz2_w(&in[0], &out_p[0], &out_v[lpc_order*j], &rd_idx[2*j], 
  155. ncd_2[0], &rd_tbl[0], dim_2[0], &weight[0], p_factor);
  157. pan_rd_qtz2_w(&in[dim_2[0]], &out_p[dim_2[0]], &out_v[lpc_order*j+dim_2[0]], 
  158. &rd_idx[2*j+1], ncd_2[1], &rd_tbl[dim_2[0]*ncd_2[0]], 
  159. dim_2[1], &weight[dim_2[0]], p_factor);
  161. /* quantized value */
  163. if(rd_idx[2*j]<ncd_2[0]) {
  164.     for(i=0;i<dim_2[0];i++) {
  165. qv_rd[lpc_order*j+i] = (p_factor*out_p[i]
  166. + (1.-p_factor)*out_v[lpc_order*j+i])
  167. + rd_tbl[rd_idx[2*j]*dim_2[0]+i];
  168.     }
  169. }else {
  170.     for(i=0;i<dim_2[0];i++) {
  171. qv_rd[lpc_order*j+i] = (p_factor*out_p[i]
  172. + (1.-p_factor)*out_v[lpc_order*j+i])
  173. - rd_tbl[(rd_idx[2*j]-ncd_2[0])*dim_2[0]+i];
  174.     }
  175. }
  176. if(rd_idx[2*j+1]<ncd_2[1]) {
  177.     for(i=0;i<dim_2[1];i++) {
  178. qv_rd[lpc_order*j+dim_2[0]+i] = (p_factor*out_p[dim_2[0]+i]
  179. + (1.-p_factor)*out_v[lpc_order*j+dim_2[0]+i])
  180. + rd_tbl[dim_2[0]*ncd_2[0]
  181. + rd_idx[2*j+1]*dim_2[1]+i];
  182.     }
  183. }else {
  184.     for(i=0;i<dim_2[1];i++) {
  185. qv_rd[lpc_order*j+dim_2[0]+i] = (p_factor*out_p[dim_2[0]+i]
  186. + (1.-p_factor)*out_v[lpc_order*j+dim_2[0]+i])
  187. - rd_tbl[dim_2[0]*ncd_2[0]
  188. +(rd_idx[2*j+1]-ncd_2[1])*dim_2[1]+i];
  189.     }
  190. }
  192. }
  193. /* ------------------------------------------------------------------ */
  194. /* Quantization mode selection */
  195. if(0==dim_1[1]) {
  196. /* PVQ */
  197. dist_rd_min1 = 1.0e9;
  198. dist_rd_min2 = 1.0e9;
  199. rd_idx_tmp1 = 0;
  200. rd_idx_tmp2 = 0;
  201. for(j=0;j<num_dc;j++) {
  202. dist_rd1 = 0.;
  203. for(i=0;i<dim_2[0];i++) 
  204. dist_rd1 += (in[i]-qv_rd[lpc_order*j+i])
  205. *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  206. dist_rd2 = 0.;
  207. for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++) 
  208. dist_rd2 += (in[i]-qv_rd[lpc_order*j+i])
  209. *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  210. if(dist_rd1+dist_rd2<dist_rd_min1+dist_rd_min2) {
  211. dist_rd_min1 = dist_rd1;
  212. dist_rd_min2 = dist_rd2;
  213. rd_idx_tmp1 = j;
  214. rd_idx_tmp2 = j;
  215. }
  216. }
  218. /* DVQ */
  219. dist_d_min1 = 1.0e9;
  220. dist_d_min2 = 1.0e9;
  221. d_idx_tmp1 = 0;
  222. d_idx_tmp2 = 0;
  223. for(j=0;j<num_dc;j++) {
  224. dist_d1 = 0.;
  225. for(i=0;i<dim_2[0];i++)
  226. dist_d1 += (in[i]-qv_d[lpc_order*j+i])
  227. *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  228. dist_d2 = 0.;
  229. for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  230. dist_d2 += (in[i]-qv_d[lpc_order*j+i])
  231. *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  232. if(dist_d1+dist_d2<dist_d_min1+dist_d_min2) {
  233. dist_d_min1 = dist_d1;
  234. dist_d_min2 = dist_d2;
  235. d_idx_tmp1 = j;
  236. d_idx_tmp2 = j;
  237. }
  238. }
  241. }else {
  242. /* Lower Part of PVQ */
  243. dist_rd_min1 = 1.0e9;
  244. rd_idx_tmp1 = 0;
  245. for(j=0;j<num_dc;j++) {
  246. dist_rd1 = 0.;
  247. for(i=0;i<dim_2[0];i++) 
  248. dist_rd1 += (in[i]-qv_rd[lpc_order*j+i])
  249. *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  250. if(dist_rd1<dist_rd_min1) {
  251. dist_rd_min1 = dist_rd1;
  252. rd_idx_tmp1 = j;
  253. }
  254. }
  256. /* Upper Part of PVQ */
  257. dist_rd_min2 = 1.0e9;
  258. rd_idx_tmp2 = 0;
  259. for(j=0;j<num_dc;j++) {
  260. dist_rd2 = 0.;
  261. for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++) 
  262. dist_rd2 += (in[i]-qv_rd[lpc_order*j+i])
  263. *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  264. if(dist_rd2<dist_rd_min2) {
  265. dist_rd_min2 = dist_rd2;
  266. rd_idx_tmp2 = j;
  267. }
  268. }
  270. /* Lower Part of DVQ */
  271. dist_d_min1 = 1.0e9;
  272. d_idx_tmp1 = 0;
  273. for(j=0;j<num_dc;j++) {
  274. dist_d1 = 0.;
  275. for(i=0;i<dim_2[0];i++)
  276. dist_d1 += (in[i]-qv_d[lpc_order*j+i])
  277. *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  278. if(dist_d1<dist_d_min1) {
  279. dist_d_min1 = dist_d1;
  280. d_idx_tmp1 = j;
  281. }
  282. }
  284. /* Upper Part of DVQ */
  285. dist_d_min2 = 1.0e9;
  286. d_idx_tmp2 = 0;
  287. for(j=0;j<num_dc;j++) {
  288. dist_d2 = 0.;
  289. for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  290. dist_d2 += (in[i]-qv_d[lpc_order*j+i])
  291. *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  292. if(dist_d2<dist_d_min2) {
  293. dist_d_min2 = dist_d2;
  294. d_idx_tmp2 = j;
  295. }
  296. }
  297. }
  299. if((dist_rd_min1+dist_rd_min2)<(dist_d_min1+dist_d_min2)) {
  300. for(i=0;i<dim_2[0];i++) out[i] = qv_rd[lpc_order*rd_idx_tmp1+i];
  301. for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++) 
  302. out[i] = qv_rd[lpc_order*rd_idx_tmp2+i];
  303. idx[0] = idx_tmp[2*rd_idx_tmp1];
  304. idx[1] = idx_tmp[2*rd_idx_tmp2+1];
  305. idx[2] = rd_idx[2*rd_idx_tmp1];
  306. idx[3] = rd_idx[2*rd_idx_tmp2+1];
  307. idx[4] = 1;
  308. }else{
  309. for(i=0;i<dim_2[0];i++) out[i] = qv_d[lpc_order*d_idx_tmp1+i];
  310. for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++) 
  311. out[i] = qv_d[lpc_order*d_idx_tmp2+i];
  312. idx[0] = idx_tmp[2*d_idx_tmp1];
  313. idx[1] = idx_tmp[2*d_idx_tmp2+1];
  314. idx[2] = d_idx[2*d_idx_tmp1];
  315. idx[3] = d_idx[2*d_idx_tmp2+1];
  316. idx[4] = 0;
  317. }
  319. if(flagStab) pan_stab(out, min_gap, lpc_order);
  321. }
  323. /* ------------------------------------------------------------------ */
  325. void pan_lspqtz2_ddVR(
  326.     float in[], /* in: input LSPs */
  327.     float out_p[], /* in: previous output LSPs */
  328.     float out[], /* out: output LSPs */
  329.     float weight[], /* in: weighting factor */
  330.     float p_factor, /* in: prediction coefficient */
  331.     float min_gap, /* in: minimum gap between adjacent LSPs */
  332.     long lpc_order, /* in: LPC order */
  333.     long num_dc, /* in: number of delayed candidates for DD */
  334.     long idx[],  /* out: LSP indicies */
  335.     float tbl[], /* in: VQ table */
  336.     float d_tbl[], /* in: DVQ table */
  337.     float rd_tbl[], /* in: PVQ table */
  338.     long dim_1[], /* in: dimensions of the 1st VQ vectors */
  339.     long ncd_1[], /* in: numbers of the 1st VQ codes */
  340.     long dim_2[], /* in: dimensions of the 2nd VQ vectors */
  341.     long ncd_2[],  /* in: numbers of the 2nd VQ codes */
  342.     int level,
  343.     int qMode
  344.     )
  345. {
  346.     float out_v[PAN_DIM_MAX*PAN_N_DC_LSP_MAX];
  347.     float qv_rd[PAN_DIM_MAX*PAN_N_DC_LSP_MAX];
  348.     float qv_d[PAN_DIM_MAX*PAN_N_DC_LSP_MAX];
  349.     float dist_rd1, dist_d1;
  350.     float dist_rd2, dist_d2;
  351.     float dist_rd_min1, dist_d_min1;
  352.     float dist_rd_min2, dist_d_min2;
  353.     long i, j;
  354.     long d_idx[2*PAN_N_DC_LSP_MAX];
  355.     long rd_idx[2*PAN_N_DC_LSP_MAX];
  356.     long d_idx_tmp1, rd_idx_tmp1;
  357.     long d_idx_tmp2, rd_idx_tmp2;
  359.     long idx_tmp[2*PAN_N_DC_LSP_MAX];
  360.     long i_tmp[PAN_N_DC_LSP_MAX];
  362.     if(lpc_order>PAN_DIM_MAX) {
  363.         printf("n LSP quantizer: LPC order exceeds the limitn");
  364.         exit(1);
  365.     }
  366.     if(num_dc>PAN_N_DC_LSP_MAX) {
  367.         printf("n LSP quantizer: number of delayed candidates exceeds the limitn");
  368.         exit(1);
  369.     }
  371. /* 1st stage vector quantization */
  372.         pan_v_qtz_w_dd(&in[0], i_tmp, ncd_1[0], &tbl[0], dim_1[0],
  373.                 &weight[0], num_dc);
  374.         for(i=0;i<num_dc;i++) idx_tmp[2*i] = i_tmp[i];
  376.         pan_v_qtz_w_dd(&in[dim_1[0]], i_tmp, ncd_1[1],
  377.                 &tbl[dim_1[0]*ncd_1[0]], dim_1[1], &weight[dim_1[0]], num_dc);
  378.         for(i=0;i<num_dc;i++) idx_tmp[2*i+1] = i_tmp[i];
  380. /* quantized value */
  381. for(j=0;j<num_dc;j++) {
  382.         for(i=0;i<dim_1[0];i++) {
  383.                 out_v[lpc_order*j+i] = tbl[dim_1[0]*idx_tmp[2*j]+i];
  384.         }
  386.         for(i=0;i<dim_1[1];i++) {
  387.                 out_v[lpc_order*j+dim_1[0]+i]
  388.                         = tbl[dim_1[0]*ncd_1[0]+dim_1[1]*idx_tmp[2*j+1]+i];
  389.         }
  390. }
  392. /* ------------------------------------------------------------------ */
  393. /* 2nd stage vector quantization */
  395. for(j=0;j<num_dc;j++) {
  396.         pan_d_qtz_w(&in[0], &out_v[lpc_order*j], &d_idx[2*j], ncd_2[0],
  397.                 &d_tbl[0], dim_2[0], &weight[0]);
  399.         pan_d_qtz_w(&in[dim_2[0]], &out_v[lpc_order*j+dim_2[0]], &d_idx[2*j+1],
  400.                 ncd_2[1], &d_tbl[dim_2[0]*ncd_2[0]],
  401.                 dim_2[1], &weight[dim_2[0]]);
  403. /* quantized value */
  405.         if(d_idx[2*j]<ncd_2[0]) {
  406.             for(i=0;i<dim_2[0];i++) {
  407.                 qv_d[lpc_order*j+i] = out_v[lpc_order*j+i]+d_tbl[d_idx[2*j]*dim_2[0]+i];
  408.             }
  409.         }else {
  410.             for(i=0;i<dim_2[0];i++) {
  411.                 qv_d[lpc_order*j+i] = out_v[lpc_order*j+i]-d_tbl[(d_idx[2*j]-ncd_2[0])*dim_2[0]+i];
  412.             }
  413.         }
  414.         if(d_idx[2*j+1]<ncd_2[1]) {
  415.             for(i=0;i<dim_2[1];i++) {
  416.                 qv_d[lpc_order*j+dim_2[0]+i] = out_v[lpc_order*j+dim_2[0]+i]
  417.                         + d_tbl[dim_2[0]*ncd_2[0]+d_idx[2*j+1]*dim_2[1]+i];
  418.             }
  419.         }else {
  420.             for(i=0;i<dim_2[1];i++) {
  421.                 qv_d[lpc_order*j+dim_2[0]+i] = out_v[lpc_order*j+dim_2[0]+i]
  422.                         - d_tbl[dim_2[0]*ncd_2[0]
  423.                                 + (d_idx[2*j+1]-ncd_2[1])*dim_2[1]+i];
  424.             }
  425.         }
  427. }
  428. /* ------------------------------------------------------------------ */
  429. /* 2nd stage predictive vector quantization */
  430. for(j=0;j<num_dc;j++) {
  432.         pan_rd_qtz2_w(&in[0], &out_p[0], &out_v[lpc_order*j], &rd_idx[2*j],
  433.                 ncd_2[0], &rd_tbl[0], dim_2[0], &weight[0], p_factor);
  435.         pan_rd_qtz2_w(&in[dim_2[0]], &out_p[dim_2[0]], &out_v[lpc_order*j+dim_2[0]],
  436.                 &rd_idx[2*j+1], ncd_2[1], &rd_tbl[dim_2[0]*ncd_2[0]],
  437.                 dim_2[1], &weight[dim_2[0]], p_factor);
  439. /* quantized value */
  441.         if(rd_idx[2*j]<ncd_2[0]) {
  442.             for(i=0;i<dim_2[0];i++) {
  443.                 qv_rd[lpc_order*j+i] = (p_factor*out_p[i]
  444.                         + (1.-p_factor)*out_v[lpc_order*j+i])
  445.                         + rd_tbl[rd_idx[2*j]*dim_2[0]+i];
  446.             }
  447.         }else {
  448.             for(i=0;i<dim_2[0];i++) {
  449.                 qv_rd[lpc_order*j+i] = (p_factor*out_p[i]
  450.                         + (1.-p_factor)*out_v[lpc_order*j+i])
  451.                         - rd_tbl[(rd_idx[2*j]-ncd_2[0])*dim_2[0]+i];
  452.             }
  453.         }
  454.         if(rd_idx[2*j+1]<ncd_2[1]) {
  455.             for(i=0;i<dim_2[1];i++) {
  456.                 qv_rd[lpc_order*j+dim_2[0]+i] = (p_factor*out_p[dim_2[0]+i]
  457.                                 + (1.-p_factor)*out_v[lpc_order*j+dim_2[0]+i])
  458.                                 + rd_tbl[dim_2[0]*ncd_2[0]
  459.                                         + rd_idx[2*j+1]*dim_2[1]+i];
  460.             }
  461.         }else {
  462.             for(i=0;i<dim_2[1];i++) {
  463.                 qv_rd[lpc_order*j+dim_2[0]+i] = (p_factor*out_p[dim_2[0]+i]
  464.                                 + (1.-p_factor)*out_v[lpc_order*j+dim_2[0]+i])
  465.                                 - rd_tbl[dim_2[0]*ncd_2[0]
  466.                                         +(rd_idx[2*j+1]-ncd_2[1])*dim_2[1]+i];
  467.             }
  468.         }
  470. }
  471. /* ------------------------------------------------------------------ */
  472. /* Quantization mode selection */
  473. if(0==dim_1[1]) {
  474. /* PVQ */
  475.         dist_rd_min1 = 1.0e9;
  476.         dist_rd_min2 = 1.0e9;
  477.         rd_idx_tmp1 = 0;
  478.         rd_idx_tmp2 = 0;
  479.         for(j=0;j<num_dc;j++) {
  480.                 dist_rd1 = 0.;
  481.                 for(i=0;i<dim_2[0];i++)
  482.                         dist_rd1 += (in[i]-qv_rd[lpc_order*j+i])
  483.                                 *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  484.                 dist_rd2 = 0.;
  485.                 for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  486.                         dist_rd2 += (in[i]-qv_rd[lpc_order*j+i])
  487.                                 *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  488.                 if(dist_rd1+dist_rd2<dist_rd_min1+dist_rd_min2) {
  489.                         dist_rd_min1 = dist_rd1;
  490.                         dist_rd_min2 = dist_rd2;
  491.                         rd_idx_tmp1 = j;
  492.                         rd_idx_tmp2 = j;
  493.                 }
  494.         }
  496. /* DVQ */
  497.         dist_d_min1 = 1.0e9;
  498.         dist_d_min2 = 1.0e9;
  499.         d_idx_tmp1 = 0;
  500.         d_idx_tmp2 = 0;
  501.         for(j=0;j<num_dc;j++) {
  502.                 dist_d1 = 0.;
  503.                 for(i=0;i<dim_2[0];i++)
  504.                         dist_d1 += (in[i]-qv_d[lpc_order*j+i])
  505.                                 *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  506.                 dist_d2 = 0.;
  507.                 for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  508.                         dist_d2 += (in[i]-qv_d[lpc_order*j+i])
  509.                                 *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  510.                 if(dist_d1+dist_d2<dist_d_min1+dist_d_min2) {
  511.                         dist_d_min1 = dist_d1;
  512.                         dist_d_min2 = dist_d2;
  513.                         d_idx_tmp1 = j;
  514.                         d_idx_tmp2 = j;
  515.                 }
  516.         }
  519. }else {
  520. /* Lower Part of PVQ */
  521.         dist_rd_min1 = 1.0e9;
  522.         rd_idx_tmp1 = 0;
  523.         for(j=0;j<num_dc;j++) {
  524.                 dist_rd1 = 0.;
  525.                 for(i=0;i<dim_2[0];i++)
  526.                         dist_rd1 += (in[i]-qv_rd[lpc_order*j+i])
  527.                                 *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  528.                 if(dist_rd1<dist_rd_min1) {
  529.                         dist_rd_min1 = dist_rd1;
  530.                         rd_idx_tmp1 = j;
  531.                 }
  532.         }
  534. /* Upper Part of PVQ */
  535.         dist_rd_min2 = 1.0e9;
  536.         rd_idx_tmp2 = 0;
  537.         for(j=0;j<num_dc;j++) {
  538.                 dist_rd2 = 0.;
  539.                 for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  540.                         dist_rd2 += (in[i]-qv_rd[lpc_order*j+i])
  541.                                 *(in[i]-qv_rd[lpc_order*j+i])*weight[i];
  542.                 if(dist_rd2<dist_rd_min2) {
  543.                         dist_rd_min2 = dist_rd2;
  544.                         rd_idx_tmp2 = j;
  545.                 }
  546.         }
  548. /* Lower Part of DVQ */
  549.         dist_d_min1 = 1.0e9;
  550.         d_idx_tmp1 = 0;
  551.         for(j=0;j<num_dc;j++) {
  552.                 dist_d1 = 0.;
  553.                 for(i=0;i<dim_2[0];i++)
  554.                         dist_d1 += (in[i]-qv_d[lpc_order*j+i])
  555.                                 *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  556.                 if(dist_d1<dist_d_min1) {
  557.                         dist_d_min1 = dist_d1;
  558.                         d_idx_tmp1 = j;
  559.                 }
  560.         }
  562. /* Upper Part of DVQ */
  563.         dist_d_min2 = 1.0e9;
  564.         d_idx_tmp2 = 0;
  565.         for(j=0;j<num_dc;j++) {
  566.                 dist_d2 = 0.;
  567.                 for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  568.                         dist_d2 += (in[i]-qv_d[lpc_order*j+i])
  569.                                 *(in[i]-qv_d[lpc_order*j+i])*weight[i];
  570.                 if(dist_d2<dist_d_min2) {
  571.                         dist_d_min2 = dist_d2;
  572.                         d_idx_tmp2 = j;
  573.                 }
  574.         }
  575. }
  577.         if((qMode != 1) &&
  578.            (dist_rd_min1+dist_rd_min2)<(dist_d_min1+dist_d_min2)) {
  579.                 for(i=0;i<dim_2[0];i++) out[i] = qv_rd[lpc_order*rd_idx_tmp1+i];
  580.                 for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  581.                         out[i] = qv_rd[lpc_order*rd_idx_tmp2+i];
  582.                 idx[0] = idx_tmp[2*rd_idx_tmp1];
  583.                 idx[1] = idx_tmp[2*rd_idx_tmp2+1];
  584.                 idx[2] = rd_idx[2*rd_idx_tmp1];
  585.                 idx[3] = rd_idx[2*rd_idx_tmp2+1];
  586.                 idx[4] = 1;
  587.         }else{
  588.                 for(i=0;i<dim_2[0];i++) out[i] = qv_d[lpc_order*d_idx_tmp1+i];
  589.                 for(i=dim_2[0];i<dim_2[0]+dim_2[1];i++)
  590.                         out[i] = qv_d[lpc_order*d_idx_tmp2+i];
  591.                 idx[0] = idx_tmp[2*d_idx_tmp1];
  592.                 idx[1] = idx_tmp[2*d_idx_tmp2+1];
  593.                 idx[2] = d_idx[2*d_idx_tmp1];
  594.                 idx[3] = d_idx[2*d_idx_tmp2+1];
  595.                 idx[4] = 0;
  596.         }
  600.     if(level == 0)
  601.     {
  602.         for(i = 0; i < lpc_order; i++)
  603.         {
  604.             out[i] = out_v[i];
  605.         }
  606.     }
  609.         pan_stab(out, min_gap, lpc_order);
  611. }
  613. /* ------------------------------------------------------------------ */
  616. void pan_v_qtz_w_dd(float in[], long code[], long cnum, float tbl[], long dim, 
  617. float wt[], long nd)
  618. {
  619. float dist, dmin[PAN_N_DC_LSP_MAX];
  620. long i, j, k;
  622. for(i=0;i<nd;i++) dmin[i] = 1e9;
  623. for(i=0;i<cnum;i++) {
  624. dist = 0.;
  625. for(j=0;j<dim;j++) {
  626. dist += (in[j]-tbl[dim*i+j])
  627. * (in[j]-tbl[dim*i+j])*wt[j];
  628. }
  629. for(j=0;j<nd;j++) {
  630. if(dist<dmin[j]) {
  631. for(k=nd-1;k>j;k--) {
  632. dmin[k] = dmin[k-1];
  633. code[k] = code[k-1];
  634. }
  635. dmin[j] = dist;
  636. code[j] = i;
  637. break;
  638. }
  639. }
  640. }
  641. }
  643. /* ------------------------------------------------------------------ */
  645. void pan_rd_qtz2_w(float in[], float out_p[], float out_v[], long *code, long cnum, 
  646. float tbl[], long dim, float wt[], float p_factor)
  647. {
  648. long i, j;
  649. float c[PAN_DIM_MAX];
  650. float dist, dmin;
  652. for(j=0;j<dim;j++) {
  653. c[j] = in[j]-(p_factor*out_p[j]+(1.-p_factor)*out_v[j]);
  654. }
  656. dmin = 1e9;
  657. for(i=0;i<cnum;i++) {
  658. dist = 0.;
  659. for(j=0;j<dim;j++) {
  660. dist += (tbl[i*dim+j]-c[j])*(tbl[i*dim+j]-c[j])*wt[j];
  661. }
  662. if(dist<dmin) {
  663. dmin = dist;
  664. *code = i;
  665. }
  666. dist = 0.;
  667. for(j=0;j<dim;j++) {
  668. dist += (-tbl[i*dim+j]-c[j])*(-tbl[i*dim+j]-c[j])*wt[j];
  669. }
  670. if(dist<dmin) {
  671. dmin = dist;
  672. *code = cnum+i;
  673. }
  674. }
  675. }
  677. /* ------------------------------------------------------------------ */
  679. void pan_d_qtz_w(float in[], float out_v[], long *code, long cnum, float tbl[], long dim, 
  680. float wt[])
  681. {
  682. long i, j;
  683. float c[PAN_DIM_MAX];
  684. float dist, dmin;
  686. for(j=0;j<dim;j++) {
  687. c[j] = in[j]-out_v[j];
  688. }
  690. dmin = 1e9;
  691. for(i=0;i<cnum;i++) {
  692. dist = 0.;
  693. for(j=0;j<dim;j++) {
  694. dist += (tbl[i*dim+j]-c[j])*(tbl[i*dim+j]-c[j])*wt[j];
  695. }
  696. if(dist<dmin) {
  697. dmin = dist;
  698. *code = i;
  699. }
  700. dist = 0.;
  701. for(j=0;j<dim;j++) {
  702. dist += (-tbl[i*dim+j]-c[j])*(-tbl[i*dim+j]-c[j])*wt[j];
  703. }
  704. if(dist<dmin) {
  705. dmin = dist;
  706. *code = cnum+i;
  707. }
  708. }
  709. }