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 "libavutil/avassert.h" 33#include "libavutil/channel_layout.h" 34#include "libavutil/float_dsp.h" 35#include "avcodec.h" 36#include "codec_internal.h" 37#include "internal.h" 38#include "get_bits.h" 39#include "qcelpdata.h" 40#include "celp_filters.h" 41#include "acelp_filters.h" 42#include "acelp_vectors.h" 43#include "lsp.h" 44 45typedef enum { 46 I_F_Q = -1, /**< insufficient frame quality */ 47 SILENCE, 48 RATE_OCTAVE, 49 RATE_QUARTER, 50 RATE_HALF, 51 RATE_FULL 52} qcelp_packet_rate; 53 54typedef struct QCELPContext { 55 GetBitContext gb; 56 qcelp_packet_rate bitrate; 57 QCELPFrame frame; /**< unpacked data frame */ 58 59 uint8_t erasure_count; 60 uint8_t octave_count; /**< count the consecutive RATE_OCTAVE frames */ 61 float prev_lspf[10]; 62 float predictor_lspf[10];/**< LSP predictor for RATE_OCTAVE and I_F_Q */ 63 float pitch_synthesis_filter_mem[303]; 64 float pitch_pre_filter_mem[303]; 65 float rnd_fir_filter_mem[180]; 66 float formant_mem[170]; 67 float last_codebook_gain; 68 int prev_g1[2]; 69 int prev_bitrate; 70 float pitch_gain[4]; 71 uint8_t pitch_lag[4]; 72 uint16_t first16bits; 73 uint8_t warned_buf_mismatch_bitrate; 74 75 /* postfilter */ 76 float postfilter_synth_mem[10]; 77 float postfilter_agc_mem; 78 float postfilter_tilt_mem; 79} QCELPContext; 80 81/** 82 * Initialize the speech codec according to the specification. 83 * 84 * TIA/EIA/IS-733 2.4.9 85 */ 86static av_cold int qcelp_decode_init(AVCodecContext *avctx) 87{ 88 QCELPContext *q = avctx->priv_data; 89 int i; 90 91 av_channel_layout_uninit(&avctx->ch_layout); 92 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; 93 avctx->sample_fmt = AV_SAMPLE_FMT_FLT; 94 95 for (i = 0; i < 10; i++) 96 q->prev_lspf[i] = (i + 1) / 11.0; 97 98 return 0; 99} 100 101/** 102 * Decode the 10 quantized LSP frequencies from the LSPV/LSP 103 * transmission codes of any bitrate and check for badly received packets. 104 * 105 * @param q the context 106 * @param lspf line spectral pair frequencies 107 * 108 * @return 0 on success, -1 if the packet is badly received 109 * 110 * TIA/EIA/IS-733 2.4.3.2.6.2-2, 2.4.8.7.3 111 */ 112static int decode_lspf(QCELPContext *q, float *lspf) 113{ 114 int i; 115 float tmp_lspf, smooth, erasure_coeff; 116 const float *predictors; 117 118 if (q->bitrate == RATE_OCTAVE || q->bitrate == I_F_Q) { 119 predictors = q->prev_bitrate != RATE_OCTAVE && 120 q->prev_bitrate != I_F_Q ? q->prev_lspf 121 : q->predictor_lspf; 122 123 if (q->bitrate == RATE_OCTAVE) { 124 q->octave_count++; 125 126 for (i = 0; i < 10; i++) { 127 q->predictor_lspf[i] = 128 lspf[i] = (q->frame.lspv[i] ? QCELP_LSP_SPREAD_FACTOR 129 : -QCELP_LSP_SPREAD_FACTOR) + 130 predictors[i] * QCELP_LSP_OCTAVE_PREDICTOR + 131 (i + 1) * ((1 - QCELP_LSP_OCTAVE_PREDICTOR) / 11); 132 } 133 smooth = q->octave_count < 10 ? .875 : 0.1; 134 } else { 135 erasure_coeff = QCELP_LSP_OCTAVE_PREDICTOR; 136 137 av_assert2(q->bitrate == I_F_Q); 138 139 if (q->erasure_count > 1) 140 erasure_coeff *= q->erasure_count < 4 ? 0.9 : 0.7; 141 142 for (i = 0; i < 10; i++) { 143 q->predictor_lspf[i] = 144 lspf[i] = (i + 1) * (1 - erasure_coeff) / 11 + 145 erasure_coeff * predictors[i]; 146 } 147 smooth = 0.125; 148 } 149 150 // Check the stability of the LSP frequencies. 151 lspf[0] = FFMAX(lspf[0], QCELP_LSP_SPREAD_FACTOR); 152 for (i = 1; i < 10; i++) 153 lspf[i] = FFMAX(lspf[i], lspf[i - 1] + QCELP_LSP_SPREAD_FACTOR); 154 155 lspf[9] = FFMIN(lspf[9], 1.0 - QCELP_LSP_SPREAD_FACTOR); 156 for (i = 9; i > 0; i--) 157 lspf[i - 1] = FFMIN(lspf[i - 1], lspf[i] - QCELP_LSP_SPREAD_FACTOR); 158 159 // Low-pass filter the LSP frequencies. 160 ff_weighted_vector_sumf(lspf, lspf, q->prev_lspf, smooth, 1.0 - smooth, 10); 161 } else { 162 q->octave_count = 0; 163 164 tmp_lspf = 0.0; 165 for (i = 0; i < 5; i++) { 166 lspf[2 * i + 0] = tmp_lspf += qcelp_lspvq[i][q->frame.lspv[i]][0] * 0.0001; 167 lspf[2 * i + 1] = tmp_lspf += qcelp_lspvq[i][q->frame.lspv[i]][1] * 0.0001; 168 } 169 170 // Check for badly received packets. 171 if (q->bitrate == RATE_QUARTER) { 172 if (lspf[9] <= .70 || lspf[9] >= .97) 173 return -1; 174 for (i = 3; i < 10; i++) 175 if (fabs(lspf[i] - lspf[i - 2]) < .08) 176 return -1; 177 } else { 178 if (lspf[9] <= .66 || lspf[9] >= .985) 179 return -1; 180 for (i = 4; i < 10; i++) 181 if (fabs(lspf[i] - lspf[i - 4]) < .0931) 182 return -1; 183 } 184 } 185 return 0; 186} 187 188/** 189 * Convert codebook transmission codes to GAIN and INDEX. 190 * 191 * @param q the context 192 * @param gain array holding the decoded gain 193 * 194 * TIA/EIA/IS-733 2.4.6.2 195 */ 196static void decode_gain_and_index(QCELPContext *q, float *gain) 197{ 198 int i, subframes_count, g1[16]; 199 float slope; 200 201 if (q->bitrate >= RATE_QUARTER) { 202 switch (q->bitrate) { 203 case RATE_FULL: subframes_count = 16; break; 204 case RATE_HALF: subframes_count = 4; break; 205 default: subframes_count = 5; 206 } 207 for (i = 0; i < subframes_count; i++) { 208 g1[i] = 4 * q->frame.cbgain[i]; 209 if (q->bitrate == RATE_FULL && !((i + 1) & 3)) { 210 g1[i] += av_clip((g1[i - 1] + g1[i - 2] + g1[i - 3]) / 3 - 6, 0, 32); 211 } 212 213 gain[i] = qcelp_g12ga[g1[i]]; 214 215 if (q->frame.cbsign[i]) { 216 gain[i] = -gain[i]; 217 q->frame.cindex[i] = (q->frame.cindex[i] - 89) & 127; 218 } 219 } 220 221 q->prev_g1[0] = g1[i - 2]; 222 q->prev_g1[1] = g1[i - 1]; 223 q->last_codebook_gain = qcelp_g12ga[g1[i - 1]]; 224 225 if (q->bitrate == RATE_QUARTER) { 226 // Provide smoothing of the unvoiced excitation energy. 227 gain[7] = gain[4]; 228 gain[6] = 0.4 * gain[3] + 0.6 * gain[4]; 229 gain[5] = gain[3]; 230 gain[4] = 0.8 * gain[2] + 0.2 * gain[3]; 231 gain[3] = 0.2 * gain[1] + 0.8 * gain[2]; 232 gain[2] = gain[1]; 233 gain[1] = 0.6 * gain[0] + 0.4 * gain[1]; 234 } 235 } else if (q->bitrate != SILENCE) { 236 if (q->bitrate == RATE_OCTAVE) { 237 g1[0] = 2 * q->frame.cbgain[0] + 238 av_clip((q->prev_g1[0] + q->prev_g1[1]) / 2 - 5, 0, 54); 239 subframes_count = 8; 240 } else { 241 av_assert2(q->bitrate == I_F_Q); 242 243 g1[0] = q->prev_g1[1]; 244 switch (q->erasure_count) { 245 case 1 : break; 246 case 2 : g1[0] -= 1; break; 247 case 3 : g1[0] -= 2; break; 248 default: g1[0] -= 6; 249 } 250 if (g1[0] < 0) 251 g1[0] = 0; 252 subframes_count = 4; 253 } 254 // This interpolation is done to produce smoother background noise. 255 slope = 0.5 * (qcelp_g12ga[g1[0]] - q->last_codebook_gain) / subframes_count; 256 for (i = 1; i <= subframes_count; i++) 257 gain[i - 1] = q->last_codebook_gain + slope * i; 258 259 q->last_codebook_gain = gain[i - 2]; 260 q->prev_g1[0] = q->prev_g1[1]; 261 q->prev_g1[1] = g1[0]; 262 } 263} 264 265/** 266 * If the received packet is Rate 1/4 a further sanity check is made of the 267 * codebook gain. 268 * 269 * @param cbgain the unpacked cbgain array 270 * @return -1 if the sanity check fails, 0 otherwise 271 * 272 * TIA/EIA/IS-733 2.4.8.7.3 273 */ 274static int codebook_sanity_check_for_rate_quarter(const uint8_t *cbgain) 275{ 276 int i, diff, prev_diff = 0; 277 278 for (i = 1; i < 5; i++) { 279 diff = cbgain[i] - cbgain[i-1]; 280 if (FFABS(diff) > 10) 281 return -1; 282 else if (FFABS(diff - prev_diff) > 12) 283 return -1; 284 prev_diff = diff; 285 } 286 return 0; 287} 288 289/** 290 * Compute the scaled codebook vector Cdn From INDEX and GAIN 291 * for all rates. 292 * 293 * The specification lacks some information here. 294 * 295 * TIA/EIA/IS-733 has an omission on the codebook index determination 296 * formula for RATE_FULL and RATE_HALF frames at section 2.4.8.1.1. It says 297 * you have to subtract the decoded index parameter from the given scaled 298 * codebook vector index 'n' to get the desired circular codebook index, but 299 * it does not mention that you have to clamp 'n' to [0-9] in order to get 300 * RI-compliant results. 301 * 302 * The reason for this mistake seems to be the fact they forgot to mention you 303 * have to do these calculations per codebook subframe and adjust given 304 * equation values accordingly. 305 * 306 * @param q the context 307 * @param gain array holding the 4 pitch subframe gain values 308 * @param cdn_vector array for the generated scaled codebook vector 309 */ 310static void compute_svector(QCELPContext *q, const float *gain, 311 float *cdn_vector) 312{ 313 int i, j, k; 314 uint16_t cbseed, cindex; 315 float *rnd, tmp_gain, fir_filter_value; 316 317 switch (q->bitrate) { 318 case RATE_FULL: 319 for (i = 0; i < 16; i++) { 320 tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO; 321 cindex = -q->frame.cindex[i]; 322 for (j = 0; j < 10; j++) 323 *cdn_vector++ = tmp_gain * 324 qcelp_rate_full_codebook[cindex++ & 127]; 325 } 326 break; 327 case RATE_HALF: 328 for (i = 0; i < 4; i++) { 329 tmp_gain = gain[i] * QCELP_RATE_HALF_CODEBOOK_RATIO; 330 cindex = -q->frame.cindex[i]; 331 for (j = 0; j < 40; j++) 332 *cdn_vector++ = tmp_gain * 333 qcelp_rate_half_codebook[cindex++ & 127]; 334 } 335 break; 336 case RATE_QUARTER: 337 cbseed = (0x0003 & q->frame.lspv[4]) << 14 | 338 (0x003F & q->frame.lspv[3]) << 8 | 339 (0x0060 & q->frame.lspv[2]) << 1 | 340 (0x0007 & q->frame.lspv[1]) << 3 | 341 (0x0038 & q->frame.lspv[0]) >> 3; 342 rnd = q->rnd_fir_filter_mem + 20; 343 for (i = 0; i < 8; i++) { 344 tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0); 345 for (k = 0; k < 20; k++) { 346 cbseed = 521 * cbseed + 259; 347 *rnd = (int16_t) cbseed; 348 349 // FIR filter 350 fir_filter_value = 0.0; 351 for (j = 0; j < 10; j++) 352 fir_filter_value += qcelp_rnd_fir_coefs[j] * 353 (rnd[-j] + rnd[-20+j]); 354 355 fir_filter_value += qcelp_rnd_fir_coefs[10] * rnd[-10]; 356 *cdn_vector++ = tmp_gain * fir_filter_value; 357 rnd++; 358 } 359 } 360 memcpy(q->rnd_fir_filter_mem, q->rnd_fir_filter_mem + 160, 361 20 * sizeof(float)); 362 break; 363 case RATE_OCTAVE: 364 cbseed = q->first16bits; 365 for (i = 0; i < 8; i++) { 366 tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0); 367 for (j = 0; j < 20; j++) { 368 cbseed = 521 * cbseed + 259; 369 *cdn_vector++ = tmp_gain * (int16_t) cbseed; 370 } 371 } 372 break; 373 case I_F_Q: 374 cbseed = -44; // random codebook index 375 for (i = 0; i < 4; i++) { 376 tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO; 377 for (j = 0; j < 40; j++) 378 *cdn_vector++ = tmp_gain * 379 qcelp_rate_full_codebook[cbseed++ & 127]; 380 } 381 break; 382 case SILENCE: 383 memset(cdn_vector, 0, 160 * sizeof(float)); 384 break; 385 } 386} 387 388/** 389 * Apply generic gain control. 390 * 391 * @param v_out output vector 392 * @param v_in gain-controlled vector 393 * @param v_ref vector to control gain of 394 * 395 * TIA/EIA/IS-733 2.4.8.3, 2.4.8.6 396 */ 397static void apply_gain_ctrl(float *v_out, const float *v_ref, const float *v_in) 398{ 399 int i; 400 401 for (i = 0; i < 160; i += 40) { 402 float res = avpriv_scalarproduct_float_c(v_ref + i, v_ref + i, 40); 403 ff_scale_vector_to_given_sum_of_squares(v_out + i, v_in + i, res, 40); 404 } 405} 406 407/** 408 * Apply filter in pitch-subframe steps. 409 * 410 * @param memory buffer for the previous state of the filter 411 * - must be able to contain 303 elements 412 * - the 143 first elements are from the previous state 413 * - the next 160 are for output 414 * @param v_in input filter vector 415 * @param gain per-subframe gain array, each element is between 0.0 and 2.0 416 * @param lag per-subframe lag array, each element is 417 * - between 16 and 143 if its corresponding pfrac is 0, 418 * - between 16 and 139 otherwise 419 * @param pfrac per-subframe boolean array, 1 if the lag is fractional, 0 420 * otherwise 421 * 422 * @return filter output vector 423 */ 424static const float *do_pitchfilter(float memory[303], const float v_in[160], 425 const float gain[4], const uint8_t *lag, 426 const uint8_t pfrac[4]) 427{ 428 int i, j; 429 float *v_lag, *v_out; 430 const float *v_len; 431 432 v_out = memory + 143; // Output vector starts at memory[143]. 433 434 for (i = 0; i < 4; i++) { 435 if (gain[i]) { 436 v_lag = memory + 143 + 40 * i - lag[i]; 437 for (v_len = v_in + 40; v_in < v_len; v_in++) { 438 if (pfrac[i]) { // If it is a fractional lag... 439 for (j = 0, *v_out = 0.0; j < 4; j++) 440 *v_out += qcelp_hammsinc_table[j] * 441 (v_lag[j - 4] + v_lag[3 - j]); 442 } else 443 *v_out = *v_lag; 444 445 *v_out = *v_in + gain[i] * *v_out; 446 447 v_lag++; 448 v_out++; 449 } 450 } else { 451 memcpy(v_out, v_in, 40 * sizeof(float)); 452 v_in += 40; 453 v_out += 40; 454 } 455 } 456 457 memmove(memory, memory + 160, 143 * sizeof(float)); 458 return memory + 143; 459} 460 461/** 462 * Apply pitch synthesis filter and pitch prefilter to the scaled codebook vector. 463 * TIA/EIA/IS-733 2.4.5.2, 2.4.8.7.2 464 * 465 * @param q the context 466 * @param cdn_vector the scaled codebook vector 467 */ 468static void apply_pitch_filters(QCELPContext *q, float *cdn_vector) 469{ 470 int i; 471 const float *v_synthesis_filtered, *v_pre_filtered; 472 473 if (q->bitrate >= RATE_HALF || q->bitrate == SILENCE || 474 (q->bitrate == I_F_Q && (q->prev_bitrate >= RATE_HALF))) { 475 476 if (q->bitrate >= RATE_HALF) { 477 // Compute gain & lag for the whole frame. 478 for (i = 0; i < 4; i++) { 479 q->pitch_gain[i] = q->frame.plag[i] ? (q->frame.pgain[i] + 1) * 0.25 : 0.0; 480 481 q->pitch_lag[i] = q->frame.plag[i] + 16; 482 } 483 } else { 484 float max_pitch_gain; 485 486 if (q->bitrate == I_F_Q) { 487 if (q->erasure_count < 3) 488 max_pitch_gain = 0.9 - 0.3 * (q->erasure_count - 1); 489 else 490 max_pitch_gain = 0.0; 491 } else { 492 av_assert2(q->bitrate == SILENCE); 493 max_pitch_gain = 1.0; 494 } 495 for (i = 0; i < 4; i++) 496 q->pitch_gain[i] = FFMIN(q->pitch_gain[i], max_pitch_gain); 497 498 memset(q->frame.pfrac, 0, sizeof(q->frame.pfrac)); 499 } 500 501 // pitch synthesis filter 502 v_synthesis_filtered = do_pitchfilter(q->pitch_synthesis_filter_mem, 503 cdn_vector, q->pitch_gain, 504 q->pitch_lag, q->frame.pfrac); 505 506 // pitch prefilter update 507 for (i = 0; i < 4; i++) 508 q->pitch_gain[i] = 0.5 * FFMIN(q->pitch_gain[i], 1.0); 509 510 v_pre_filtered = do_pitchfilter(q->pitch_pre_filter_mem, 511 v_synthesis_filtered, 512 q->pitch_gain, q->pitch_lag, 513 q->frame.pfrac); 514 515 apply_gain_ctrl(cdn_vector, v_synthesis_filtered, v_pre_filtered); 516 } else { 517 memcpy(q->pitch_synthesis_filter_mem, 518 cdn_vector + 17, 143 * sizeof(float)); 519 memcpy(q->pitch_pre_filter_mem, cdn_vector + 17, 143 * sizeof(float)); 520 memset(q->pitch_gain, 0, sizeof(q->pitch_gain)); 521 memset(q->pitch_lag, 0, sizeof(q->pitch_lag)); 522 } 523} 524 525/** 526 * Reconstruct LPC coefficients from the line spectral pair frequencies 527 * and perform bandwidth expansion. 528 * 529 * @param lspf line spectral pair frequencies 530 * @param lpc linear predictive coding coefficients 531 * 532 * @note: bandwidth_expansion_coeff could be precalculated into a table 533 * but it seems to be slower on x86 534 * 535 * TIA/EIA/IS-733 2.4.3.3.5 536 */ 537static void lspf2lpc(const float *lspf, float *lpc) 538{ 539 double lsp[10]; 540 double bandwidth_expansion_coeff = QCELP_BANDWIDTH_EXPANSION_COEFF; 541 int i; 542 543 for (i = 0; i < 10; i++) 544 lsp[i] = cos(M_PI * lspf[i]); 545 546 ff_acelp_lspd2lpc(lsp, lpc, 5); 547 548 for (i = 0; i < 10; i++) { 549 lpc[i] *= bandwidth_expansion_coeff; 550 bandwidth_expansion_coeff *= QCELP_BANDWIDTH_EXPANSION_COEFF; 551 } 552} 553 554/** 555 * Interpolate LSP frequencies and compute LPC coefficients 556 * for a given bitrate & pitch subframe. 557 * 558 * TIA/EIA/IS-733 2.4.3.3.4, 2.4.8.7.2 559 * 560 * @param q the context 561 * @param curr_lspf LSP frequencies vector of the current frame 562 * @param lpc float vector for the resulting LPC 563 * @param subframe_num frame number in decoded stream 564 */ 565static void interpolate_lpc(QCELPContext *q, const float *curr_lspf, 566 float *lpc, const int subframe_num) 567{ 568 float interpolated_lspf[10]; 569 float weight; 570 571 if (q->bitrate >= RATE_QUARTER) 572 weight = 0.25 * (subframe_num + 1); 573 else if (q->bitrate == RATE_OCTAVE && !subframe_num) 574 weight = 0.625; 575 else 576 weight = 1.0; 577 578 if (weight != 1.0) { 579 ff_weighted_vector_sumf(interpolated_lspf, curr_lspf, q->prev_lspf, 580 weight, 1.0 - weight, 10); 581 lspf2lpc(interpolated_lspf, lpc); 582 } else if (q->bitrate >= RATE_QUARTER || 583 (q->bitrate == I_F_Q && !subframe_num)) 584 lspf2lpc(curr_lspf, lpc); 585 else if (q->bitrate == SILENCE && !subframe_num) 586 lspf2lpc(q->prev_lspf, lpc); 587} 588 589static qcelp_packet_rate buf_size2bitrate(const int buf_size) 590{ 591 switch (buf_size) { 592 case 35: return RATE_FULL; 593 case 17: return RATE_HALF; 594 case 8: return RATE_QUARTER; 595 case 4: return RATE_OCTAVE; 596 case 1: return SILENCE; 597 } 598 599 return I_F_Q; 600} 601 602/** 603 * Determine the bitrate from the frame size and/or the first byte of the frame. 604 * 605 * @param avctx the AV codec context 606 * @param buf_size length of the buffer 607 * @param buf the buffer 608 * 609 * @return the bitrate on success, 610 * I_F_Q if the bitrate cannot be satisfactorily determined 611 * 612 * TIA/EIA/IS-733 2.4.8.7.1 613 */ 614static qcelp_packet_rate determine_bitrate(AVCodecContext *avctx, 615 const int buf_size, 616 const uint8_t **buf) 617{ 618 qcelp_packet_rate bitrate; 619 620 if ((bitrate = buf_size2bitrate(buf_size)) >= 0) { 621 if (bitrate > **buf) { 622 QCELPContext *q = avctx->priv_data; 623 if (!q->warned_buf_mismatch_bitrate) { 624 av_log(avctx, AV_LOG_WARNING, 625 "Claimed bitrate and buffer size mismatch.\n"); 626 q->warned_buf_mismatch_bitrate = 1; 627 } 628 bitrate = **buf; 629 } else if (bitrate < **buf) { 630 av_log(avctx, AV_LOG_ERROR, 631 "Buffer is too small for the claimed bitrate.\n"); 632 return I_F_Q; 633 } 634 (*buf)++; 635 } else if ((bitrate = buf_size2bitrate(buf_size + 1)) >= 0) { 636 av_log(avctx, AV_LOG_WARNING, 637 "Bitrate byte missing, guessing bitrate from packet size.\n"); 638 } else 639 return I_F_Q; 640 641 if (bitrate == SILENCE) { 642 // FIXME: Remove this warning when tested with samples. 643 avpriv_request_sample(avctx, "Blank frame handling"); 644 } 645 return bitrate; 646} 647 648static void warn_insufficient_frame_quality(AVCodecContext *avctx, 649 const char *message) 650{ 651 av_log(avctx, AV_LOG_WARNING, "Frame #%d, IFQ: %s\n", 652 avctx->frame_number, message); 653} 654 655static void postfilter(QCELPContext *q, float *samples, float *lpc) 656{ 657 static const float pow_0_775[10] = { 658 0.775000, 0.600625, 0.465484, 0.360750, 0.279582, 659 0.216676, 0.167924, 0.130141, 0.100859, 0.078166 660 }, pow_0_625[10] = { 661 0.625000, 0.390625, 0.244141, 0.152588, 0.095367, 662 0.059605, 0.037253, 0.023283, 0.014552, 0.009095 663 }; 664 float lpc_s[10], lpc_p[10], pole_out[170], zero_out[160]; 665 int n; 666 667 for (n = 0; n < 10; n++) { 668 lpc_s[n] = lpc[n] * pow_0_625[n]; 669 lpc_p[n] = lpc[n] * pow_0_775[n]; 670 } 671 672 ff_celp_lp_zero_synthesis_filterf(zero_out, lpc_s, 673 q->formant_mem + 10, 160, 10); 674 memcpy(pole_out, q->postfilter_synth_mem, sizeof(float) * 10); 675 ff_celp_lp_synthesis_filterf(pole_out + 10, lpc_p, zero_out, 160, 10); 676 memcpy(q->postfilter_synth_mem, pole_out + 160, sizeof(float) * 10); 677 678 ff_tilt_compensation(&q->postfilter_tilt_mem, 0.3, pole_out + 10, 160); 679 680 ff_adaptive_gain_control(samples, pole_out + 10, 681 avpriv_scalarproduct_float_c(q->formant_mem + 10, 682 q->formant_mem + 10, 683 160), 684 160, 0.9375, &q->postfilter_agc_mem); 685} 686 687static int qcelp_decode_frame(AVCodecContext *avctx, AVFrame *frame, 688 int *got_frame_ptr, AVPacket *avpkt) 689{ 690 const uint8_t *buf = avpkt->data; 691 int buf_size = avpkt->size; 692 QCELPContext *q = avctx->priv_data; 693 float *outbuffer; 694 int i, ret; 695 float quantized_lspf[10], lpc[10]; 696 float gain[16]; 697 float *formant_mem; 698 699 /* get output buffer */ 700 frame->nb_samples = 160; 701 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 702 return ret; 703 outbuffer = (float *)frame->data[0]; 704 705 if ((q->bitrate = determine_bitrate(avctx, buf_size, &buf)) == I_F_Q) { 706 warn_insufficient_frame_quality(avctx, "Bitrate cannot be determined."); 707 goto erasure; 708 } 709 710 if (q->bitrate == RATE_OCTAVE && 711 (q->first16bits = AV_RB16(buf)) == 0xFFFF) { 712 warn_insufficient_frame_quality(avctx, "Bitrate is 1/8 and first 16 bits are on."); 713 goto erasure; 714 } 715 716 if (q->bitrate > SILENCE) { 717 const QCELPBitmap *bitmaps = qcelp_unpacking_bitmaps_per_rate[q->bitrate]; 718 const QCELPBitmap *bitmaps_end = qcelp_unpacking_bitmaps_per_rate[q->bitrate] + 719 qcelp_unpacking_bitmaps_lengths[q->bitrate]; 720 uint8_t *unpacked_data = (uint8_t *)&q->frame; 721 722 if ((ret = init_get_bits8(&q->gb, buf, buf_size)) < 0) 723 return ret; 724 725 memset(&q->frame, 0, sizeof(QCELPFrame)); 726 727 for (; bitmaps < bitmaps_end; bitmaps++) 728 unpacked_data[bitmaps->index] |= get_bits(&q->gb, bitmaps->bitlen) << bitmaps->bitpos; 729 730 // Check for erasures/blanks on rates 1, 1/4 and 1/8. 731 if (q->frame.reserved) { 732 warn_insufficient_frame_quality(avctx, "Wrong data in reserved frame area."); 733 goto erasure; 734 } 735 if (q->bitrate == RATE_QUARTER && 736 codebook_sanity_check_for_rate_quarter(q->frame.cbgain)) { 737 warn_insufficient_frame_quality(avctx, "Codebook gain sanity check failed."); 738 goto erasure; 739 } 740 741 if (q->bitrate >= RATE_HALF) { 742 for (i = 0; i < 4; i++) { 743 if (q->frame.pfrac[i] && q->frame.plag[i] >= 124) { 744 warn_insufficient_frame_quality(avctx, "Cannot initialize pitch filter."); 745 goto erasure; 746 } 747 } 748 } 749 } 750 751 decode_gain_and_index(q, gain); 752 compute_svector(q, gain, outbuffer); 753 754 if (decode_lspf(q, quantized_lspf) < 0) { 755 warn_insufficient_frame_quality(avctx, "Badly received packets in frame."); 756 goto erasure; 757 } 758 759 apply_pitch_filters(q, outbuffer); 760 761 if (q->bitrate == I_F_Q) { 762erasure: 763 q->bitrate = I_F_Q; 764 q->erasure_count++; 765 decode_gain_and_index(q, gain); 766 compute_svector(q, gain, outbuffer); 767 decode_lspf(q, quantized_lspf); 768 apply_pitch_filters(q, outbuffer); 769 } else 770 q->erasure_count = 0; 771 772 formant_mem = q->formant_mem + 10; 773 for (i = 0; i < 4; i++) { 774 interpolate_lpc(q, quantized_lspf, lpc, i); 775 ff_celp_lp_synthesis_filterf(formant_mem, lpc, 776 outbuffer + i * 40, 40, 10); 777 formant_mem += 40; 778 } 779 780 // postfilter, as per TIA/EIA/IS-733 2.4.8.6 781 postfilter(q, outbuffer, lpc); 782 783 memcpy(q->formant_mem, q->formant_mem + 160, 10 * sizeof(float)); 784 785 memcpy(q->prev_lspf, quantized_lspf, sizeof(q->prev_lspf)); 786 q->prev_bitrate = q->bitrate; 787 788 *got_frame_ptr = 1; 789 790 return buf_size; 791} 792 793const FFCodec ff_qcelp_decoder = { 794 .p.name = "qcelp", 795 .p.long_name = NULL_IF_CONFIG_SMALL("QCELP / PureVoice"), 796 .p.type = AVMEDIA_TYPE_AUDIO, 797 .p.id = AV_CODEC_ID_QCELP, 798 .init = qcelp_decode_init, 799 FF_CODEC_DECODE_CB(qcelp_decode_frame), 800 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, 801 .priv_data_size = sizeof(QCELPContext), 802 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 803}; 804