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 "codec_internal.h" 30#include "internal.h" 31 32 33#include "g729.h" 34#include "lsp.h" 35#include "celp_math.h" 36#include "celp_filters.h" 37#include "acelp_filters.h" 38#include "acelp_pitch_delay.h" 39#include "acelp_vectors.h" 40#include "g729data.h" 41#include "g729postfilter.h" 42 43/** 44 * minimum quantized LSF value (3.2.4) 45 * 0.005 in Q13 46 */ 47#define LSFQ_MIN 40 48 49/** 50 * maximum quantized LSF value (3.2.4) 51 * 3.135 in Q13 52 */ 53#define LSFQ_MAX 25681 54 55/** 56 * minimum LSF distance (3.2.4) 57 * 0.0391 in Q13 58 */ 59#define LSFQ_DIFF_MIN 321 60 61/// interpolation filter length 62#define INTERPOL_LEN 11 63 64/** 65 * minimum gain pitch value (3.8, Equation 47) 66 * 0.2 in (1.14) 67 */ 68#define SHARP_MIN 3277 69 70/** 71 * maximum gain pitch value (3.8, Equation 47) 72 * (EE) This does not comply with the specification. 73 * Specification says about 0.8, which should be 74 * 13107 in (1.14), but reference C code uses 75 * 13017 (equals to 0.7945) instead of it. 76 */ 77#define SHARP_MAX 13017 78 79/** 80 * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7.13) 81 */ 82#define MR_ENERGY 1018156 83 84#define DECISION_NOISE 0 85#define DECISION_INTERMEDIATE 1 86#define DECISION_VOICE 2 87 88typedef enum { 89 FORMAT_G729_8K = 0, 90 FORMAT_G729D_6K4, 91 FORMAT_COUNT, 92} G729Formats; 93 94typedef struct { 95 uint8_t ac_index_bits[2]; ///< adaptive codebook index for second subframe (size in bits) 96 uint8_t parity_bit; ///< parity bit for pitch delay 97 uint8_t gc_1st_index_bits; ///< gain codebook (first stage) index (size in bits) 98 uint8_t gc_2nd_index_bits; ///< gain codebook (second stage) index (size in bits) 99 uint8_t fc_signs_bits; ///< number of pulses in fixed-codebook vector 100 uint8_t fc_indexes_bits; ///< size (in bits) of fixed-codebook index entry 101 uint8_t block_size; 102} G729FormatDescription; 103 104typedef struct { 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} G729ChannelContext; 156 157typedef struct { 158 AudioDSPContext adsp; 159 160 G729ChannelContext *channel_context; 161} G729Context; 162 163static const G729FormatDescription format_g729_8k = { 164 .ac_index_bits = {8,5}, 165 .parity_bit = 1, 166 .gc_1st_index_bits = GC_1ST_IDX_BITS_8K, 167 .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K, 168 .fc_signs_bits = 4, 169 .fc_indexes_bits = 13, 170 .block_size = G729_8K_BLOCK_SIZE, 171}; 172 173static const G729FormatDescription format_g729d_6k4 = { 174 .ac_index_bits = {8,4}, 175 .parity_bit = 0, 176 .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4, 177 .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4, 178 .fc_signs_bits = 2, 179 .fc_indexes_bits = 9, 180 .block_size = G729D_6K4_BLOCK_SIZE, 181}; 182 183/** 184 * @brief pseudo random number generator 185 */ 186static inline uint16_t g729_prng(uint16_t value) 187{ 188 return 31821 * value + 13849; 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 out[i] = in[i]; 281 out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14; 282 out[i] += (gain_code * fc_new[i] + 0x2000) >> 14; 283 } 284} 285 286/** 287 * Makes decision about onset in current subframe 288 * @param past_onset decision result of previous subframe 289 * @param past_gain_code gain code of current and previous subframe 290 * 291 * @return onset decision result for current subframe 292 */ 293static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code) 294{ 295 if ((past_gain_code[0] >> 1) > past_gain_code[1]) 296 return 2; 297 298 return FFMAX(past_onset-1, 0); 299} 300 301/** 302 * Makes decision about voice presence in current subframe 303 * @param onset onset level 304 * @param prev_voice_decision voice decision result from previous subframe 305 * @param past_gain_pitch pitch gain of current and previous subframes 306 * 307 * @return voice decision result for current subframe 308 */ 309static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch) 310{ 311 int i, low_gain_pitch_cnt, voice_decision; 312 313 if (past_gain_pitch[0] >= 14745) { // 0.9 314 voice_decision = DECISION_VOICE; 315 } else if (past_gain_pitch[0] <= 9830) { // 0.6 316 voice_decision = DECISION_NOISE; 317 } else { 318 voice_decision = DECISION_INTERMEDIATE; 319 } 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 int64_t res = 0; 340 341 while (order--) 342 res += *v1++ * *v2++; 343 344 if (res > INT32_MAX) return INT32_MAX; 345 else if (res < INT32_MIN) return INT32_MIN; 346 347 return res; 348} 349 350static av_cold int decoder_init(AVCodecContext * avctx) 351{ 352 G729Context *s = avctx->priv_data; 353 G729ChannelContext *ctx; 354 int channels = avctx->ch_layout.nb_channels; 355 int c,i,k; 356 357 if (channels < 1 || channels > 2) { 358 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo are supported (requested channels: %d).\n", channels); 359 return AVERROR(EINVAL); 360 } 361 avctx->sample_fmt = AV_SAMPLE_FMT_S16P; 362 363 /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */ 364 avctx->frame_size = SUBFRAME_SIZE << 1; 365 366 ctx = 367 s->channel_context = av_mallocz(sizeof(G729ChannelContext) * channels); 368 if (!ctx) 369 return AVERROR(ENOMEM); 370 371 for (c = 0; c < channels; c++) { 372 ctx->gain_coeff = 16384; // 1.0 in (1.14) 373 374 for (k = 0; k < MA_NP + 1; k++) { 375 ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k]; 376 for (i = 1; i < 11; i++) 377 ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3; 378 } 379 380 ctx->lsp[0] = ctx->lsp_buf[0]; 381 ctx->lsp[1] = ctx->lsp_buf[1]; 382 memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t)); 383 384 ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN]; 385 386 ctx->pitch_delay_int_prev = PITCH_DELAY_MIN; 387 388 /* random seed initialization */ 389 ctx->rand_value = 21845; 390 391 /* quantized prediction error */ 392 for (i = 0; i < 4; i++) 393 ctx->quant_energy[i] = -14336; // -14 in (5.10) 394 395 ctx++; 396 } 397 398 ff_audiodsp_init(&s->adsp); 399 s->adsp.scalarproduct_int16 = scalarproduct_int16_c; 400 401 return 0; 402} 403 404static int decode_frame(AVCodecContext *avctx, AVFrame *frame, 405 int *got_frame_ptr, AVPacket *avpkt) 406{ 407 const uint8_t *buf = avpkt->data; 408 int buf_size = avpkt->size; 409 int16_t *out_frame; 410 GetBitContext gb; 411 const G729FormatDescription *format; 412 int c, i; 413 int16_t *tmp; 414 G729Formats packet_type; 415 G729Context *s = avctx->priv_data; 416 G729ChannelContext *ctx = s->channel_context; 417 int channels = avctx->ch_layout.nb_channels; 418 int16_t lp[2][11]; // (3.12) 419 uint8_t ma_predictor; ///< switched MA predictor of LSP quantizer 420 uint8_t quantizer_1st; ///< first stage vector of quantizer 421 uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits) 422 uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits) 423 424 int pitch_delay_int[2]; // pitch delay, integer part 425 int pitch_delay_3x; // pitch delay, multiplied by 3 426 int16_t fc[SUBFRAME_SIZE]; // fixed-codebook vector 427 int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector 428 int j, ret; 429 int gain_before, gain_after; 430 431 frame->nb_samples = SUBFRAME_SIZE<<1; 432 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 433 return ret; 434 435 if (buf_size && buf_size % ((G729_8K_BLOCK_SIZE + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * channels) == 0) { 436 packet_type = FORMAT_G729_8K; 437 format = &format_g729_8k; 438 //Reset voice decision 439 ctx->onset = 0; 440 ctx->voice_decision = DECISION_VOICE; 441 av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s"); 442 } else if (buf_size == G729D_6K4_BLOCK_SIZE * channels && avctx->codec_id != AV_CODEC_ID_ACELP_KELVIN) { 443 packet_type = FORMAT_G729D_6K4; 444 format = &format_g729d_6k4; 445 av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s"); 446 } else { 447 av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size); 448 return AVERROR_INVALIDDATA; 449 } 450 451 for (c = 0; c < channels; c++) { 452 int frame_erasure = 0; ///< frame erasure detected during decoding 453 int bad_pitch = 0; ///< parity check failed 454 int is_periodic = 0; ///< whether one of the subframes is declared as periodic or not 455 out_frame = (int16_t*)frame->data[c]; 456 if (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN) { 457 if (*buf != ((avctx->ch_layout.nb_channels - 1 - c) * 0x80 | 2)) 458 avpriv_request_sample(avctx, "First byte value %x for channel %d", *buf, c); 459 buf++; 460 } 461 462 for (i = 0; i < format->block_size; i++) 463 frame_erasure |= buf[i]; 464 frame_erasure = !frame_erasure; 465 466 init_get_bits8(&gb, buf, format->block_size); 467 468 ma_predictor = get_bits(&gb, 1); 469 quantizer_1st = get_bits(&gb, VQ_1ST_BITS); 470 quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS); 471 quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS); 472 473 if (frame_erasure) { 474 lsf_restore_from_previous(ctx->lsfq, ctx->past_quantizer_outputs, 475 ctx->ma_predictor_prev); 476 } else { 477 lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs, 478 ma_predictor, 479 quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi); 480 ctx->ma_predictor_prev = ma_predictor; 481 } 482 483 tmp = ctx->past_quantizer_outputs[MA_NP]; 484 memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs, 485 MA_NP * sizeof(int16_t*)); 486 ctx->past_quantizer_outputs[0] = tmp; 487 488 ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10); 489 490 ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10); 491 492 FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]); 493 494 for (i = 0; i < 2; i++) { 495 int gain_corr_factor; 496 497 uint8_t ac_index; ///< adaptive codebook index 498 uint8_t pulses_signs; ///< fixed-codebook vector pulse signs 499 int fc_indexes; ///< fixed-codebook indexes 500 uint8_t gc_1st_index; ///< gain codebook (first stage) index 501 uint8_t gc_2nd_index; ///< gain codebook (second stage) index 502 503 ac_index = get_bits(&gb, format->ac_index_bits[i]); 504 if (!i && format->parity_bit) 505 bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb); 506 fc_indexes = get_bits(&gb, format->fc_indexes_bits); 507 pulses_signs = get_bits(&gb, format->fc_signs_bits); 508 gc_1st_index = get_bits(&gb, format->gc_1st_index_bits); 509 gc_2nd_index = get_bits(&gb, format->gc_2nd_index_bits); 510 511 if (frame_erasure) { 512 pitch_delay_3x = 3 * ctx->pitch_delay_int_prev; 513 } else if (!i) { 514 if (bad_pitch) { 515 pitch_delay_3x = 3 * ctx->pitch_delay_int_prev; 516 } else { 517 pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index); 518 } 519 } else { 520 int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5, 521 PITCH_DELAY_MIN, PITCH_DELAY_MAX - 9); 522 523 if (packet_type == FORMAT_G729D_6K4) { 524 pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min); 525 } else { 526 pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min); 527 } 528 } 529 530 /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */ 531 pitch_delay_int[i] = (pitch_delay_3x + 1) / 3; 532 if (pitch_delay_int[i] > PITCH_DELAY_MAX) { 533 av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]); 534 pitch_delay_int[i] = PITCH_DELAY_MAX; 535 } 536 537 if (frame_erasure) { 538 ctx->rand_value = g729_prng(ctx->rand_value); 539 fc_indexes = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits); 540 541 ctx->rand_value = g729_prng(ctx->rand_value); 542 pulses_signs = ctx->rand_value; 543 } 544 545 546 memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE); 547 switch (packet_type) { 548 case FORMAT_G729_8K: 549 ff_acelp_fc_pulse_per_track(fc, ff_fc_4pulses_8bits_tracks_13, 550 ff_fc_4pulses_8bits_track_4, 551 fc_indexes, pulses_signs, 3, 3); 552 break; 553 case FORMAT_G729D_6K4: 554 ff_acelp_fc_pulse_per_track(fc, ff_fc_2pulses_9bits_track1_gray, 555 ff_fc_2pulses_9bits_track2_gray, 556 fc_indexes, pulses_signs, 1, 4); 557 break; 558 } 559 560 /* 561 This filter enhances harmonic components of the fixed-codebook vector to 562 improve the quality of the reconstructed speech. 563 564 / fc_v[i], i < pitch_delay 565 fc_v[i] = < 566 \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay 567 */ 568 if (SUBFRAME_SIZE > pitch_delay_int[i]) 569 ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i], 570 fc + pitch_delay_int[i], 571 fc, 1 << 14, 572 av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX), 573 0, 14, 574 SUBFRAME_SIZE - pitch_delay_int[i]); 575 576 memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t)); 577 ctx->past_gain_code[1] = ctx->past_gain_code[0]; 578 579 if (frame_erasure) { 580 ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15) 581 ctx->past_gain_code[0] = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11) 582 583 gain_corr_factor = 0; 584 } else { 585 if (packet_type == FORMAT_G729D_6K4) { 586 ctx->past_gain_pitch[0] = cb_gain_1st_6k4[gc_1st_index][0] + 587 cb_gain_2nd_6k4[gc_2nd_index][0]; 588 gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] + 589 cb_gain_2nd_6k4[gc_2nd_index][1]; 590 591 /* Without check below overflow can occur in ff_acelp_update_past_gain. 592 It is not issue for G.729, because gain_corr_factor in it's case is always 593 greater than 1024, while in G.729D it can be even zero. */ 594 gain_corr_factor = FFMAX(gain_corr_factor, 1024); 595 #ifndef G729_BITEXACT 596 gain_corr_factor >>= 1; 597 #endif 598 } else { 599 ctx->past_gain_pitch[0] = cb_gain_1st_8k[gc_1st_index][0] + 600 cb_gain_2nd_8k[gc_2nd_index][0]; 601 gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] + 602 cb_gain_2nd_8k[gc_2nd_index][1]; 603 } 604 605 /* Decode the fixed-codebook gain. */ 606 ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&s->adsp, gain_corr_factor, 607 fc, MR_ENERGY, 608 ctx->quant_energy, 609 ma_prediction_coeff, 610 SUBFRAME_SIZE, 4); 611 #ifdef G729_BITEXACT 612 /* 613 This correction required to get bit-exact result with 614 reference code, because gain_corr_factor in G.729D is 615 two times larger than in original G.729. 616 617 If bit-exact result is not issue then gain_corr_factor 618 can be simpler divided by 2 before call to g729_get_gain_code 619 instead of using correction below. 620 */ 621 if (packet_type == FORMAT_G729D_6K4) { 622 gain_corr_factor >>= 1; 623 ctx->past_gain_code[0] >>= 1; 624 } 625 #endif 626 } 627 ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure); 628 629 /* Routine requires rounding to lowest. */ 630 ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE, 631 ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3, 632 ff_acelp_interp_filter, 6, 633 (pitch_delay_3x % 3) << 1, 634 10, SUBFRAME_SIZE); 635 636 ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE, 637 ctx->exc + i * SUBFRAME_SIZE, fc, 638 (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0], 639 ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0], 640 1 << 13, 14, SUBFRAME_SIZE); 641 642 memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t)); 643 644 if (ff_celp_lp_synthesis_filter( 645 synth+10, 646 &lp[i][1], 647 ctx->exc + i * SUBFRAME_SIZE, 648 SUBFRAME_SIZE, 649 10, 650 1, 651 0, 652 0x800)) 653 /* Overflow occurred, downscale excitation signal... */ 654 for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++) 655 ctx->exc_base[j] >>= 2; 656 657 /* ... and make synthesis again. */ 658 if (packet_type == FORMAT_G729D_6K4) { 659 int16_t exc_new[SUBFRAME_SIZE]; 660 661 ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code); 662 ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch); 663 664 g729d_get_new_exc(exc_new, ctx->exc + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE); 665 666 ff_celp_lp_synthesis_filter( 667 synth+10, 668 &lp[i][1], 669 exc_new, 670 SUBFRAME_SIZE, 671 10, 672 0, 673 0, 674 0x800); 675 } else { 676 ff_celp_lp_synthesis_filter( 677 synth+10, 678 &lp[i][1], 679 ctx->exc + i * SUBFRAME_SIZE, 680 SUBFRAME_SIZE, 681 10, 682 0, 683 0, 684 0x800); 685 } 686 /* Save data (without postfilter) for use in next subframe. */ 687 memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t)); 688 689 /* Calculate gain of unfiltered signal for use in AGC. */ 690 gain_before = 0; 691 for (j = 0; j < SUBFRAME_SIZE; j++) 692 gain_before += FFABS(synth[j+10]); 693 694 /* Call postfilter and also update voicing decision for use in next frame. */ 695 ff_g729_postfilter( 696 &s->adsp, 697 &ctx->ht_prev_data, 698 &is_periodic, 699 &lp[i][0], 700 pitch_delay_int[0], 701 ctx->residual, 702 ctx->res_filter_data, 703 ctx->pos_filter_data, 704 synth+10, 705 SUBFRAME_SIZE); 706 707 /* Calculate gain of filtered signal for use in AGC. */ 708 gain_after = 0; 709 for (j = 0; j < SUBFRAME_SIZE; j++) 710 gain_after += FFABS(synth[j+10]); 711 712 ctx->gain_coeff = ff_g729_adaptive_gain_control( 713 gain_before, 714 gain_after, 715 synth+10, 716 SUBFRAME_SIZE, 717 ctx->gain_coeff); 718 719 if (frame_erasure) { 720 ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX); 721 } else { 722 ctx->pitch_delay_int_prev = pitch_delay_int[i]; 723 } 724 725 memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t)); 726 ff_acelp_high_pass_filter( 727 out_frame + i*SUBFRAME_SIZE, 728 ctx->hpf_f, 729 synth+10, 730 SUBFRAME_SIZE); 731 memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t)); 732 } 733 734 ctx->was_periodic = is_periodic; 735 736 /* Save signal for use in next frame. */ 737 memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t)); 738 739 buf += format->block_size; 740 ctx++; 741 } 742 743 *got_frame_ptr = 1; 744 return (format->block_size + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * channels; 745} 746 747static av_cold int decode_close(AVCodecContext *avctx) 748{ 749 G729Context *s = avctx->priv_data; 750 av_freep(&s->channel_context); 751 752 return 0; 753} 754 755const FFCodec ff_g729_decoder = { 756 .p.name = "g729", 757 .p.long_name = NULL_IF_CONFIG_SMALL("G.729"), 758 .p.type = AVMEDIA_TYPE_AUDIO, 759 .p.id = AV_CODEC_ID_G729, 760 .priv_data_size = sizeof(G729Context), 761 .init = decoder_init, 762 FF_CODEC_DECODE_CB(decode_frame), 763 .close = decode_close, 764 .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1, 765 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 766}; 767 768const FFCodec ff_acelp_kelvin_decoder = { 769 .p.name = "acelp.kelvin", 770 .p.long_name = NULL_IF_CONFIG_SMALL("Sipro ACELP.KELVIN"), 771 .p.type = AVMEDIA_TYPE_AUDIO, 772 .p.id = AV_CODEC_ID_ACELP_KELVIN, 773 .priv_data_size = sizeof(G729Context), 774 .init = decoder_init, 775 FF_CODEC_DECODE_CB(decode_frame), 776 .close = decode_close, 777 .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1, 778 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 779}; 780