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
30
31
41
42 /**
43 * minimum quantized LSF value (3.2.4)
44 * 0.005 in Q13
45 */
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
92
94 uint8_t ac_index_bits[2];
///< adaptive codebook index for second subframe (size in bits)
101
104
105 /// past excitation signal buffer
107
108 int16_t*
exc;
///< start of past excitation data in buffer
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)
127
128 /// previous speech data for residual calculation filter
130
131 /// previous speech data for short-term postfilter
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
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)
147 uint16_t
rand_value;
///< random number generator value (4.4.4)
149
150 /// (14.14) high-pass filter data (past input)
152
153 /// high-pass filter data (past output)
156
159 .parity_bit = 1,
162 .fc_signs_bits = 4,
163 .fc_indexes_bits = 13,
164 };
165
168 .parity_bit = 0,
171 .fc_signs_bits = 2,
172 .fc_indexes_bits = 9,
173 };
174
175 /**
176 * @brief pseudo random number generator
177 */
179 {
180 return 31821 * value + 13849;
181 }
182
183 /**
184 * Get parity bit of bit 2..7
185 */
187 {
188 return (0x6996966996696996ULL >> (value >> 2)) & 1;
189 }
190
191 /**
192 * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
193 * @param[out] lsfq (2.13) quantized LSF coefficients
194 * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
195 * @param ma_predictor switched MA predictor of LSP quantizer
196 * @param vq_1st first stage vector of quantizer
197 * @param vq_2nd_low second stage lower vector of LSP quantizer
198 * @param vq_2nd_high second stage higher vector of LSP quantizer
199 */
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++) {
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++) {
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
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 */
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
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 */
269 const int16_t* fc_cur,
270 int dstate,
271 int gain_code,
272 int subframe_size)
273 {
274 int i;
276
278
279 for(i=0; i<subframe_size; i++)
280 {
281 out[i] = in[i];
282 out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
283 out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
284 }
285 }
286
287 /**
288 * Makes decision about onset in current subframe
289 * @param past_onset decision result of previous subframe
290 * @param past_gain_code gain code of current and previous subframe
291 *
292 * @return onset decision result for current subframe
293 */
295 {
296 if((past_gain_code[0] >> 1) > past_gain_code[1])
297 return 2;
298 else
299 return FFMAX(past_onset-1, 0);
300 }
301
302 /**
303 * Makes decision about voice presence in current subframe
304 * @param onset onset level
305 * @param prev_voice_decision voice decision result from previous subframe
306 * @param past_gain_pitch pitch gain of current and previous subframes
307 *
308 * @return voice decision result for current subframe
309 */
311 {
312 int i, low_gain_pitch_cnt, voice_decision;
313
314 if(past_gain_pitch[0] >= 14745) // 0.9
316 else if (past_gain_pitch[0] <= 9830) // 0.6
318 else
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)
327
328 if(!onset && voice_decision > prev_voice_decision + 1)
329 voice_decision--;
330
332 voice_decision++;
333
334 return voice_decision;
335 }
336
338 {
340
341 while (order--)
342 res += *v1++ * *v2++;
343
345 }
346
348 {
350 int i,k;
351
355 }
357
358 /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
360
362
363 for (k = 0; k <
MA_NP + 1; k++) {
365 for (i = 1; i < 11; i++)
367 }
368
371 memcpy(ctx->
lsp[0],
lsp_init, 10 *
sizeof(int16_t));
372
374
376
377 /* random seed initialization */
379
380 /* quantized prediction error */
381 for(i=0; i<4; i++)
383
386
387 return 0;
388 }
389
392 {
394 int buf_size = avpkt->
size;
395 int16_t *out_frame;
398 int frame_erasure = 0;
///< frame erasure detected during decoding
399 int bad_pitch = 0; ///< parity check failed
400 int i;
401 int16_t *tmp;
404 int16_t lp[2][11]; // (3.12)
405 uint8_t ma_predictor;
///< switched MA predictor of LSP quantizer
406 uint8_t quantizer_1st;
///< first stage vector of quantizer
407 uint8_t quantizer_2nd_lo;
///< second stage lower vector of quantizer (size in bits)
408 uint8_t quantizer_2nd_hi;
///< second stage higher vector of quantizer (size in bits)
409
410 int pitch_delay_int[2]; // pitch delay, integer part
411 int pitch_delay_3x; // pitch delay, multiplied by 3
415 int gain_before, gain_after;
416 int is_periodic = 0; // whether one of the subframes is declared as periodic or not
418
422 out_frame = (int16_t*) frame->
data[0];
423
424 if (buf_size == 10) {
427 //Reset voice decision
431 } else if (buf_size == 8) {
435 } else {
438 }
439
440 for (i=0; i < buf_size; i++)
441 frame_erasure |= buf[i];
443
445
450
451 if(frame_erasure)
454 else {
456 ma_predictor,
457 quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
459 }
460
463 MA_NP *
sizeof(int16_t*));
465
467
469
471
472 for (i = 0; i < 2; i++) {
473 int gain_corr_factor;
474
475 uint8_t ac_index;
///< adaptive codebook index
476 uint8_t pulses_signs;
///< fixed-codebook vector pulse signs
477 int fc_indexes; ///< fixed-codebook indexes
478 uint8_t gc_1st_index;
///< gain codebook (first stage) index
479 uint8_t gc_2nd_index;
///< gain codebook (second stage) index
480
488
489 if (frame_erasure)
491 else if(!i) {
492 if (bad_pitch)
494 else
496 } else {
499
502 else
504 }
505
506 /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
507 pitch_delay_int[i] = (pitch_delay_3x + 1) / 3;
511 }
512
513 if (frame_erasure) {
516
519 }
520
521
523 switch (packet_type) {
527 fc_indexes, pulses_signs, 3, 3);
528 break;
532 fc_indexes, pulses_signs, 1, 4);
533 break;
534 }
535
536 /*
537 This filter enhances harmonic components of the fixed-codebook vector to
538 improve the quality of the reconstructed speech.
539
540 / fc_v[i], i < pitch_delay
541 fc_v[i] = <
542 \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
543 */
545 fc + pitch_delay_int[i],
546 fc, 1 << 14,
548 0, 14,
549 SUBFRAME_SIZE - pitch_delay_int[i]);
550
553
554 if (frame_erasure) {
557
558 gain_corr_factor = 0;
559 } else {
564 cb_gain_2nd_6k4[gc_2nd_index][1];
565
566 /* Without check below overflow can occur in ff_acelp_update_past_gain.
567 It is not issue for G.729, because gain_corr_factor in it's case is always
568 greater than 1024, while in G.729D it can be even zero. */
569 gain_corr_factor =
FFMAX(gain_corr_factor, 1024);
570 #ifndef G729_BITEXACT
571 gain_corr_factor >>= 1;
572 #endif
573 } else {
577 cb_gain_2nd_8k[gc_2nd_index][1];
578 }
579
580 /* Decode the fixed-codebook gain. */
585 SUBFRAME_SIZE, 4);
586 #ifdef G729_BITEXACT
587 /*
588 This correction required to get bit-exact result with
589 reference code, because gain_corr_factor in G.729D is
590 two times larger than in original G.729.
591
592 If bit-exact result is not issue then gain_corr_factor
593 can be simpler divided by 2 before call to g729_get_gain_code
594 instead of using correction below.
595 */
597 gain_corr_factor >>= 1;
599 }
600 #endif
601 }
603
604 /* Routine requires rounding to lowest. */
606 ctx->
exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
608 (pitch_delay_3x % 3) << 1,
609 10, SUBFRAME_SIZE);
610
612 ctx->
exc + i * SUBFRAME_SIZE, fc,
615 1 << 13, 14, SUBFRAME_SIZE);
616
618
620 synth+10,
621 &lp[i][1],
622 ctx->
exc + i * SUBFRAME_SIZE,
623 SUBFRAME_SIZE,
624 10,
625 1,
626 0,
627 0x800))
628 /* Overflow occurred, downscale excitation signal... */
631
632 /* ... and make synthesis again. */
635
638
640
642 synth+10,
643 &lp[i][1],
644 exc_new,
645 SUBFRAME_SIZE,
646 10,
647 0,
648 0,
649 0x800);
650 } else {
652 synth+10,
653 &lp[i][1],
654 ctx->
exc + i * SUBFRAME_SIZE,
655 SUBFRAME_SIZE,
656 10,
657 0,
658 0,
659 0x800);
660 }
661 /* Save data (without postfilter) for use in next subframe. */
662 memcpy(ctx->
syn_filter_data, synth+SUBFRAME_SIZE, 10 *
sizeof(int16_t));
663
664 /* Calculate gain of unfiltered signal for use in AGC. */
665 gain_before = 0;
667 gain_before +=
FFABS(synth[j+10]);
668
669 /* Call postfilter and also update voicing decision for use in next frame. */
673 &is_periodic,
674 &lp[i][0],
675 pitch_delay_int[0],
679 synth+10,
680 SUBFRAME_SIZE);
681
682 /* Calculate gain of filtered signal for use in AGC. */
683 gain_after = 0;
685 gain_after +=
FFABS(synth[j+10]);
686
688 gain_before,
689 gain_after,
690 synth+10,
691 SUBFRAME_SIZE,
693
694 if (frame_erasure)
696 else
698
699 memcpy(synth+8, ctx->
hpf_z, 2*
sizeof(int16_t));
701 out_frame + i*SUBFRAME_SIZE,
703 synth+10,
704 SUBFRAME_SIZE);
705 memcpy(ctx->
hpf_z, synth+8+SUBFRAME_SIZE, 2*
sizeof(int16_t));
706 }
707
709
710 /* Save signal for use in next frame. */
712
713 *got_frame_ptr = 1;
714 return buf_size;
715 }
716
726 };