ffmpeg / libavcodec / qcelpdec.c @ 9106a698
History  View  Annotate  Download (25.6 KB)
1 
/*


2 
* QCELP decoder

3 
* Copyright (c) 2007 Reynaldo H. Verdejo Pinochet

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2.1 of the License, or (at your option) any later version.

11 
*

12 
* FFmpeg is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
/**

23 
* @file libavcodec/qcelpdec.c

24 
* QCELP decoder

25 
* @author Reynaldo H. Verdejo Pinochet

26 
* @remark FFmpeg merging spearheaded by Kenan Gillet

27 
* @remark Development mentored by Benjamin Larson

28 
*/

29  
30 
#include <stddef.h> 
31  
32 
#include "avcodec.h" 
33 
#include "internal.h" 
34 
#include "get_bits.h" 
35  
36 
#include "qcelpdata.h" 
37  
38 
#include "celp_math.h" 
39 
#include "celp_filters.h" 
40 
#include "acelp_vectors.h" 
41  
42 
#undef NDEBUG

43 
#include <assert.h> 
44  
45 
typedef enum 
46 
{ 
47 
I_F_Q = 1, /*!< insufficient frame quality */ 
48 
SILENCE, 
49 
RATE_OCTAVE, 
50 
RATE_QUARTER, 
51 
RATE_HALF, 
52 
RATE_FULL 
53 
} qcelp_packet_rate; 
54  
55 
typedef struct 
56 
{ 
57 
GetBitContext gb; 
58 
qcelp_packet_rate bitrate; 
59 
QCELPFrame frame; /*!< unpacked data frame */

60  
61 
uint8_t erasure_count; 
62 
uint8_t octave_count; /*!< count the consecutive RATE_OCTAVE frames */

63 
float prev_lspf[10]; 
64 
float predictor_lspf[10];/*!< LSP predictor for RATE_OCTAVE and I_F_Q */ 
65 
float pitch_synthesis_filter_mem[303]; 
66 
float pitch_pre_filter_mem[303]; 
67 
float rnd_fir_filter_mem[180]; 
68 
float formant_mem[170]; 
69 
float last_codebook_gain;

70 
int prev_g1[2]; 
71 
int prev_bitrate;

72 
float pitch_gain[4]; 
73 
uint8_t pitch_lag[4];

74 
uint16_t first16bits; 
75 
uint8_t warned_buf_mismatch_bitrate; 
76 
} QCELPContext; 
77  
78 
/**

79 
* Reconstructs LPC coefficients from the line spectral pair frequencies.

80 
*

81 
* TIA/EIA/IS733 2.4.3.3.5

82 
*/

83 
void ff_celp_lspf2lpc(const double *lspf, float *lpc); 
84  
85 
/**

86 
* Initialize the speech codec according to the specification.

87 
*

88 
* TIA/EIA/IS733 2.4.9

89 
*/

90 
static av_cold int qcelp_decode_init(AVCodecContext *avctx) 
91 
{ 
92 
QCELPContext *q = avctx>priv_data; 
93 
int i;

94  
95 
avctx>sample_fmt = SAMPLE_FMT_FLT; 
96  
97 
for(i=0; i<10; i++) 
98 
q>prev_lspf[i] = (i+1)/11.; 
99  
100 
return 0; 
101 
} 
102  
103 
/**

104 
* Decodes the 10 quantized LSP frequencies from the LSPV/LSP

105 
* transmission codes of any bitrate and checks for badly received packets.

106 
*

107 
* @param q the context

108 
* @param lspf line spectral pair frequencies

109 
*

110 
* @return 0 on success, 1 if the packet is badly received

111 
*

112 
* TIA/EIA/IS733 2.4.3.2.6.22, 2.4.8.7.3

113 
*/

