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 02110-1301 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 47typedef 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 57typedef 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/IS-733 2.4.9 89 */ 90static 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/IS-733 2.4.3.2.6.2-2, 2.4.8.7.3 113 */ 114static 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[i-1] + 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[i-1] = FFMIN(lspf[i-1], (lspf[i] - QCELP_LSP_SPREAD_FACTOR)); 165 166 // Low-pass filter the LSP frequencies. 167 ff_weighted_vector_sumf(lspf, lspf, q->prev_lspf, smooth, 1.0-smooth, 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[i-2]) < .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[i-4]) < .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/IS-733 2.4.6.2 206 */ 207static 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[i-1] + g1[i-2] + g1[i-3]) / 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[i-2]; 238 q->prev_g1[1] = g1[i-1]; 239 q->last_codebook_gain = qcelp_g12ga[g1[i-1]]; 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[i-1] = q->last_codebook_gain + slope * i; 279 280 q->last_codebook_gain = gain[i-2]; 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/IS-733 2.4.8.7.3 294 */ 295static 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[i-1]; 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/IS-733 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 [0-9] in order to get 322 * RI-compliant 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 */ 332static 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 gain-controlled vector 419 * @param v_ref vector to control gain of 420 * 421 * TIA/EIA/IS-733 2.4.8.3, 2.4.8.6 422 */ 423static 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 pitch-subframe 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 per-subframe gain array, each element is between 0.0 and 2.0 444 * @param lag per-subframe 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 per-subframe boolean array, 1 if the lag is fractional, 0 448 * otherwise 449 * 450 * @return filter output vector 451 */ 452static 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[j-4] + v_lag[3-j]); 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/IS-733 2.4.5.2, 2.4.8.7.2 496 * 497 * @param q the context 498 * @param cdn_vector the scaled codebook vector 499 */ 500static 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 * Reconstructs LPC coefficients from the line spectral pair frequencies 568 * and performs 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/IS-733 2.4.3.3.5 577 */ 578static 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 * Interpolates LSP frequencies and computes LPC coefficients 598 * for a given bitrate & pitch subframe. 599 * 600 * TIA/EIA/IS-733 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 */ 607static 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 632static 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/IS-733 2.4.8.7.1 657 */ 658static 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 697static 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 704static 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 734static 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 { 813erasure: 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/IS-733 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 845AVCodec 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}; 855