2 * G.729, G729 Annex D decoders
3 * Copyright (c) 2008 Vladimir Voroshilov
5 * This file is part of FFmpeg.
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.
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.
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
26 #include "libavutil/avutil.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"
40 #include "g729postfilter.h"
43 * minimum quantized LSF value (3.2.4)
49 * maximum quantized LSF value (3.2.4)
52 #define LSFQ_MAX 25681
55 * minimum LSF distance (3.2.4)
58 #define LSFQ_DIFF_MIN 321
60 /// interpolation filter length
61 #define INTERPOL_LEN 11
64 * minimum gain pitch value (3.8, Equation 47)
67 #define SHARP_MIN 3277
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.
76 #define SHARP_MAX 13017
79 * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7.13)
81 #define MR_ENERGY 1018156
83 #define DECISION_NOISE 0
84 #define DECISION_INTERMEDIATE 1
85 #define DECISION_VOICE 2
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
;
103 AudioDSPContext adsp
;
105 /// past excitation signal buffer
106 int16_t exc_base
[2*SUBFRAME_SIZE
+PITCH_DELAY_MAX
+INTERPOL_LEN
];
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)
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];
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
119 int16_t quant_energy
[4]; ///< (5.10) past quantized energy
121 /// previous speech data for LP synthesis filter
122 int16_t syn_filter_data
[10];
125 /// residual signal buffer (used in long-term postfilter)
126 int16_t residual
[SUBFRAME_SIZE
+ RES_PREV_DATA_SIZE
];
128 /// previous speech data for residual calculation filter
129 int16_t res_filter_data
[SUBFRAME_SIZE
+10];
131 /// previous speech data for short-term postfilter
132 int16_t pos_filter_data
[SUBFRAME_SIZE
+10];
134 /// (1.14) pitch gain of current and five previous subframes
135 int16_t past_gain_pitch
[6];
137 /// (14.1) gain code from current and previous subframe
138 int16_t past_gain_code
[2];
140 /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
141 int16_t voice_decision
;
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
150 /// (14.14) high-pass filter data (past input)
153 /// high-pass filter data (past output)
157 static const G729FormatDescription format_g729_8k
= {
158 .ac_index_bits
= {8,5},
160 .gc_1st_index_bits
= GC_1ST_IDX_BITS_8K
,
161 .gc_2nd_index_bits
= GC_2ND_IDX_BITS_8K
,
163 .fc_indexes_bits
= 13,
166 static const G729FormatDescription format_g729d_6k4
= {
167 .ac_index_bits
= {8,4},
169 .gc_1st_index_bits
= GC_1ST_IDX_BITS_6K4
,
170 .gc_2nd_index_bits
= GC_2ND_IDX_BITS_6K4
,
172 .fc_indexes_bits
= 9,
176 * @brief pseudo random number generator
178 static inline uint16_t g729_prng(uint16_t value
)
180 return 31821 * value
+ 13849;
184 * Get parity bit of bit 2..7
186 static inline int get_parity(uint8_t value
)
188 return (0x6996966996696996ULL
>> (value
>> 2)) & 1;
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
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
)
205 static const uint8_t min_distance
[2]={10, 5}; //(2.13)
206 int16_t* quantizer_output
= past_quantizer_outputs
[MA_NP
];
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];
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;
217 quantizer_output
[i
- 1] -= diff
;
218 quantizer_output
[i
] += diff
;
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
];
231 ff_acelp_reorder_lsf(lsfq
, LSFQ_DIFF_MIN
, LSFQ_MIN
, LSFQ_MAX
, 10);
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
241 static void lsf_restore_from_previous(int16_t* lsfq
,
242 int16_t* past_quantizer_outputs
[MA_NP
+ 1],
243 int ma_predictor_prev
)
245 int16_t* quantizer_output
= past_quantizer_outputs
[MA_NP
];
248 for (i
= 0; i
< 10; i
++) {
249 int tmp
= lsfq
[i
] << 15;
251 for (k
= 0; k
< MA_NP
; k
++)
252 tmp
-= past_quantizer_outputs
[k
][i
] * cb_ma_predictor
[ma_predictor_prev
][k
][i
];
254 quantizer_output
[i
] = ((tmp
>> 15) * cb_ma_predictor_sum_inv
[ma_predictor_prev
][i
]) >> 12;
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
266 static void g729d_get_new_exc(
269 const int16_t* fc_cur
,
275 int16_t fc_new
[SUBFRAME_SIZE
];
277 ff_celp_convolve_circ(fc_new
, fc_cur
, phase_filter
[dstate
], subframe_size
);
279 for(i
=0; i
<subframe_size
; i
++)
282 out
[i
] -= (gain_code
* fc_cur
[i
] + 0x2000) >> 14;
283 out
[i
] += (gain_code
* fc_new
[i
] + 0x2000) >> 14;
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
292 * @return onset decision result for current subframe
294 static int g729d_onset_decision(int past_onset
, const int16_t* past_gain_code
)
296 if((past_gain_code
[0] >> 1) > past_gain_code
[1])
299 return FFMAX(past_onset
-1, 0);
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
308 * @return voice decision result for current subframe
310 static int16_t g729d_voice_decision(int onset
, int prev_voice_decision
, const int16_t* past_gain_pitch
)
312 int i
, low_gain_pitch_cnt
, voice_decision
;
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
;
319 voice_decision
= DECISION_INTERMEDIATE
;
321 for(i
=0, low_gain_pitch_cnt
=0; i
<6; i
++)
322 if(past_gain_pitch
[i
] < 9830)
323 low_gain_pitch_cnt
++;
325 if(low_gain_pitch_cnt
> 2 && !onset
)
326 voice_decision
= DECISION_NOISE
;
328 if(!onset
&& voice_decision
> prev_voice_decision
+ 1)
331 if(onset
&& voice_decision
< DECISION_VOICE
)
334 return voice_decision
;
337 static int32_t scalarproduct_int16_c(const int16_t * v1
, const int16_t * v2
, int order
)
342 res
+= *v1
++ * *v2
++;
347 static av_cold
int decoder_init(AVCodecContext
* avctx
)
349 G729Context
* ctx
= avctx
->priv_data
;
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
);
356 avctx
->sample_fmt
= AV_SAMPLE_FMT_S16
;
358 /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
359 avctx
->frame_size
= SUBFRAME_SIZE
<< 1;
361 ctx
->gain_coeff
= 16384; // 1.0 in (1.14)
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;
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));
373 ctx
->exc
= &ctx
->exc_base
[PITCH_DELAY_MAX
+INTERPOL_LEN
];
375 ctx
->pitch_delay_int_prev
= PITCH_DELAY_MIN
;
377 /* random seed initialization */
378 ctx
->rand_value
= 21845;
380 /* quantized prediction error */
382 ctx
->quant_energy
[i
] = -14336; // -14 in (5.10)
384 ff_audiodsp_init(&ctx
->adsp
);
385 ctx
->adsp
.scalarproduct_int16
= scalarproduct_int16_c
;
390 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame_ptr
,
393 const uint8_t *buf
= avpkt
->data
;
394 int buf_size
= avpkt
->size
;
397 const G729FormatDescription
*format
;
398 int frame_erasure
= 0; ///< frame erasure detected during decoding
399 int bad_pitch
= 0; ///< parity check failed
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)
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
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
;
419 frame
->nb_samples
= SUBFRAME_SIZE
<<1;
420 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
422 out_frame
= (int16_t*) frame
->data
[0];
424 if (buf_size
== 10) {
425 packet_type
= FORMAT_G729_8K
;
426 format
= &format_g729_8k
;
427 //Reset voice decision
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");
436 av_log(avctx
, AV_LOG_ERROR
, "Packet size %d is unknown.\n", buf_size
);
437 return AVERROR_INVALIDDATA
;
440 for (i
=0; i
< buf_size
; i
++)
441 frame_erasure
|= buf
[i
];
442 frame_erasure
= !frame_erasure
;
444 init_get_bits(&gb
, buf
, 8*buf_size
);
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
);
452 lsf_restore_from_previous(ctx
->lsfq
, ctx
->past_quantizer_outputs
,
453 ctx
->ma_predictor_prev
);
455 lsf_decode(ctx
->lsfq
, ctx
->past_quantizer_outputs
,
457 quantizer_1st
, quantizer_2nd_lo
, quantizer_2nd_hi
);
458 ctx
->ma_predictor_prev
= ma_predictor
;
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
;
466 ff_acelp_lsf2lsp(ctx
->lsp
[1], ctx
->lsfq
, 10);
468 ff_acelp_lp_decode(&lp
[0][0], &lp
[1][0], ctx
->lsp
[1], ctx
->lsp
[0], 10);
470 FFSWAP(int16_t*, ctx
->lsp
[1], ctx
->lsp
[0]);
472 for (i
= 0; i
< 2; i
++) {
473 int gain_corr_factor
;
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
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
);
490 pitch_delay_3x
= 3 * ctx
->pitch_delay_int_prev
;
493 pitch_delay_3x
= 3 * ctx
->pitch_delay_int_prev
;
495 pitch_delay_3x
= ff_acelp_decode_8bit_to_1st_delay3(ac_index
);
497 int pitch_delay_min
= av_clip(ctx
->pitch_delay_int_prev
- 5,
498 PITCH_DELAY_MIN
, PITCH_DELAY_MAX
- 9);
500 if(packet_type
== FORMAT_G729D_6K4
)
501 pitch_delay_3x
= ff_acelp_decode_4bit_to_2nd_delay3(ac_index
, pitch_delay_min
);
503 pitch_delay_3x
= ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index
, pitch_delay_min
);
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
;
514 ctx
->rand_value
= g729_prng(ctx
->rand_value
);
515 fc_indexes
= ctx
->rand_value
& ((1 << format
->fc_indexes_bits
) - 1);
517 ctx
->rand_value
= g729_prng(ctx
->rand_value
);
518 pulses_signs
= ctx
->rand_value
;
522 memset(fc
, 0, sizeof(int16_t) * SUBFRAME_SIZE
);
523 switch (packet_type
) {
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);
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);
537 This filter enhances harmonic components of the fixed-codebook vector to
538 improve the quality of the reconstructed speech.
540 / fc_v[i], i < pitch_delay
542 \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
544 ff_acelp_weighted_vector_sum(fc
+ pitch_delay_int
[i
],
545 fc
+ pitch_delay_int
[i
],
547 av_clip(ctx
->past_gain_pitch
[0], SHARP_MIN
, SHARP_MAX
),
549 SUBFRAME_SIZE
- pitch_delay_int
[i
]);
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];
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)
558 gain_corr_factor
= 0;
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];
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;
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];
580 /* Decode the fixed-codebook gain. */
581 ctx
->past_gain_code
[0] = ff_acelp_decode_gain_code(&ctx
->adsp
, gain_corr_factor
,
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.
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.
596 if (packet_type
== FORMAT_G729D_6K4
) {
597 gain_corr_factor
>>= 1;
598 ctx
->past_gain_code
[0] >>= 1;
602 ff_acelp_update_past_gain(ctx
->quant_energy
, gain_corr_factor
, 2, frame_erasure
);
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,
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
);
617 memcpy(synth
, ctx
->syn_filter_data
, 10 * sizeof(int16_t));
619 if (ff_celp_lp_synthesis_filter(
622 ctx
->exc
+ i
* SUBFRAME_SIZE
,
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;
632 /* ... and make synthesis again. */
633 if (packet_type
== FORMAT_G729D_6K4
) {
634 int16_t exc_new
[SUBFRAME_SIZE
];
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
);
639 g729d_get_new_exc(exc_new
, ctx
->exc
+ i
* SUBFRAME_SIZE
, fc
, ctx
->voice_decision
, ctx
->past_gain_code
[0], SUBFRAME_SIZE
);
641 ff_celp_lp_synthesis_filter(
651 ff_celp_lp_synthesis_filter(
654 ctx
->exc
+ i
* SUBFRAME_SIZE
,
661 /* Save data (without postfilter) for use in next subframe. */
662 memcpy(ctx
->syn_filter_data
, synth
+SUBFRAME_SIZE
, 10 * sizeof(int16_t));
664 /* Calculate gain of unfiltered signal for use in AGC. */
666 for (j
= 0; j
< SUBFRAME_SIZE
; j
++)
667 gain_before
+= FFABS(synth
[j
+10]);
669 /* Call postfilter and also update voicing decision for use in next frame. */
677 ctx
->res_filter_data
,
678 ctx
->pos_filter_data
,
682 /* Calculate gain of filtered signal for use in AGC. */
684 for(j
=0; j
<SUBFRAME_SIZE
; j
++)
685 gain_after
+= FFABS(synth
[j
+10]);
687 ctx
->gain_coeff
= ff_g729_adaptive_gain_control(
695 ctx
->pitch_delay_int_prev
= FFMIN(ctx
->pitch_delay_int_prev
+ 1, PITCH_DELAY_MAX
);
697 ctx
->pitch_delay_int_prev
= pitch_delay_int
[i
];
699 memcpy(synth
+8, ctx
->hpf_z
, 2*sizeof(int16_t));
700 ff_acelp_high_pass_filter(
701 out_frame
+ i
*SUBFRAME_SIZE
,
705 memcpy(ctx
->hpf_z
, synth
+8+SUBFRAME_SIZE
, 2*sizeof(int16_t));
708 ctx
->was_periodic
= is_periodic
;
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));
717 AVCodec ff_g729_decoder
= {
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
,