114 
static int decode_lspf(QCELPContext *q, float *lspf) 
115 
{ 
116 
int i;

117 
float tmp_lspf, smooth, erasure_coeff;

118 
const float *predictors; 
119  
120 
if(q>bitrate == RATE_OCTAVE  q>bitrate == I_F_Q)

121 
{ 
122 
predictors = (q>prev_bitrate != RATE_OCTAVE && 
123 
q>prev_bitrate != I_F_Q ? 
124 
q>prev_lspf : q>predictor_lspf); 
125  
126 
if(q>bitrate == RATE_OCTAVE)

127 
{ 
128 
q>octave_count++; 
129  
130 
for(i=0; i<10; i++) 
131 
{ 
132 
q>predictor_lspf[i] = 
133 
lspf[i] = (q>frame.lspv[i] ? QCELP_LSP_SPREAD_FACTOR 
134 
: QCELP_LSP_SPREAD_FACTOR) 
135 
+ predictors[i] * QCELP_LSP_OCTAVE_PREDICTOR 
136 
+ (i + 1) * ((1  QCELP_LSP_OCTAVE_PREDICTOR)/11); 
137 
} 
138 
smooth = (q>octave_count < 10 ? .875 : 0.1); 
139 
}else

140 
{ 
141 
erasure_coeff = QCELP_LSP_OCTAVE_PREDICTOR; 
142  
143 
assert(q>bitrate == I_F_Q); 
144  
145 
if(q>erasure_count > 1) 
146 
erasure_coeff *= (q>erasure_count < 4 ? 0.9 : 0.7); 
147  
148 
for(i=0; i<10; i++) 
149 
{ 
150 
q>predictor_lspf[i] = 
151 
lspf[i] = (i + 1) * ( 1  erasure_coeff)/11 
152 
+ erasure_coeff * predictors[i]; 
153 
} 
154 
smooth = 0.125; 
155 
} 
156  
157 
// Check the stability of the LSP frequencies.

158 
lspf[0] = FFMAX(lspf[0], QCELP_LSP_SPREAD_FACTOR); 
159 
for(i=1; i<10; i++) 
160 
lspf[i] = FFMAX(lspf[i], (lspf[i1] + QCELP_LSP_SPREAD_FACTOR));

161  
162 
lspf[9] = FFMIN(lspf[9], (1.0  QCELP_LSP_SPREAD_FACTOR)); 
163 
for(i=9; i>0; i) 
164 
lspf[i1] = FFMIN(lspf[i1], (lspf[i]  QCELP_LSP_SPREAD_FACTOR)); 
165  
166 
// Lowpass filter the LSP frequencies.

167 
ff_weighted_vector_sumf(lspf, lspf, q>prev_lspf, smooth, 1.0smooth, 10); 
168 
}else

169 
{ 
170 
q>octave_count = 0;

171  
172 
tmp_lspf = 0.;

173 
for(i=0; i<5 ; i++) 
174 
{ 
175 
lspf[2*i+0] = tmp_lspf += qcelp_lspvq[i][q>frame.lspv[i]][0] * 0.0001; 
176 
lspf[2*i+1] = tmp_lspf += qcelp_lspvq[i][q>frame.lspv[i]][1] * 0.0001; 
177 
} 
178  
179 
// Check for badly received packets.

180 
if(q>bitrate == RATE_QUARTER)

181 
{ 
182 
if(lspf[9] <= .70  lspf[9] >= .97) 
183 
return 1; 
184 
for(i=3; i<10; i++) 
185 
if(fabs(lspf[i]  lspf[i2]) < .08) 
186 
return 1; 
187 
}else

188 
{ 
189 
if(lspf[9] <= .66  lspf[9] >= .985) 
190 
return 1; 
191 
for(i=4; i<10; i++) 
192 
if (fabs(lspf[i]  lspf[i4]) < .0931) 
193 
return 1; 
194 
} 
195 
} 
196 
return 0; 
197 
} 
198  
199 
/**

200 
* Converts codebook transmission codes to GAIN and INDEX.

201 
*

202 
* @param q the context

203 
* @param gain array holding the decoded gain

204 
*

205 
* TIA/EIA/IS733 2.4.6.2

206 
*/

