ffmpeg / libavcodec / qcelpdec.c @ 5d6e4c16
History  View  Annotate  Download (25.9 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

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_filters.h" 
41 
#include "acelp_vectors.h" 
42 
#include "lsp.h" 
43  
44 
#undef NDEBUG

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

62  
63 
uint8_t erasure_count; 
64 
uint8_t octave_count; /*!< count the consecutive RATE_OCTAVE frames */

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

72 
int prev_g1[2]; 
73 
int prev_bitrate;

74 
float pitch_gain[4]; 
75 
uint8_t pitch_lag[4];

76 
uint16_t first16bits; 
77 
uint8_t warned_buf_mismatch_bitrate; 
78  
79 
/* postfilter */

80 
float postfilter_synth_mem[10]; 
81 
float postfilter_agc_mem;

82 
float postfilter_tilt_mem;

83 
} QCELPContext; 
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 = AV_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 
* Decode the 10 quantized LSP frequencies from the LSPV/LSP

105 
* transmission codes of any bitrate and check 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 
* Convert 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 if (q>bitrate != SILENCE) 
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 
* Compute 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 
* Apply generic gain control.

416 
*

417 
* @param v_out output vector

418 
* @param v_in gaincontrolled vector

419 
* @param v_ref vector to control gain of

420 
*

421 
* TIA/EIA/IS733 2.4.8.3, 2.4.8.6

422 
*/

423 
static void apply_gain_ctrl(float *v_out, const float *v_ref, 
424 
const float *v_in) 
425 
{ 
426 
int i;

427  
428 
for (i = 0; i < 160; i += 40) 
429 
ff_scale_vector_to_given_sum_of_squares(v_out + i, v_in + i, 
430 
ff_dot_productf(v_ref + i, 
431 
v_ref + i, 40),

432 
40);

433 
} 
434  
435 
/**

436 
* Apply filter in pitchsubframe steps.

437 
*

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

439 
*  must be able to contain 303 elements

440 
*  the 143 first elements are from the previous state

441 
*  the next 160 are for output

442 
* @param v_in input filter vector

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

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

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

446 
*  between 16 and 139 otherwise

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

448 
* otherwise

449 
*

450 
* @return filter output vector

451 
*/

452 
static const float *do_pitchfilter(float memory[303], const float v_in[160], 
453 
const float gain[4], const uint8_t *lag, 
454 
const uint8_t pfrac[4]) 
455 
{ 
456 
int i, j;

457 
float *v_lag, *v_out;

458 
const float *v_len; 
459  
460 
v_out = memory + 143; // Output vector starts at memory[143]. 
461  
462 
for(i=0; i<4; i++) 
463 
{ 
464 
if(gain[i])

465 
{ 
466 
v_lag = memory + 143 + 40 * i  lag[i]; 
467 
for(v_len=v_in+40; v_in<v_len; v_in++) 
468 
{ 
469 
if(pfrac[i]) // If it is a fractional lag... 
470 
{ 
471 
for(j=0, *v_out=0.; j<4; j++) 
472 
*v_out += qcelp_hammsinc_table[j] * (v_lag[j4] + v_lag[3j]); 
473 
}else

474 
*v_out = *v_lag; 
475  
476 
*v_out = *v_in + gain[i] * *v_out; 
477  
478 
v_lag++; 
479 
v_out++; 
480 
} 
481 
}else

482 
{ 
483 
memcpy(v_out, v_in, 40 * sizeof(float)); 
484 
v_in += 40;

485 
v_out += 40;

486 
} 
487 
} 
488  
489 
memmove(memory, memory + 160, 143 * sizeof(float)); 
490 
return memory + 143; 
491 
} 
492  
493 
/**

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

495 
* TIA/EIA/IS733 2.4.5.2, 2.4.8.7.2

496 
*

497 
* @param q the context

498 
* @param cdn_vector the scaled codebook vector

499 
*/

