1 /*/////////////////////////////////////////////////////////////////////////////
2 //
3 // INTEL CORPORATION PROPRIETARY INFORMATION
4 // This software is supplied under the terms of a license agreement or
5 // nondisclosure agreement with Intel Corporation and may not be copied
6 // or disclosed except in accordance with the terms of that agreement.
7 // Copyright(c) 2005-2013 Intel Corporation. All Rights Reserved.
8 //
9 // Intel(R) Integrated Performance Primitives
10 // USC - Unified Speech Codec interface library
11 //
12 // By downloading and installing USC codec, you hereby agree that the
13 // accompanying Materials are being provided to you under the terms and
14 // conditions of the End User License Agreement for the Intel(R) Integrated
15 // Performance Primitives product previously accepted by you. Please refer
16 // to the file ippEULA.rtf or ippEULA.txt located in the root directory of your Intel(R) IPP
17 // product installation for more information.
18 //
19 // A speech coding standards promoted by ITU, ETSI, 3GPP and other
20 // organizations. Implementations of these standards, or the standard enabled
21 // platforms may require licenses from various entities, including
22 // Intel Corporation.
23 //
24 //
25 // Purpose: G.729/A/B/D/E speech codec: decoder API functions.
26 //
27 */
28
29 #ifndef G72X_IPP_LEGACY
30 #include <ipps.h>
31 #include <ippsc.h>
32 #else
33 #include <ipps90legacy.h>
34 #include <ippsc90legacy.h>
35 #endif
36 #include "owng729.h"
37
38 /* HPF coefficients */
39
40 static __ALIGN32 CONST Ipp16s tab1[3] = {
41 7699,
42 -15398,
43 7699};
44 static __ALIGN32 CONST Ipp16s tab2[3] = {BWF_HARMONIC_E, 15836, -7667};
45 static __ALIGN32 CONST Ipp16s lspSID_init[LPF_DIM] = {31441, 27566, 21458, 13612,
46 4663, -4663, -13612,
47 -21458, -27566, -31441};
48
49 static __ALIGN32 CONST Ipp16s tab3[32] = {
50 1, 3, 8, 6, 18, 16,
51 11, 13, 38, 36, 31, 33,
52 21, 23, 28, 26, 0,0,0,0,
53 0,0,0,0,0,0,0,0,0,0,0,0};
54
55 static __ALIGN32 CONST Ipp16s tab4[32] = {
56 0, 2, 5, 4, 12, 10, 7, 9, 25,
57 24, 20, 22, 14, 15, 19, 17,
58 36, 31, 21, 26, 1, 6, 16, 11,
59 27, 29, 32, 30, 39, 37, 34, 35};
60
DecoderObjSize(void)61 static Ipp32s DecoderObjSize(void) {
62 Ipp32s fltSize;
63 Ipp32s objSize = sizeof(G729Decoder_Obj);
64 ippsHighPassFilterSize_G729(&fltSize);
65 objSize += fltSize; /* provide memory for postprocessing high pass filter with upscaling */
66 SynthesisFilterSize_G729(&fltSize);
67 objSize += 2 * fltSize;/* provide memory for two synthesis filters */
68 ippsPhaseDispersionGetStateSize_G729D_16s(&fltSize);
69 objSize += fltSize; /* provide memory for phase dispersion */
70 objSize += 4*32;
71 return objSize;
72 }
73
74 G729_CODECFUN( APIG729_Status, apiG729Decoder_Alloc,
75 (G729Codec_Type codecType, Ipp32s *pCodecSize)) {
76 if((codecType != G729_CODEC)&&(codecType != G729A_CODEC)
77 &&(codecType != G729D_CODEC)&&(codecType != G729E_CODEC)&&(codecType != G729I_CODEC)) {
78 return APIG729_StsBadCodecType;
79 }
80 *pCodecSize = DecoderObjSize();
81 return APIG729_StsNoErr;
82 }
83
84 G729_CODECFUN( APIG729_Status, apiG729Decoder_Init,
85 (G729Decoder_Obj* decoderObj, G729Codec_Type codecType)) {
86 Ipp32s i,fltSize;
87 Ipp16s abDec[6];
88
89 Ipp8s* oldMemBuff;
90
91 if((codecType != G729_CODEC)&&(codecType != G729A_CODEC)
92 &&(codecType != G729D_CODEC)&&(codecType != G729E_CODEC)&&(codecType != G729I_CODEC)) {
93 return APIG729_StsBadCodecType;
94 }
95
96 oldMemBuff = decoderObj->Mem.base; /* if Reinit */
97
98 ippsZero_16s((Ipp16s*)decoderObj,sizeof(*decoderObj)>>1) ;
99
100 decoderObj->objPrm.objSize = DecoderObjSize();
101 decoderObj->objPrm.key = DEC_KEY;
102 decoderObj->objPrm.codecType=codecType;
103
104 decoderObj->codecType=codecType;
105 decoderObj->synFltw=NULL;
106 decoderObj->synFltw0=NULL;
107 decoderObj->PhDispMem=NULL;
108
109 decoderObj->postProc = (Ipp8s*)decoderObj + sizeof(G729Decoder_Obj);
110 decoderObj->postProc = IPP_ALIGNED_PTR(decoderObj->postProc, 16);
111 ippsHighPassFilterSize_G729(&fltSize);
112 decoderObj->synFltw = (Ipp8s*)decoderObj->postProc + fltSize;
113 decoderObj->synFltw = IPP_ALIGNED_PTR(decoderObj->synFltw, 16);
114 SynthesisFilterSize_G729(&fltSize);
115 decoderObj->synFltw0 = (Ipp8s*)decoderObj->synFltw + fltSize;
116 decoderObj->synFltw0 = IPP_ALIGNED_PTR(decoderObj->synFltw0, 16);
117 decoderObj->PhDispMem = (IppsPhaseDispersion_State_G729D*)((char*)decoderObj->synFltw0 + fltSize);
118 decoderObj->PhDispMem = IPP_ALIGNED_PTR(decoderObj->PhDispMem, 16);
119 abDec[0] = tab2[0];
120 abDec[1] = tab2[1];
121 abDec[2] = tab2[2];
122 abDec[3] = tab1[0];
123 abDec[4] = tab1[1];
124 abDec[5] = tab1[2];
125 for(i=0;i<4;i++) decoderObj->prevFrameQuantEn[i]=-14336;
126 ippsHighPassFilterInit_G729(abDec,decoderObj->postProc);
127 SynthesisFilterInit_G729(decoderObj->synFltw);
128 SynthesisFilterInit_G729(decoderObj->synFltw0);
129 ippsPhaseDispersionInit_G729D_16s(decoderObj->PhDispMem);
130
131 /* synthesis speech buffer*/
132 ippsZero_16s(decoderObj->LTPostFilt,TBWD_DIM);
133 decoderObj->voiceFlag=60;
134 ippsZero_16s(decoderObj->prevExcitat, L_prevExcitat);
135 decoderObj->betaPreFilter = PITCH_SHARP_MIN;
136 decoderObj->prevFrameDelay = 60;
137 decoderObj->gains[0] = 0;
138 decoderObj->gains[1] = 0;
139 for(i=0; i<LSP_MA_ORDER; i++)
140 ippsCopy_16s( &resetPrevLSP[0], &decoderObj->prevLSPfreq[i][0], LPF_DIM );
141 ippsCopy_16s(presetLSP, decoderObj->prevSubfrLSP, LPF_DIM );
142 ippsCopy_16s(resetPrevLSP, decoderObj->prevSubfrLSPquant, LPF_DIM);
143 decoderObj->preemphFilt = 0;
144 ippsZero_16s(decoderObj->resFilBuf1, MAX_PITCH_LAG+LP_SUBFRAME_DIM);
145 ippsZero_16s(decoderObj->zeroPostFiltVec1 + LPF_DIM+1, BWLPCF1_DIM/*IMP_RESP_LEN*/);
146 decoderObj->seedSavage = 21845;
147 decoderObj->seed = SEED_INIT;
148 decoderObj->CNGvar = 3;
149
150 decoderObj->pstFltMode = 1;
151
152 if(decoderObj->codecType == G729_CODEC ) {
153 decoderObj->gainExact = BWF_HARMONIC;
154 } else if( decoderObj->codecType == G729A_CODEC) {
155 decoderObj->gainExact = (1<<12);
156 decoderObj->CNGidx = 0;
157 decoderObj->SIDflag0 = 0;
158 decoderObj->SIDflag1 = 1;
159 ippsCopy_16s( lspSID_init, decoderObj->lspSID, LPF_DIM );
160 } else {
161 decoderObj->prevMA = 0;
162 decoderObj->gammaPost1 = BWF1_PST_E;
163 decoderObj->gammaPost2 = BWF2_PST_E;
164 decoderObj->gammaHarm = BWF_HARMONIC_E;
165 decoderObj->BWDcounter2 = 0;
166 decoderObj->FWDcounter2 = 0;
167
168 ippsZero_16s(decoderObj->pBwdLPC, BWLPCF1_DIM);
169 ippsZero_16s(decoderObj->pBwdLPC2, BWLPCF1_DIM);
170 decoderObj->pBwdLPC[0] = (1<<12);
171 decoderObj->pBwdLPC2[0] = (1<<12);
172
173 decoderObj->prevVoiceFlag = 0;
174 decoderObj->prevBFI = 0;
175 decoderObj->prevLPmode = 0;
176 decoderObj->interpCoeff2 = 0;
177 decoderObj->interpCoeff2_2 = 4506;
178 ippsZero_16s(decoderObj->pPrevFilt, BWLPCF1_DIM);
179 decoderObj->pPrevFilt[0] = (1<<12);
180 decoderObj->prevPitch = 30;
181 decoderObj->stat_pitch = 0;
182 ippsZero_16s(decoderObj->pPrevBwdLPC, BWLPCF1_DIM);
183 decoderObj->pPrevBwdLPC[0]= (1<<12);
184 ippsZero_16s(decoderObj->pPrevBwdRC, 2);
185 decoderObj->valGainAttenuation = IPP_MAX_16S;
186 decoderObj->BFIcount = 0;
187 decoderObj->BWDFrameCounter = 0;
188
189 decoderObj->gainExact = BWF_HARMONIC;
190 ippsWinHybridGetStateSize_G729E_16s(&fltSize);
191 if(fltSize > sizeof(Ipp32s)*BWLPCF1_DIM) {
192 return APIG729_StsNotInitialized;
193 }
194 ippsWinHybridInit_G729E_16s((IppsWinHybridState_G729E_16s*)&decoderObj->hwState);
195
196 decoderObj->SIDflag0 = 0;
197 decoderObj->SIDflag1 = 1;
198 decoderObj->CNGidx = 0;
199 ippsCopy_16s( lspSID_init, decoderObj->lspSID, LPF_DIM );
200 decoderObj->sidGain = SIDgain[0];
201 }
202
203 apiG729Decoder_InitBuff(decoderObj,oldMemBuff);
204
205 return APIG729_StsNoErr;
206 }
207
208 G729_CODECFUN( APIG729_Status, apiG729Decoder_InitBuff,
209 (G729Decoder_Obj* decoderObj, Ipp8s *buff)) {
210 if(NULL==decoderObj || NULL==buff)
211 return APIG729_StsBadArgErr;
212
213 decoderObj->Mem.base = buff;
214 decoderObj->Mem.CurPtr = decoderObj->Mem.base;
215 decoderObj->Mem.VecPtr = (Ipp32s *)(decoderObj->Mem.base+G729_ENCODER_SCRATCH_MEMORY_SIZE);
216
217 return APIG729_StsNoErr;
218 }
219
220 G729_CODECFUN( APIG729_Status, apiG729Decoder_Mode,
221 (G729Decoder_Obj* decoderObj, Ipp32s mode))
222 {
223 if(NULL==decoderObj)
224 return APIG729_StsBadArgErr;
225 decoderObj->pstFltMode = mode;
226 return APIG729_StsNoErr;
227 }
228 static APIG729_Status G729Decode
229 (G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst);
230 static APIG729_Status G729ADecode
231 (G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst);
232 static APIG729_Status G729BaseDecode
233 (G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst);
234
235 G729_CODECFUN( APIG729_Status, apiG729Decode,
236 (G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst)) {
237 if(decoderObj->codecType == G729A_CODEC) {
238 if(G729ADecode(decoderObj,src,frametype,dst) != APIG729_StsNoErr) {
239 return APIG729_StsErr;
240 }
241 } else if(decoderObj->codecType == G729_CODEC && frametype != 2 && frametype != 4) {
242 if(G729BaseDecode(decoderObj,src,frametype,dst) != APIG729_StsNoErr) {
243 return APIG729_StsErr;
244 }
245 } else {
246 if(G729Decode(decoderObj,src,frametype,dst) != APIG729_StsNoErr) {
247 return APIG729_StsErr;
248 }
249 }
250 return APIG729_StsNoErr;
251 }
252
G729Decode(G729Decoder_Obj * decoderObj,const Ipp8u * src,Ipp32s frametype,Ipp16s * dst)253 APIG729_Status G729Decode
254 (G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst) {
255
256 LOCAL_ALIGN_ARRAY(32, Ipp16s, AzDec, BWLPCF1_DIM*2,decoderObj);
257 LOCAL_ALIGN_ARRAY(32, Ipp16s, newLSP,LPF_DIM,decoderObj);
258 LOCAL_ALIGN_ARRAY(32, Ipp16s, ACELPcodeVec, LP_SUBFRAME_DIM,decoderObj);
259 LOCAL_ALIGN_ARRAY(32, Ipp16s, BWDfiltLPC, 2*BWLPCF1_DIM,decoderObj);
260 LOCAL_ALIGN_ARRAY(32, Ipp16s, FWDfiltLPC, 2*LPF_DIM+2,decoderObj);
261 LOCAL_ALIGN_ARRAY(32, Ipp16s, BWDrc,BWLPCF_DIM,decoderObj);
262 LOCAL_ALIGN_ARRAY(32, Ipp32s, BWDacf,BWLPCF1_DIM,decoderObj);
263 LOCAL_ALIGN_ARRAY(32, Ipp32s, BWDhighAcf,BWLPCF1_DIM,decoderObj);
264 LOCAL_ALIGN_ARRAY(32, Ipp16s, phaseDispExcit,LP_SUBFRAME_DIM,decoderObj);
265 LOCAL_ARRAY(Ipp16s, idx,4,decoderObj);
266 LOCAL_ARRAY(Ipp16s, delayVal,2,decoderObj);
267 LOCAL_ARRAY(Ipp16s, tmp_parm,5,decoderObj);
268 Ipp16s prevFrameDelay1=0; /* 1-st subframe pitch lag*/
269 Ipp16s subfrVoiceFlag, *pAz, *pA;
270 Ipp8s *synFltw = decoderObj->synFltw;
271 Ipp16s *prevExcitat = decoderObj->prevExcitat;
272 Ipp16s *excitation = prevExcitat + L_prevExcitat;
273 Ipp16s *synth = decoderObj->LTPostFilt+SYNTH_BWD_DIM;
274 Ipp16s *prevSubfrLSP = decoderObj->prevSubfrLSP;
275 const Ipp8u *pParm;
276 const Ipp16s *parm;
277 Ipp16s *ppAz, temp, badFrameIndicator, badPitch, index, pulseSign, gPl, gC;
278 Ipp16s voiceFlag = decoderObj->voiceFlag;
279 Ipp16s sidGain = decoderObj->sidGain;
280 Ipp16s gainNow = decoderObj->gainNow;
281 Ipp16s *lspSID = decoderObj->lspSID;
282 Ipp32s i, j, subfrIdx, index2, fType, gpVal=0, LPmode = 0;
283 Ipp16s satFilter, statStat, mAq, prevM, dominantBWDmode = 0, L_hSt;
284 IppStatus status;
285
286 if(NULL==decoderObj || NULL==src || NULL ==dst)
287 return APIG729_StsBadArgErr;
288 if((decoderObj->codecType != G729_CODEC)
289 &&(decoderObj->codecType != G729D_CODEC)&&(decoderObj->codecType != G729E_CODEC)&&(decoderObj->codecType != G729I_CODEC)) {
290 return APIG729_StsBadCodecType;
291 }
292 if(decoderObj->objPrm.objSize <= 0)
293 return APIG729_StsNotInitialized;
294 if(DEC_KEY != decoderObj->objPrm.key)
295 return APIG729_StsBadCodecType;
296
297 delayVal[0]=delayVal[1]=0;
298
299 pParm = src;
300 if(frametype == -1) {
301 decoderObj->decPrm[1] = 0;
302 decoderObj->decPrm[0] = 1;
303 } else if(frametype == 0) {
304 decoderObj->decPrm[1] = 0;
305 decoderObj->decPrm[0] = 0;
306
307 } else if(frametype == 1) {
308 decoderObj->decPrm[1] = 1;
309 decoderObj->decPrm[0] = 0;
310 i=0;
311 decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1);
312 decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,5);
313 decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,4);
314 decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,5);
315
316 } else if(frametype == 2) {
317 decoderObj->decPrm[0] = 0;
318 decoderObj->decPrm[1] = 2;
319 i=0;
320 decoderObj->decPrm[2] = ExtractBitsG729(&pParm,&i,1+FIR_STAGE_BITS);
321 decoderObj->decPrm[3] = ExtractBitsG729(&pParm,&i,SEC_STAGE_BITS*2);
322 decoderObj->decPrm[4] = ExtractBitsG729(&pParm,&i,8);
323 decoderObj->decPrm[5] = ExtractBitsG729(&pParm,&i,9);
324 decoderObj->decPrm[6] = ExtractBitsG729(&pParm,&i,2);
325 decoderObj->decPrm[7] = ExtractBitsG729(&pParm,&i,6);
326 decoderObj->decPrm[8] = ExtractBitsG729(&pParm,&i,4);
327 decoderObj->decPrm[9] = ExtractBitsG729(&pParm,&i,9);
328 decoderObj->decPrm[10] = ExtractBitsG729(&pParm,&i,2);
329 decoderObj->decPrm[11] = ExtractBitsG729(&pParm,&i,6);
330
331 decoderObj->codecType = G729D_CODEC;
332 } else if(frametype == 3) {
333 i=0;
334 decoderObj->decPrm[1] = 3;
335 decoderObj->decPrm[0] = 0;
336 decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1+FIR_STAGE_BITS);
337 decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,SEC_STAGE_BITS*2);
338 decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,8);
339 decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,1);
340 decoderObj->decPrm[1+5] = ExtractBitsG729(&pParm,&i,13);
341 decoderObj->decPrm[1+6] = ExtractBitsG729(&pParm,&i,4);
342 decoderObj->decPrm[1+7] = ExtractBitsG729(&pParm,&i,7);
343 decoderObj->decPrm[1+8] = ExtractBitsG729(&pParm,&i,5);
344 decoderObj->decPrm[1+9] = ExtractBitsG729(&pParm,&i,13);
345 decoderObj->decPrm[1+10] = ExtractBitsG729(&pParm,&i,4);
346 decoderObj->decPrm[1+11] = ExtractBitsG729(&pParm,&i,7);
347 decoderObj->decPrm[1+4] = (Ipp16s)((equality(decoderObj->decPrm[1+3])+decoderObj->decPrm[1+4]) & 0x00000001); /* parity error (1) */
348 decoderObj->codecType = G729_CODEC;
349 } else if(frametype == 4) {
350 Ipp16s tmp;
351 i=0;
352 tmp = ExtractBitsG729(&pParm,&i,2);
353
354 decoderObj->decPrm[0] = 0;
355 decoderObj->decPrm[1] = 4;
356 if(tmp==0) {
357 decoderObj->decPrm[2] = 0;
358
359 decoderObj->decPrm[3] = ExtractBitsG729(&pParm,&i,1+FIR_STAGE_BITS);
360 decoderObj->decPrm[4] = ExtractBitsG729(&pParm,&i,SEC_STAGE_BITS*2);
361 decoderObj->decPrm[5] = ExtractBitsG729(&pParm,&i,8);
362 decoderObj->decPrm[6] = ExtractBitsG729(&pParm,&i,1);
363 decoderObj->decPrm[7] = ExtractBitsG729(&pParm,&i,7);
364 decoderObj->decPrm[8] = ExtractBitsG729(&pParm,&i,7);
365 decoderObj->decPrm[9] = ExtractBitsG729(&pParm,&i,7);
366 decoderObj->decPrm[10] = ExtractBitsG729(&pParm,&i,7);
367 decoderObj->decPrm[11] = ExtractBitsG729(&pParm,&i,7);
368 decoderObj->decPrm[12] = ExtractBitsG729(&pParm,&i,7);
369 decoderObj->decPrm[13] = ExtractBitsG729(&pParm,&i,5);
370 decoderObj->decPrm[14] = ExtractBitsG729(&pParm,&i,7);
371 decoderObj->decPrm[15] = ExtractBitsG729(&pParm,&i,7);
372 decoderObj->decPrm[16] = ExtractBitsG729(&pParm,&i,7);
373 decoderObj->decPrm[17] = ExtractBitsG729(&pParm,&i,7);
374 decoderObj->decPrm[18] = ExtractBitsG729(&pParm,&i,7);
375 decoderObj->decPrm[19] = ExtractBitsG729(&pParm,&i,7);
376
377 i = decoderObj->decPrm[5]>>1;
378 i &= 1;
379 decoderObj->decPrm[6] = (Ipp16s)(decoderObj->decPrm[6] + i);
380 decoderObj->decPrm[6] = (Ipp16s)((equality(decoderObj->decPrm[5])+decoderObj->decPrm[6]) & 0x00000001);/* parm[6] = parity error (1) */
381 } else {
382 decoderObj->decPrm[2] = 1; /*LPmode*/
383
384 decoderObj->decPrm[3] = ExtractBitsG729(&pParm,&i,8);
385 decoderObj->decPrm[4] = ExtractBitsG729(&pParm,&i,1);
386 decoderObj->decPrm[5] = ExtractBitsG729(&pParm,&i,13);
387 decoderObj->decPrm[6] = ExtractBitsG729(&pParm,&i,10);
388 decoderObj->decPrm[7] = ExtractBitsG729(&pParm,&i,7);
389 decoderObj->decPrm[8] = ExtractBitsG729(&pParm,&i,7);
390 decoderObj->decPrm[9] = ExtractBitsG729(&pParm,&i,7);
391 decoderObj->decPrm[10] = ExtractBitsG729(&pParm,&i,7);
392 decoderObj->decPrm[11] = ExtractBitsG729(&pParm,&i,5);
393 decoderObj->decPrm[12] = ExtractBitsG729(&pParm,&i,13);
394 decoderObj->decPrm[13] = ExtractBitsG729(&pParm,&i,10);
395 decoderObj->decPrm[14] = ExtractBitsG729(&pParm,&i,7);
396 decoderObj->decPrm[15] = ExtractBitsG729(&pParm,&i,7);
397 decoderObj->decPrm[16] = ExtractBitsG729(&pParm,&i,7);
398 decoderObj->decPrm[17] = ExtractBitsG729(&pParm,&i,7);
399
400 i = decoderObj->decPrm[3]>>1;
401 i &= 1;
402 decoderObj->decPrm[4] = (Ipp16s)(decoderObj->decPrm[4] + i);
403 decoderObj->decPrm[4] = (Ipp16s)((equality(decoderObj->decPrm[3])+decoderObj->decPrm[4]) & 0x00000001);/* parm[4] = parity error (1) */
404 }
405 decoderObj->codecType = G729E_CODEC;
406 }
407
408 parm = decoderObj->decPrm;
409
410 badFrameIndicator = *parm++;
411 fType = *parm;
412 if(badFrameIndicator == 1) {
413 fType = decoderObj->CNGvar;
414 if(fType == 1) fType = 0;
415 } else {
416 decoderObj->valGainAttenuation = IPP_MAX_16S;
417 decoderObj->BFIcount = 0;
418 }
419
420 if( fType == 4) {
421 if(badFrameIndicator != 0) {
422 LPmode = decoderObj->prevLPmode;
423 } else {
424 LPmode = parm[1];
425 }
426 if(decoderObj->prevBFI != 0) {
427 voiceFlag = decoderObj->prevVoiceFlag;
428 decoderObj->voiceFlag = decoderObj->prevVoiceFlag;
429 }
430 ippsWinHybrid_G729E_16s32s(decoderObj->LTPostFilt, BWDacf,
431 (IppsWinHybridState_G729E_16s*)&decoderObj->hwState);
432
433 BWDLagWindow(BWDacf, BWDhighAcf);
434
435 if(ippsLevinsonDurbin_G729_32s16s(BWDhighAcf, BWLPCF_DIM, &BWDfiltLPC[BWLPCF1_DIM], BWDrc,&temp) == ippStsOverflow) {
436 ippsCopy_16s(decoderObj->pPrevBwdLPC,&BWDfiltLPC[BWLPCF1_DIM],BWLPCF1_DIM);
437 BWDrc[0] = decoderObj->pPrevBwdRC[0];
438 BWDrc[1] = decoderObj->pPrevBwdRC[1];
439
440 } else {
441 ippsCopy_16s(&BWDfiltLPC[BWLPCF1_DIM],decoderObj->pPrevBwdLPC,BWLPCF1_DIM);
442 decoderObj->pPrevBwdRC[0] = BWDrc[0];
443 decoderObj->pPrevBwdRC[1] = BWDrc[1];
444 }
445
446 satFilter = 0;
447 for(i=BWLPCF1_DIM; i<2*BWLPCF1_DIM; i++) {
448 if(BWDfiltLPC[i] >= IPP_MAX_16S) {
449 satFilter = 1;
450 break;
451 }
452 }
453 if(satFilter == 1) ippsCopy_16s(decoderObj->pBwdLPC2, &BWDfiltLPC[BWLPCF1_DIM], BWLPCF1_DIM);
454 else ippsCopy_16s(&BWDfiltLPC[BWLPCF1_DIM], decoderObj->pBwdLPC2, BWLPCF1_DIM);
455
456 ippsMulPowerC_NR_16s_Sfs(&BWDfiltLPC[BWLPCF1_DIM], N0_98, &BWDfiltLPC[BWLPCF1_DIM], BWLPCF1_DIM, 15);
457 }
458 ippsMove_16s(&decoderObj->LTPostFilt[LP_FRAME_DIM], &decoderObj->LTPostFilt[0], SYNTH_BWD_DIM);
459
460 if(LPmode == 1) {
461 Ipp16s tmp;
462
463 if((decoderObj->interpCoeff2 != 0)) {
464 tmp = (Ipp16s)((1<<12) - decoderObj->interpCoeff2);
465 ippsInterpolateC_G729_16s_Sfs(BWDfiltLPC + BWLPCF1_DIM, tmp,
466 decoderObj->pBwdLPC, decoderObj->interpCoeff2, BWDfiltLPC + BWLPCF1_DIM, BWLPCF1_DIM, 12);
467 }
468 }
469 if((badFrameIndicator != 0)&&(decoderObj->prevBFI == 0) && (decoderObj->CNGvar >3))
470 ippsCopy_16s(&BWDfiltLPC[BWLPCF1_DIM],decoderObj->pBwdLPC,BWLPCF1_DIM);
471
472 if(fType < 2) {
473 if(fType == 1) {
474 LOCAL_ALIGN_ARRAY(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
475 sidGain = SIDgain[(Ipp32s)parm[4]];
476 ippsLSFDecode_G729B_16s(&parm[1],(Ipp16s*)(decoderObj->prevLSPfreq),lsfq);
477 ippsLSFToLSP_G729_16s(lsfq,lspSID);
478 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
479 } else {
480 if(decoderObj->CNGvar > 1) {
481 QuantSIDGain_G729B_16s(&decoderObj->SIDflag0, &decoderObj->SIDflag1, 0, &temp, &index2);
482 sidGain = SIDgain[(Ipp32s)index2];
483 }
484 }
485 if(decoderObj->CNGvar > 1) {
486 gainNow = sidGain;
487 } else {
488 gainNow = (Ipp16s)((gainNow * GAIN0 + BWF_HARMONIC)>>15);
489 gainNow = Add_16s(gainNow, (Ipp16s)((sidGain * GAIN1 + BWF_HARMONIC)>>15));
490 }
491
492 if(gainNow == 0) {
493 ippsZero_16s(excitation,LP_FRAME_DIM);
494 gpVal = 0;
495 for(subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {
496 ippsPhaseDispersionUpdate_G729D_16s((Ipp16s)gpVal, gainNow,decoderObj->PhDispMem);
497 }
498 } else {
499 for(i = 0; i < LP_FRAME_DIM; i += LP_SUBFRAME_DIM) {
500 Ipp32s invSq;
501 Ipp16s pG2, tmp, tmp2;
502 const Ipp16s *excCached;
503 LOCAL_ARRAY(Ipp16s, IdxVec, 4, decoderObj);
504 LOCAL_ARRAY(Ipp16s, pulseSignVec, 4, decoderObj);
505 LOCAL_ALIGN_ARRAY(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
506 LOCAL_ARRAY(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);
507 RandomCodebookParm_G729B_16s(&decoderObj->seed,IdxVec,pulseSignVec,&pG2,delayVal);
508 ippsDecodeAdaptiveVector_G729_16s_I(delayVal,&prevExcitat[i]);
509 if(decoderObj->CNGidx > CNG_STACK_SIZE-1) { /* not cached */
510 ippsRandomNoiseExcitation_G729B_16s(&decoderObj->seed,excg,LP_SUBFRAME_DIM);
511 ippsDotProd_16s32s_Sfs(excg,excg,LP_SUBFRAME_DIM,&invSq,0);
512 ippsInvSqrt_32s_I(&invSq,1);
513 excCached=excg;
514 } else {
515 decoderObj->seed = cngSeedOut[decoderObj->CNGidx];
516 invSq = cngInvSqrt[decoderObj->CNGidx];
517 excCached=&cngCache[decoderObj->CNGidx][0];
518 decoderObj->CNGidx++;
519 }
520 NoiseExcitationFactorization_G729B_16s(excCached,invSq,gainNow,excg,LP_SUBFRAME_DIM);
521 tmp2 = (Ipp16s)ComfortNoiseExcitation_G729B_16s_I(excg,IdxVec,pulseSignVec,gainNow,pG2,&excitation[i],&tmp,tempArray);
522 if(tmp2 < 0) gpVal = 0;
523 if(tmp < 0) tmp = -tmp;
524
525 ippsPhaseDispersionUpdate_G729D_16s((Ipp16s)gpVal,tmp,decoderObj->PhDispMem);
526
527 LOCAL_ARRAY_FREE(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);
528 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
529 LOCAL_ARRAY_FREE(Ipp16s, pulseSignVec, 4, decoderObj);
530 LOCAL_ARRAY_FREE(Ipp16s, IdxVec, 4, decoderObj);
531 }
532 }
533 ippsInterpolate_G729_16s(prevSubfrLSP,lspSID,prevSubfrLSP, LPF_DIM );
534 ippsLSPToLPC_G729_16s(prevSubfrLSP,&FWDfiltLPC[0]);
535 ippsLSPToLPC_G729_16s(lspSID,&FWDfiltLPC[LPF_DIM+1]);
536 ippsCopy_16s(lspSID, prevSubfrLSP, LPF_DIM );
537 decoderObj->sidGain = sidGain;
538 decoderObj->gainNow = gainNow;
539
540 ppAz = FWDfiltLPC;
541 for(subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {
542 if(SynthesisFilter_G729_16s(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,20)==
543 ippStsOverflow) {
544 /* scale down excitation and redo in case of overflow */
545 ippsRShiftC_16s(prevExcitat,2,prevExcitat,L_prevExcitat+LP_FRAME_DIM);
546 SynthesisFilterOvf_G729_16s(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,20);
547 }
548
549 ppAz += LPF_DIM+1;
550 }
551 decoderObj->betaPreFilter = PITCH_SHARP_MIN;
552
553 prevFrameDelay1 = decoderObj->prevFrameDelay;
554 decoderObj->interpCoeff2_2 = 4506;
555 decoderObj->BWDFrameCounter = 0;
556 decoderObj->stat_pitch = 0;
557 ippsCopy_16s(&FWDfiltLPC[LPF_DIM+1], decoderObj->pPrevFilt, LPF_DIM+1);
558 ippsZero_16s(&decoderObj->pPrevFilt[LPF_DIM+1], (BWLPCF1_DIM-LPF_DIM-1));
559
560 } else {
561 decoderObj->seed = SEED_INIT;
562 decoderObj->CNGidx = 0;
563 parm++;
564 if(decoderObj->codecType == G729E_CODEC) parm++;
565 if( LPmode==0 ) {
566 LOCAL_ARRAY(Ipp16s, qIndex,4,decoderObj);
567
568 qIndex[0] = (Ipp16s)((parm[0] >> FIR_STAGE_BITS) & 1);
569 qIndex[1] = (Ipp16s)(parm[0] & (FIR_STAGE - 1));
570 qIndex[2] = (Ipp16s)((parm[1] >> SEC_STAGE_BITS) & (SEC_STAGE - 1));
571 qIndex[3] = (Ipp16s)(parm[1] & (SEC_STAGE - 1));
572 if(!badFrameIndicator) {
573 decoderObj->prevMA = qIndex[0];
574 ippsLSFDecode_G729_16s( qIndex, (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
575 } else {
576 ippsLSFDecodeErased_G729_16s( decoderObj->prevMA,
577 (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
578 }
579
580 ippsLSFToLSP_G729_16s(decoderObj->prevSubfrLSPquant, newLSP); /* Convert LSFs to LSPs */
581 parm += 2;
582 LOCAL_ARRAY_FREE(Ipp16s, qIndex,4,decoderObj);
583
584 if( decoderObj->prevLPmode == 0) {
585 ippsInterpolate_G729_16s(newLSP,prevSubfrLSP,prevSubfrLSP, LPF_DIM );
586
587 ippsLSPToLPC_G729_16s(prevSubfrLSP, FWDfiltLPC); /* 1-st subframe */
588
589 ippsLSPToLPC_G729_16s(newLSP, &FWDfiltLPC[LPF_DIM+1]); /* 2-nd subframe */
590 } else {
591 ippsLSPToLPC_G729_16s(newLSP, FWDfiltLPC); /* 1-st subframe */
592 ippsMove_16s(FWDfiltLPC, &FWDfiltLPC[LPF_DIM+1], LPF_DIM+1);/* 2-nd subframe */
593 }
594
595 /* update the next frame LSFs*/
596 ippsCopy_16s(newLSP, prevSubfrLSP, LPF_DIM );
597 decoderObj->interpCoeff2_2 = 4506;
598 mAq = LPF_DIM;
599 pA = FWDfiltLPC;
600 ippsCopy_16s(&FWDfiltLPC[LPF_DIM+1], decoderObj->pPrevFilt, LPF_DIM+1);
601 ippsZero_16s(&decoderObj->pPrevFilt[LPF_DIM+1], (BWLPCF1_DIM-LPF_DIM-1));
602 } else {
603 Ipp16s tmp;
604 decoderObj->interpCoeff2_2 = (Ipp16s)(decoderObj->interpCoeff2_2 - 410);
605 if( decoderObj->interpCoeff2_2 < 0) decoderObj->interpCoeff2_2 = 0;
606 tmp = (Ipp16s)((1<<12) - decoderObj->interpCoeff2_2);
607 ippsInterpolateC_G729_16s_Sfs(BWDfiltLPC + BWLPCF1_DIM, tmp,
608 decoderObj->pPrevFilt, decoderObj->interpCoeff2_2, BWDfiltLPC + BWLPCF1_DIM, BWLPCF1_DIM, 12);
609 ippsInterpolate_G729_16s
610 (BWDfiltLPC + BWLPCF1_DIM, decoderObj->pPrevFilt, BWDfiltLPC, BWLPCF1_DIM);
611 mAq = BWLPCF_DIM;
612 pA = BWDfiltLPC;
613 ippsCopy_16s(&BWDfiltLPC[BWLPCF1_DIM], decoderObj->pPrevFilt, BWLPCF1_DIM);
614 }
615
616 for(ppAz=pA,subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {
617 Ipp32s pitchIndx;
618 pitchIndx = *parm++;
619 badPitch = badFrameIndicator;
620
621 if(subfrIdx == 0) {
622 if(decoderObj->codecType != G729D_CODEC)
623 badPitch = (Ipp16s)(badFrameIndicator + *parm++);
624 }
625 DecodeAdaptCodebookDelays(&decoderObj->prevFrameDelay,&decoderObj->prevFrameDelay2,delayVal,subfrIdx,badPitch,pitchIndx,decoderObj->codecType);
626 if(subfrIdx == 0)
627 prevFrameDelay1 = delayVal[0]; /* if first frame */
628 ippsDecodeAdaptiveVector_G729_16s_I(delayVal,&prevExcitat[subfrIdx]);
629
630 /* pitch tracking */
631 if( decoderObj->codecType == G729E_CODEC) {
632 PitchTracking_G729E(&decoderObj->prevFrameDelay, &decoderObj->prevFrameDelay2, &decoderObj->prevPitch, &decoderObj->stat_pitch,
633 &decoderObj->pitchStatIntDelay, &decoderObj->pitchStatFracDelay);
634 } else {
635 Ipp16s sTmpPrevFrameDelay, sTmpPrevFrameDelay2;
636 sTmpPrevFrameDelay = decoderObj->prevFrameDelay;
637 sTmpPrevFrameDelay2 = decoderObj->prevFrameDelay2;
638 PitchTracking_G729E(&sTmpPrevFrameDelay, &sTmpPrevFrameDelay2, &decoderObj->prevPitch, &decoderObj->stat_pitch,
639 &decoderObj->pitchStatIntDelay, &decoderObj->pitchStatFracDelay);
640 }
641
642 statStat = 0;
643 if(decoderObj->codecType == G729_CODEC) {
644 if(badFrameIndicator != 0) {
645 index = (Ipp16s)(Rand_16s(&decoderObj->seedSavage) & (Ipp16s)0x1fff); /* 13 bits random */
646 pulseSign = (Ipp16s)(Rand_16s(&decoderObj->seedSavage) & (Ipp16s)15); /* 4 bits random */
647 } else {
648 index = parm[0];
649 pulseSign = parm[1];
650 }
651 i = index & 7;
652 idx[0] = (Ipp16s)(5 * i);
653 index = (Ipp16s)(index >> 3);
654 i = index & 7;
655 idx[1] = (Ipp16s)(5 * i + 1);
656 index = (Ipp16s)(index >> 3);
657 i = index & 7;
658 idx[2] = (Ipp16s)(5 * i + 2);
659 index = (Ipp16s)(index >> 3);
660 j = index & 1;
661 index = (Ipp16s)(index >> 1);
662 i = index & 7;
663 idx[3] = (Ipp16s)(i * 5 + 3 + j);
664
665 /* decode the signs & build the codeword */
666 ippsZero_16s(ACELPcodeVec,LP_SUBFRAME_DIM);
667 for(j=0; j<4; j++) {
668 if((pulseSign & 1) != 0) {
669 ACELPcodeVec[idx[j]] = 8191;
670 } else {
671 ACELPcodeVec[idx[j]] = -BWF_HARMONIC_E;
672 }
673 pulseSign = (Ipp16s)(pulseSign >> 1);
674 }
675
676 parm += 2;
677 decoderObj->BWDFrameCounter = 0;
678 } else if(decoderObj->codecType == G729D_CODEC) {
679 Ipp16s sTmpIdx;
680
681 if(badFrameIndicator != 0) {
682 index = Rand_16s(&decoderObj->seedSavage);
683 pulseSign = Rand_16s(&decoderObj->seedSavage);
684 } else {
685 index = parm[0];
686 pulseSign = parm[1];
687 }
688 ippsZero_16s(ACELPcodeVec,LP_SUBFRAME_DIM);
689 sTmpIdx = tab3[index & 15];
690 if((pulseSign & 1) != 0) {
691 ACELPcodeVec[sTmpIdx] += 8191;
692 } else {
693 ACELPcodeVec[sTmpIdx] -= BWF_HARMONIC_E;
694 }
695 index >>= 4;
696 pulseSign >>= 1;
697 sTmpIdx = tab4[index & 31];
698
699 if((pulseSign & 1) != 0) {
700 ACELPcodeVec[sTmpIdx] += 8191;
701 } else {
702 ACELPcodeVec[sTmpIdx] -= BWF_HARMONIC_E;
703 }
704
705 parm += 2;
706 decoderObj->BWDFrameCounter = 0;
707 } else if(decoderObj->codecType == G729E_CODEC) {
708 Ipp16s sIdxCounter, trackVal;
709 Ipp16s pos1, pos2, pos3, sTmpPulseSign;
710 ippsZero_16s(ACELPcodeVec,LP_SUBFRAME_DIM);
711
712 if(badFrameIndicator != 0) {
713 tmp_parm[0] = Rand_16s(&decoderObj->seedSavage);
714 tmp_parm[1] = Rand_16s(&decoderObj->seedSavage);
715 tmp_parm[2] = Rand_16s(&decoderObj->seedSavage);
716 tmp_parm[3] = Rand_16s(&decoderObj->seedSavage);
717 tmp_parm[4] = Rand_16s(&decoderObj->seedSavage);
718 } else {
719 ippsCopy_16s(parm, tmp_parm, 5);
720 }
721 if(LPmode == 0) {
722
723 pos1 = (Ipp16s)((tmp_parm[0] & 7) * 5);
724 if(((tmp_parm[0]>>3) & 1) == 0)
725 sTmpPulseSign = (1<<12);
726 else sTmpPulseSign = -(1<<12);
727 ACELPcodeVec[pos1] = sTmpPulseSign;
728 pos2 = (Ipp16s)(((tmp_parm[0]>>4) & 7) * 5);
729 if(pos2 > pos1)
730 sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
731 ACELPcodeVec[pos2] = (Ipp16s)(ACELPcodeVec[pos2] + sTmpPulseSign);
732 pos1 = (Ipp16s)(((tmp_parm[1] & 7) * 5) + 1);
733 if(((tmp_parm[1]>>3) & 1) == 0)
734 sTmpPulseSign = (1<<12);
735 else
736 sTmpPulseSign = -(1<<12);
737 ACELPcodeVec[pos1] = sTmpPulseSign;
738
739 pos2 = (Ipp16s)((((tmp_parm[1]>>4) & 7) * 5) + 1);
740 if(pos2 > pos1)
741 sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
742
743 ACELPcodeVec[pos2] = (Ipp16s)(ACELPcodeVec[pos2] + sTmpPulseSign);
744
745 pos1 = (Ipp16s)(((tmp_parm[2] & 7) * 5) + 2);
746 if(((tmp_parm[2]>>3) & 1) == 0)
747 sTmpPulseSign = (1<<12);
748 else
749 sTmpPulseSign = -(1<<12);
750 ACELPcodeVec[pos1] = sTmpPulseSign;
751
752 pos2 = (Ipp16s)((((tmp_parm[2]>>4) & 7) * 5) + 2);
753 if(pos2 > pos1)
754 sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
755 ACELPcodeVec[pos2] = (Ipp16s)(ACELPcodeVec[pos2] + sTmpPulseSign);
756 pos1 = (Ipp16s)(((tmp_parm[3] & 7) * 5) + 3);
757 if(((tmp_parm[3]>>3) & 1) == 0)
758 sTmpPulseSign = (1<<12);
759 else
760 sTmpPulseSign = -(1<<12);
761 ACELPcodeVec[pos1] = sTmpPulseSign;
762 pos2 = (Ipp16s)((((tmp_parm[3]>>4) & 7) * 5) + 3);
763 if(pos2 > pos1)
764 sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
765
766 ACELPcodeVec[pos2] = (Ipp16s)(ACELPcodeVec[pos2] + sTmpPulseSign);
767
768 pos1 = (Ipp16s)(((tmp_parm[4] & 7) * 5) + 4);
769 if(((tmp_parm[4]>>3) & 1) == 0)
770 sTmpPulseSign = (1<<12);
771 else sTmpPulseSign = -(1<<12);
772 ACELPcodeVec[pos1] = sTmpPulseSign;
773
774 pos2 = (Ipp16s)((((tmp_parm[4]>>4) & 7) * 5) + 4);
775 if(pos2 > pos1) sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
776
777 ACELPcodeVec[pos2] = (Ipp16s)(ACELPcodeVec[pos2] + sTmpPulseSign);
778 decoderObj->BWDFrameCounter = 0;
779 } else {
780 trackVal = (Ipp16s)((tmp_parm[0]>>10) & 7);
781 if(trackVal > 4)
782 trackVal = 4;
783
784 for(sIdxCounter=0; sIdxCounter<2; sIdxCounter++) {
785 pos1 = (Ipp16s)(((tmp_parm[sIdxCounter] & 7) * 5) + trackVal);
786 if(((tmp_parm[sIdxCounter]>>3) & 1) == 0)
787 sTmpPulseSign = (1<<12);
788 else
789 sTmpPulseSign = -(1<<12);
790 ACELPcodeVec[pos1] = sTmpPulseSign;
791
792 pos2 = (Ipp16s)((((tmp_parm[sIdxCounter]>>4) & 7) * 5) + trackVal);
793 if(pos2 > pos1)
794 sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
795
796 ACELPcodeVec[pos2] = (Ipp16s)(ACELPcodeVec[pos2] + sTmpPulseSign);
797
798 pos3 = (Ipp16s)((((tmp_parm[sIdxCounter]>>7) & 7) * 5) + trackVal);
799 if(pos3 > pos2)
800 sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
801
802 ACELPcodeVec[pos3] = (Ipp16s)(ACELPcodeVec[pos3] + sTmpPulseSign);
803
804 trackVal++;
805 if(trackVal > 4)
806 trackVal = 0;
807 }
808
809 for(sIdxCounter=2; sIdxCounter<5; sIdxCounter++) {
810 pos1 = (Ipp16s)(((tmp_parm[sIdxCounter] & 7) * 5) + trackVal);
811 if(((tmp_parm[sIdxCounter]>>3) & 1) == 0)
812 sTmpPulseSign = (1<<12);
813 else
814 sTmpPulseSign = -(1<<12);
815 ACELPcodeVec[pos1] = sTmpPulseSign;
816
817 pos2 = (Ipp16s)((((tmp_parm[sIdxCounter]>>4) & 7) * 5) + trackVal);
818 if(pos2 > pos1)
819 sTmpPulseSign = (Ipp16s)(-sTmpPulseSign);
820 ACELPcodeVec[pos2] = (Ipp16s)(ACELPcodeVec[pos2] + sTmpPulseSign);
821 trackVal++;
822 if(trackVal > 4)
823 trackVal = 0;
824 }
825 decoderObj->BWDFrameCounter++;
826 if(decoderObj->BWDFrameCounter >= 30) {
827 statStat = 1;
828 decoderObj->BWDFrameCounter = 30;
829 }
830 }
831 parm += 5;
832 }
833
834 decoderObj->betaPreFilter = (Ipp16s)(decoderObj->betaPreFilter << 1);
835 if(delayVal[0] < LP_SUBFRAME_DIM) {
836 ippsHarmonicFilter_16s_I(decoderObj->betaPreFilter,delayVal[0],&ACELPcodeVec[delayVal[0]],LP_SUBFRAME_DIM-delayVal[0]);
837 }
838 pitchIndx = *parm++;
839
840 if(decoderObj->codecType == G729_CODEC) {
841 if(!badFrameIndicator) {
842 LOCAL_ARRAY(Ipp16s, gIngx, 2, decoderObj);
843 ippsDotProd_16s32s_Sfs(ACELPcodeVec, ACELPcodeVec, LP_SUBFRAME_DIM, &i, 0); /* ACELPcodeVec energy */
844 gIngx[0] = (Ipp16s)(pitchIndx >> CDBK2_BIT_NUM) ;
845 gIngx[1] = (Ipp16s)(pitchIndx & (CDBK2_DIM-1));
846 ippsDecodeGain_G729_16s(i, decoderObj->prevFrameQuantEn, gIngx, decoderObj->gains);
847 LOCAL_ARRAY_FREE(Ipp16s, gIngx, 2, decoderObj);
848 } else {
849 ippsDecodeGain_G729_16s(0, decoderObj->prevFrameQuantEn, NULL, decoderObj->gains);
850 }
851 } else {
852 Ipp32s energy;
853
854 ippsDotProd_16s32s_Sfs(ACELPcodeVec, ACELPcodeVec, LP_SUBFRAME_DIM, &energy, 0); /* ACELPcodeVec energy */
855 if(decoderObj->codecType == G729D_CODEC) {
856 if(badFrameIndicator) {
857 ippsDecodeGain_G729_16s(0, decoderObj->prevFrameQuantEn, NULL, decoderObj->gains);
858 } else {
859 LOCAL_ARRAY(Ipp16s, gIngx, 2, decoderObj);
860 Ipp16s foo = 1;
861 gIngx[0] = (Ipp16s)(pitchIndx >> CDBK2_BIT_NUM_6K) ;
862 gIngx[1] = (Ipp16s)(pitchIndx & (CDBK2_DIM_6K-1)) ;
863 ippsDecodeGain_G729I_16s(energy, foo, decoderObj->prevFrameQuantEn, gIngx, decoderObj->gains );
864 LOCAL_ARRAY_FREE(Ipp16s, gIngx, 2, decoderObj);
865 }
866 } else { /* G729E_CODEC*/
867 if(!badFrameIndicator) {
868 LOCAL_ARRAY(Ipp16s, gIngx, 2, decoderObj);
869 gIngx[0] = (Ipp16s)(pitchIndx >> CDBK2_BIT_NUM) ;
870 gIngx[1] = (Ipp16s)(pitchIndx & (CDBK2_DIM-1));
871 ippsDecodeGain_G729_16s(energy, decoderObj->prevFrameQuantEn, gIngx, decoderObj->gains);
872 LOCAL_ARRAY_FREE(Ipp16s, gIngx, 2, decoderObj);
873 } else { /* erasure*/
874 Ipp16s oldCodebookGain = decoderObj->gains[1];
875
876 ippsDecodeGain_G729I_16s(0, decoderObj->valGainAttenuation, decoderObj->prevFrameQuantEn, NULL, decoderObj->gains );
877 if(decoderObj->BFIcount < 2) {
878 decoderObj->gains[0] = (Ipp16s)((statStat)? BWF_HARMONIC : PITCH_GAIN_MAX);
879 decoderObj->gains[1] = oldCodebookGain;
880 } else {
881 if(statStat) {
882 if(decoderObj->BFIcount > 10) decoderObj->valGainAttenuation = (Ipp16s)((decoderObj->valGainAttenuation * 32604)>>15);
883 } else decoderObj->valGainAttenuation = (Ipp16s)((decoderObj->valGainAttenuation * 32112)>>15);
884 }
885 }
886 }
887 }
888
889 /* update pitch sharpening with quantized gain pitch */
890 decoderObj->betaPreFilter = decoderObj->gains[0];
891 if(decoderObj->betaPreFilter > PITCH_SHARP_MAX)
892 decoderObj->betaPreFilter = PITCH_SHARP_MAX;
893 if(decoderObj->betaPreFilter < PITCH_SHARP_MIN)
894 decoderObj->betaPreFilter = PITCH_SHARP_MIN;
895
896 /* synthesis of speech corresponding to excitation*/
897 if(badFrameIndicator) {
898 decoderObj->BFIcount++;
899 if(voiceFlag == 0 ) {
900 gC = decoderObj->gains[1];
901 gPl = 0;
902 } else {
903 gC = 0;
904 gPl = decoderObj->gains[0];
905 }
906 } else {
907 gC = decoderObj->gains[1];
908 gPl = decoderObj->gains[0];
909 }
910 ippsInterpolateC_NR_G729_16s_Sfs(&excitation[subfrIdx],gPl,ACELPcodeVec,gC,&excitation[subfrIdx],LP_SUBFRAME_DIM,14);
911 if(decoderObj->codecType == G729D_CODEC)
912 status = SynthesisFilter_G729_16s_update(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,BWLPCF_DIM-mAq,0);
913 else
914 status = SynthesisFilter_G729_16s(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,BWLPCF_DIM-mAq);
915 if(status == ippStsOverflow) {
916
917 ippsRShiftC_16s(prevExcitat,2,prevExcitat,L_prevExcitat+LP_FRAME_DIM);
918 SynthesisFilterOvf_G729_16s(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,BWLPCF_DIM-mAq);
919 }
920 if(decoderObj->codecType == G729D_CODEC) {
921 ippsPhaseDispersion_G729D_16s(&excitation[subfrIdx], phaseDispExcit, decoderObj->gains[1],
922 decoderObj->gains[0], ACELPcodeVec, decoderObj->PhDispMem);
923 SynthesisFilter_G729_16s(ppAz,phaseDispExcit,&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,BWLPCF_DIM-mAq);
924 } else {
925 ippsPhaseDispersionUpdate_G729D_16s(decoderObj->gains[0], decoderObj->gains[1],decoderObj->PhDispMem);
926 }
927 ppAz += mAq+1;
928 }
929 }
930
931 if(badFrameIndicator == 0) {
932 ippsDotProd_16s32s_Sfs(excitation,excitation,LP_FRAME_DIM,&i,-1);
933 decoderObj->SIDflag1 = Exp_32s(i);
934 decoderObj->SIDflag0 = (Ipp16s)(((i << decoderObj->SIDflag1)+0x8000)>>16);
935 decoderObj->SIDflag1 = (Ipp16s)(16 - decoderObj->SIDflag1);
936 }
937 decoderObj->CNGvar = (Ipp16s)fType;
938
939 if(enerDB(synth, (Ipp16s)LP_FRAME_DIM) >= BWF_HARMONIC_E) tstDominantBWDmode(&decoderObj->BWDcounter2,&decoderObj->FWDcounter2,&dominantBWDmode, (Ipp16s)LPmode);
940
941 ippsMove_16s(&prevExcitat[LP_FRAME_DIM], &prevExcitat[0], L_prevExcitat);
942
943 if( LPmode == 0) {
944 ippsCopy_16s(FWDfiltLPC, AzDec, 2*LPF_DIM+2);
945 prevM = LPF_DIM;
946 } else {
947 ippsCopy_16s(BWDfiltLPC, AzDec, 2*BWLPCF1_DIM);
948 prevM = BWLPCF_DIM;
949 }
950
951 decoderObj->prevBFI = badFrameIndicator;
952 decoderObj->prevLPmode = (Ipp16s)LPmode;
953 decoderObj->prevVoiceFlag = voiceFlag;
954
955 if(badFrameIndicator != 0)
956 decoderObj->interpCoeff2 = (1<<12);
957 else {
958 if(LPmode == 0)
959 decoderObj->interpCoeff2 = 0;
960 else {
961 if(dominantBWDmode == 1)
962 decoderObj->interpCoeff2 -= 410;
963 else decoderObj->interpCoeff2 -= 2048;
964 if(decoderObj->interpCoeff2 < 0)
965 decoderObj->interpCoeff2= 0;
966 }
967 }
968 decoderObj->voiceFlag = 0;
969 pAz = AzDec;
970
971 if (decoderObj->pstFltMode) {
972 if((decoderObj->codecType == G729_CODEC)&&(fType>2)) {
973 for(subfrIdx=0; subfrIdx<LP_FRAME_DIM; subfrIdx+=LP_SUBFRAME_DIM) {
974 Post_G729(prevFrameDelay1,(Ipp16s)subfrIdx,pAz,&dst[subfrIdx],&subfrVoiceFlag,decoderObj);
975 if(subfrVoiceFlag != 0) {
976 decoderObj->voiceFlag = subfrVoiceFlag;
977 }
978 pAz += LPF_DIM+1;
979 }
980 } else {
981 parm = decoderObj->decPrm;
982 if(fType<4) {
983 L_hSt = IMP_RESP_LEN;
984 decoderObj->gammaPost1 = BWF1_PST;
985 decoderObj->gammaPost2 = BWF2_PST;
986 decoderObj->gammaHarm = BWF_HARMONIC;
987 } else {
988 L_hSt = IMP_RESP_LEN_E;
989 /* reduce postfiltering */
990 if((parm[2] == 1) && (dominantBWDmode == 1)) {
991 decoderObj->gammaHarm -= 410;
992 if(decoderObj->gammaHarm < 0)
993 decoderObj->gammaHarm = 0;
994 decoderObj->gammaPost1 -= 1147;
995 if(decoderObj->gammaPost1 < 0)
996 decoderObj->gammaPost1 = 0;
997 decoderObj->gammaPost2 -= 1065;
998 if(decoderObj->gammaPost2 < 0)
999 decoderObj->gammaPost2 = 0;
1000 } else {
1001 decoderObj->gammaHarm += 410;
1002 if(decoderObj->gammaHarm > BWF_HARMONIC_E)
1003 decoderObj->gammaHarm = BWF_HARMONIC_E;
1004 decoderObj->gammaPost1 += 1147;
1005 if(decoderObj->gammaPost1 > BWF1_PST_E)
1006 decoderObj->gammaPost1 = BWF1_PST_E;
1007 decoderObj->gammaPost2 += 1065;
1008 if(decoderObj->gammaPost2 > BWF2_PST_E)
1009 decoderObj->gammaPost2 = BWF2_PST_E;
1010 }
1011 }
1012
1013 for(i=0; i<LP_FRAME_DIM; i+=LP_SUBFRAME_DIM) {
1014 Post_G729I(prevFrameDelay1, (Ipp16s)i, pAz, &dst[i],
1015 &subfrVoiceFlag, L_hSt, prevM, (Ipp16s)fType, decoderObj);
1016 if(subfrVoiceFlag != 0)
1017 decoderObj->voiceFlag = subfrVoiceFlag;
1018 pAz += prevM+1;
1019 }
1020 }
1021 ippsHighPassFilter_G729_16s_ISfs(dst,LP_FRAME_DIM,13,decoderObj->postProc);
1022 } else {
1023 ippsAdd_16s(synth, synth, dst, LP_FRAME_DIM);
1024 }
1025
1026 CLEAR_SCRATCH_MEMORY(decoderObj);
1027
1028 return APIG729_StsNoErr;
1029 }
1030
Post_G729Base(Ipp16s delayVal,Ipp16s subfrIdx,const Ipp16s * srcLPC,Ipp16s * dstSignal,Ipp16s * voiceFlag,Ipp16s fType,G729Decoder_Obj * decoderObj)1031 void Post_G729Base(
1032 Ipp16s delayVal, /* pitch delayVal given by coder */
1033 Ipp16s subfrIdx,
1034 const Ipp16s *srcLPC, /* LPC coefficients for current subframe */
1035 Ipp16s *dstSignal, /* postfiltered output */
1036 Ipp16s *voiceFlag, /* voiceFlag decision 0 = uv, > 0 delayVal */
1037 Ipp16s fType,
1038 G729Decoder_Obj *decoderObj
1039 ) {
1040 Ipp16s bwf1 = decoderObj->gammaPost1;
1041 Ipp16s bwf2 = decoderObj->gammaPost2;
1042 Ipp16s gamma_harm = decoderObj->gammaHarm;
1043 LOCAL_ARRAY(Ipp32s,irACF,2, decoderObj);
1044 LOCAL_ALIGN_ARRAY(32, Ipp16s,y, IMP_RESP_LEN_E, decoderObj);
1045 LOCAL_ALIGN_ARRAY(32,Ipp16s, LTPsignal, LP_SUBFRAME_DIM+1, decoderObj);
1046 LOCAL_ALIGN_ARRAY(32,Ipp16s, LPCdenom, LPF_DIM+1, decoderObj); /* denominator srcLPC */
1047 LOCAL_ALIGN_ARRAY(32,Ipp16s, LPCnum, IMP_RESP_LEN_E, decoderObj); /* numerator srcLPC */
1048 Ipp16s tmp, g0Val, temp, ACFval0, ACFval1;
1049 Ipp16s *iirdl = ((SynthesisFilterState*)decoderObj->synFltw0)->buffer;
1050 Ipp32s L_g0Val, normVal = 0, status = 0;
1051 const Ipp16s *signal_ptr = &decoderObj->LTPostFilt[SYNTH_BWD_DIM+subfrIdx];
1052 irACF[0] = irACF[1] = 0;
1053 ippsZero_16s(LPCnum, IMP_RESP_LEN_E);
1054
1055 ippsMulPowerC_NR_16s_Sfs(srcLPC,bwf1, LPCdenom,LPF_DIM+1,15);
1056 ippsMulPowerC_NR_16s_Sfs(srcLPC,bwf2, LPCnum,LPF_DIM+1,15);
1057
1058 ippsResidualFilter_G729_16s((Ipp16s *)signal_ptr, LPCnum, &decoderObj->resFilBuf1[RES_FIL_DIM]);
1059
1060 if(fType > 1)
1061 ippsLongTermPostFilter_G729_16s(gamma_harm,delayVal, &decoderObj->resFilBuf1[RES_FIL_DIM],
1062 LTPsignal + 1, voiceFlag);
1063 else {
1064 *voiceFlag = 0;
1065 ippsCopy_16s(&decoderObj->resFilBuf1[RES_FIL_DIM], LTPsignal + 1, LP_SUBFRAME_DIM);
1066 }
1067 LTPsignal[0] = decoderObj->preemphFilt;
1068 ippsSynthesisFilter_NR_16s_Sfs(LPCdenom, LPCnum,y,IMP_RESP_LEN, 12, &decoderObj->zeroPostFiltVec1[LPF_DIM+1]);
1069
1070 status = ippsAutoCorr_NormE_16s32s(y,IMP_RESP_LEN,irACF,2,&normVal);
1071 ACFval0 = (Ipp16s)(irACF[0]>>16);
1072 ACFval1 = (Ipp16s)(irACF[1]>>16);
1073 if( ACFval0 < Abs_16s(ACFval1) || status) {
1074 tmp = 0;
1075 } else {
1076 tmp = (Ipp16s)((Abs_16s(ACFval1)<<15)/ACFval0);
1077 if(ACFval1 > 0) {
1078 tmp = (Ipp16s)(-tmp);
1079 }
1080 }
1081
1082 ippsAbs_16s(y,y,IMP_RESP_LEN);
1083 ippsSum_16s32s_Sfs(y,IMP_RESP_LEN,&L_g0Val,0);
1084 g0Val = (Ipp16s)(ShiftL_32s(L_g0Val, 14)>>16);
1085
1086 if(g0Val > 1024) {
1087 temp = (Ipp16s)((1024<<15)/g0Val);
1088 ippsMulC_NR_16s_ISfs(temp,LTPsignal + 1,LP_SUBFRAME_DIM,15);
1089 }
1090 ippsSynthesisFilter_NR_16s_ISfs(LPCdenom, LTPsignal + 1, LP_SUBFRAME_DIM, 12, &iirdl[BWLPCF_DIM-LPF_DIM]);
1091 decoderObj->preemphFilt = LTPsignal[LP_SUBFRAME_DIM];
1092 ippsCopy_16s(<Psignal[LP_SUBFRAME_DIM-LPF_DIM+1], &iirdl[BWLPCF_DIM-LPF_DIM], LPF_DIM );
1093 ippsTiltCompensation_G729E_16s(tmp,LTPsignal, dstSignal);
1094 ippsGainControl_G729_16s_I(signal_ptr, dstSignal, &decoderObj->gainExact);
1095 ippsMove_16s(&decoderObj->resFilBuf1[LP_SUBFRAME_DIM], &decoderObj->resFilBuf1[0], RES_FIL_DIM);
1096
1097 LOCAL_ALIGN_ARRAY_FREE(32,Ipp16s, LPCnum, IMP_RESP_LEN_E, decoderObj); /* numerator srcLPC */
1098 LOCAL_ALIGN_ARRAY_FREE(32,Ipp16s, LPCdenom, LPF_DIM+1, decoderObj); /* denominator srcLPC */
1099 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, LTPsignal,LP_SUBFRAME_DIM+1,decoderObj);
1100 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s,y, IMP_RESP_LEN_E,decoderObj);
1101 LOCAL_ARRAY_FREE(Ipp32s, irACF, 2,decoderObj);
1102 return;
1103 }
1104
Post_G729(Ipp16s delayVal,Ipp16s subfrIdx,const Ipp16s * srcLPC,Ipp16s * dstSignal,Ipp16s * voiceFlag,G729Decoder_Obj * decoderObj)1105 void Post_G729( Ipp16s delayVal, Ipp16s subfrIdx, const Ipp16s *srcLPC, Ipp16s *dstSignal,
1106 Ipp16s *voiceFlag, G729Decoder_Obj *decoderObj) {
1107 Ipp16s *gainExact = &decoderObj->gainExact;
1108 Ipp16s *iirdl = ((SynthesisFilterState*)decoderObj->synFltw0)->buffer;
1109 LOCAL_ALIGN_ARRAY(32, Ipp16s,y, IMP_RESP_LEN, decoderObj);
1110 LOCAL_ALIGN_ARRAY(32, Ipp16s, LTPsignalBuf, LP_SUBFRAME_DIM+1+LPF_DIM, decoderObj);
1111 LOCAL_ALIGN_ARRAY(32, Ipp16s, LPCnum, LPF_DIM+1, decoderObj);
1112 Ipp16s tmp;
1113 const Ipp16s *res = &decoderObj->LTPostFilt[SYNTH_BWD_DIM+subfrIdx];
1114 Ipp16s *LTPsignal = LTPsignalBuf+LPF_DIM+1;
1115
1116 ippsMul_NR_16s_Sfs(g729gammaFac2_pst,srcLPC, LPCnum,LPF_DIM+1,15);
1117 ippsResidualFilter_G729_16s(res, LPCnum, decoderObj->resFilBuf1 + RES_FIL_DIM);
1118 ippsLongTermPostFilter_G729_16s(BWF_HARMONIC,delayVal, decoderObj->resFilBuf1 + RES_FIL_DIM, LTPsignal+1, &tmp);
1119 *voiceFlag = (Ipp16s)(tmp != 0);
1120
1121 ippsMove_16s(&decoderObj->resFilBuf1[LP_SUBFRAME_DIM], &decoderObj->resFilBuf1[0], RES_FIL_DIM);
1122 ippsCopy_16s(iirdl+20,LTPsignal+1-LPF_DIM, LPF_DIM );
1123 ippsShortTermPostFilter_G729_16s(srcLPC, LTPsignal+1,LTPsignal+1,y);
1124 ippsCopy_16s((LTPsignal+1+LP_SUBFRAME_DIM-BWLPCF_DIM), iirdl, BWLPCF_DIM);
1125
1126 LTPsignal[0] = decoderObj->preemphFilt;
1127 decoderObj->preemphFilt = LTPsignal[LP_SUBFRAME_DIM];
1128
1129 ippsTiltCompensation_G729_16s(y, LTPsignal+1);
1130 ippsCopy_16s(LTPsignal+1, dstSignal,LP_SUBFRAME_DIM);
1131 ippsGainControl_G729_16s_I(res, dstSignal, gainExact);
1132
1133 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, LPCnum, LPF_DIM+1,decoderObj);
1134 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, LTPsignalBuf,LP_SUBFRAME_DIM+1+LPF_DIM,decoderObj);
1135 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s,y, IMP_RESP_LEN,decoderObj);
1136
1137 return;
1138 }
1139
Post_G729AB(Ipp16s delayVal,Ipp16s subfrIdx,const Ipp16s * srcLPC,Ipp16s * syn_pst,Ipp16s ftype,G729Decoder_Obj * decoderObj)1140 void Post_G729AB(Ipp16s delayVal, Ipp16s subfrIdx, const Ipp16s *srcLPC, Ipp16s *syn_pst,
1141 Ipp16s ftype, G729Decoder_Obj *decoderObj) {
1142 Ipp16s *iirdl = ((SynthesisFilterState*)decoderObj->synFltw0)->buffer;
1143 Ipp16s *preemphFilt = &decoderObj->preemphFilt;
1144 LOCAL_ALIGN_ARRAY(32, Ipp16s,sndLPC,2*(LPF_DIM+1), decoderObj);
1145 LOCAL_ALIGN_ARRAY(32, Ipp16s, prevResidual, LP_SUBFRAME_DIM+8, decoderObj);
1146 LOCAL_ALIGN_ARRAY(32, Ipp16s, prevBuf, LP_SUBFRAME_DIM+LPF_DIM, decoderObj);
1147 Ipp16s *prevResidual2 = prevResidual+8;
1148 Ipp16s *pst = prevBuf+LPF_DIM;
1149
1150 ippsMul_NR_16s_Sfs(g729gammaFac2_pst,srcLPC, decoderObj->zeroPostFiltVec1, LPF_DIM+1,15);
1151 ippsMul_NR_16s_Sfs(g729gammaFac2_pst,srcLPC, sndLPC, LPF_DIM+1,15);
1152 ippsMul_NR_16s_Sfs(g729gammaFac1_pst,srcLPC, sndLPC+LPF_DIM+1,LPF_DIM+1,15);
1153
1154 ippsLongTermPostFilter_G729A_16s(delayVal,&decoderObj->LTPostFilt[LPF_DIM+subfrIdx],
1155 sndLPC,decoderObj->resFilBuf1-LPF_DIM-1,prevResidual2);
1156 ippsMove_16s(&decoderObj->resFilBuf1[LP_SUBFRAME_DIM], &decoderObj->resFilBuf1[0], MAX_PITCH_LAG);
1157 if(3 != ftype)
1158 ippsCopy_16s(decoderObj->resFilBuf1 + MAX_PITCH_LAG,prevResidual2,LP_SUBFRAME_DIM);
1159 prevResidual2[-1] = *preemphFilt;
1160 *preemphFilt = prevResidual2[LP_SUBFRAME_DIM-1];
1161
1162 ippsTiltCompensation_G729A_16s(sndLPC,prevResidual2);
1163
1164 ippsCopy_16s(iirdl,pst-LPF_DIM, LPF_DIM );
1165 ippsSynthesisFilter_NR_16s_Sfs(sndLPC+LPF_DIM+1,prevResidual2,pst,
1166 LP_SUBFRAME_DIM, 12, pst-LPF_DIM);
1167 ippsCopy_16s((pst+LP_SUBFRAME_DIM-LPF_DIM), iirdl, LPF_DIM );
1168 ippsCopy_16s(pst,syn_pst,LP_SUBFRAME_DIM);
1169
1170 ippsGainControl_G729A_16s_I(&decoderObj->LTPostFilt[LPF_DIM+subfrIdx], syn_pst, &decoderObj->gainExact);
1171
1172 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, prevBuf,LP_SUBFRAME_DIM+LPF_DIM,decoderObj);
1173 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, prevResidual, LP_SUBFRAME_DIM+8,decoderObj);
1174 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, sndLPC, 2*(LPF_DIM+1),decoderObj);
1175 }
1176
Post_G729I(Ipp16s delayVal,Ipp16s subfrIdx,const Ipp16s * srcLPC,Ipp16s * dstSignal,Ipp16s * voiceFlag,Ipp16s L_hSt,Ipp16s prevM,Ipp16s fType,G729Decoder_Obj * decoderObj)1177 void Post_G729I( Ipp16s delayVal, Ipp16s subfrIdx, const Ipp16s *srcLPC, Ipp16s *dstSignal,
1178 Ipp16s *voiceFlag, Ipp16s L_hSt, Ipp16s prevM, Ipp16s fType,
1179 G729Decoder_Obj *decoderObj){
1180 Ipp16s bwf1 = decoderObj->gammaPost1;
1181 Ipp16s bwf2 = decoderObj->gammaPost2;
1182 Ipp16s gamma_harm = decoderObj->gammaHarm;
1183 LOCAL_ARRAY(Ipp32s,irACF,2, decoderObj);
1184 LOCAL_ALIGN_ARRAY(32, Ipp16s,y, IMP_RESP_LEN_E, decoderObj);
1185 LOCAL_ALIGN_ARRAY(32,Ipp16s, LTPsignal, LP_SUBFRAME_DIM+1, decoderObj);
1186 LOCAL_ALIGN_ARRAY(32,Ipp16s, LPCdenom, BWLPCF1_DIM, decoderObj);
1187 LOCAL_ALIGN_ARRAY(32,Ipp16s, LPCnum, IMP_RESP_LEN_E, decoderObj);
1188 Ipp16s tmp, g0Val, temp, ACFval0, ACFval1;
1189 Ipp16s *iirdl = ((SynthesisFilterState*)decoderObj->synFltw0)->buffer;
1190 Ipp32s L_g0Val, normVal = 0, status = 0;
1191 const Ipp16s *signal_ptr = &decoderObj->LTPostFilt[SYNTH_BWD_DIM+subfrIdx];
1192 irACF[0] = irACF[1] = 0;
1193 ippsZero_16s(LPCnum, IMP_RESP_LEN_E);
1194
1195 ippsMulPowerC_NR_16s_Sfs(srcLPC,bwf1, LPCdenom,prevM+1,15);
1196 ippsMulPowerC_NR_16s_Sfs(srcLPC,bwf2, LPCnum,prevM+1,15);
1197 ippsResidualFilter_G729E_16s(LPCnum, prevM,(Ipp16s *)signal_ptr, &decoderObj->resFilBuf1[RES_FIL_DIM], LP_SUBFRAME_DIM);
1198 if(fType > 1)
1199 ippsLongTermPostFilter_G729_16s(gamma_harm,delayVal, &decoderObj->resFilBuf1[RES_FIL_DIM],
1200 LTPsignal + 1, voiceFlag);
1201 else {
1202 *voiceFlag = 0;
1203 ippsCopy_16s(&decoderObj->resFilBuf1[RES_FIL_DIM], LTPsignal + 1, LP_SUBFRAME_DIM);
1204 }
1205
1206 LTPsignal[0] = decoderObj->preemphFilt;
1207 ippsSynthesisFilter_G729E_16s(LPCdenom, prevM,LPCnum,y, L_hSt, &decoderObj->zeroPostFiltVec1[LPF_DIM+1]);
1208 status = ippsAutoCorr_NormE_16s32s(y,L_hSt,irACF,2,&normVal);
1209 ACFval0 = (Ipp16s)(irACF[0]>>16);
1210 ACFval1 = (Ipp16s)(irACF[1]>>16);
1211 if( ACFval0 < Abs_16s(ACFval1) || status) {
1212 tmp = 0;
1213 } else {
1214 tmp = (Ipp16s)((Abs_16s(ACFval1)<<15)/ACFval0);
1215 if(ACFval1 > 0) {
1216 tmp = (Ipp16s)(-tmp);
1217 }
1218 }
1219 ippsAbs_16s(y,y,L_hSt);
1220 ippsSum_16s32s_Sfs(y,L_hSt,&L_g0Val,0);
1221 g0Val = (Ipp16s)(ShiftL_32s(L_g0Val, 14)>>16);
1222 if(g0Val > 1024) {
1223 temp = (Ipp16s)((1024<<15)/g0Val);
1224 ippsMulC_NR_16s_ISfs(temp,LTPsignal + 1,LP_SUBFRAME_DIM,15);
1225 }
1226 ippsSynthesisFilter_G729E_16s_I(LPCdenom,prevM,LTPsignal + 1, LP_SUBFRAME_DIM,&iirdl[BWLPCF_DIM-prevM]);
1227 decoderObj->preemphFilt = LTPsignal[LP_SUBFRAME_DIM];
1228 ippsCopy_16s(<Psignal[LP_SUBFRAME_DIM-BWLPCF_DIM+1], iirdl, BWLPCF_DIM);
1229
1230 ippsTiltCompensation_G729E_16s(tmp,LTPsignal, dstSignal);
1231
1232 ippsGainControl_G729_16s_I(signal_ptr, dstSignal, &decoderObj->gainExact);
1233
1234 ippsMove_16s(&decoderObj->resFilBuf1[LP_SUBFRAME_DIM], &decoderObj->resFilBuf1[0], RES_FIL_DIM);
1235
1236 LOCAL_ALIGN_ARRAY_FREE(32,Ipp16s, LPCnum, IMP_RESP_LEN_E, decoderObj);
1237 LOCAL_ALIGN_ARRAY_FREE(32,Ipp16s, LPCdenom, BWLPCF1_DIM, decoderObj);
1238 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, LTPsignal,LP_SUBFRAME_DIM+1,decoderObj);
1239 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s,y, IMP_RESP_LEN_E,decoderObj);
1240 LOCAL_ARRAY_FREE(Ipp32s, irACF, 2,decoderObj);
1241 return;
1242 }
1243
G729ADecode(G729Decoder_Obj * decoderObj,const Ipp8u * src,Ipp32s frametype,Ipp16s * dst)1244 APIG729_Status G729ADecode
1245 (G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst) {
1246
1247 /* LOCAL_ALIGN_ARRAY(32, Ipp16s, AzDec, (LPF_DIM+1)*2,decoderObj); */
1248 LOCAL_ALIGN_ARRAY(32, Ipp16s, newLSP,LPF_DIM,decoderObj);
1249 LOCAL_ALIGN_ARRAY(32, Ipp16s, ACELPcodeVec, LP_SUBFRAME_DIM,decoderObj);
1250 LOCAL_ALIGN_ARRAY(32, Ipp16s, FWDfiltLPC, 2*LPF_DIM+2,decoderObj);
1251 LOCAL_ARRAY(Ipp16s, prevFrameDelay,2,decoderObj);
1252 LOCAL_ARRAY(Ipp16s, idx,4,decoderObj);
1253 LOCAL_ARRAY(Ipp16s, delayVal,2,decoderObj);
1254 Ipp16s *pAz, *pA, *ppAz, temp;
1255 Ipp8s *synFltw = decoderObj->synFltw;
1256 Ipp16s *prevExcitat = decoderObj->prevExcitat;
1257 Ipp16s *excitation = prevExcitat + L_prevExcitat;
1258 Ipp16s *synth = decoderObj->LTPostFilt+LPF_DIM;
1259 Ipp16s *prevSubfrLSP = decoderObj->prevSubfrLSP;
1260 const Ipp8u *pParm;
1261 const Ipp16s *parm;
1262 Ipp16s sidGain = decoderObj->sidGain;
1263 Ipp16s gainNow = decoderObj->gainNow;
1264 Ipp16s *lspSID = decoderObj->lspSID;
1265 Ipp32s i, j, subfrIdx, index2, fType;
1266 Ipp16s badFrameIndicator, badPitch, index, pulseSign;
1267
1268 if(NULL==decoderObj || NULL==src || NULL ==dst)
1269 return APIG729_StsBadArgErr;
1270 if(decoderObj->objPrm.objSize <= 0)
1271 return APIG729_StsNotInitialized;
1272 if(DEC_KEY != decoderObj->objPrm.key)
1273 return APIG729_StsBadCodecType;
1274
1275 delayVal[0]=delayVal[1]=0;
1276 pParm = src;
1277
1278 if(frametype == -1) {
1279 decoderObj->decPrm[1] = 0;
1280 decoderObj->decPrm[0] = 1;
1281 } else if(frametype == 0) {
1282 decoderObj->decPrm[1] = 0;
1283 decoderObj->decPrm[0] = 0;
1284 } else if(frametype == 1 || frametype == 5) {
1285 decoderObj->decPrm[1] = 1;
1286 decoderObj->decPrm[0] = 0;
1287 i=0;
1288 decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1);
1289 decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,5);
1290 decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,4);
1291 decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,5);
1292 } else if(frametype == 3) {
1293 i=0;
1294 decoderObj->decPrm[1] = 3;
1295 decoderObj->decPrm[0] = 0;
1296 decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1+FIR_STAGE_BITS);
1297 decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,SEC_STAGE_BITS*2);
1298 decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,8);
1299 decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,1);
1300 decoderObj->decPrm[1+5] = ExtractBitsG729(&pParm,&i,13);
1301 decoderObj->decPrm[1+6] = ExtractBitsG729(&pParm,&i,4);
1302 decoderObj->decPrm[1+7] = ExtractBitsG729(&pParm,&i,7);
1303 decoderObj->decPrm[1+8] = ExtractBitsG729(&pParm,&i,5);
1304 decoderObj->decPrm[1+9] = ExtractBitsG729(&pParm,&i,13);
1305 decoderObj->decPrm[1+10] = ExtractBitsG729(&pParm,&i,4);
1306 decoderObj->decPrm[1+11] = ExtractBitsG729(&pParm,&i,7);
1307 decoderObj->decPrm[1+4] = (Ipp16s)((equality(decoderObj->decPrm[1+3])+decoderObj->decPrm[1+4]) & 0x00000001); /* parity error (1) */
1308 }
1309
1310 parm = decoderObj->decPrm;
1311
1312 badFrameIndicator = *parm++;
1313 fType = *parm;
1314 if(badFrameIndicator == 1) {
1315 fType = decoderObj->CNGvar;
1316 if(fType == 1) fType = 0;
1317 }
1318
1319 ippsMove_16s(&decoderObj->LTPostFilt[LP_FRAME_DIM], &decoderObj->LTPostFilt[0], LPF_DIM );
1320
1321 if(fType < 2) {
1322 if(fType == 1) {
1323 LOCAL_ALIGN_ARRAY(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
1324 sidGain = SIDgain[(Ipp32s)parm[4]];
1325 ippsLSFDecode_G729B_16s(&parm[1],(Ipp16s*)(decoderObj->prevLSPfreq),lsfq);
1326 ippsLSFToLSP_G729_16s(lsfq,lspSID);
1327 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
1328 } else {
1329 if(decoderObj->CNGvar > 1) {
1330 QuantSIDGain_G729B_16s(&decoderObj->SIDflag0, &decoderObj->SIDflag1, 0, &temp, &index2);
1331 sidGain = SIDgain[(Ipp32s)index2];
1332 }
1333 }
1334 if(decoderObj->CNGvar > 1 || frametype == 5) {
1335 gainNow = sidGain;
1336 } else {
1337 gainNow = (Ipp16s)((gainNow * GAIN0 + BWF_HARMONIC)>>15);
1338 gainNow = Add_16s(gainNow, (Ipp16s)((sidGain * GAIN1 + BWF_HARMONIC)>>15));
1339 }
1340
1341 if(gainNow == 0) ippsZero_16s(excitation,LP_FRAME_DIM);
1342 else {
1343 for(i = 0; i < LP_FRAME_DIM; i += LP_SUBFRAME_DIM) {
1344 Ipp32s invSq;
1345 Ipp16s pG2;
1346 Ipp16s g;
1347 const Ipp16s *excCached;
1348 LOCAL_ARRAY(Ipp16s, tmpIdxVec, 4, decoderObj);
1349 LOCAL_ARRAY(Ipp16s, pulsesSigns, 4, decoderObj);
1350 LOCAL_ALIGN_ARRAY(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
1351 LOCAL_ARRAY(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);
1352
1353 RandomCodebookParm_G729B_16s(&decoderObj->seed,tmpIdxVec,pulsesSigns,&pG2,delayVal);
1354 ippsDecodeAdaptiveVector_G729_16s_I(delayVal,&prevExcitat[i]);
1355 if(decoderObj->CNGidx > CNG_STACK_SIZE-1) { /* not cached */
1356 ippsRandomNoiseExcitation_G729B_16s(&decoderObj->seed,excg,LP_SUBFRAME_DIM);
1357 ippsDotProd_16s32s_Sfs(excg,excg,LP_SUBFRAME_DIM,&invSq,0);
1358 ippsInvSqrt_32s_I(&invSq,1); /* Q30 */
1359 excCached=excg;
1360 } else {
1361 decoderObj->seed = cngSeedOut[decoderObj->CNGidx];
1362 invSq = cngInvSqrt[decoderObj->CNGidx];
1363 excCached=&cngCache[decoderObj->CNGidx][0];
1364 decoderObj->CNGidx++;
1365 }
1366 NoiseExcitationFactorization_G729B_16s(excCached,invSq,gainNow,excg,LP_SUBFRAME_DIM);
1367 ComfortNoiseExcitation_G729B_16s_I(excg,tmpIdxVec,pulsesSigns,gainNow,pG2,&excitation[i],&g,tempArray);
1368
1369 LOCAL_ARRAY_FREE(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);
1370 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
1371 LOCAL_ARRAY_FREE(Ipp16s, pulsesSigns, 4, decoderObj);
1372 LOCAL_ARRAY_FREE(Ipp16s, tmpIdxVec, 4, decoderObj);
1373 }
1374 }
1375 ippsInterpolate_G729_16s(prevSubfrLSP,lspSID,prevSubfrLSP, LPF_DIM );
1376 ippsLSPToLPC_G729_16s(prevSubfrLSP,&FWDfiltLPC[0]);
1377 ippsLSPToLPC_G729_16s(lspSID,&FWDfiltLPC[LPF_DIM+1]);
1378 ippsCopy_16s(lspSID, prevSubfrLSP, LPF_DIM );
1379 decoderObj->sidGain = sidGain;
1380 decoderObj->gainNow = gainNow;
1381
1382 ppAz = FWDfiltLPC;
1383 for(subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {
1384 if(ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx], LP_SUBFRAME_DIM, 12,
1385 ((SynthesisFilterState*)synFltw)->buffer)==ippStsOverflow) {
1386 ippsRShiftC_16s(prevExcitat,2,prevExcitat,L_prevExcitat+LP_FRAME_DIM);
1387 ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,12,
1388 ((SynthesisFilterState*)synFltw)->buffer);
1389 }
1390 ippsCopy_16s((&synth[subfrIdx]+LP_SUBFRAME_DIM-LPF_DIM), ((SynthesisFilterState*)synFltw)->buffer, LPF_DIM );
1391
1392 ppAz += LPF_DIM+1;
1393 prevFrameDelay[subfrIdx/LP_SUBFRAME_DIM] = decoderObj->prevFrameDelay;
1394 }
1395 decoderObj->betaPreFilter = PITCH_SHARP_MIN;
1396
1397 } else {
1398 LOCAL_ARRAY(Ipp16s, qIndex,4,decoderObj);
1399 decoderObj->seed = SEED_INIT;
1400 decoderObj->CNGidx = 0;
1401 parm++;
1402
1403 qIndex[0] = (Ipp16s)((parm[0] >> FIR_STAGE_BITS) & 1);
1404 qIndex[1] = (Ipp16s)(parm[0] & (FIR_STAGE - 1));
1405 qIndex[2] = (Ipp16s)((parm[1] >> SEC_STAGE_BITS) & (SEC_STAGE - 1));
1406 qIndex[3] = (Ipp16s)(parm[1] & (SEC_STAGE - 1));
1407 if(!badFrameIndicator) {
1408 decoderObj->prevMA = qIndex[0];
1409 ippsLSFDecode_G729_16s( qIndex, (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
1410 } else {
1411 ippsLSFDecodeErased_G729_16s( decoderObj->prevMA,
1412 (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
1413 }
1414
1415 ippsLSFToLSP_G729_16s(decoderObj->prevSubfrLSPquant, newLSP); /* Convert LSFs to LSPs */
1416 parm += 2;
1417 LOCAL_ARRAY_FREE(Ipp16s, qIndex,4,decoderObj);
1418 ippsInterpolate_G729_16s(newLSP,prevSubfrLSP,prevSubfrLSP, LPF_DIM );
1419
1420 ippsLSPToLPC_G729_16s(prevSubfrLSP, FWDfiltLPC); /* 1-st subframe */
1421
1422 ippsLSPToLPC_G729_16s(newLSP, &FWDfiltLPC[LPF_DIM+1]); /* 2-nd subframe*/
1423
1424 ippsCopy_16s(newLSP, prevSubfrLSP, LPF_DIM );
1425 pA = FWDfiltLPC; ppAz = pA;
1426
1427 for(subfrIdx=0; subfrIdx < LP_FRAME_DIM; subfrIdx+=LP_SUBFRAME_DIM) {
1428 Ipp32s pitchIndx;
1429 badPitch = badFrameIndicator;
1430 pitchIndx = *parm++;
1431 if(subfrIdx == 0) {
1432 i = (Ipp16s)(*parm++);
1433 badPitch = (Ipp16s)(badFrameIndicator + i);
1434 }
1435 DecodeAdaptCodebookDelays(&decoderObj->prevFrameDelay,&decoderObj->prevFrameDelay2,delayVal,subfrIdx,badPitch,pitchIndx,decoderObj->codecType);
1436 prevFrameDelay[subfrIdx/LP_SUBFRAME_DIM] = delayVal[0];
1437 ippsDecodeAdaptiveVector_G729_16s_I(delayVal,&prevExcitat[subfrIdx]);
1438
1439 if(badFrameIndicator != 0) {
1440 index = (Ipp16s)(Rand_16s(&decoderObj->seedSavage) & (Ipp16s)0x1fff);
1441 pulseSign = (Ipp16s)(Rand_16s(&decoderObj->seedSavage) & (Ipp16s)15);
1442 } else {
1443 index = parm[0];
1444 pulseSign = parm[1];
1445 }
1446
1447 i = index & 7;
1448 idx[0] = (Ipp16s)(5 * i);
1449
1450 index = (Ipp16s)(index >> 3);
1451 i = index & 7;
1452 idx[1] = (Ipp16s)(5 * i + 1);
1453
1454 index = (Ipp16s)(index >> 3);
1455 i = index & 7;
1456 idx[2] = (Ipp16s)(5 * i + 2);
1457
1458 index = (Ipp16s)(index >> 3);
1459 j = index & 1;
1460 index = (Ipp16s)(index >> 1);
1461 i = index & 7;
1462 idx[3] = (Ipp16s)(i * 5 + 3 + j);
1463
1464 ippsZero_16s(ACELPcodeVec,LP_SUBFRAME_DIM);
1465
1466 for(j=0; j<4; j++) {
1467 if((pulseSign & 1) != 0) {
1468 ACELPcodeVec[idx[j]] = 8191;
1469 } else {
1470 ACELPcodeVec[idx[j]] = -BWF_HARMONIC_E;
1471 }
1472 pulseSign = (Ipp16s)(pulseSign >> 1);
1473 }
1474 parm += 2;
1475
1476 decoderObj->betaPreFilter = (Ipp16s)(decoderObj->betaPreFilter << 1);
1477 if(delayVal[0] < LP_SUBFRAME_DIM) {
1478 ippsHarmonicFilter_16s_I(decoderObj->betaPreFilter,delayVal[0],&ACELPcodeVec[delayVal[0]],LP_SUBFRAME_DIM-delayVal[0]);
1479 }
1480
1481 pitchIndx = *parm++;
1482 if(!badFrameIndicator) {
1483 LOCAL_ARRAY(Ipp16s, gIngx, 2, decoderObj);
1484 ippsDotProd_16s32s_Sfs(ACELPcodeVec, ACELPcodeVec, LP_SUBFRAME_DIM, &i, 0);
1485 gIngx[0] = (Ipp16s)(pitchIndx >> CDBK2_BIT_NUM) ;
1486 gIngx[1] = (Ipp16s)(pitchIndx & (CDBK2_DIM-1));
1487 ippsDecodeGain_G729_16s(i, decoderObj->prevFrameQuantEn, gIngx, decoderObj->gains);
1488 LOCAL_ARRAY_FREE(Ipp16s, gIngx, 2, decoderObj);
1489 } else {
1490 ippsDecodeGain_G729_16s(0, decoderObj->prevFrameQuantEn, NULL, decoderObj->gains);
1491 }
1492 decoderObj->betaPreFilter = decoderObj->gains[0];
1493 if(decoderObj->betaPreFilter > PITCH_SHARP_MAX) decoderObj->betaPreFilter = PITCH_SHARP_MAX;
1494 if(decoderObj->betaPreFilter < PITCH_SHARP_MIN) decoderObj->betaPreFilter = PITCH_SHARP_MIN;
1495 ippsInterpolateC_NR_G729_16s_Sfs(
1496 &excitation[subfrIdx],decoderObj->gains[0],ACELPcodeVec,decoderObj->gains[1],&excitation[subfrIdx],LP_SUBFRAME_DIM,14);
1497 if(ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx], LP_SUBFRAME_DIM, 12,
1498 ((SynthesisFilterState*)synFltw)->buffer)==ippStsOverflow) {
1499
1500 ippsRShiftC_16s(prevExcitat,2,prevExcitat,L_prevExcitat+LP_FRAME_DIM);
1501 ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,12,
1502 ((SynthesisFilterState*)synFltw)->buffer);
1503 }
1504 ippsCopy_16s((&synth[subfrIdx]+LP_SUBFRAME_DIM-LPF_DIM), ((SynthesisFilterState*)synFltw)->buffer, LPF_DIM );
1505 ppAz += LPF_DIM+1;
1506 }
1507 }
1508
1509 if(badFrameIndicator == 0) {
1510 ippsDotProd_16s32s_Sfs(excitation,excitation,LP_FRAME_DIM,&i,-1);
1511 decoderObj->SIDflag1 = Exp_32s(i);
1512 decoderObj->SIDflag0 = (Ipp16s)(((i << decoderObj->SIDflag1)+0x8000)>>16);
1513 decoderObj->SIDflag1 = (Ipp16s)(16 - decoderObj->SIDflag1);
1514 }
1515 decoderObj->CNGvar = (Ipp16s)(fType);
1516 ippsMove_16s(&prevExcitat[LP_FRAME_DIM], &prevExcitat[0], L_prevExcitat);
1517 if (decoderObj->pstFltMode) {
1518 pAz = FWDfiltLPC;
1519 for(i=0, subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM,i++) {
1520 Post_G729AB(prevFrameDelay[i],(Ipp16s)subfrIdx,pAz,&dst[subfrIdx],(Ipp16s)fType,decoderObj);
1521 pAz += LPF_DIM+1;
1522 }
1523 ippsHighPassFilter_G729_16s_ISfs(dst,LP_FRAME_DIM,13,decoderObj->postProc);
1524 } else {
1525 ippsAdd_16s(synth, synth, dst, LP_FRAME_DIM);
1526 }
1527 CLEAR_SCRATCH_MEMORY(decoderObj);
1528 return APIG729_StsNoErr;
1529 }
1530
G729BaseDecode(G729Decoder_Obj * decoderObj,const Ipp8u * src,Ipp32s frametype,Ipp16s * dst)1531 APIG729_Status G729BaseDecode
1532 (G729Decoder_Obj* decoderObj,const Ipp8u* src, Ipp32s frametype, Ipp16s* dst) {
1533 LOCAL_ALIGN_ARRAY(32, Ipp16s, AzDec, (LPF_DIM+1)*2,decoderObj);
1534 LOCAL_ALIGN_ARRAY(32, Ipp16s, newLSP,LPF_DIM,decoderObj);
1535 LOCAL_ALIGN_ARRAY(32, Ipp16s, ACELPcodeVec, LP_SUBFRAME_DIM,decoderObj);
1536 LOCAL_ARRAY(Ipp16s, idx,4,decoderObj);
1537 LOCAL_ARRAY(Ipp16s, delayVal,2,decoderObj);
1538 Ipp16s prevFrameDelay1=0, subfrVoiceFlag, *ppAz;
1539 Ipp8s *synFltw = decoderObj->synFltw;
1540 Ipp16s *prevExcitat = decoderObj->prevExcitat;
1541 Ipp16s *excitation = prevExcitat + L_prevExcitat;
1542 Ipp16s *synth = decoderObj->LTPostFilt+SYNTH_BWD_DIM;
1543 Ipp16s *prevSubfrLSP = decoderObj->prevSubfrLSP;
1544 const Ipp8u *pParm;
1545 const Ipp16s *parm;
1546 Ipp16s voiceFlag = decoderObj->voiceFlag;
1547 Ipp16s sidGain = decoderObj->sidGain;
1548 Ipp16s gainNow = decoderObj->gainNow;
1549 Ipp16s *lspSID = decoderObj->lspSID;
1550 Ipp16s temp, badFrameIndicator, badPitch, index, pulseSign, gPl, gC, fType;
1551 Ipp32s i, j, subfrIdx, index2;
1552 IppStatus status;
1553
1554 if(NULL==decoderObj || NULL==src || NULL ==dst)
1555 return APIG729_StsBadArgErr;
1556 if(decoderObj->objPrm.objSize <= 0)
1557 return APIG729_StsNotInitialized;
1558 if(DEC_KEY != decoderObj->objPrm.key)
1559 return APIG729_StsBadCodecType;
1560
1561 delayVal[0]=delayVal[1]=0;
1562 pParm = src;
1563
1564 if(frametype == -1) {
1565 decoderObj->decPrm[1] = 0;
1566 decoderObj->decPrm[0] = 1;
1567 } else if(frametype == 0) {
1568 decoderObj->decPrm[1] = 0;
1569 decoderObj->decPrm[0] = 0;
1570
1571 } else if(frametype == 1) {
1572 decoderObj->decPrm[1] = 1;
1573 decoderObj->decPrm[0] = 0;
1574 i=0;
1575 decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1);
1576 decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,5);
1577 decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,4);
1578 decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,5);
1579 } else if(frametype == 3) {
1580 i=0;
1581 decoderObj->decPrm[1] = 3;
1582 decoderObj->decPrm[0] = 0;
1583 decoderObj->decPrm[1+1] = ExtractBitsG729(&pParm,&i,1+FIR_STAGE_BITS);
1584 decoderObj->decPrm[1+2] = ExtractBitsG729(&pParm,&i,SEC_STAGE_BITS*2);
1585 decoderObj->decPrm[1+3] = ExtractBitsG729(&pParm,&i,8);
1586 decoderObj->decPrm[1+4] = ExtractBitsG729(&pParm,&i,1);
1587 decoderObj->decPrm[1+5] = ExtractBitsG729(&pParm,&i,13);
1588 decoderObj->decPrm[1+6] = ExtractBitsG729(&pParm,&i,4);
1589 decoderObj->decPrm[1+7] = ExtractBitsG729(&pParm,&i,7);
1590 decoderObj->decPrm[1+8] = ExtractBitsG729(&pParm,&i,5);
1591 decoderObj->decPrm[1+9] = ExtractBitsG729(&pParm,&i,13);
1592 decoderObj->decPrm[1+10] = ExtractBitsG729(&pParm,&i,4);
1593 decoderObj->decPrm[1+11] = ExtractBitsG729(&pParm,&i,7);
1594 decoderObj->decPrm[1+4] = (Ipp16s)((equality(decoderObj->decPrm[1+3])+decoderObj->decPrm[1+4]) & 0x00000001); /* parity error (1) */
1595 decoderObj->codecType = G729_CODEC;
1596 }
1597 parm = decoderObj->decPrm;
1598
1599 badFrameIndicator = *parm++;
1600 fType = *parm;
1601 if(badFrameIndicator == 1) {
1602 fType = decoderObj->CNGvar;
1603 if(fType == 1)
1604 fType = 0;
1605 } else {
1606 decoderObj->valGainAttenuation = IPP_MAX_16S;
1607 decoderObj->BFIcount = 0;
1608 }
1609
1610 ippsMove_16s(&decoderObj->LTPostFilt[LP_FRAME_DIM+SYNTH_BWD_DIM-LPF_DIM], &decoderObj->LTPostFilt[SYNTH_BWD_DIM-LPF_DIM], LPF_DIM );
1611
1612 if(fType < 2) {
1613 if(fType == 1) {
1614 LOCAL_ALIGN_ARRAY(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
1615 sidGain = SIDgain[(Ipp32s)parm[4]];
1616 ippsLSFDecode_G729B_16s(&parm[1],(Ipp16s*)(decoderObj->prevLSPfreq),lsfq);
1617 ippsLSFToLSP_G729_16s(lsfq,lspSID);
1618 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, lsfq,LPF_DIM,decoderObj);
1619 } else {
1620 if(decoderObj->CNGvar > 1) {
1621 QuantSIDGain_G729B_16s(&decoderObj->SIDflag0, &decoderObj->SIDflag1, 0, &temp, &index2);
1622 sidGain = SIDgain[(Ipp32s)index2];
1623 }
1624 }
1625 if(decoderObj->CNGvar > 1) {
1626 gainNow = sidGain;
1627 } else {
1628 gainNow = (Ipp16s)((gainNow * GAIN0 + BWF_HARMONIC)>>15);
1629 gainNow = Add_16s(gainNow, (Ipp16s)((sidGain * GAIN1 + BWF_HARMONIC)>>15));
1630 }
1631
1632 if(gainNow == 0) {
1633 ippsZero_16s(excitation,LP_FRAME_DIM);
1634 } else {
1635 for(i = 0; i < LP_FRAME_DIM; i += LP_SUBFRAME_DIM) {
1636 Ipp32s invSq;
1637 Ipp16s pG2, tmp;
1638 const Ipp16s *excCached;
1639 LOCAL_ARRAY(Ipp16s, IdxsVec, 4, decoderObj);
1640 LOCAL_ARRAY(Ipp16s, pulsesSignsVec, 4, decoderObj);
1641 LOCAL_ALIGN_ARRAY(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
1642 LOCAL_ARRAY(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);
1643 RandomCodebookParm_G729B_16s(&decoderObj->seed,IdxsVec,pulsesSignsVec,&pG2,delayVal);
1644 ippsDecodeAdaptiveVector_G729_16s_I(delayVal,&prevExcitat[i]);
1645 if(decoderObj->CNGidx > CNG_STACK_SIZE-1) { /* not cached */
1646 ippsRandomNoiseExcitation_G729B_16s(&decoderObj->seed,excg,LP_SUBFRAME_DIM);
1647 ippsDotProd_16s32s_Sfs(excg,excg,LP_SUBFRAME_DIM,&invSq,0);
1648 ippsInvSqrt_32s_I(&invSq,1);
1649 excCached=excg;
1650 } else {
1651 decoderObj->seed = cngSeedOut[decoderObj->CNGidx];
1652 invSq = cngInvSqrt[decoderObj->CNGidx];
1653 excCached=&cngCache[decoderObj->CNGidx][0];
1654 decoderObj->CNGidx++;
1655 }
1656 NoiseExcitationFactorization_G729B_16s(excCached,invSq,gainNow,excg,LP_SUBFRAME_DIM);
1657 ComfortNoiseExcitation_G729B_16s_I(excg,IdxsVec,pulsesSignsVec,gainNow,pG2,&excitation[i],&tmp,tempArray);
1658
1659 LOCAL_ARRAY_FREE(Ipp16s,tempArray,LP_SUBFRAME_DIM, decoderObj);
1660 LOCAL_ALIGN_ARRAY_FREE(32, Ipp16s, excg, LP_SUBFRAME_DIM, decoderObj);
1661 LOCAL_ARRAY_FREE(Ipp16s, pulsesSignsVec, 4, decoderObj);
1662 LOCAL_ARRAY_FREE(Ipp16s, IdxsVec, 4, decoderObj);
1663 }
1664 }
1665 ippsInterpolate_G729_16s(prevSubfrLSP,lspSID,prevSubfrLSP, LPF_DIM );
1666 ippsLSPToLPC_G729_16s(prevSubfrLSP,&AzDec[0]);
1667 ippsLSPToLPC_G729_16s(lspSID,&AzDec[LPF_DIM+1]);
1668 ippsCopy_16s(lspSID, prevSubfrLSP, LPF_DIM );
1669 decoderObj->sidGain = sidGain;
1670 decoderObj->gainNow = gainNow;
1671
1672 ppAz = AzDec;
1673 for(subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {
1674 if(ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,12,
1675 ((SynthesisFilterState*)synFltw)->buffer+BWLPCF_DIM-LPF_DIM)==ippStsOverflow) {
1676 ippsRShiftC_16s(prevExcitat,2,prevExcitat,L_prevExcitat+LP_FRAME_DIM);
1677 SynthesisFilterOvf_G729_16s(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,20);
1678 } else
1679 ippsCopy_16s((&synth[subfrIdx]+LP_SUBFRAME_DIM-LPF_DIM), ((SynthesisFilterState*)synFltw)->buffer+BWLPCF_DIM-LPF_DIM, LPF_DIM );
1680
1681 ppAz += LPF_DIM+1;
1682 }
1683 decoderObj->betaPreFilter = PITCH_SHARP_MIN;
1684 } else {
1685 decoderObj->seed = SEED_INIT;
1686 decoderObj->CNGidx = 0;
1687 parm++;
1688 {
1689 LOCAL_ARRAY(Ipp16s, qIndex,4,decoderObj);
1690
1691 qIndex[0] = (Ipp16s)((parm[0] >> FIR_STAGE_BITS) & 1);
1692 qIndex[1] = (Ipp16s)(parm[0] & (FIR_STAGE - 1));
1693 qIndex[2] = (Ipp16s)((parm[1] >> SEC_STAGE_BITS) & (SEC_STAGE - 1));
1694 qIndex[3] = (Ipp16s)(parm[1] & (SEC_STAGE - 1));
1695 if(!badFrameIndicator) {
1696 decoderObj->prevMA = qIndex[0];
1697 ippsLSFDecode_G729_16s( qIndex, (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
1698 } else {
1699 ippsLSFDecodeErased_G729_16s( decoderObj->prevMA,
1700 (Ipp16s*)decoderObj->prevLSPfreq, decoderObj->prevSubfrLSPquant);
1701 }
1702
1703 ippsLSFToLSP_G729_16s(decoderObj->prevSubfrLSPquant, newLSP);
1704 parm += 2;
1705 LOCAL_ARRAY_FREE(Ipp16s, qIndex,4,decoderObj);
1706 ippsInterpolate_G729_16s(newLSP,prevSubfrLSP,prevSubfrLSP, LPF_DIM );
1707 ippsLSPToLPC_G729_16s(prevSubfrLSP, AzDec); /* 1-st subframe */
1708 ippsLSPToLPC_G729_16s(newLSP, &AzDec[LPF_DIM+1]); /* 2-nd one */
1709 ippsCopy_16s(newLSP, prevSubfrLSP, LPF_DIM );
1710 decoderObj->interpCoeff2_2 = 4506;
1711 }
1712 ppAz = AzDec;
1713
1714 for(subfrIdx = 0; subfrIdx < LP_FRAME_DIM; subfrIdx += LP_SUBFRAME_DIM) {
1715 Ipp32s pitchIndx;
1716 badPitch = badFrameIndicator;
1717 pitchIndx = *parm++;
1718 if(subfrIdx == 0) {
1719 i = *parm++;
1720 badPitch = (Ipp16s)(badFrameIndicator + i);
1721 }
1722 DecodeAdaptCodebookDelays(&decoderObj->prevFrameDelay,&decoderObj->prevFrameDelay2,delayVal,subfrIdx,badPitch,pitchIndx,decoderObj->codecType);
1723 if(subfrIdx == 0)
1724 prevFrameDelay1 = delayVal[0];
1725
1726 ippsDecodeAdaptiveVector_G729_16s_I(delayVal,&prevExcitat[subfrIdx]);
1727
1728 if(badFrameIndicator != 0) {
1729 index = (Ipp16s)(Rand_16s(&decoderObj->seedSavage) & (Ipp16s)0x1fff);
1730 pulseSign = (Ipp16s)(Rand_16s(&decoderObj->seedSavage) & (Ipp16s)15);
1731 } else {
1732 index = parm[0]; pulseSign = parm[1];
1733 }
1734
1735 i = index & 7;
1736 idx[0] = (Ipp16s)(5 * i);
1737
1738 index = (Ipp16s)(index >> 3);
1739 i = index & 7;
1740 idx[1] = (Ipp16s)(5 * i + 1);
1741
1742 index = (Ipp16s)(index >> 3);
1743 i = index & 7;
1744 idx[2] = (Ipp16s)(5 * i + 2);
1745
1746 index = (Ipp16s)(index >> 3);
1747 j = index & 1;
1748 index = (Ipp16s)(index >> 1);
1749 i = index & 7;
1750 idx[3] = (Ipp16s)(i * 5 + 3 + j);
1751
1752 ippsZero_16s(ACELPcodeVec,LP_SUBFRAME_DIM);
1753 for(j=0; j<4; j++) {
1754 if((pulseSign & 1) != 0) {
1755 ACELPcodeVec[idx[j]] = 8191;
1756 } else {
1757 ACELPcodeVec[idx[j]] = -BWF_HARMONIC_E;
1758 }
1759 pulseSign = (Ipp16s)(pulseSign >> 1);
1760 }
1761
1762 parm += 2;
1763 decoderObj->betaPreFilter = (Ipp16s)(decoderObj->betaPreFilter << 1);
1764 if(delayVal[0] < LP_SUBFRAME_DIM) {
1765 ippsHarmonicFilter_16s_I(decoderObj->betaPreFilter,delayVal[0],&ACELPcodeVec[delayVal[0]],LP_SUBFRAME_DIM-delayVal[0]);
1766 }
1767
1768 pitchIndx = *parm++;
1769 if(!badFrameIndicator) {
1770 LOCAL_ARRAY(Ipp16s, gIngx, 2, decoderObj);
1771 ippsDotProd_16s32s_Sfs(ACELPcodeVec, ACELPcodeVec, LP_SUBFRAME_DIM, &i, 0); /* ACELPcodeVec energy */
1772 gIngx[0] = (Ipp16s)(pitchIndx >> CDBK2_BIT_NUM) ;
1773 gIngx[1] = (Ipp16s)(pitchIndx & (CDBK2_DIM-1));
1774 ippsDecodeGain_G729_16s(i, decoderObj->prevFrameQuantEn, gIngx, decoderObj->gains);
1775 LOCAL_ARRAY_FREE(Ipp16s, gIngx, 2, decoderObj);
1776 } else {
1777 ippsDecodeGain_G729_16s(0, decoderObj->prevFrameQuantEn, NULL, decoderObj->gains);
1778 }
1779 /* update the pitch sharpening using the quantized gain pitch */
1780 decoderObj->betaPreFilter = decoderObj->gains[0];
1781 if(decoderObj->betaPreFilter > PITCH_SHARP_MAX)
1782 decoderObj->betaPreFilter = PITCH_SHARP_MAX;
1783 if(decoderObj->betaPreFilter < PITCH_SHARP_MIN)
1784 decoderObj->betaPreFilter = PITCH_SHARP_MIN;
1785
1786 if(badFrameIndicator) {
1787 decoderObj->BFIcount++;
1788 if(voiceFlag == 0 ) {
1789 gC = decoderObj->gains[1];
1790 gPl = 0;
1791 } else {
1792 gC = 0;
1793 gPl = decoderObj->gains[0];
1794 }
1795 } else {
1796 gC = decoderObj->gains[1];
1797 gPl = decoderObj->gains[0];
1798 }
1799 ippsInterpolateC_NR_G729_16s_Sfs(&excitation[subfrIdx],gPl,ACELPcodeVec,gC,&excitation[subfrIdx],LP_SUBFRAME_DIM,14);
1800 status = ippsSynthesisFilter_NR_16s_Sfs(ppAz,&excitation[subfrIdx],&synth[subfrIdx], LP_SUBFRAME_DIM, 12,
1801 ((SynthesisFilterState*)synFltw)->buffer+BWLPCF_DIM-LPF_DIM);
1802 if(status == ippStsOverflow) {
1803 ippsRShiftC_16s(prevExcitat,2,prevExcitat,L_prevExcitat+LP_FRAME_DIM);
1804 SynthesisFilterOvf_G729_16s(ppAz,&excitation[subfrIdx],&synth[subfrIdx],LP_SUBFRAME_DIM,synFltw,BWLPCF_DIM-LPF_DIM);
1805 } else
1806 ippsCopy_16s((&synth[subfrIdx]+LP_SUBFRAME_DIM-LPF_DIM), ((SynthesisFilterState*)synFltw)->buffer+BWLPCF_DIM-LPF_DIM, LPF_DIM );
1807 ppAz += LPF_DIM+1;
1808 }
1809 }
1810 if(badFrameIndicator == 0) {
1811 ippsDotProd_16s32s_Sfs(excitation,excitation,LP_FRAME_DIM,&i,-1);
1812 decoderObj->SIDflag1 = Exp_32s(i);
1813 decoderObj->SIDflag0 = (Ipp16s)(((i << decoderObj->SIDflag1)+0x8000)>>16);
1814 decoderObj->SIDflag1 = (Ipp16s)(16 - decoderObj->SIDflag1);
1815 }
1816 decoderObj->CNGvar = fType;
1817 ippsMove_16s(&prevExcitat[LP_FRAME_DIM], &prevExcitat[0], L_prevExcitat);
1818 decoderObj->voiceFlag = 0;
1819 decoderObj->gammaPost1 = BWF1_PST;
1820 decoderObj->gammaPost2 = BWF2_PST;
1821 decoderObj->gammaHarm = BWF_HARMONIC;
1822 if (decoderObj->pstFltMode) {
1823 for(subfrIdx=0; subfrIdx<LP_FRAME_DIM; subfrIdx+=LP_SUBFRAME_DIM) {
1824 Post_G729Base(prevFrameDelay1, (Ipp16s)subfrIdx, AzDec, &dst[subfrIdx],
1825 &subfrVoiceFlag, fType, decoderObj);
1826 if(subfrVoiceFlag != 0) decoderObj->voiceFlag = subfrVoiceFlag;
1827 AzDec += LPF_DIM+1;
1828 }
1829 ippsHighPassFilter_G729_16s_ISfs(dst,LP_FRAME_DIM,13,decoderObj->postProc);
1830 } else {
1831 ippsAdd_16s(synth, synth, dst, LP_FRAME_DIM);
1832 }
1833 CLEAR_SCRATCH_MEMORY(decoderObj);
1834 return APIG729_StsNoErr;
1835 }
1836