207 
static void decode_gain_and_index(QCELPContext *q, 
208 
float *gain) {

209 
int i, subframes_count, g1[16]; 
210 
float slope;

211  
212 
if(q>bitrate >= RATE_QUARTER)

213 
{ 
214 
switch(q>bitrate)

215 
{ 
216 
case RATE_FULL: subframes_count = 16; break; 
217 
case RATE_HALF: subframes_count = 4; break; 
218 
default: subframes_count = 5; 
219 
} 
220 
for(i=0; i<subframes_count; i++) 
221 
{ 
222 
g1[i] = 4 * q>frame.cbgain[i];

223 
if(q>bitrate == RATE_FULL && !((i+1) & 3)) 
224 
{ 
225 
g1[i] += av_clip((g1[i1] + g1[i2] + g1[i3]) / 3  6, 0, 32); 
226 
} 
227  
228 
gain[i] = qcelp_g12ga[g1[i]]; 
229  
230 
if(q>frame.cbsign[i])

231 
{ 
232 
gain[i] = gain[i]; 
233 
q>frame.cindex[i] = (q>frame.cindex[i]89) & 127; 
234 
} 
235 
} 
236  
237 
q>prev_g1[0] = g1[i2]; 
238 
q>prev_g1[1] = g1[i1]; 
239 
q>last_codebook_gain = qcelp_g12ga[g1[i1]];

240  
241 
if(q>bitrate == RATE_QUARTER)

242 
{ 
243 
// Provide smoothing of the unvoiced excitation energy.

244 
gain[7] = gain[4]; 
245 
gain[6] = 0.4*gain[3] + 0.6*gain[4]; 
246 
gain[5] = gain[3]; 
247 
gain[4] = 0.8*gain[2] + 0.2*gain[3]; 
248 
gain[3] = 0.2*gain[1] + 0.8*gain[2]; 
249 
gain[2] = gain[1]; 
250 
gain[1] = 0.6*gain[0] + 0.4*gain[1]; 
251 
} 
252 
}else

253 
{ 
254 
if(q>bitrate == RATE_OCTAVE)

255 
{ 
256 
g1[0] = 2 * q>frame.cbgain[0] 
257 
+ av_clip((q>prev_g1[0] + q>prev_g1[1]) / 2  5, 0, 54); 
258 
subframes_count = 8;

259 
}else

260 
{ 
261 
assert(q>bitrate == I_F_Q); 
262  
263 
g1[0] = q>prev_g1[1]; 
264 
switch(q>erasure_count)

265 
{ 
266 
case 1 : break; 
267 
case 2 : g1[0] = 1; break; 
268 
case 3 : g1[0] = 2; break; 
269 
default: g1[0] = 6; 
270 
} 
271 
if(g1[0] < 0) 
272 
g1[0] = 0; 
273 
subframes_count = 4;

274 
} 
275 
// This interpolation is done to produce smoother background noise.

276 
slope = 0.5*(qcelp_g12ga[g1[0]]  q>last_codebook_gain) / subframes_count; 
277 
for(i=1; i<=subframes_count; i++) 
278 
gain[i1] = q>last_codebook_gain + slope * i;

279  
280 
q>last_codebook_gain = gain[i2];

281 
q>prev_g1[0] = q>prev_g1[1]; 
282 
q>prev_g1[1] = g1[0]; 
283 
} 
284 
} 
285  
286 
/**

287 
* If the received packet is Rate 1/4 a further sanity check is made of the

288 
* codebook gain.

289 
*

290 
* @param cbgain the unpacked cbgain array

291 
* @return 1 if the sanity check fails, 0 otherwise

292 
*

293 
* TIA/EIA/IS733 2.4.8.7.3

294 
*/

295 
static int codebook_sanity_check_for_rate_quarter(const uint8_t *cbgain) 
296 
{ 
297 
int i, diff, prev_diff=0; 
298  
299 
for(i=1; i<5; i++) 
300 
{ 
301 
diff = cbgain[i]  cbgain[i1];

302 
if(FFABS(diff) > 10) 
303 
return 1; 
304 
else if(FFABS(diff  prev_diff) > 12) 
305 
return 1; 
306 
prev_diff = diff; 
307 
} 
308 
return 0; 
309 
} 
310  
311 
/**

312 
* Computes the scaled codebook vector Cdn From INDEX and GAIN

313 
* for all rates.

314 
*

315 
* The specification lacks some information here.

316 
*

317 
* TIA/EIA/IS733 has an omission on the codebook index determination

318 
* formula for RATE_FULL and RATE_HALF frames at section 2.4.8.1.1. It says

319 
* you have to subtract the decoded index parameter from the given scaled

320 
* codebook vector index 'n' to get the desired circular codebook index, but

321 
* it does not mention that you have to clamp 'n' to [09] in order to get

322 
* RIcompliant results.

323 
*

324 
* The reason for this mistake seems to be the fact they forgot to mention you

325 
* have to do these calculations per codebook subframe and adjust given

326 
* equation values accordingly.

327 
*

328 
* @param q the context

329 
* @param gain array holding the 4 pitch subframe gain values

330 
* @param cdn_vector array for the generated scaled codebook vector

331 
*/