500 
static void apply_pitch_filters(QCELPContext *q, float *cdn_vector) 
501 
{ 
502 
int i;

503 
const float *v_synthesis_filtered, *v_pre_filtered; 
504  
505 
if(q>bitrate >= RATE_HALF 

506 
q>bitrate == SILENCE  
507 
(q>bitrate == I_F_Q && (q>prev_bitrate >= RATE_HALF))) 
508 
{ 
509  
510 
if(q>bitrate >= RATE_HALF)

511 
{ 
512  
513 
// Compute gain & lag for the whole frame.

514 
for(i=0; i<4; i++) 
515 
{ 
516 
q>pitch_gain[i] = q>frame.plag[i] ? (q>frame.pgain[i] + 1) * 0.25 : 0.0; 
517  
518 
q>pitch_lag[i] = q>frame.plag[i] + 16;

519 
} 
520 
}else

521 
{ 
522 
float max_pitch_gain;

523  
524 
if (q>bitrate == I_F_Q)

525 
{ 
526 
if (q>erasure_count < 3) 
527 
max_pitch_gain = 0.9  0.3 * (q>erasure_count  1); 
528 
else

529 
max_pitch_gain = 0.0; 
530 
}else

531 
{ 
532 
assert(q>bitrate == SILENCE); 
533 
max_pitch_gain = 1.0; 
534 
} 
535 
for(i=0; i<4; i++) 
536 
q>pitch_gain[i] = FFMIN(q>pitch_gain[i], max_pitch_gain); 
537  
538 
memset(q>frame.pfrac, 0, sizeof(q>frame.pfrac)); 
539 
} 
540  
541 
// pitch synthesis filter

542 
v_synthesis_filtered = do_pitchfilter(q>pitch_synthesis_filter_mem, 
543 
cdn_vector, q>pitch_gain, 
544 
q>pitch_lag, q>frame.pfrac); 
545  
546 
// pitch prefilter update

547 
for(i=0; i<4; i++) 
548 
q>pitch_gain[i] = 0.5 * FFMIN(q>pitch_gain[i], 1.0); 
549  
550 
v_pre_filtered = do_pitchfilter(q>pitch_pre_filter_mem, 
551 
v_synthesis_filtered, 
552 
q>pitch_gain, q>pitch_lag, 
553 
q>frame.pfrac); 
554  
555 
apply_gain_ctrl(cdn_vector, v_synthesis_filtered, v_pre_filtered); 
556 
}else

557 
{ 
558 
memcpy(q>pitch_synthesis_filter_mem, cdn_vector + 17,

559 
143 * sizeof(float)); 
560 
memcpy(q>pitch_pre_filter_mem, cdn_vector + 17, 143 * sizeof(float)); 
561 
memset(q>pitch_gain, 0, sizeof(q>pitch_gain)); 
562 
memset(q>pitch_lag, 0, sizeof(q>pitch_lag)); 
563 
} 
564 
} 
565  
566 
/**

567 
* Reconstruct LPC coefficients from the line spectral pair frequencies

568 
* and perform bandwidth expansion.

569 
*

570 
* @param lspf line spectral pair frequencies

571 
* @param lpc linear predictive coding coefficients

572 
*

573 
* @note: bandwidth_expansion_coeff could be precalculated into a table

574 
* but it seems to be slower on x86

575 
*

576 
* TIA/EIA/IS733 2.4.3.3.5

577 
*/

578 
static void lspf2lpc(const float *lspf, float *lpc) 
579 
{ 
580 
double lsp[10]; 
581 
double bandwidth_expansion_coeff = QCELP_BANDWIDTH_EXPANSION_COEFF;

582 
int i;

583  
584 
for (i=0; i<10; i++) 
585 
lsp[i] = cos(M_PI * lspf[i]); 
586  
587 
ff_acelp_lspd2lpc(lsp, lpc, 5);

588  
589 
for (i=0; i<10; i++) 
590 
{ 
591 
lpc[i] *= bandwidth_expansion_coeff; 
592 
bandwidth_expansion_coeff *= QCELP_BANDWIDTH_EXPANSION_COEFF; 
593 
} 
594 
} 
595  
596 
/**

597 
* Interpolate LSP frequencies and compute LPC coefficients

598 
* for a given bitrate & pitch subframe.

599 
*

600 
* TIA/EIA/IS733 2.4.3.3.4, 2.4.8.7.2

601 
*

602 
* @param q the context

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

604 
* @param lpc float vector for the resulting LPC

605 
* @param subframe_num frame number in decoded stream

606 
*/

