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