332 
static void compute_svector(QCELPContext *q, const float *gain, 
333 
float *cdn_vector)

334 
{ 
335 
int i, j, k;

336 
uint16_t cbseed, cindex; 
337 
float *rnd, tmp_gain, fir_filter_value;

338  
339 
switch(q>bitrate)

340 
{ 
341 
case RATE_FULL:

342 
for(i=0; i<16; i++) 
343 
{ 
344 
tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO; 
345 
cindex = q>frame.cindex[i]; 
346 
for(j=0; j<10; j++) 
347 
*cdn_vector++ = tmp_gain * qcelp_rate_full_codebook[cindex++ & 127];

348 
} 
349 
break;

350 
case RATE_HALF:

351 
for(i=0; i<4; i++) 
352 
{ 
353 
tmp_gain = gain[i] * QCELP_RATE_HALF_CODEBOOK_RATIO; 
354 
cindex = q>frame.cindex[i]; 
355 
for (j = 0; j < 40; j++) 
356 
*cdn_vector++ = tmp_gain * qcelp_rate_half_codebook[cindex++ & 127];

357 
} 
358 
break;

359 
case RATE_QUARTER:

360 
cbseed = (0x0003 & q>frame.lspv[4])<<14  
361 
(0x003F & q>frame.lspv[3])<< 8  
362 
(0x0060 & q>frame.lspv[2])<< 1  
363 
(0x0007 & q>frame.lspv[1])<< 3  
364 
(0x0038 & q>frame.lspv[0])>> 3 ; 
365 
rnd = q>rnd_fir_filter_mem + 20;

366 
for(i=0; i<8; i++) 
367 
{ 
368 
tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0); 
369 
for(k=0; k<20; k++) 
370 
{ 
371 
cbseed = 521 * cbseed + 259; 
372 
*rnd = (int16_t)cbseed; 
373  
374 
// FIR filter

375 
fir_filter_value = 0.0; 
376 
for(j=0; j<10; j++) 
377 
fir_filter_value += qcelp_rnd_fir_coefs[j ] 
378 
* (rnd[j ] + rnd[20+j]);

379  
380 
fir_filter_value += qcelp_rnd_fir_coefs[10] * rnd[10]; 
381 
*cdn_vector++ = tmp_gain * fir_filter_value; 
382 
rnd++; 
383 
} 
384 
} 
385 
memcpy(q>rnd_fir_filter_mem, q>rnd_fir_filter_mem + 160, 20 * sizeof(float)); 
386 
break;

387 
case RATE_OCTAVE:

388 
cbseed = q>first16bits; 
389 
for(i=0; i<8; i++) 
390 
{ 
391 
tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0); 
392 
for(j=0; j<20; j++) 
393 
{ 
394 
cbseed = 521 * cbseed + 259; 
395 
*cdn_vector++ = tmp_gain * (int16_t)cbseed; 
396 
} 
397 
} 
398 
break;

399 
case I_F_Q:

400 
cbseed = 44; // random codebook index 
401 
for(i=0; i<4; i++) 
402 
{ 
403 
tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO; 
404 
for(j=0; j<40; j++) 
405 
*cdn_vector++ = tmp_gain * qcelp_rate_full_codebook[cbseed++ & 127];

406 
} 
407 
break;

408 
case SILENCE:

409 
memset(cdn_vector, 0, 160 * sizeof(float)); 
410 
break;

411 
} 
412 
} 
413  
414 
/**

415 
* Compute the gain control

416 
*

417 
* @param v_in gaincontrolled vector

418 
* @param v_ref vector to control gain of

419 
*

420 
* @return gain control

421 
*

422 
* FIXME: If v_ref is a zero vector, it energy is zero

423 
* and the behavior of the gain control is

424 
* undefined in the specs.

425 
*

426 
* TIA/EIA/IS733 2.4.8.32/3/4/5, 2.4.8.6

427 
*/