607 
static void interpolate_lpc(QCELPContext *q, const float *curr_lspf, 
608 
float *lpc, const int subframe_num) 
609 
{ 
610 
float interpolated_lspf[10]; 
611 
float weight;

612  
613 
if(q>bitrate >= RATE_QUARTER)

614 
weight = 0.25 * (subframe_num + 1); 
615 
else if(q>bitrate == RATE_OCTAVE && !subframe_num) 
616 
weight = 0.625; 
617 
else

618 
weight = 1.0; 
619  
620 
if(weight != 1.0) 
621 
{ 
622 
ff_weighted_vector_sumf(interpolated_lspf, curr_lspf, q>prev_lspf, 
623 
weight, 1.0  weight, 10); 
624 
lspf2lpc(interpolated_lspf, lpc); 
625 
}else if(q>bitrate >= RATE_QUARTER  
626 
(q>bitrate == I_F_Q && !subframe_num)) 
627 
lspf2lpc(curr_lspf, lpc); 
628 
else if(q>bitrate == SILENCE && !subframe_num) 
629 
lspf2lpc(q>prev_lspf, lpc); 
630 
} 
631  
632 
static qcelp_packet_rate buf_size2bitrate(const int buf_size) 
633 
{ 
634 
switch(buf_size)

635 
{ 
636 
case 35: return RATE_FULL; 
637 
case 17: return RATE_HALF; 
638 
case 8: return RATE_QUARTER; 
639 
case 4: return RATE_OCTAVE; 
640 
case 1: return SILENCE; 
641 
} 
642  
643 
return I_F_Q;

644 
} 
645  
646 
/**

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

648 
*

649 
* @param avctx the AV codec context

650 
* @param buf_size length of the buffer

651 
* @param buf the bufffer

652 
*

653 
* @return the bitrate on success,

654 
* I_F_Q if the bitrate cannot be satisfactorily determined

655 
*

656 
* TIA/EIA/IS733 2.4.8.7.1

657 
*/

658 
static qcelp_packet_rate determine_bitrate(AVCodecContext *avctx, const int buf_size, 
659 
const uint8_t **buf)

