FreeCalypso > hg > gsm-codec-lib

comparison libgsmefr/d_gains.c @ 61:a18782a7d270

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
libgsmefr: d_gains.c compiles
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 25 Nov 2022 20:19:30 +0000
parents 49dd1ac8e75b
children 9b07190a6d08
comparison
equal deleted inserted replaced
60:d273a77d5523 61:a18782a7d270
8 * 8 *
9 * MA prediction is performed on the innovation energy 9 * MA prediction is performed on the innovation energy
10 * ( in dB/(20*log10(2)) ) with mean removed. 10 * ( in dB/(20*log10(2)) ) with mean removed.
11 *************************************************************************/ 11 *************************************************************************/
12 12
13 #include "gsm_efr.h"
13 #include "typedef.h" 14 #include "typedef.h"
15 #include "namespace.h"
14 #include "basic_op.h" 16 #include "basic_op.h"
15 #include "oper_32b.h" 17 #include "oper_32b.h"
16 #include "count.h" 18 #include "no_count.h"
17 #include "sig_proc.h" 19 #include "sig_proc.h"
20 #include "memops.h"
21 #include "codec.h"
18 22
19 #include "gains_tb.h" 23 #include "gains_tb.h"
20 24
21 #include "cnst.h" 25 #include "cnst.h"
26 #include "dec_state.h"
22 #include "dtx.h" 27 #include "dtx.h"
23
24 extern Word16 gain_code_old_rx[4 * DTX_HANGOVER];
25
26 /* Static variables for bad frame handling */
27
28 /* Variables used by d_gain_pitch: */
29 Word16 pbuf[5], past_gain_pit, prev_gp;
30
31 /* Variables used by d_gain_code: */
32 Word16 gbuf[5], past_gain_code, prev_gc;
33
34 /* Static variables for CNI (used by d_gain_code) */
35
36 Word16 gcode0_CN, gain_code_old_CN, gain_code_new_CN, gain_code_muting_CN;
37
38 /* Memories of gain dequantization: */
39
40 /* past quantized energies. */
41 /* initialized to -14.0/constant, constant = 20*Log10(2) */
42
43 Word16 past_qua_en[4];
44
45 /* MA prediction coeff */
46 Word16 pred[4];
47 28
48 /************************************************************************* 29 /*************************************************************************
49 * 30 *
50 * FUNCTION: gmed5 31 * FUNCTION: gmed5
51 * 32 *
53 * 34 *
54 * DESCRIPTION: 35 * DESCRIPTION:
55 * 36 *
56 *************************************************************************/ 37 *************************************************************************/
57 38
58 Word16 gmed5 ( /* out : index of the median value (0...4) */ 39 static Word16 gmed5 ( /* out : index of the median value (0...4) */
59 Word16 ind[] /* in : Past gain values */ 40 Word16 ind[] /* in : Past gain values */
60 ) 41 )
61 { 42 {
62 Word16 i, j, ix = 0, tmp[5]; 43 Word16 i, j, ix = 0, tmp[5];
63 Word16 max, tmp2[5]; 44 Word16 max, tmp2[5];
64 45
65 for (i = 0; i < 5; i++) 46 Copy (ind, tmp2, 5);
66 {
67 tmp2[i] = ind[i]; move16 ();
68 }
69 47
70 for (i = 0; i < 5; i++) 48 for (i = 0; i < 5; i++)
71 { 49 {
72 max = -8192; move16 (); 50 max = -8192; move16 ();
73 for (j = 0; j < 5; j++) 51 for (j = 0; j < 5; j++)
74 { 52 {
75 test (); 53 if (tmp2[j] >= max)
76 if (sub (tmp2[j], max) >= 0)
77 { 54 {
78 max = tmp2[j]; move16 (); 55 max = tmp2[j]; move16 ();
79 ix = j; move16 (); 56 ix = j; move16 ();
80 } 57 }
81 } 58 }
98 * past gain is used. 75 * past gain is used.
99 * 76 *
100 *************************************************************************/ 77 *************************************************************************/
101 78
102 Word16 d_gain_pitch ( /* out : quantized pitch gain */ 79 Word16 d_gain_pitch ( /* out : quantized pitch gain */
80 struct EFR_decoder_state *st,
103 Word16 index, /* in : index of quantization */ 81 Word16 index, /* in : index of quantization */
104 Word16 bfi, /* in : bad frame indicator (good = 0) */ 82 Word16 bfi, /* in : bad frame indicator (good = 0) */
105 Word16 state, 83 Word16 state,
106 Word16 prev_bf, 84 Word16 prev_bf,
107 Word16 rxdtx_ctrl 85 Word16 rxdtx_ctrl
113 9830, 6553, 6553 91 9830, 6553, 6553
114 }; 92 };
115 93
116 Word16 gain, tmp, i; 94 Word16 gain, tmp, i;
117 95
118 test ();
119 if (bfi == 0) 96 if (bfi == 0)
120 { 97 {
121 test (); logic16 ();
122 if ((rxdtx_ctrl & RX_SP_FLAG) != 0) 98 if ((rxdtx_ctrl & RX_SP_FLAG) != 0)
123 { 99 {
124 gain = shr (qua_gain_pitch[index], 2); move16 (); 100 gain = shr (qua_gain_pitch[index], 2);
125 101
126 test ();
127 if (prev_bf != 0) 102 if (prev_bf != 0)
128 { 103 {
129 test (); 104 if (gain > st->prev_gp)
130 if (sub (gain, prev_gp) > 0)
131 { 105 {
132 gain = prev_gp; 106 gain = st->prev_gp;
133 } 107 }
134 } 108 }
135 } 109 }
136 else 110 else
137 { 111 {
138 gain = 0; move16 (); 112 gain = 0;
139 } 113 }
140 prev_gp = gain; move16 (); 114 st->prev_gp = gain;
141 } 115 }
142 else 116 else
143 { 117 {
144 test (); logic16 ();
145 if ((rxdtx_ctrl & RX_SP_FLAG) != 0) 118 if ((rxdtx_ctrl & RX_SP_FLAG) != 0)
146 { 119 {
147 tmp = gmed5 (pbuf); move16 (); 120 tmp = gmed5 (st->pbuf);
148 121
149 test (); 122 if (tmp < st->past_gain_pit)
150 if (sub (tmp, past_gain_pit) < 0) 123 {
151 { 124 st->past_gain_pit = tmp;
152 past_gain_pit = tmp; move16 (); 125 }
153 } 126 gain = mult (pdown[state], st->past_gain_pit);
154 gain = mult (pdown[state], past_gain_pit); 127 }
155 } 128 else
156 else 129 {
157 { 130 gain = 0;
158 gain = 0; move16 (); 131 }
159 } 132 }
160 } 133
161 134 st->past_gain_pit = gain;
162 past_gain_pit = gain; move16 (); 135
163 136 if (sub (st->past_gain_pit, 4096) > 0) /* if (past_gain_pit > 1.0) */
164 test (); 137 {
165 if (sub (past_gain_pit, 4096) > 0) /* if (past_gain_pit > 1.0) */ 138 st->past_gain_pit = 4096;
166 {
167 past_gain_pit = 4096; move16 ();
168 } 139 }
169 for (i = 1; i < 5; i++) 140 for (i = 1; i < 5; i++)
170 { 141 {
171 pbuf[i - 1] = pbuf[i]; move16 (); 142 st->pbuf[i - 1] = st->pbuf[i];
172 } 143 }
173 144
174 pbuf[4] = past_gain_pit; move16 (); 145 st->pbuf[4] = st->past_gain_pit;
175 146
176 return gain; 147 return gain;
177 } 148 }
178 149
179 /************************************************************************* 150 /*************************************************************************
195 /* average innovation energy. */ 166 /* average innovation energy. */
196 /* MEAN_ENER = 36.0/constant, constant = 20*Log10(2) */ 167 /* MEAN_ENER = 36.0/constant, constant = 20*Log10(2) */
197 #define MEAN_ENER 783741L /* 36/(20*log10(2)) */ 168 #define MEAN_ENER 783741L /* 36/(20*log10(2)) */
198 169
199 void d_gain_code ( 170 void d_gain_code (
171 struct EFR_decoder_state *st,
200 Word16 index, /* input : received quantization index */ 172 Word16 index, /* input : received quantization index */
201 Word16 code[], /* input : innovation codevector */ 173 Word16 code[], /* input : innovation codevector */
202 Word16 lcode, /* input : codevector length */ 174 Word16 lcode, /* input : codevector length */
203 Word16 *gain_code, /* output: decoded innovation gain */ 175 Word16 *gain_code, /* output: decoded innovation gain */
204 Word16 bfi, /* input : bad frame indicator */ 176 Word16 bfi, /* input : bad frame indicator */
217 189
218 Word16 i, tmp; 190 Word16 i, tmp;
219 Word16 gcode0, exp, frac, av_pred_en; 191 Word16 gcode0, exp, frac, av_pred_en;
220 Word32 ener, ener_code; 192 Word32 ener, ener_code;
221 193
222 test (); test (); logic16 ();
223 if (((rxdtx_ctrl & RX_UPD_SID_QUANT_MEM) != 0) && (i_subfr == 0)) 194 if (((rxdtx_ctrl & RX_UPD_SID_QUANT_MEM) != 0) && (i_subfr == 0))
224 { 195 {
225 gcode0_CN = update_gcode0_CN (gain_code_old_rx); move16 (); 196 st->gcode0_CN = update_gcode0_CN (st->gain_code_old_rx);
226 gcode0_CN = shl (gcode0_CN, 4); 197 st->gcode0_CN = shl (st->gcode0_CN, 4);
227 } 198 }
228 199
229 /* Handle cases of comfort noise fixed codebook gain decoding in 200 /* Handle cases of comfort noise fixed codebook gain decoding in
230 which past valid SID frames are repeated */ 201 which past valid SID frames are repeated */
231 202
232 test (); test (); test (); logic16 (); logic16 (); logic16 ();
233 if (((rxdtx_ctrl & RX_NO_TRANSMISSION) != 0) 203 if (((rxdtx_ctrl & RX_NO_TRANSMISSION) != 0)
234 || ((rxdtx_ctrl & RX_INVALID_SID_FRAME) != 0) 204 || ((rxdtx_ctrl & RX_INVALID_SID_FRAME) != 0)
235 || ((rxdtx_ctrl & RX_LOST_SID_FRAME) != 0)) 205 || ((rxdtx_ctrl & RX_LOST_SID_FRAME) != 0))
236 { 206 {
237 207
238 test (); logic16 ();
239 if ((rxdtx_ctrl & RX_NO_TRANSMISSION) != 0) 208 if ((rxdtx_ctrl & RX_NO_TRANSMISSION) != 0)
240 { 209 {
241 /* DTX active: no transmission. Interpolate gain values 210 /* DTX active: no transmission. Interpolate gain values
242 in memory */ 211 in memory */
243 test ();
244 if (i_subfr == 0) 212 if (i_subfr == 0)
245 { 213 {
246 *gain_code = interpolate_CN_param (gain_code_old_CN, 214 *gain_code = interpolate_CN_param (st->gain_code_old_CN,
247 gain_code_new_CN, rx_dtx_state); 215 st->gain_code_new_CN, rx_dtx_state);
248 move16 ();
249 } 216 }
250 else 217 else
251 { 218 {
252 *gain_code = prev_gc; move16 (); 219 *gain_code = st->prev_gc;
253 } 220 }
254 } 221 }
255 else 222 else
256 { /* Invalid or lost SID frame: 223 { /* Invalid or lost SID frame:
257 use gain values from last good SID frame */ 224 use gain values from last good SID frame */
258 gain_code_old_CN = gain_code_new_CN; move16 (); 225 st->gain_code_old_CN = st->gain_code_new_CN;
259 *gain_code = gain_code_new_CN; move16 (); 226 *gain_code = st->gain_code_new_CN;
260 227
261 /* reset table of past quantized energies */ 228 /* reset table of past quantized energies */
262 for (i = 0; i < 4; i++) 229 for (i = 0; i < 4; i++)
263 { 230 {
264 past_qua_en[i] = -2381; move16 (); 231 st->past_qua_en[i] = -2381;
265 } 232 }
266 } 233 }
267 234
268 test (); logic16 ();
269 if ((rxdtx_ctrl & RX_DTX_MUTING) != 0) 235 if ((rxdtx_ctrl & RX_DTX_MUTING) != 0)
270 { 236 {
271 /* attenuate the gain value by 0.75 dB in each subframe */ 237 /* attenuate the gain value by 0.75 dB in each subframe */
272 /* (total of 3 dB per frame) */ 238 /* (total of 3 dB per frame) */
273 gain_code_muting_CN = mult (gain_code_muting_CN, 30057); 239 st->gain_code_muting_CN = mult (st->gain_code_muting_CN, 30057);
274 *gain_code = gain_code_muting_CN; move16 (); 240 *gain_code = st->gain_code_muting_CN;
275 } 241 }
276 else 242 else
277 { 243 {
278 /* Prepare for DTX muting by storing last good gain value */ 244 /* Prepare for DTX muting by storing last good gain value */
279 gain_code_muting_CN = gain_code_new_CN; move16 (); 245 st->gain_code_muting_CN = st->gain_code_new_CN;
280 } 246 }
281 247
282 past_gain_code = *gain_code; move16 (); 248 st->past_gain_code = *gain_code;
283 249
284 for (i = 1; i < 5; i++) 250 for (i = 1; i < 5; i++)
285 { 251 {
286 gbuf[i - 1] = gbuf[i]; move16 (); 252 st->gbuf[i - 1] = st->gbuf[i];
287 } 253 }
288 254
289 gbuf[4] = past_gain_code; move16 (); 255 st->gbuf[4] = st->past_gain_code;
290 prev_gc = past_gain_code; move16 (); 256 st->prev_gc = st->past_gain_code;
291 257
292 return; 258 return;
293 } 259 }
294 260
295 /*----------------- Test erasure ---------------*/ 261 /*----------------- Test erasure ---------------*/
296 262
297 test ();
298 if (bfi != 0) 263 if (bfi != 0)
299 { 264 {
300 tmp = gmed5 (gbuf); move16 (); 265 tmp = gmed5 (st->gbuf);
301 test (); 266 if (sub (tmp, st->past_gain_code) < 0)
302 if (sub (tmp, past_gain_code) < 0) 267 {
303 { 268 st->past_gain_code = tmp;
304 past_gain_code = tmp; move16 (); 269 }
305 } 270 st->past_gain_code = mult (st->past_gain_code, cdown[state]);
306 past_gain_code = mult (past_gain_code, cdown[state]); 271 *gain_code = st->past_gain_code;
307 *gain_code = past_gain_code; move16 (); 272
308 273 av_pred_en = 0;
309 av_pred_en = 0; move16 ();
310 for (i = 0; i < 4; i++) 274 for (i = 0; i < 4; i++)
311 { 275 {
312 av_pred_en = add (av_pred_en, past_qua_en[i]); 276 av_pred_en = add (av_pred_en, st->past_qua_en[i]);
313 } 277 }
314 278
315 /* av_pred_en = 0.25*av_pred_en - 4/(20Log10(2)) */ 279 /* av_pred_en = 0.25*av_pred_en - 4/(20Log10(2)) */
316 av_pred_en = mult (av_pred_en, 8192); /* *= 0.25 */ 280 av_pred_en = mult (av_pred_en, 8192); /* *= 0.25 */
317 281
318 /* if (av_pred_en < -14/(20Log10(2))) av_pred_en = .. */ 282 /* if (av_pred_en < -14/(20Log10(2))) av_pred_en = .. */
319 test ();
320 if (sub (av_pred_en, -2381) < 0) 283 if (sub (av_pred_en, -2381) < 0)
321 { 284 {
322 av_pred_en = -2381; move16 (); 285 av_pred_en = -2381;
323 } 286 }
324 for (i = 3; i > 0; i--) 287 for (i = 3; i > 0; i--)
325 { 288 {
326 past_qua_en[i] = past_qua_en[i - 1]; move16 (); 289 st->past_qua_en[i] = st->past_qua_en[i - 1];
327 } 290 }
328 past_qua_en[0] = av_pred_en; move16 (); 291 st->past_qua_en[0] = av_pred_en;
329 for (i = 1; i < 5; i++) 292 for (i = 1; i < 5; i++)
330 { 293 {
331 gbuf[i - 1] = gbuf[i]; move16 (); 294 st->gbuf[i - 1] = st->gbuf[i];
332 } 295 }
333 gbuf[4] = past_gain_code; move16 (); 296 st->gbuf[4] = st->past_gain_code;
334 297
335 /* Use the most recent comfort noise fixed codebook gain value 298 /* Use the most recent comfort noise fixed codebook gain value
336 for updating the fixed codebook gain history */ 299 for updating the fixed codebook gain history */
337 test (); 300 if (st->gain_code_new_CN == 0)
338 if (gain_code_new_CN == 0) 301 {
339 { 302 tmp = st->prev_gc;
340 tmp = prev_gc; move16 (); 303 }
341 } 304 else
342 else 305 {
343 { 306 tmp = st->gain_code_new_CN;
344 tmp = gain_code_new_CN; 307 }
345 } 308
346 309 update_gain_code_history_rx (st, tmp);
347 update_gain_code_history_rx (tmp, gain_code_old_rx); 310
348
349 test ();
350 if (sub (i_subfr, (3 * L_SUBFR)) == 0) 311 if (sub (i_subfr, (3 * L_SUBFR)) == 0)
351 { 312 {
352 gain_code_old_CN = *gain_code; move16 (); 313 st->gain_code_old_CN = *gain_code;
353 } 314 }
354 return; 315 return;
355 } 316 }
356 317
357 test (); logic16 ();
358 if ((rxdtx_ctrl & RX_SP_FLAG) != 0) 318 if ((rxdtx_ctrl & RX_SP_FLAG) != 0)
359 { 319 {
360 320
361 /*-------------- Decode codebook gain ---------------*/ 321 /*-------------- Decode codebook gain ---------------*/
362 322
384 /* predicted energy */ 344 /* predicted energy */
385 345
386 ener = MEAN_ENER; move32 (); 346 ener = MEAN_ENER; move32 ();
387 for (i = 0; i < 4; i++) 347 for (i = 0; i < 4; i++)
388 { 348 {
389 ener = L_mac (ener, past_qua_en[i], pred[i]); 349 ener = L_mac (ener, st->past_qua_en[i], st->pred[i]);
390 } 350 }
391 351
392 /*-------------------------------------------------------------------* 352 /*-------------------------------------------------------------------*
393 * predicted codebook gain * 353 * predicted codebook gain *
394 * ~~~~~~~~~~~~~~~~~~~~~~~ * 354 * ~~~~~~~~~~~~~~~~~~~~~~~ *
404 364
405 gcode0 = shl (gcode0, 4); 365 gcode0 = shl (gcode0, 4);
406 366
407 *gain_code = mult (qua_gain_code[index], gcode0); move16 (); 367 *gain_code = mult (qua_gain_code[index], gcode0); move16 ();
408 368
409 test ();
410 if (prev_bf != 0) 369 if (prev_bf != 0)
411 { 370 {
412 test (); 371 if (sub (*gain_code, st->prev_gc) > 0)
413 if (sub (*gain_code, prev_gc) > 0) 372 {
414 { 373 *gain_code = st->prev_gc;
415 *gain_code = prev_gc; move16 ();
416 } 374 }
417 } 375 }
418 /*-------------------------------------------------------------------* 376 /*-------------------------------------------------------------------*
419 * update table of past quantized energies * 377 * update table of past quantized energies *
420 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * 378 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *
423 * constant = 20*Log10(2) * 381 * constant = 20*Log10(2) *
424 *-------------------------------------------------------------------*/ 382 *-------------------------------------------------------------------*/
425 383
426 for (i = 3; i > 0; i--) 384 for (i = 3; i > 0; i--)
427 { 385 {
428 past_qua_en[i] = past_qua_en[i - 1]; move16 (); 386 st->past_qua_en[i] = st->past_qua_en[i - 1];
429 } 387 }
430 Log2 (L_deposit_l (qua_gain_code[index]), &exp, &frac); 388 Log2 (L_deposit_l (qua_gain_code[index]), &exp, &frac);
431 389
432 past_qua_en[0] = shr (frac, 5); move16 (); 390 st->past_qua_en[0] = shr (frac, 5);
433 past_qua_en[0] = add (past_qua_en[0], shl (sub (exp, 11), 10)); 391 st->past_qua_en[0] = add (st->past_qua_en[0], shl (sub (exp, 11), 10));
434 move16 (); 392
435 393 update_gain_code_history_rx (st, *gain_code);
436 update_gain_code_history_rx (*gain_code, gain_code_old_rx);
437 394
438 if (sub (i_subfr, (3 * L_SUBFR)) == 0) 395 if (sub (i_subfr, (3 * L_SUBFR)) == 0)
439 { 396 {
440 gain_code_old_CN = *gain_code; move16 (); 397 st->gain_code_old_CN = *gain_code;
441 } 398 }
442 } 399 }
443 else 400 else
444 { 401 {
445 test (); test (); logic16 ();
446 if (((rxdtx_ctrl & RX_FIRST_SID_UPDATE) != 0) && (i_subfr == 0)) 402 if (((rxdtx_ctrl & RX_FIRST_SID_UPDATE) != 0) && (i_subfr == 0))
447 { 403 {
448 gain_code_new_CN = mult (gcode0_CN, qua_gain_code[index]); 404 st->gain_code_new_CN = mult (st->gcode0_CN, qua_gain_code[index]);
449 405
450 /*---------------------------------------------------------------* 406 /*---------------------------------------------------------------*
451 * reset table of past quantized energies * 407 * reset table of past quantized energies *
452 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * 408 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *
453 *---------------------------------------------------------------*/ 409 *---------------------------------------------------------------*/
454 410
455 for (i = 0; i < 4; i++) 411 for (i = 0; i < 4; i++)
456 { 412 {
457 past_qua_en[i] = -2381; move16 (); 413 st->past_qua_en[i] = -2381;
458 } 414 }
459 } 415 }
460 test (); test (); logic16 ();
461 if (((rxdtx_ctrl & RX_CONT_SID_UPDATE) != 0) && (i_subfr == 0)) 416 if (((rxdtx_ctrl & RX_CONT_SID_UPDATE) != 0) && (i_subfr == 0))
462 { 417 {
463 gain_code_old_CN = gain_code_new_CN; move16 (); 418 st->gain_code_old_CN = st->gain_code_new_CN;
464 gain_code_new_CN = mult (gcode0_CN, qua_gain_code[index]); 419 st->gain_code_new_CN = mult (st->gcode0_CN, qua_gain_code[index]);
465 move16 (); 420 }
466 }
467 test ();
468 if (i_subfr == 0) 421 if (i_subfr == 0)
469 { 422 {
470 *gain_code = interpolate_CN_param (gain_code_old_CN, 423 *gain_code = interpolate_CN_param (st->gain_code_old_CN,
471 gain_code_new_CN, 424 st->gain_code_new_CN,
472 rx_dtx_state); move16 (); 425 rx_dtx_state);
473 } 426 }
474 else 427 else
475 { 428 {
476 *gain_code = prev_gc; move16 (); 429 *gain_code = st->prev_gc;
477 } 430 }
478 } 431 }
479 432
480 past_gain_code = *gain_code; move16 (); 433 st->past_gain_code = *gain_code;
481 434
482 for (i = 1; i < 5; i++) 435 for (i = 1; i < 5; i++)
483 { 436 {
484 gbuf[i - 1] = gbuf[i]; move16 (); 437 st->gbuf[i - 1] = st->gbuf[i];
485 } 438 }
486 gbuf[4] = past_gain_code; move16 (); 439 st->gbuf[4] = st->past_gain_code;
487 prev_gc = past_gain_code; move16 (); 440 st->prev_gc = st->past_gain_code;
488 441
489 return; 442 return;
490 } 443 }