428 
static float compute_gain_ctrl(const float *v_ref, const float *v_in, const int len) 
429 
{ 
430 
float scalefactor = ff_dot_productf(v_in, v_in, len);

431  
432 
if(scalefactor)

433 
scalefactor = sqrt(ff_dot_productf(v_ref, v_ref, len) / scalefactor); 
434 
else

435 
ff_log_missing_feature(NULL, "Zero energy for gain control", 1); 
436 
return scalefactor;

437 
} 
438  
439 
/**

440 
* Apply generic gain control.

441 
*

442 
* @param v_out output vector

443 
* @param v_in gaincontrolled vector

444 
* @param v_ref vector to control gain of

445 
*

446 
* TIA/EIA/IS733 2.4.8.3, 2.4.8.6

447 
*/

448 
static void apply_gain_ctrl(float *v_out, const float *v_ref, 
449 
const float *v_in) 
450 
{ 
451 
int i, j, len;

452 
float scalefactor;

453  
454 
for(i=0, j=0; i<4; i++) 
455 
{ 
456 
scalefactor = compute_gain_ctrl(v_ref + j, v_in + j, 40);

457 
for(len=j+40; j<len; j++) 
458 
v_out[j] = scalefactor * v_in[j]; 
459 
} 
460 
} 
461  
462 
/**

463 
* Apply filter in pitchsubframe steps.

464 
*

465 
* @param memory buffer for the previous state of the filter

466 
*  must be able to contain 303 elements

467 
*  the 143 first elements are from the previous state

468 
*  the next 160 are for output

469 
* @param v_in input filter vector

470 
* @param gain persubframe gain array, each element is between 0.0 and 2.0

471 
* @param lag persubframe lag array, each element is

472 
*  between 16 and 143 if its corresponding pfrac is 0,

473 
*  between 16 and 139 otherwise

474 
* @param pfrac persubframe boolean array, 1 if the lag is fractional, 0

475 
* otherwise

476 
*

477 
* @return filter output vector

478 
*/

479 
static const float *do_pitchfilter(float memory[303], const float v_in[160], 
480 
const float gain[4], const uint8_t *lag, 
481 
const uint8_t pfrac[4]) 
482 
{ 
483 
int i, j;

484 
float *v_lag, *v_out;

485 
const float *v_len; 
486  
487 
v_out = memory + 143; // Output vector starts at memory[143]. 
488  
489 
for(i=0; i<4; i++) 
490 
{ 
491 
if(gain[i])

492 
{ 
493 
v_lag = memory + 143 + 40 * i  lag[i]; 
494 
for(v_len=v_in+40; v_in<v_len; v_in++) 
495 
{ 
496 
if(pfrac[i]) // If it is a fractional lag... 
497 
{ 
498 
for(j=0, *v_out=0.; j<4; j++) 
499 
*v_out += qcelp_hammsinc_table[j] * (v_lag[j4] + v_lag[3j]); 
500 
}else

501 
*v_out = *v_lag; 
502  
503 
*v_out = *v_in + gain[i] * *v_out; 
504  
505 
v_lag++; 
506 
v_out++; 
507 
} 
508 
}else

509 
{ 
510 
memcpy(v_out, v_in, 40 * sizeof(float)); 
511 
v_in += 40;

512 
v_out += 40;

513 
} 
514 
} 
515  
516 
memmove(memory, memory + 160, 143 * sizeof(float)); 
517 
return memory + 143; 
518 
} 
519  
520 
/**

521 
* Apply pitch synthesis filter and pitch prefilter to the scaled codebook vector.

522 
* TIA/EIA/IS733 2.4.5.2, 2.4.8.7.2

523 
*

524 
* @param q the context

525 
* @param cdn_vector the scaled codebook vector

526 
*/

