Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * G.722 ADPCM audio encoder/decoder | |
3 | * | |
4 | * Copyright (c) CMU 1993 Computer Science, Speech Group | |
5 | * Chengxiang Lu and Alex Hauptmann | |
6 | * Copyright (c) 2005 Steve Underwood <steveu at coppice.org> | |
7 | * Copyright (c) 2009 Kenan Gillet | |
8 | * Copyright (c) 2010 Martin Storsjo | |
9 | * | |
10 | * This file is part of FFmpeg. | |
11 | * | |
12 | * FFmpeg is free software; you can redistribute it and/or | |
13 | * modify it under the terms of the GNU Lesser General Public | |
14 | * License as published by the Free Software Foundation; either | |
15 | * version 2.1 of the License, or (at your option) any later version. | |
16 | * | |
17 | * FFmpeg is distributed in the hope that it will be useful, | |
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
20 | * Lesser General Public License for more details. | |
21 | * | |
22 | * You should have received a copy of the GNU Lesser General Public | |
23 | * License along with FFmpeg; if not, write to the Free Software | |
24 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
25 | */ | |
26 | ||
27 | /** | |
28 | * @file | |
29 | * G.722 ADPCM audio codec | |
30 | * | |
31 | * This G.722 decoder is a bit-exact implementation of the ITU G.722 | |
32 | * specification for all three specified bitrates - 64000bps, 56000bps | |
33 | * and 48000bps. It passes the ITU tests. | |
34 | * | |
35 | * @note For the 56000bps and 48000bps bitrates, the lowest 1 or 2 bits | |
36 | * respectively of each byte are ignored. | |
37 | */ | |
38 | ||
39 | #include "mathops.h" | |
40 | #include "g722.h" | |
41 | ||
42 | static const int8_t sign_lookup[2] = { -1, 1 }; | |
43 | ||
44 | static const int16_t inv_log2_table[32] = { | |
45 | 2048, 2093, 2139, 2186, 2233, 2282, 2332, 2383, | |
46 | 2435, 2489, 2543, 2599, 2656, 2714, 2774, 2834, | |
47 | 2896, 2960, 3025, 3091, 3158, 3228, 3298, 3371, | |
48 | 3444, 3520, 3597, 3676, 3756, 3838, 3922, 4008 | |
49 | }; | |
50 | static const int16_t high_log_factor_step[2] = { 798, -214 }; | |
51 | const int16_t ff_g722_high_inv_quant[4] = { -926, -202, 926, 202 }; | |
52 | /** | |
53 | * low_log_factor_step[index] == wl[rl42[index]] | |
54 | */ | |
55 | static const int16_t low_log_factor_step[16] = { | |
56 | -60, 3042, 1198, 538, 334, 172, 58, -30, | |
57 | 3042, 1198, 538, 334, 172, 58, -30, -60 | |
58 | }; | |
59 | const int16_t ff_g722_low_inv_quant4[16] = { | |
60 | 0, -2557, -1612, -1121, -786, -530, -323, -150, | |
61 | 2557, 1612, 1121, 786, 530, 323, 150, 0 | |
62 | }; | |
63 | const int16_t ff_g722_low_inv_quant6[64] = { | |
64 | -17, -17, -17, -17, -3101, -2738, -2376, -2088, | |
65 | -1873, -1689, -1535, -1399, -1279, -1170, -1072, -982, | |
66 | -899, -822, -750, -682, -618, -558, -501, -447, | |
67 | -396, -347, -300, -254, -211, -170, -130, -91, | |
68 | 3101, 2738, 2376, 2088, 1873, 1689, 1535, 1399, | |
69 | 1279, 1170, 1072, 982, 899, 822, 750, 682, | |
70 | 618, 558, 501, 447, 396, 347, 300, 254, | |
71 | 211, 170, 130, 91, 54, 17, -54, -17 | |
72 | }; | |
73 | ||
74 | /** | |
75 | * quadrature mirror filter (QMF) coefficients | |
76 | * | |
77 | * ITU-T G.722 Table 11 | |
78 | */ | |
79 | static const int16_t qmf_coeffs[12] = { | |
80 | 3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11, | |
81 | }; | |
82 | ||
83 | ||
84 | /** | |
85 | * adaptive predictor | |
86 | * | |
87 | * @param cur_diff the dequantized and scaled delta calculated from the | |
88 | * current codeword | |
89 | */ | |
90 | static void do_adaptive_prediction(struct G722Band *band, const int cur_diff) | |
91 | { | |
92 | int sg[2], limit, i, cur_qtzd_reconst; | |
93 | ||
94 | const int cur_part_reconst = band->s_zero + cur_diff < 0; | |
95 | ||
96 | sg[0] = sign_lookup[cur_part_reconst != band->part_reconst_mem[0]]; | |
97 | sg[1] = sign_lookup[cur_part_reconst == band->part_reconst_mem[1]]; | |
98 | band->part_reconst_mem[1] = band->part_reconst_mem[0]; | |
99 | band->part_reconst_mem[0] = cur_part_reconst; | |
100 | ||
101 | band->pole_mem[1] = av_clip((sg[0] * av_clip(band->pole_mem[0], -8191, 8191) >> 5) + | |
102 | (sg[1] << 7) + (band->pole_mem[1] * 127 >> 7), -12288, 12288); | |
103 | ||
104 | limit = 15360 - band->pole_mem[1]; | |
105 | band->pole_mem[0] = av_clip(-192 * sg[0] + (band->pole_mem[0] * 255 >> 8), -limit, limit); | |
106 | ||
107 | ||
108 | if (cur_diff) { | |
109 | for (i = 0; i < 6; i++) | |
110 | band->zero_mem[i] = ((band->zero_mem[i]*255) >> 8) + | |
111 | ((band->diff_mem[i]^cur_diff) < 0 ? -128 : 128); | |
112 | } else | |
113 | for (i = 0; i < 6; i++) | |
114 | band->zero_mem[i] = (band->zero_mem[i]*255) >> 8; | |
115 | ||
116 | for (i = 5; i > 0; i--) | |
117 | band->diff_mem[i] = band->diff_mem[i-1]; | |
118 | band->diff_mem[0] = av_clip_int16(cur_diff << 1); | |
119 | ||
120 | band->s_zero = 0; | |
121 | for (i = 5; i >= 0; i--) | |
122 | band->s_zero += (band->zero_mem[i]*band->diff_mem[i]) >> 15; | |
123 | ||
124 | ||
125 | cur_qtzd_reconst = av_clip_int16((band->s_predictor + cur_diff) << 1); | |
126 | band->s_predictor = av_clip_int16(band->s_zero + | |
127 | (band->pole_mem[0] * cur_qtzd_reconst >> 15) + | |
128 | (band->pole_mem[1] * band->prev_qtzd_reconst >> 15)); | |
129 | band->prev_qtzd_reconst = cur_qtzd_reconst; | |
130 | } | |
131 | ||
132 | static inline int linear_scale_factor(const int log_factor) | |
133 | { | |
134 | const int wd1 = inv_log2_table[(log_factor >> 6) & 31]; | |
135 | const int shift = log_factor >> 11; | |
136 | return shift < 0 ? wd1 >> -shift : wd1 << shift; | |
137 | } | |
138 | ||
139 | void ff_g722_update_low_predictor(struct G722Band *band, const int ilow) | |
140 | { | |
141 | do_adaptive_prediction(band, | |
142 | band->scale_factor * ff_g722_low_inv_quant4[ilow] >> 10); | |
143 | ||
144 | // quantizer adaptation | |
145 | band->log_factor = av_clip((band->log_factor * 127 >> 7) + | |
146 | low_log_factor_step[ilow], 0, 18432); | |
147 | band->scale_factor = linear_scale_factor(band->log_factor - (8 << 11)); | |
148 | } | |
149 | ||
150 | void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, | |
151 | const int ihigh) | |
152 | { | |
153 | do_adaptive_prediction(band, dhigh); | |
154 | ||
155 | // quantizer adaptation | |
156 | band->log_factor = av_clip((band->log_factor * 127 >> 7) + | |
157 | high_log_factor_step[ihigh&1], 0, 22528); | |
158 | band->scale_factor = linear_scale_factor(band->log_factor - (10 << 11)); | |
159 | } | |
160 | ||
161 | void ff_g722_apply_qmf(const int16_t *prev_samples, int *xout1, int *xout2) | |
162 | { | |
163 | int i; | |
164 | ||
165 | *xout1 = 0; | |
166 | *xout2 = 0; | |
167 | for (i = 0; i < 12; i++) { | |
168 | MAC16(*xout2, prev_samples[2*i ], qmf_coeffs[i ]); | |
169 | MAC16(*xout1, prev_samples[2*i+1], qmf_coeffs[11-i]); | |
170 | } | |
171 | } |