1/* 2 * G.729, G729 Annex D decoders 3 * Copyright (c) 2008 Vladimir Voroshilov 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#include <inttypes.h> 23#include <string.h> 24 25#include "avcodec.h" 26#include "libavutil/avutil.h" 27#include "get_bits.h" 28#include "audiodsp.h" 29#include "internal.h" 30 31 32#include "g729.h" 33#include "lsp.h" 34#include "celp_math.h" 35#include "celp_filters.h" 36#include "acelp_filters.h" 37#include "acelp_pitch_delay.h" 38#include "acelp_vectors.h" 39#include "g729data.h" 40#include "g729postfilter.h" 41 42/** 43 * minimum quantized LSF value (3.2.4) 44 * 0.005 in Q13 45 */ 46#define LSFQ_MIN 40 47 48/** 49 * maximum quantized LSF value (3.2.4) 50 * 3.135 in Q13 51 */ 52#define LSFQ_MAX 25681 53 54/** 55 * minimum LSF distance (3.2.4) 56 * 0.0391 in Q13 57 */ 58#define LSFQ_DIFF_MIN 321 59 60/// interpolation filter length 61#define INTERPOL_LEN 11 62 63/** 64 * minimum gain pitch value (3.8, Equation 47) 65 * 0.2 in (1.14) 66 */ 67#define SHARP_MIN 3277 68 69/** 70 * maximum gain pitch value (3.8, Equation 47) 71 * (EE) This does not comply with the specification. 72 * Specification says about 0.8, which should be 73 * 13107 in (1.14), but reference C code uses 74 * 13017 (equals to 0.7945) instead of it. 75 */ 76#define SHARP_MAX 13017 77 78/** 79 * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7.13) 80 */ 81#define MR_ENERGY 1018156 82 83#define DECISION_NOISE 0 84#define DECISION_INTERMEDIATE 1 85#define DECISION_VOICE 2 86 87typedef enum { 88 FORMAT_G729_8K = 0, 89 FORMAT_G729D_6K4, 90 FORMAT_COUNT, 91} G729Formats; 92 93typedef struct { 94 uint8_t ac_index_bits[2]; ///< adaptive codebook index for second subframe (size in bits) 95 uint8_t parity_bit; ///< parity bit for pitch delay 96 uint8_t gc_1st_index_bits; ///< gain codebook (first stage) index (size in bits) 97 uint8_t gc_2nd_index_bits; ///< gain codebook (second stage) index (size in bits) 98 uint8_t fc_signs_bits; ///< number of pulses in fixed-codebook vector 99 uint8_t fc_indexes_bits; ///< size (in bits) of fixed-codebook index entry 100} G729FormatDescription; 101 102typedef struct { 103 AudioDSPContext adsp; 104 105 /// past excitation signal buffer 106 int16_t exc_base[2*SUBFRAME_SIZE+PITCH_DELAY_MAX+INTERPOL_LEN]; 107 108 int16_t* exc; ///< start of past excitation data in buffer 109 int pitch_delay_int_prev; ///< integer part of previous subframe's pitch delay (4.1.3) 110 111 /// (2.13) LSP quantizer outputs 112 int16_t past_quantizer_output_buf[MA_NP + 1][10]; 113 int16_t* past_quantizer_outputs[MA_NP + 1]; 114 115 int16_t lsfq[10]; ///< (2.13) quantized LSF coefficients from previous frame 116 int16_t lsp_buf[2][10]; ///< (0.15) LSP coefficients (previous and current frames) (3.2.5) 117 int16_t *lsp[2]; ///< pointers to lsp_buf 118 119 int16_t quant_energy[4]; ///< (5.10) past quantized energy 120 121 /// previous speech data for LP synthesis filter 122 int16_t syn_filter_data[10]; 123 124 125 /// residual signal buffer (used in long-term postfilter) 126 int16_t residual[SUBFRAME_SIZE + RES_PREV_DATA_SIZE]; 127 128 /// previous speech data for residual calculation filter 129 int16_t res_filter_data[SUBFRAME_SIZE+10]; 130 131 /// previous speech data for short-term postfilter 132 int16_t pos_filter_data[SUBFRAME_SIZE+10]; 133 134 /// (1.14) pitch gain of current and five previous subframes 135 int16_t past_gain_pitch[6]; 136 137 /// (14.1) gain code from current and previous subframe 138 int16_t past_gain_code[2]; 139 140 /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D 141 int16_t voice_decision; 142 143 int16_t onset; ///< detected onset level (0-2) 144 int16_t was_periodic; ///< whether previous frame was declared as periodic or not (4.4) 145 int16_t ht_prev_data; ///< previous data for 4.2.3, equation 86 146 int gain_coeff; ///< (1.14) gain coefficient (4.2.4) 147 uint16_t rand_value; ///< random number generator value (4.4.4) 148 int ma_predictor_prev; ///< switched MA predictor of LSP quantizer from last good frame 149 150 /// (14.14) high-pass filter data (past input) 151 int hpf_f[2]; 152 153 /// high-pass filter data (past output) 154 int16_t hpf_z[2]; 155} G729Context; 156 157static const G729FormatDescription format_g729_8k = { 158 .ac_index_bits = {8,5}, 159 .parity_bit = 1, 160 .gc_1st_index_bits = GC_1ST_IDX_BITS_8K, 161 .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K, 162 .fc_signs_bits = 4, 163 .fc_indexes_bits = 13, 164}; 165 166static const G729FormatDescription format_g729d_6k4 = { 167 .ac_index_bits = {8,4}, 168 .parity_bit = 0, 169 .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4, 170 .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4, 171 .fc_signs_bits = 2, 172 .fc_indexes_bits = 9, 173}; 174 175/** 176 * @brief pseudo random number generator 177 */ 178static inline uint16_t g729_prng(uint16_t value) 179{ 180 return 31821 * value + 13849; 181} 182 183/** 184 * Get parity bit of bit 2..7 185 */ 186static inline int get_parity(uint8_t value) 187{ 188 return (0x6996966996696996ULL >> (value >> 2)) & 1; 189} 190 191/** 192 * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4). 193 * @param[out] lsfq (2.13) quantized LSF coefficients 194 * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames 195 * @param ma_predictor switched MA predictor of LSP quantizer 196 * @param vq_1st first stage vector of quantizer 197 * @param vq_2nd_low second stage lower vector of LSP quantizer 198 * @param vq_2nd_high second stage higher vector of LSP quantizer 199 */ 200static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1], 201 int16_t ma_predictor, 202 int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high) 203{ 204 int i,j; 205 static const uint8_t min_distance[2]={10, 5}; //(2.13) 206 int16_t* quantizer_output = past_quantizer_outputs[MA_NP]; 207 208 for (i = 0; i < 5; i++) { 209 quantizer_output[i] = cb_lsp_1st[vq_1st][i ] + cb_lsp_2nd[vq_2nd_low ][i ]; 210 quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5]; 211 } 212 213 for (j = 0; j < 2; j++) { 214 for (i = 1; i < 10; i++) { 215 int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1; 216 if (diff > 0) { 217 quantizer_output[i - 1] -= diff; 218 quantizer_output[i ] += diff; 219 } 220 } 221 } 222 223 for (i = 0; i < 10; i++) { 224 int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i]; 225 for (j = 0; j < MA_NP; j++) 226 sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i]; 227 228 lsfq[i] = sum >> 15; 229 } 230 231 ff_acelp_reorder_lsf(lsfq, LSFQ_DIFF_MIN, LSFQ_MIN, LSFQ_MAX, 10); 232} 233 234/** 235 * Restores past LSP quantizer output using LSF from previous frame 236 * @param[in,out] lsfq (2.13) quantized LSF coefficients 237 * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames 238 * @param ma_predictor_prev MA predictor from previous frame 239 * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame 240 */ 241static void lsf_restore_from_previous(int16_t* lsfq, 242 int16_t* past_quantizer_outputs[MA_NP + 1], 243 int ma_predictor_prev) 244{ 245 int16_t* quantizer_output = past_quantizer_outputs[MA_NP]; 246 int i,k; 247 248 for (i = 0; i < 10; i++) { 249 int tmp = lsfq[i] << 15; 250 251 for (k = 0; k < MA_NP; k++) 252 tmp -= past_quantizer_outputs[k][i] * cb_ma_predictor[ma_predictor_prev][k][i]; 253 254 quantizer_output[i] = ((tmp >> 15) * cb_ma_predictor_sum_inv[ma_predictor_prev][i]) >> 12; 255 } 256} 257 258/** 259 * Constructs new excitation signal and applies phase filter to it 260 * @param[out] out constructed speech signal 261 * @param in original excitation signal 262 * @param fc_cur (2.13) original fixed-codebook vector 263 * @param gain_code (14.1) gain code 264 * @param subframe_size length of the subframe 265 */ 266static void g729d_get_new_exc( 267 int16_t* out, 268 const int16_t* in, 269 const int16_t* fc_cur, 270 int dstate, 271 int gain_code, 272 int subframe_size) 273{ 274 int i; 275 int16_t fc_new[SUBFRAME_SIZE]; 276 277 ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size); 278 279 for(i=0; i<subframe_size; i++) 280 { 281 out[i] = in[i]; 282 out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14; 283 out[i] += (gain_code * fc_new[i] + 0x2000) >> 14; 284 } 285} 286 287/** 288 * Makes decision about onset in current subframe 289 * @param past_onset decision result of previous subframe 290 * @param past_gain_code gain code of current and previous subframe 291 * 292 * @return onset decision result for current subframe 293 */ 294static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code) 295{ 296 if((past_gain_code[0] >> 1) > past_gain_code[1]) 297 return 2; 298 else 299 return FFMAX(past_onset-1, 0); 300} 301 302/** 303 * Makes decision about voice presence in current subframe 304 * @param onset onset level 305 * @param prev_voice_decision voice decision result from previous subframe 306 * @param past_gain_pitch pitch gain of current and previous subframes 307 * 308 * @return voice decision result for current subframe 309 */ 310static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch) 311{ 312 int i, low_gain_pitch_cnt, voice_decision; 313 314 if(past_gain_pitch[0] >= 14745) // 0.9 315 voice_decision = DECISION_VOICE; 316 else if (past_gain_pitch[0] <= 9830) // 0.6 317 voice_decision = DECISION_NOISE; 318 else 319 voice_decision = DECISION_INTERMEDIATE; 320 321 for(i=0, low_gain_pitch_cnt=0; i<6; i++) 322 if(past_gain_pitch[i] < 9830) 323 low_gain_pitch_cnt++; 324 325 if(low_gain_pitch_cnt > 2 && !onset) 326 voice_decision = DECISION_NOISE; 327 328 if(!onset && voice_decision > prev_voice_decision + 1) 329 voice_decision--; 330 331 if(onset && voice_decision < DECISION_VOICE) 332 voice_decision++; 333 334 return voice_decision; 335} 336 337static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order) 338{ 339 int res = 0; 340 341 while (order--) 342 res += *v1++ * *v2++; 343 344 return res; 345} 346 347static av_cold int decoder_init(AVCodecContext * avctx) 348{ 349 G729Context* ctx = avctx->priv_data; 350 int i,k; 351 352 if (avctx->channels != 1) { 353 av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels); 354 return AVERROR(EINVAL); 355 } 356 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 357 358 /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */ 359 avctx->frame_size = SUBFRAME_SIZE << 1; 360 361 ctx->gain_coeff = 16384; // 1.0 in (1.14) 362 363 for (k = 0; k < MA_NP + 1; k++) { 364 ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k]; 365 for (i = 1; i < 11; i++) 366 ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3; 367 } 368 369 ctx->lsp[0] = ctx->lsp_buf[0]; 370 ctx->lsp[1] = ctx->lsp_buf[1]; 371 memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t)); 372 373 ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN]; 374 375 ctx->pitch_delay_int_prev = PITCH_DELAY_MIN; 376 377 /* random seed initialization */ 378 ctx->rand_value = 21845; 379 380 /* quantized prediction error */ 381 for(i=0; i<4; i++) 382 ctx->quant_energy[i] = -14336; // -14 in (5.10) 383 384 ff_audiodsp_init(&ctx->adsp); 385 ctx->adsp.scalarproduct_int16 = scalarproduct_int16_c; 386 387 return 0; 388} 389 390static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, 391 AVPacket *avpkt) 392{ 393 const uint8_t *buf = avpkt->data; 394 int buf_size = avpkt->size; 395 int16_t *out_frame; 396 GetBitContext gb; 397 const G729FormatDescription *format; 398 int frame_erasure = 0; ///< frame erasure detected during decoding 399 int bad_pitch = 0; ///< parity check failed 400 int i; 401 int16_t *tmp; 402 G729Formats packet_type; 403 G729Context *ctx = avctx->priv_data; 404 int16_t lp[2][11]; // (3.12) 405 uint8_t ma_predictor; ///< switched MA predictor of LSP quantizer 406 uint8_t quantizer_1st; ///< first stage vector of quantizer 407 uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits) 408 uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits) 409 410 int pitch_delay_int[2]; // pitch delay, integer part 411 int pitch_delay_3x; // pitch delay, multiplied by 3 412 int16_t fc[SUBFRAME_SIZE]; // fixed-codebook vector 413 int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector 414 int j, ret; 415 int gain_before, gain_after; 416 int is_periodic = 0; // whether one of the subframes is declared as periodic or not 417 AVFrame *frame = data; 418 419 frame->nb_samples = SUBFRAME_SIZE<<1; 420 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 421 return ret; 422 out_frame = (int16_t*) frame->data[0]; 423 424 if (buf_size == 10) { 425 packet_type = FORMAT_G729_8K; 426 format = &format_g729_8k; 427 //Reset voice decision 428 ctx->onset = 0; 429 ctx->voice_decision = DECISION_VOICE; 430 av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s"); 431 } else if (buf_size == 8) { 432 packet_type = FORMAT_G729D_6K4; 433 format = &format_g729d_6k4; 434 av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s"); 435 } else { 436 av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size); 437 return AVERROR_INVALIDDATA; 438 } 439 440 for (i=0; i < buf_size; i++) 441 frame_erasure |= buf[i]; 442 frame_erasure = !frame_erasure; 443 444 init_get_bits(&gb, buf, 8*buf_size); 445 446 ma_predictor = get_bits(&gb, 1); 447 quantizer_1st = get_bits(&gb, VQ_1ST_BITS); 448 quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS); 449 quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS); 450 451 if(frame_erasure) 452 lsf_restore_from_previous(ctx->lsfq, ctx->past_quantizer_outputs, 453 ctx->ma_predictor_prev); 454 else { 455 lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs, 456 ma_predictor, 457 quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi); 458 ctx->ma_predictor_prev = ma_predictor; 459 } 460 461 tmp = ctx->past_quantizer_outputs[MA_NP]; 462 memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs, 463 MA_NP * sizeof(int16_t*)); 464 ctx->past_quantizer_outputs[0] = tmp; 465 466 ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10); 467 468 ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10); 469 470 FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]); 471 472 for (i = 0; i < 2; i++) { 473 int gain_corr_factor; 474 475 uint8_t ac_index; ///< adaptive codebook index 476 uint8_t pulses_signs; ///< fixed-codebook vector pulse signs 477 int fc_indexes; ///< fixed-codebook indexes 478 uint8_t gc_1st_index; ///< gain codebook (first stage) index 479 uint8_t gc_2nd_index; ///< gain codebook (second stage) index 480 481 ac_index = get_bits(&gb, format->ac_index_bits[i]); 482 if(!i && format->parity_bit) 483 bad_pitch = get_parity(ac_index) == get_bits1(&gb); 484 fc_indexes = get_bits(&gb, format->fc_indexes_bits); 485 pulses_signs = get_bits(&gb, format->fc_signs_bits); 486 gc_1st_index = get_bits(&gb, format->gc_1st_index_bits); 487 gc_2nd_index = get_bits(&gb, format->gc_2nd_index_bits); 488 489 if (frame_erasure) 490 pitch_delay_3x = 3 * ctx->pitch_delay_int_prev; 491 else if(!i) { 492 if (bad_pitch) 493 pitch_delay_3x = 3 * ctx->pitch_delay_int_prev; 494 else 495 pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index); 496 } else { 497 int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5, 498 PITCH_DELAY_MIN, PITCH_DELAY_MAX - 9); 499 500 if(packet_type == FORMAT_G729D_6K4) 501 pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min); 502 else 503 pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min); 504 } 505 506 /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */ 507 pitch_delay_int[i] = (pitch_delay_3x + 1) / 3; 508 if (pitch_delay_int[i] > PITCH_DELAY_MAX) { 509 av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]); 510 pitch_delay_int[i] = PITCH_DELAY_MAX; 511 } 512 513 if (frame_erasure) { 514 ctx->rand_value = g729_prng(ctx->rand_value); 515 fc_indexes = ctx->rand_value & ((1 << format->fc_indexes_bits) - 1); 516 517 ctx->rand_value = g729_prng(ctx->rand_value); 518 pulses_signs = ctx->rand_value; 519 } 520 521 522 memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE); 523 switch (packet_type) { 524 case FORMAT_G729_8K: 525 ff_acelp_fc_pulse_per_track(fc, ff_fc_4pulses_8bits_tracks_13, 526 ff_fc_4pulses_8bits_track_4, 527 fc_indexes, pulses_signs, 3, 3); 528 break; 529 case FORMAT_G729D_6K4: 530 ff_acelp_fc_pulse_per_track(fc, ff_fc_2pulses_9bits_track1_gray, 531 ff_fc_2pulses_9bits_track2_gray, 532 fc_indexes, pulses_signs, 1, 4); 533 break; 534 } 535 536 /* 537 This filter enhances harmonic components of the fixed-codebook vector to 538 improve the quality of the reconstructed speech. 539 540 / fc_v[i], i < pitch_delay 541 fc_v[i] = < 542 \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay 543 */ 544 ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i], 545 fc + pitch_delay_int[i], 546 fc, 1 << 14, 547 av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX), 548 0, 14, 549 SUBFRAME_SIZE - pitch_delay_int[i]); 550 551 memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t)); 552 ctx->past_gain_code[1] = ctx->past_gain_code[0]; 553 554 if (frame_erasure) { 555 ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15) 556 ctx->past_gain_code[0] = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11) 557 558 gain_corr_factor = 0; 559 } else { 560 if (packet_type == FORMAT_G729D_6K4) { 561 ctx->past_gain_pitch[0] = cb_gain_1st_6k4[gc_1st_index][0] + 562 cb_gain_2nd_6k4[gc_2nd_index][0]; 563 gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] + 564 cb_gain_2nd_6k4[gc_2nd_index][1]; 565 566 /* Without check below overflow can occur in ff_acelp_update_past_gain. 567 It is not issue for G.729, because gain_corr_factor in it's case is always 568 greater than 1024, while in G.729D it can be even zero. */ 569 gain_corr_factor = FFMAX(gain_corr_factor, 1024); 570#ifndef G729_BITEXACT 571 gain_corr_factor >>= 1; 572#endif 573 } else { 574 ctx->past_gain_pitch[0] = cb_gain_1st_8k[gc_1st_index][0] + 575 cb_gain_2nd_8k[gc_2nd_index][0]; 576 gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] + 577 cb_gain_2nd_8k[gc_2nd_index][1]; 578 } 579 580 /* Decode the fixed-codebook gain. */ 581 ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&ctx->adsp, gain_corr_factor, 582 fc, MR_ENERGY, 583 ctx->quant_energy, 584 ma_prediction_coeff, 585 SUBFRAME_SIZE, 4); 586#ifdef G729_BITEXACT 587 /* 588 This correction required to get bit-exact result with 589 reference code, because gain_corr_factor in G.729D is 590 two times larger than in original G.729. 591 592 If bit-exact result is not issue then gain_corr_factor 593 can be simpler divided by 2 before call to g729_get_gain_code 594 instead of using correction below. 595 */ 596 if (packet_type == FORMAT_G729D_6K4) { 597 gain_corr_factor >>= 1; 598 ctx->past_gain_code[0] >>= 1; 599 } 600#endif 601 } 602 ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure); 603 604 /* Routine requires rounding to lowest. */ 605 ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE, 606 ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3, 607 ff_acelp_interp_filter, 6, 608 (pitch_delay_3x % 3) << 1, 609 10, SUBFRAME_SIZE); 610 611 ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE, 612 ctx->exc + i * SUBFRAME_SIZE, fc, 613 (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0], 614 ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0], 615 1 << 13, 14, SUBFRAME_SIZE); 616 617 memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t)); 618 619 if (ff_celp_lp_synthesis_filter( 620 synth+10, 621 &lp[i][1], 622 ctx->exc + i * SUBFRAME_SIZE, 623 SUBFRAME_SIZE, 624 10, 625 1, 626 0, 627 0x800)) 628 /* Overflow occurred, downscale excitation signal... */ 629 for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++) 630 ctx->exc_base[j] >>= 2; 631 632 /* ... and make synthesis again. */ 633 if (packet_type == FORMAT_G729D_6K4) { 634 int16_t exc_new[SUBFRAME_SIZE]; 635 636 ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code); 637 ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch); 638 639 g729d_get_new_exc(exc_new, ctx->exc + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE); 640 641 ff_celp_lp_synthesis_filter( 642 synth+10, 643 &lp[i][1], 644 exc_new, 645 SUBFRAME_SIZE, 646 10, 647 0, 648 0, 649 0x800); 650 } else { 651 ff_celp_lp_synthesis_filter( 652 synth+10, 653 &lp[i][1], 654 ctx->exc + i * SUBFRAME_SIZE, 655 SUBFRAME_SIZE, 656 10, 657 0, 658 0, 659 0x800); 660 } 661 /* Save data (without postfilter) for use in next subframe. */ 662 memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t)); 663 664 /* Calculate gain of unfiltered signal for use in AGC. */ 665 gain_before = 0; 666 for (j = 0; j < SUBFRAME_SIZE; j++) 667 gain_before += FFABS(synth[j+10]); 668 669 /* Call postfilter and also update voicing decision for use in next frame. */ 670 ff_g729_postfilter( 671 &ctx->adsp, 672 &ctx->ht_prev_data, 673 &is_periodic, 674 &lp[i][0], 675 pitch_delay_int[0], 676 ctx->residual, 677 ctx->res_filter_data, 678 ctx->pos_filter_data, 679 synth+10, 680 SUBFRAME_SIZE); 681 682 /* Calculate gain of filtered signal for use in AGC. */ 683 gain_after = 0; 684 for(j=0; j<SUBFRAME_SIZE; j++) 685 gain_after += FFABS(synth[j+10]); 686 687 ctx->gain_coeff = ff_g729_adaptive_gain_control( 688 gain_before, 689 gain_after, 690 synth+10, 691 SUBFRAME_SIZE, 692 ctx->gain_coeff); 693 694 if (frame_erasure) 695 ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX); 696 else 697 ctx->pitch_delay_int_prev = pitch_delay_int[i]; 698 699 memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t)); 700 ff_acelp_high_pass_filter( 701 out_frame + i*SUBFRAME_SIZE, 702 ctx->hpf_f, 703 synth+10, 704 SUBFRAME_SIZE); 705 memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t)); 706 } 707 708 ctx->was_periodic = is_periodic; 709 710 /* Save signal for use in next frame. */ 711 memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t)); 712 713 *got_frame_ptr = 1; 714 return buf_size; 715} 716 717AVCodec ff_g729_decoder = { 718 .name = "g729", 719 .long_name = NULL_IF_CONFIG_SMALL("G.729"), 720 .type = AVMEDIA_TYPE_AUDIO, 721 .id = AV_CODEC_ID_G729, 722 .priv_data_size = sizeof(G729Context), 723 .init = decoder_init, 724 .decode = decode_frame, 725 .capabilities = CODEC_CAP_DR1, 726}; 727