527 
static void apply_pitch_filters(QCELPContext *q, float *cdn_vector) 
528 
{ 
529 
int i;

530 
const float *v_synthesis_filtered, *v_pre_filtered; 
531  
532 
if(q>bitrate >= RATE_HALF 

533 
q>bitrate == SILENCE  
534 
(q>bitrate == I_F_Q && (q>prev_bitrate >= RATE_HALF))) 
535 
{ 
536  
537 
if(q>bitrate >= RATE_HALF)

538 
{ 
539  
540 
// Compute gain & lag for the whole frame.

541 
for(i=0; i<4; i++) 
542 
{ 
543 
q>pitch_gain[i] = q>frame.plag[i] ? (q>frame.pgain[i] + 1) * 0.25 : 0.0; 
544  
545 
q>pitch_lag[i] = q>frame.plag[i] + 16;

546 
} 
547 
}else

548 
{ 
549 
float max_pitch_gain;

550  
551 
if (q>bitrate == I_F_Q)

552 
{ 
553 
if (q>erasure_count < 3) 
554 
max_pitch_gain = 0.9  0.3 * (q>erasure_count  1); 
555 
else

556 
max_pitch_gain = 0.0; 
557 
}else

558 
{ 
559 
assert(q>bitrate == SILENCE); 
560 
max_pitch_gain = 1.0; 
561 
} 
562 
for(i=0; i<4; i++) 
563 
q>pitch_gain[i] = FFMIN(q>pitch_gain[i], max_pitch_gain); 
564  
565 
memset(q>frame.pfrac, 0, sizeof(q>frame.pfrac)); 
566 
} 
567  
568 
// pitch synthesis filter

569 
v_synthesis_filtered = do_pitchfilter(q>pitch_synthesis_filter_mem, 
570 
cdn_vector, q>pitch_gain, 
571 
q>pitch_lag, q>frame.pfrac); 
572  
573 
// pitch prefilter update

574 
for(i=0; i<4; i++) 
575 
q>pitch_gain[i] = 0.5 * FFMIN(q>pitch_gain[i], 1.0); 
576  
577 
v_pre_filtered = do_pitchfilter(q>pitch_pre_filter_mem, 
578 
v_synthesis_filtered, 
579 
q>pitch_gain, q>pitch_lag, 
580 
q>frame.pfrac); 
581  
582 
apply_gain_ctrl(cdn_vector, v_synthesis_filtered, v_pre_filtered); 
583 
}else

584 
{ 
585 
memcpy(q>pitch_synthesis_filter_mem, cdn_vector + 17,

586 
143 * sizeof(float)); 
587 
memcpy(q>pitch_pre_filter_mem, cdn_vector + 17, 143 * sizeof(float)); 
588 
memset(q>pitch_gain, 0, sizeof(q>pitch_gain)); 
589 
memset(q>pitch_lag, 0, sizeof(q>pitch_lag)); 
590 
} 
591 
} 
592  
593 
/**

594 
* Reconstructs LPC coefficients from the line spectral pair frequencies

595 
* and performs bandwidth expansion.

596 
*

597 
* @param lspf line spectral pair frequencies

598 
* @param lpc linear predictive coding coefficients

599 
*

600 
* @note: bandwith_expansion_coeff could be precalculated into a table

601 
* but it seems to be slower on x86

602 
*

603 
* TIA/EIA/IS733 2.4.3.3.5

604 
*/

605 
static void lspf2lpc(const float *lspf, float *lpc) 
606 
{ 
607 
double lsf[10]; 
608 
double bandwith_expansion_coeff = QCELP_BANDWITH_EXPANSION_COEFF;

609 
int i;

610  
611 
for (i=0; i<10; i++) 
612 
lsf[i] = cos(M_PI * lspf[i]); 
613  
614 
ff_celp_lspf2lpc(lsf, lpc); 
615  
616 
for (i=0; i<10; i++) 
617 
{ 
618 
lpc[i] *= bandwith_expansion_coeff; 
619 
bandwith_expansion_coeff *= QCELP_BANDWITH_EXPANSION_COEFF; 
620 
} 
621 
} 
622  
623 
/**

624 
* Interpolates LSP frequencies and computes LPC coefficients

625 
* for a given bitrate & pitch subframe.

626 
*

627 
* TIA/EIA/IS733 2.4.3.3.4, 2.4.8.7.2

628 
*

629 
* @param q the context

630 
* @param curr_lspf LSP frequencies vector of the current frame

631 
* @param lpc float vector for the resulting LPC

632 
* @param subframe_num frame number in decoded stream

633 
*/

