Add a G.722 encoder
[ffmpeg.git] / libavcodec / g722.c
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  *
30  * G.722 ADPCM audio codec
31  *
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.
35  *
36  * @note For the 56000bps and 48000bps bitrates, the lowest 1 or 2 bits
37  *       respectively of each byte are ignored.
38  */
39
40 #include "avcodec.h"
41 #include "mathops.h"
42 #include "get_bits.h"
43
44 #define PREV_SAMPLES_BUF_SIZE 1024
45
46 typedef struct {
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
49
50     /**
51      * The band[0] and band[1] correspond respectively to the lower band and higher band.
52      */
53     struct G722Band {
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
63     } band[2];
64 } G722Context;
65
66
67 static const int8_t sign_lookup[2] = { -1, 1 };
68
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
74 };
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 };
77 /**
78  * low_log_factor_step[index] == wl[rl42[index]]
79  */
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
83 };
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
87 };
88
89 /**
90  * quadrature mirror filter (QMF) coefficients
91  *
92  * ITU-T G.722 Table 11
93  */
94 static const int16_t qmf_coeffs[12] = {
95     3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11,
96 };
97
98
99 /**
100  * adaptive predictor
101  *
102  * @param cur_diff the dequantized and scaled delta calculated from the
103  *                 current codeword
104  */
105 static void do_adaptive_prediction(struct G722Band *band, const int cur_diff)
106 {
107     int sg[2], limit, i, cur_qtzd_reconst;
108
109     const int cur_part_reconst = band->s_zero + cur_diff < 0;
110
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;
115
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);
118
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);
121
122
123     if (cur_diff) {
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);
127     } else
128         for (i = 0; i < 6; i++)
129             band->zero_mem[i] = (band->zero_mem[i]*255) >> 8;
130
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);
134
135     band->s_zero = 0;
136     for (i = 5; i >= 0; i--)
137         band->s_zero += (band->zero_mem[i]*band->diff_mem[i]) >> 15;
138
139
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;
145 }
146
147 static int inline linear_scale_factor(const int log_factor)
148 {
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;
152 }
153
154 static void update_low_predictor(struct G722Band *band, const int ilow)
155 {
156     do_adaptive_prediction(band,
157                            band->scale_factor * low_inv_quant4[ilow] >> 10);
158
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));
163 }
164
165 static void update_high_predictor(struct G722Band *band, const int dhigh,
166                                   const int ihigh)
167 {
168     do_adaptive_prediction(band, dhigh);
169
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));
174 }
175
176 static void apply_qmf(const int16_t *prev_samples, int *xout1, int *xout2)
177 {
178     int i;
179
180     *xout1 = 0;
181     *xout2 = 0;
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]);
185     }
186 }
187
188 static av_cold int g722_init(AVCodecContext * avctx)
189 {
190     G722Context *c = avctx->priv_data;
191
192     if (avctx->channels != 1) {
193         av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n");
194         return AVERROR_INVALIDDATA;
195     }
196     avctx->sample_fmt = SAMPLE_FMT_S16;
197
198     switch (avctx->bits_per_coded_sample) {
199     case 8:
200     case 7:
201     case 6:
202         break;
203     default:
204         av_log(avctx, AV_LOG_WARNING, "Unsupported bits_per_coded_sample [%d], "
205                                       "assuming 8\n",
206                                       avctx->bits_per_coded_sample);
207     case 0:
208         avctx->bits_per_coded_sample = 8;
209         break;
210     }
211
212     c->band[0].scale_factor = 8;
213     c->band[1].scale_factor = 2;
214     c->prev_samples_pos = 22;
215
216     if (avctx->lowres)
217         avctx->sample_rate /= 2;
218
219     return 0;
220 }
221
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
228 };
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
238 };
239
240 static const int16_t *low_inv_quants[3] = { low_inv_quant6, low_inv_quant5,
241                                  low_inv_quant4 };
242
243 static int g722_decode_frame(AVCodecContext *avctx, void *data,
244                              int *data_size, AVPacket *avpkt)
245 {
246     G722Context *c = avctx->priv_data;
247     int16_t *out_buf = data;
248     int j, out_len = 0;
249     const int skip = 8 - avctx->bits_per_coded_sample;
250     const int16_t *quantizer_table = low_inv_quants[skip];
251     GetBitContext gb;
252
253     init_get_bits(&gb, avpkt->data, avpkt->size * 8);
254
255     for (j = 0; j < avpkt->size; j++) {
256         int ilow, ihigh, rlow;
257
258         ihigh = get_bits(&gb, 2);
259         ilow = get_bits(&gb, 6 - skip);
260         skip_bits(&gb, skip);
261
262         rlow = av_clip((c->band[0].scale_factor * quantizer_table[ilow] >> 10)
263                       + c->band[0].s_predictor, -16384, 16383);
264
265         update_low_predictor(&c->band[0], ilow >> (2 - skip));
266
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,
271                                       -16384, 16383);
272             int xout1, xout2;
273
274             update_high_predictor(&c->band[1], dhigh, ihigh);
275
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,
279                       &xout1, &xout2);
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;
287             }
288         } else
289             out_buf[out_len++] = rlow;
290     }
291     *data_size = out_len << 1;
292     return avpkt->size;
293 }
294
295 AVCodec adpcm_g722_decoder = {
296     .name           = "g722",
297     .type           = AVMEDIA_TYPE_AUDIO,
298     .id             = CODEC_ID_ADPCM_G722,
299     .priv_data_size = sizeof(G722Context),
300     .init           = g722_init,
301     .decode         = g722_decode_frame,
302     .long_name      = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
303     .max_lowres     = 1,
304 };
305 #endif
306
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
313 };
314
315 static inline void filter_samples(G722Context *c, const int16_t *samples,
316                                   int *xlow, int *xhigh)
317 {
318     int xout1, xout2;
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;
329     }
330 }
331
332 static inline int encode_high(const struct G722Band *state, int xhigh)
333 {
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);
338 }
339
340 static inline int encode_low(const struct G722Band* state, int xlow)
341 {
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));
345     int i = 0;
346     limit = limit + 1 << 10;
347     if (limit > low_quant[8] * state->scale_factor)
348         i = 9;
349     while (i < 29 && limit > low_quant[i] * state->scale_factor)
350         i++;
351     return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
352 }
353
354 static int g722_encode_frame(AVCodecContext *avctx,
355                              uint8_t *dst, int buf_size, void *data)
356 {
357     G722Context *c = avctx->priv_data;
358     const int16_t *samples = data;
359     int i;
360
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;
370     }
371     return i;
372 }
373
374 AVCodec adpcm_g722_encoder = {
375     .name           = "g722",
376     .type           = AVMEDIA_TYPE_AUDIO,
377     .id             = CODEC_ID_ADPCM_G722,
378     .priv_data_size = sizeof(G722Context),
379     .init           = g722_init,
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},
383 };
384 #endif
385