2 * G.722 ADPCM audio encoder/decoder
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
10 * This file is part of FFmpeg.
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.
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.
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
30 * G.722 ADPCM audio codec
32 * This G.722 decoder is a bit-exact implementation of the ITU G.722
33 * specification for all three specified bitrates - 64000bps, 56000bps
34 * and 48000bps. It passes the ITU tests.
36 * @note For the 56000bps and 48000bps bitrates, the lowest 1 or 2 bits
37 * respectively of each byte are ignored.
44 #define PREV_SAMPLES_BUF_SIZE 1024
47 int16_t prev_samples[PREV_SAMPLES_BUF_SIZE]; ///< memory of past decoded samples
48 int prev_samples_pos; ///< the number of values in prev_samples
51 * The band[0] and band[1] correspond respectively to the lower band and higher band.
54 int16_t s_predictor; ///< predictor output value
55 int32_t s_zero; ///< previous output signal from zero predictor
56 int8_t part_reconst_mem[2]; ///< signs of previous partially reconstructed signals
57 int16_t prev_qtzd_reconst; ///< previous quantized reconstructed signal (internal value, using low_inv_quant4)
58 int16_t pole_mem[2]; ///< second-order pole section coefficient buffer
59 int32_t diff_mem[6]; ///< quantizer difference signal memory
60 int16_t zero_mem[6]; ///< Seventh-order zero section coefficient buffer
61 int16_t log_factor; ///< delayed 2-logarithmic quantizer factor
62 int16_t scale_factor; ///< delayed quantizer scale factor
67 static const int8_t sign_lookup[2] = { -1, 1 };
69 static const int16_t inv_log2_table[32] = {
70 2048, 2093, 2139, 2186, 2233, 2282, 2332, 2383,
71 2435, 2489, 2543, 2599, 2656, 2714, 2774, 2834,
72 2896, 2960, 3025, 3091, 3158, 3228, 3298, 3371,
73 3444, 3520, 3597, 3676, 3756, 3838, 3922, 4008
75 static const int16_t high_log_factor_step[2] = { 798, -214 };
76 static const int16_t high_inv_quant[4] = { -926, -202, 926, 202 };
78 * low_log_factor_step[index] == wl[rl42[index]]
80 static const int16_t low_log_factor_step[16] = {
81 -60, 3042, 1198, 538, 334, 172, 58, -30,
82 3042, 1198, 538, 334, 172, 58, -30, -60
84 static const int16_t low_inv_quant4[16] = {
85 0, -2557, -1612, -1121, -786, -530, -323, -150,
86 2557, 1612, 1121, 786, 530, 323, 150, 0
90 * quadrature mirror filter (QMF) coefficients
92 * ITU-T G.722 Table 11
94 static const int16_t qmf_coeffs[12] = {
95 3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11,
102 * @param cur_diff the dequantized and scaled delta calculated from the
105 static void do_adaptive_prediction(struct G722Band *band, const int cur_diff)
107 int sg[2], limit, i, cur_qtzd_reconst;
109 const int cur_part_reconst = band->s_zero + cur_diff < 0;
111 sg[0] = sign_lookup[cur_part_reconst != band->part_reconst_mem[0]];
112 sg[1] = sign_lookup[cur_part_reconst == band->part_reconst_mem[1]];
113 band->part_reconst_mem[1] = band->part_reconst_mem[0];
114 band->part_reconst_mem[0] = cur_part_reconst;
116 band->pole_mem[1] = av_clip((sg[0] * av_clip(band->pole_mem[0], -8191, 8191) >> 5) +
117 (sg[1] << 7) + (band->pole_mem[1] * 127 >> 7), -12288, 12288);
119 limit = 15360 - band->pole_mem[1];
120 band->pole_mem[0] = av_clip(-192 * sg[0] + (band->pole_mem[0] * 255 >> 8), -limit, limit);
124 for (i = 0; i < 6; i++)
125 band->zero_mem[i] = ((band->zero_mem[i]*255) >> 8) +
126 ((band->diff_mem[i]^cur_diff) < 0 ? -128 : 128);
128 for (i = 0; i < 6; i++)
129 band->zero_mem[i] = (band->zero_mem[i]*255) >> 8;
131 for (i = 5; i > 0; i--)
132 band->diff_mem[i] = band->diff_mem[i-1];
133 band->diff_mem[0] = av_clip_int16(cur_diff << 1);
136 for (i = 5; i >= 0; i--)
137 band->s_zero += (band->zero_mem[i]*band->diff_mem[i]) >> 15;
140 cur_qtzd_reconst = av_clip_int16((band->s_predictor + cur_diff) << 1);
141 band->s_predictor = av_clip_int16(band->s_zero +
142 (band->pole_mem[0] * cur_qtzd_reconst >> 15) +
143 (band->pole_mem[1] * band->prev_qtzd_reconst >> 15));
144 band->prev_qtzd_reconst = cur_qtzd_reconst;
147 static int inline linear_scale_factor(const int log_factor)
149 const int wd1 = inv_log2_table[(log_factor >> 6) & 31];
150 const int shift = log_factor >> 11;
151 return shift < 0 ? wd1 >> -shift : wd1 << shift;
154 static void update_low_predictor(struct G722Band *band, const int ilow)
156 do_adaptive_prediction(band,
157 band->scale_factor * low_inv_quant4[ilow] >> 10);
159 // quantizer adaptation
160 band->log_factor = av_clip((band->log_factor * 127 >> 7) +
161 low_log_factor_step[ilow], 0, 18432);
162 band->scale_factor = linear_scale_factor(band->log_factor - (8 << 11));
165 static void update_high_predictor(struct G722Band *band, const int dhigh,
168 do_adaptive_prediction(band, dhigh);
170 // quantizer adaptation
171 band->log_factor = av_clip((band->log_factor * 127 >> 7) +
172 high_log_factor_step[ihigh&1], 0, 22528);
173 band->scale_factor = linear_scale_factor(band->log_factor - (10 << 11));
176 static void apply_qmf(const int16_t *prev_samples, int *xout1, int *xout2)
182 for (i = 0; i < 12; i++) {
183 MAC16(*xout2, prev_samples[2*i ], qmf_coeffs[i ]);
184 MAC16(*xout1, prev_samples[2*i+1], qmf_coeffs[11-i]);
188 static av_cold int g722_init(AVCodecContext * avctx)
190 G722Context *c = avctx->priv_data;
192 if (avctx->channels != 1) {
193 av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n");
194 return AVERROR_INVALIDDATA;
196 avctx->sample_fmt = SAMPLE_FMT_S16;
198 switch (avctx->bits_per_coded_sample) {
204 av_log(avctx, AV_LOG_WARNING, "Unsupported bits_per_coded_sample [%d], "
206 avctx->bits_per_coded_sample);
208 avctx->bits_per_coded_sample = 8;
212 c->band[0].scale_factor = 8;
213 c->band[1].scale_factor = 2;
214 c->prev_samples_pos = 22;
217 avctx->sample_rate /= 2;
222 #if CONFIG_ADPCM_G722_DECODER
223 static const int16_t low_inv_quant5[32] = {
224 -35, -35, -2919, -2195, -1765, -1458, -1219, -1023,
225 -858, -714, -587, -473, -370, -276, -190, -110,
226 2919, 2195, 1765, 1458, 1219, 1023, 858, 714,
227 587, 473, 370, 276, 190, 110, 35, -35
229 static const int16_t low_inv_quant6[64] = {
230 -17, -17, -17, -17, -3101, -2738, -2376, -2088,
231 -1873, -1689, -1535, -1399, -1279, -1170, -1072, -982,
232 -899, -822, -750, -682, -618, -558, -501, -447,
233 -396, -347, -300, -254, -211, -170, -130, -91,
234 3101, 2738, 2376, 2088, 1873, 1689, 1535, 1399,
235 1279, 1170, 1072, 982, 899, 822, 750, 682,
236 618, 558, 501, 447, 396, 347, 300, 254,
237 211, 170, 130, 91, 54, 17, -54, -17
240 static const int16_t *low_inv_quants[3] = { low_inv_quant6, low_inv_quant5,
243 static int g722_decode_frame(AVCodecContext *avctx, void *data,
244 int *data_size, AVPacket *avpkt)
246 G722Context *c = avctx->priv_data;
247 int16_t *out_buf = data;
249 const int skip = 8 - avctx->bits_per_coded_sample;
250 const int16_t *quantizer_table = low_inv_quants[skip];
253 init_get_bits(&gb, avpkt->data, avpkt->size * 8);
255 for (j = 0; j < avpkt->size; j++) {
256 int ilow, ihigh, rlow;
258 ihigh = get_bits(&gb, 2);
259 ilow = get_bits(&gb, 6 - skip);
260 skip_bits(&gb, skip);
262 rlow = av_clip((c->band[0].scale_factor * quantizer_table[ilow] >> 10)
263 + c->band[0].s_predictor, -16384, 16383);
265 update_low_predictor(&c->band[0], ilow >> (2 - skip));
267 if (!avctx->lowres) {
268 const int dhigh = c->band[1].scale_factor *
269 high_inv_quant[ihigh] >> 10;
270 const int rhigh = av_clip(dhigh + c->band[1].s_predictor,
274 update_high_predictor(&c->band[1], dhigh, ihigh);
276 c->prev_samples[c->prev_samples_pos++] = rlow + rhigh;
277 c->prev_samples[c->prev_samples_pos++] = rlow - rhigh;
278 apply_qmf(c->prev_samples + c->prev_samples_pos - 24,
280 out_buf[out_len++] = av_clip_int16(xout1 >> 12);
281 out_buf[out_len++] = av_clip_int16(xout2 >> 12);
282 if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
283 memmove(c->prev_samples,
284 c->prev_samples + c->prev_samples_pos - 22,
285 22 * sizeof(c->prev_samples[0]));
286 c->prev_samples_pos = 22;
289 out_buf[out_len++] = rlow;
291 *data_size = out_len << 1;
295 AVCodec adpcm_g722_decoder = {
297 .type = AVMEDIA_TYPE_AUDIO,
298 .id = CODEC_ID_ADPCM_G722,
299 .priv_data_size = sizeof(G722Context),
301 .decode = g722_decode_frame,
302 .long_name = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
307 #if CONFIG_ADPCM_G722_ENCODER
308 static const int16_t low_quant[33] = {
309 35, 72, 110, 150, 190, 233, 276, 323,
310 370, 422, 473, 530, 587, 650, 714, 786,
311 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
312 1765, 1980, 2195, 2557, 2919
315 static inline void filter_samples(G722Context *c, const int16_t *samples,
316 int *xlow, int *xhigh)
319 c->prev_samples[c->prev_samples_pos++] = samples[0];
320 c->prev_samples[c->prev_samples_pos++] = samples[1];
321 apply_qmf(c->prev_samples + c->prev_samples_pos - 24, &xout1, &xout2);
322 *xlow = xout1 + xout2 >> 13;
323 *xhigh = xout1 - xout2 >> 13;
324 if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
325 memmove(c->prev_samples,
326 c->prev_samples + c->prev_samples_pos - 22,
327 22 * sizeof(c->prev_samples[0]));
328 c->prev_samples_pos = 22;
332 static inline int encode_high(const struct G722Band *state, int xhigh)
334 int diff = av_clip_int16(xhigh - state->s_predictor);
335 int pred = 141 * state->scale_factor >> 8;
336 /* = diff >= 0 ? (diff < pred) + 2 : diff >= -pred */
337 return ((diff ^ (diff >> (sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
340 static inline int encode_low(const struct G722Band* state, int xlow)
342 int diff = av_clip_int16(xlow - state->s_predictor);
343 /* = diff >= 0 ? diff : -(diff + 1) */
344 int limit = diff ^ (diff >> (sizeof(diff)*8-1));
346 limit = limit + 1 << 10;
347 if (limit > low_quant[8] * state->scale_factor)
349 while (i < 29 && limit > low_quant[i] * state->scale_factor)
351 return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
354 static int g722_encode_frame(AVCodecContext *avctx,
355 uint8_t *dst, int buf_size, void *data)
357 G722Context *c = avctx->priv_data;
358 const int16_t *samples = data;
361 for (i = 0; i < buf_size >> 1; i++) {
362 int xlow, xhigh, ihigh, ilow;
363 filter_samples(c, &samples[2*i], &xlow, &xhigh);
364 ihigh = encode_high(&c->band[1], xhigh);
365 ilow = encode_low(&c->band[0], xlow);
366 update_high_predictor(&c->band[1], c->band[1].scale_factor *
367 high_inv_quant[ihigh] >> 10, ihigh);
368 update_low_predictor(&c->band[0], ilow >> 2);
369 *dst++ = ihigh << 6 | ilow;
374 AVCodec adpcm_g722_encoder = {
376 .type = AVMEDIA_TYPE_AUDIO,
377 .id = CODEC_ID_ADPCM_G722,
378 .priv_data_size = sizeof(G722Context),
380 .encode = g722_encode_frame,
381 .long_name = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
382 .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},