634 
void interpolate_lpc(QCELPContext *q, const float *curr_lspf, float *lpc, 
635 
const int subframe_num) 
636 
{ 
637 
float interpolated_lspf[10]; 
638 
float weight;

639  
640 
if(q>bitrate >= RATE_QUARTER)

641 
weight = 0.25 * (subframe_num + 1); 
642 
else if(q>bitrate == RATE_OCTAVE && !subframe_num) 
643 
weight = 0.625; 
644 
else

645 
weight = 1.0; 
646  
647 
if(weight != 1.0) 
648 
{ 
649 
ff_weighted_vector_sumf(interpolated_lspf, curr_lspf, q>prev_lspf, 
650 
weight, 1.0  weight, 10); 
651 
lspf2lpc(interpolated_lspf, lpc); 
652 
}else if(q>bitrate >= RATE_QUARTER  
653 
(q>bitrate == I_F_Q && !subframe_num)) 
654 
lspf2lpc(curr_lspf, lpc); 
655 
else if(q>bitrate == SILENCE && !subframe_num) 
656 
lspf2lpc(q>prev_lspf, lpc); 
657 
} 
658  
659 
static qcelp_packet_rate buf_size2bitrate(const int buf_size) 
660 
{ 
661 
switch(buf_size)

662 
{ 
663 
case 35: return RATE_FULL; 
664 
case 17: return RATE_HALF; 
665 
case 8: return RATE_QUARTER; 
666 
case 4: return RATE_OCTAVE; 
667 
case 1: return SILENCE; 
668 
} 
669  
670 
return I_F_Q;

671 
} 
672  
673 
/**

674 
* Determine the bitrate from the frame size and/or the first byte of the frame.

675 
*

676 
* @param avctx the AV codec context

677 
* @param buf_size length of the buffer

678 
* @param buf the bufffer

679 
*

680 
* @return the bitrate on success,

681 
* I_F_Q if the bitrate cannot be satisfactorily determined

682 
*

683 
* TIA/EIA/IS733 2.4.8.7.1

684 
*/

685 
static qcelp_packet_rate determine_bitrate(AVCodecContext *avctx, const int buf_size, 
686 
const uint8_t **buf)

