Statistics
| Branch: | Revision:

ffmpeg / libavcodec / g722.c @ 21e681ba

History | View | Annotate | Download (13.4 KB)

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