| 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 | } |