687 
{ 
688 
qcelp_packet_rate bitrate; 
689  
690 
if((bitrate = buf_size2bitrate(buf_size)) >= 0) 
691 
{ 
692 
if(bitrate > **buf)

693 
{ 
694 
QCELPContext *q = avctx>priv_data; 
695 
if (!q>warned_buf_mismatch_bitrate)

696 
{ 
697 
av_log(avctx, AV_LOG_WARNING, 
698 
"Claimed bitrate and buffer size mismatch.\n");

699 
q>warned_buf_mismatch_bitrate = 1;

700 
} 
701 
bitrate = **buf; 
702 
}else if(bitrate < **buf) 
703 
{ 
704 
av_log(avctx, AV_LOG_ERROR, 
705 
"Buffer is too small for the claimed bitrate.\n");

706 
return I_F_Q;

707 
} 
708 
(*buf)++; 
709 
}else if((bitrate = buf_size2bitrate(buf_size + 1)) >= 0) 
710 
{ 
711 
av_log(avctx, AV_LOG_WARNING, 
712 
"Bitrate byte is missing, guessing the bitrate from packet size.\n");

713 
}else

714 
return I_F_Q;

715  
716 
if(bitrate == SILENCE)

717 
{ 
718 
//FIXME: Remove experimental warning when tested with samples.

719 
ff_log_ask_for_sample(avctx, "'Blank frame handling is experimental.");

720 
} 
721 
return bitrate;

722 
} 
723  
724 
static void warn_insufficient_frame_quality(AVCodecContext *avctx, 
725 
const char *message) 
726 
{ 
727 
av_log(avctx, AV_LOG_WARNING, "Frame #%d, IFQ: %s\n", avctx>frame_number,

728 
message); 
729 
} 
730  
731 
static int qcelp_decode_frame(AVCodecContext *avctx, void *data, int *data_size, 
732 
AVPacket *avpkt) 
733 
{ 
734 
const uint8_t *buf = avpkt>data;

735 
int buf_size = avpkt>size;

736 
QCELPContext *q = avctx>priv_data; 
737 
float *outbuffer = data;

738 
int i;

739 
float quantized_lspf[10], lpc[10]; 
740 
float gain[16]; 
741 
float *formant_mem;

742  
743 
if((q>bitrate = determine_bitrate(avctx, buf_size, &buf)) == I_F_Q)

744 
{ 
745 
warn_insufficient_frame_quality(avctx, "bitrate cannot be determined.");

746 
goto erasure;

747 
} 
748  
749 
if(q>bitrate == RATE_OCTAVE &&

750 
(q>first16bits = AV_RB16(buf)) == 0xFFFF)

751 
{ 
752 
warn_insufficient_frame_quality(avctx, "Bitrate is 1/8 and first 16 bits are on.");

753 
goto erasure;

754 
} 
755  
756 
if(q>bitrate > SILENCE)

757 
{ 
758 
const QCELPBitmap *bitmaps = qcelp_unpacking_bitmaps_per_rate[q>bitrate];

759 
const QCELPBitmap *bitmaps_end = qcelp_unpacking_bitmaps_per_rate[q>bitrate]

760 
+ qcelp_unpacking_bitmaps_lengths[q>bitrate]; 
761 
uint8_t *unpacked_data = (uint8_t *)&q>frame; 
762  
763 
init_get_bits(&q>gb, buf, 8*buf_size);

764  
765 
memset(&q>frame, 0, sizeof(QCELPFrame)); 
766  
767 
for(; bitmaps < bitmaps_end; bitmaps++)

768 
unpacked_data[bitmaps>index] = get_bits(&q>gb, bitmaps>bitlen) << bitmaps>bitpos; 
769  
770 
// Check for erasures/blanks on rates 1, 1/4 and 1/8.

771 
if(q>frame.reserved)

772 
{ 
773 
warn_insufficient_frame_quality(avctx, "Wrong data in reserved frame area.");

774 
goto erasure;

775 
} 
776 
if(q>bitrate == RATE_QUARTER &&

777 
codebook_sanity_check_for_rate_quarter(q>frame.cbgain)) 
778 
{ 
779 
warn_insufficient_frame_quality(avctx, "Codebook gain sanity check failed.");

780 
goto erasure;

781 
} 
782  
783 
if(q>bitrate >= RATE_HALF)

784 
{ 
785 
for(i=0; i<4; i++) 
786 
{ 
787 
if(q>frame.pfrac[i] && q>frame.plag[i] >= 124) 
788 
{ 
789 
warn_insufficient_frame_quality(avctx, "Cannot initialize pitch filter.");

790 
goto erasure;

791 
} 
792 
} 
793 
} 
794 
} 
795  
796 
decode_gain_and_index(q, gain); 
797 
compute_svector(q, gain, outbuffer); 
798  
799 
if(decode_lspf(q, quantized_lspf) < 0) 
800 
{ 
801 
warn_insufficient_frame_quality(avctx, "Badly received packets in frame.");

802 
goto erasure;

803 
} 
804  
805  
806 
apply_pitch_filters(q, outbuffer); 
807  
808 
if(q>bitrate == I_F_Q)

809 
{ 
810 
erasure:

811 
q>bitrate = I_F_Q; 
812 
q>erasure_count++; 
813 
decode_gain_and_index(q, gain); 
814 
compute_svector(q, gain, outbuffer); 
815 
decode_lspf(q, quantized_lspf); 
816 
apply_pitch_filters(q, outbuffer); 
817 
}else

818 
q>erasure_count = 0;

819  
820 
formant_mem = q>formant_mem + 10;

821 
for(i=0; i<4; i++) 
822 
{ 
823 
interpolate_lpc(q, quantized_lspf, lpc, i); 
824 
ff_celp_lp_synthesis_filterf(formant_mem, lpc, outbuffer + i * 40, 40, 
825 
10);

826 
formant_mem += 40;

827 
} 
828 
memcpy(q>formant_mem, q>formant_mem + 160, 10 * sizeof(float)); 
829  
830 
// FIXME: postfilter and final gain control should be here.

831 
// TIA/EIA/IS733 2.4.8.6

832  
833 
formant_mem = q>formant_mem + 10;

834 
for(i=0; i<160; i++) 
835 
*outbuffer++ = av_clipf(*formant_mem++, QCELP_CLIP_LOWER_BOUND, 
836 
QCELP_CLIP_UPPER_BOUND); 
837  
838 
memcpy(q>prev_lspf, quantized_lspf, sizeof(q>prev_lspf));

839 
q>prev_bitrate = q>bitrate; 
840  
841 
*data_size = 160 * sizeof(*outbuffer); 
842  
843 
return *data_size;

844 
} 
845  
846 
AVCodec qcelp_decoder = 
847 
{ 
848 
.name = "qcelp",

849 
.type = CODEC_TYPE_AUDIO, 
850 
.id = CODEC_ID_QCELP, 
851 
.init = qcelp_decode_init, 
852 
.decode = qcelp_decode_frame, 
853 
.priv_data_size = sizeof(QCELPContext),

854 
.long_name = NULL_IF_CONFIG_SMALL("QCELP / PureVoice"),

855 
}; 