660 
{ 
661 
qcelp_packet_rate bitrate; 
662  
663 
if((bitrate = buf_size2bitrate(buf_size)) >= 0) 
664 
{ 
665 
if(bitrate > **buf)

666 
{ 
667 
QCELPContext *q = avctx>priv_data; 
668 
if (!q>warned_buf_mismatch_bitrate)

669 
{ 
670 
av_log(avctx, AV_LOG_WARNING, 
671 
"Claimed bitrate and buffer size mismatch.\n");

672 
q>warned_buf_mismatch_bitrate = 1;

673 
} 
674 
bitrate = **buf; 
675 
}else if(bitrate < **buf) 
676 
{ 
677 
av_log(avctx, AV_LOG_ERROR, 
678 
"Buffer is too small for the claimed bitrate.\n");

679 
return I_F_Q;

680 
} 
681 
(*buf)++; 
682 
}else if((bitrate = buf_size2bitrate(buf_size + 1)) >= 0) 
683 
{ 
684 
av_log(avctx, AV_LOG_WARNING, 
685 
"Bitrate byte is missing, guessing the bitrate from packet size.\n");

686 
}else

687 
return I_F_Q;

688  
689 
if(bitrate == SILENCE)

690 
{ 
691 
//FIXME: Remove experimental warning when tested with samples.

692 
av_log_ask_for_sample(avctx, "'Blank frame handling is experimental.");

693 
} 
694 
return bitrate;

695 
} 
696  
697 
static void warn_insufficient_frame_quality(AVCodecContext *avctx, 
698 
const char *message) 
699 
{ 
700 
av_log(avctx, AV_LOG_WARNING, "Frame #%d, IFQ: %s\n", avctx>frame_number,

701 
message); 
702 
} 
703  
704 
static void postfilter(QCELPContext *q, float *samples, float *lpc) 
705 
{ 
706 
static const float pow_0_775[10] = { 
707 
0.775000, 0.600625, 0.465484, 0.360750, 0.279582, 
708 
0.216676, 0.167924, 0.130141, 0.100859, 0.078166 
709 
}, pow_0_625[10] = {

710 
0.625000, 0.390625, 0.244141, 0.152588, 0.095367, 
711 
0.059605, 0.037253, 0.023283, 0.014552, 0.009095 
712 
}; 
713 
float lpc_s[10], lpc_p[10], pole_out[170], zero_out[160]; 
714 
int n;

715  
716 
for (n = 0; n < 10; n++) { 
717 
lpc_s[n] = lpc[n] * pow_0_625[n]; 
718 
lpc_p[n] = lpc[n] * pow_0_775[n]; 
719 
} 
720  
721 
ff_celp_lp_zero_synthesis_filterf(zero_out, lpc_s, 
722 
q>formant_mem + 10, 160, 10); 
723 
memcpy(pole_out, q>postfilter_synth_mem, sizeof(float) * 10); 
724 
ff_celp_lp_synthesis_filterf(pole_out + 10, lpc_p, zero_out, 160, 10); 
725 
memcpy(q>postfilter_synth_mem, pole_out + 160, sizeof(float) * 10); 
726  
727 
ff_tilt_compensation(&q>postfilter_tilt_mem, 0.3, pole_out + 10, 160); 
728  
729 
ff_adaptive_gain_control(samples, pole_out + 10,

730 
ff_dot_productf(q>formant_mem + 10, q>formant_mem + 10, 160), 
731 
160, 0.9375, &q>postfilter_agc_mem); 
732 
} 
733  
734 
static int qcelp_decode_frame(AVCodecContext *avctx, void *data, int *data_size, 
735 
AVPacket *avpkt) 
736 
{ 
737 
const uint8_t *buf = avpkt>data;

738 
int buf_size = avpkt>size;

739 
QCELPContext *q = avctx>priv_data; 
740 
float *outbuffer = data;

741 
int i;

742 
float quantized_lspf[10], lpc[10]; 
743 
float gain[16]; 
744 
float *formant_mem;

745  
746 
if((q>bitrate = determine_bitrate(avctx, buf_size, &buf)) == I_F_Q)

747 
{ 
748 
warn_insufficient_frame_quality(avctx, "bitrate cannot be determined.");

749 
goto erasure;

750 
} 
751  
752 
if(q>bitrate == RATE_OCTAVE &&

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

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

756 
goto erasure;

757 
} 
758  
759 
if(q>bitrate > SILENCE)

760 
{ 
761 
const QCELPBitmap *bitmaps = qcelp_unpacking_bitmaps_per_rate[q>bitrate];

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

763 
+ qcelp_unpacking_bitmaps_lengths[q>bitrate]; 
764 
uint8_t *unpacked_data = (uint8_t *)&q>frame; 
765  
766 
init_get_bits(&q>gb, buf, 8*buf_size);

767  
768 
memset(&q>frame, 0, sizeof(QCELPFrame)); 
769  
770 
for(; bitmaps < bitmaps_end; bitmaps++)

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

774 
if(q>frame.reserved)

775 
{ 
776 
warn_insufficient_frame_quality(avctx, "Wrong data in reserved frame area.");

777 
goto erasure;

778 
} 
779 
if(q>bitrate == RATE_QUARTER &&

780 
codebook_sanity_check_for_rate_quarter(q>frame.cbgain)) 
781 
{ 
782 
warn_insufficient_frame_quality(avctx, "Codebook gain sanity check failed.");

783 
goto erasure;

784 
} 
785  
786 
if(q>bitrate >= RATE_HALF)

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

793 
goto erasure;

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

805 
goto erasure;

806 
} 
807  
808  
809 
apply_pitch_filters(q, outbuffer); 
810  
811 
if(q>bitrate == I_F_Q)

812 
{ 
813 
erasure:

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

821 
q>erasure_count = 0;

822  
823 
formant_mem = q>formant_mem + 10;

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

829 
formant_mem += 40;

830 
} 
831  
832 
// postfilter, as per TIA/EIA/IS733 2.4.8.6

833 
postfilter(q, outbuffer, lpc); 
834  
835 
memcpy(q>formant_mem, q>formant_mem + 160, 10 * sizeof(float)); 
836  
837 
memcpy(q>prev_lspf, quantized_lspf, sizeof(q>prev_lspf));

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

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

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

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

854 
}; 