FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/g729dec.c
Date: 2022-07-07 01:21:54
Exec Total Coverage
Lines: 0 251 0.0%
Branches: 0 129 0.0%

Line Branch Exec Source
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
88 typedef enum {
89 FORMAT_G729_8K = 0,
90 FORMAT_G729D_6K4,
91 FORMAT_COUNT,
92 } G729Formats;
93
94 typedef 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
104 typedef 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
157 typedef struct {
158 AudioDSPContext adsp;
159
160 G729ChannelContext *channel_context;
161 } G729Context;
162
163 static 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
173 static 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 */
186 static 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 */
200 static 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 */
241 static 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 */
266 static 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 */
293 static 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 */
309 static 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
337 static 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
350 static 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
404 static 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
747 static 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
755 const 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
768 const 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