2 * Copyright (c) CMU 1993 Computer Science, Speech Group
3 * Chengxiang Lu and Alex Hauptmann
4 * Copyright (c) 2005 Steve Underwood <steveu at coppice.org>
5 * Copyright (c) 2009 Kenan Gillet
6 * Copyright (c) 2010 Martin Storsjo
8 * This file is part of Libav.
10 * Libav is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * Libav is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * G.722 ADPCM audio encoder
30 #include "libavutil/avassert.h"
34 #include "libavutil/common.h"
36 #define FREEZE_INTERVAL 128
38 /* This is an arbitrary value. Allowing insanely large values leads to strange
39 problems, so we limit it to a reasonable value */
40 #define MAX_FRAME_SIZE 32768
42 /* We clip the value of avctx->trellis to prevent data type overflows and
43 undefined behavior. Using larger values is insanely slow anyway. */
45 #define MAX_TRELLIS 16
47 static av_cold int g722_encode_close(AVCodecContext *avctx)
49 G722Context *c = avctx->priv_data;
51 for (i = 0; i < 2; i++) {
52 av_freep(&c->paths[i]);
53 av_freep(&c->node_buf[i]);
54 av_freep(&c->nodep_buf[i]);
56 #if FF_API_OLD_ENCODE_AUDIO
57 av_freep(&avctx->coded_frame);
62 static av_cold int g722_encode_init(AVCodecContext * avctx)
64 G722Context *c = avctx->priv_data;
67 if (avctx->channels != 1) {
68 av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n");
69 return AVERROR_INVALIDDATA;
72 c->band[0].scale_factor = 8;
73 c->band[1].scale_factor = 2;
74 c->prev_samples_pos = 22;
77 int frontier = 1 << avctx->trellis;
78 int max_paths = frontier * FREEZE_INTERVAL;
80 for (i = 0; i < 2; i++) {
81 c->paths[i] = av_mallocz(max_paths * sizeof(**c->paths));
82 c->node_buf[i] = av_mallocz(2 * frontier * sizeof(**c->node_buf));
83 c->nodep_buf[i] = av_mallocz(2 * frontier * sizeof(**c->nodep_buf));
84 if (!c->paths[i] || !c->node_buf[i] || !c->nodep_buf[i]) {
85 ret = AVERROR(ENOMEM);
91 if (avctx->frame_size) {
92 /* validate frame size */
93 if (avctx->frame_size & 1 || avctx->frame_size > MAX_FRAME_SIZE) {
96 if (avctx->frame_size == 1)
98 else if (avctx->frame_size > MAX_FRAME_SIZE)
99 new_frame_size = MAX_FRAME_SIZE;
101 new_frame_size = avctx->frame_size - 1;
103 av_log(avctx, AV_LOG_WARNING, "Requested frame size is not "
104 "allowed. Using %d instead of %d\n", new_frame_size,
106 avctx->frame_size = new_frame_size;
109 /* This is arbitrary. We use 320 because it's 20ms @ 16kHz, which is
110 a common packet size for VoIP applications */
111 avctx->frame_size = 320;
115 if (avctx->trellis) {
116 /* validate trellis */
117 if (avctx->trellis < MIN_TRELLIS || avctx->trellis > MAX_TRELLIS) {
118 int new_trellis = av_clip(avctx->trellis, MIN_TRELLIS, MAX_TRELLIS);
119 av_log(avctx, AV_LOG_WARNING, "Requested trellis value is not "
120 "allowed. Using %d instead of %d\n", new_trellis,
122 avctx->trellis = new_trellis;
126 #if FF_API_OLD_ENCODE_AUDIO
127 avctx->coded_frame = avcodec_alloc_frame();
128 if (!avctx->coded_frame) {
129 ret = AVERROR(ENOMEM);
136 g722_encode_close(avctx);
140 static const int16_t low_quant[33] = {
141 35, 72, 110, 150, 190, 233, 276, 323,
142 370, 422, 473, 530, 587, 650, 714, 786,
143 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
144 1765, 1980, 2195, 2557, 2919
147 static inline void filter_samples(G722Context *c, const int16_t *samples,
148 int *xlow, int *xhigh)
151 c->prev_samples[c->prev_samples_pos++] = samples[0];
152 c->prev_samples[c->prev_samples_pos++] = samples[1];
153 ff_g722_apply_qmf(c->prev_samples + c->prev_samples_pos - 24, &xout1, &xout2);
154 *xlow = xout1 + xout2 >> 14;
155 *xhigh = xout1 - xout2 >> 14;
156 if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
157 memmove(c->prev_samples,
158 c->prev_samples + c->prev_samples_pos - 22,
159 22 * sizeof(c->prev_samples[0]));
160 c->prev_samples_pos = 22;
164 static inline int encode_high(const struct G722Band *state, int xhigh)
166 int diff = av_clip_int16(xhigh - state->s_predictor);
167 int pred = 141 * state->scale_factor >> 8;
168 /* = diff >= 0 ? (diff < pred) + 2 : diff >= -pred */
169 return ((diff ^ (diff >> (sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
172 static inline int encode_low(const struct G722Band* state, int xlow)
174 int diff = av_clip_int16(xlow - state->s_predictor);
175 /* = diff >= 0 ? diff : -(diff + 1) */
176 int limit = diff ^ (diff >> (sizeof(diff)*8-1));
178 limit = limit + 1 << 10;
179 if (limit > low_quant[8] * state->scale_factor)
181 while (i < 29 && limit > low_quant[i] * state->scale_factor)
183 return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
186 static void g722_encode_trellis(G722Context *c, int trellis,
187 uint8_t *dst, int nb_samples,
188 const int16_t *samples)
191 int frontier = 1 << trellis;
192 struct TrellisNode **nodes[2];
193 struct TrellisNode **nodes_next[2];
194 int pathn[2] = {0, 0}, froze = -1;
195 struct TrellisPath *p[2];
197 for (i = 0; i < 2; i++) {
198 nodes[i] = c->nodep_buf[i];
199 nodes_next[i] = c->nodep_buf[i] + frontier;
200 memset(c->nodep_buf[i], 0, 2 * frontier * sizeof(*c->nodep_buf[i]));
201 nodes[i][0] = c->node_buf[i] + frontier;
202 nodes[i][0]->ssd = 0;
203 nodes[i][0]->path = 0;
204 nodes[i][0]->state = c->band[i];
207 for (i = 0; i < nb_samples >> 1; i++) {
209 struct TrellisNode *next[2];
210 int heap_pos[2] = {0, 0};
212 for (j = 0; j < 2; j++) {
213 next[j] = c->node_buf[j] + frontier*(i & 1);
214 memset(nodes_next[j], 0, frontier * sizeof(**nodes_next));
217 filter_samples(c, &samples[2*i], &xlow, &xhigh);
219 for (j = 0; j < frontier && nodes[0][j]; j++) {
220 /* Only k >> 2 affects the future adaptive state, therefore testing
221 * small steps that don't change k >> 2 is useless, the original
222 * value from encode_low is better than them. Since we step k
223 * in steps of 4, make sure range is a multiple of 4, so that
224 * we don't miss the original value from encode_low. */
225 int range = j < frontier/2 ? 4 : 0;
226 struct TrellisNode *cur_node = nodes[0][j];
228 int ilow = encode_low(&cur_node->state, xlow);
230 for (k = ilow - range; k <= ilow + range && k <= 63; k += 4) {
231 int decoded, dec_diff, pos;
233 struct TrellisNode* node;
238 decoded = av_clip((cur_node->state.scale_factor *
239 ff_g722_low_inv_quant6[k] >> 10)
240 + cur_node->state.s_predictor, -16384, 16383);
241 dec_diff = xlow - decoded;
243 #define STORE_NODE(index, UPDATE, VALUE)\
244 ssd = cur_node->ssd + dec_diff*dec_diff;\
245 /* Check for wraparound. Using 64 bit ssd counters would \
246 * be simpler, but is slower on x86 32 bit. */\
247 if (ssd < cur_node->ssd)\
249 if (heap_pos[index] < frontier) {\
250 pos = heap_pos[index]++;\
251 av_assert2(pathn[index] < FREEZE_INTERVAL * frontier);\
252 node = nodes_next[index][pos] = next[index]++;\
253 node->path = pathn[index]++;\
255 /* Try to replace one of the leaf nodes with the new \
256 * one, but not always testing the same leaf position */\
257 pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
258 if (ssd >= nodes_next[index][pos]->ssd)\
261 node = nodes_next[index][pos];\
264 node->state = cur_node->state;\
266 c->paths[index][node->path].value = VALUE;\
267 c->paths[index][node->path].prev = cur_node->path;\
268 /* Sift the newly inserted node up in the heap to restore \
269 * the heap property */\
271 int parent = (pos - 1) >> 1;\
272 if (nodes_next[index][parent]->ssd <= ssd)\
274 FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
275 nodes_next[index][pos]);\
278 STORE_NODE(0, ff_g722_update_low_predictor(&node->state, k >> 2), k);
282 for (j = 0; j < frontier && nodes[1][j]; j++) {
284 struct TrellisNode *cur_node = nodes[1][j];
286 /* We don't try to get any initial guess for ihigh via
287 * encode_high - since there's only 4 possible values, test
288 * them all. Testing all of these gives a much, much larger
289 * gain than testing a larger range around ilow. */
290 for (ihigh = 0; ihigh < 4; ihigh++) {
291 int dhigh, decoded, dec_diff, pos;
293 struct TrellisNode* node;
295 dhigh = cur_node->state.scale_factor *
296 ff_g722_high_inv_quant[ihigh] >> 10;
297 decoded = av_clip(dhigh + cur_node->state.s_predictor,
299 dec_diff = xhigh - decoded;
301 STORE_NODE(1, ff_g722_update_high_predictor(&node->state, dhigh, ihigh), ihigh);
305 for (j = 0; j < 2; j++) {
306 FFSWAP(struct TrellisNode**, nodes[j], nodes_next[j]);
308 if (nodes[j][0]->ssd > (1 << 16)) {
309 for (k = 1; k < frontier && nodes[j][k]; k++)
310 nodes[j][k]->ssd -= nodes[j][0]->ssd;
311 nodes[j][0]->ssd = 0;
315 if (i == froze + FREEZE_INTERVAL) {
316 p[0] = &c->paths[0][nodes[0][0]->path];
317 p[1] = &c->paths[1][nodes[1][0]->path];
318 for (j = i; j > froze; j--) {
319 dst[j] = p[1]->value << 6 | p[0]->value;
320 p[0] = &c->paths[0][p[0]->prev];
321 p[1] = &c->paths[1][p[1]->prev];
324 pathn[0] = pathn[1] = 0;
325 memset(nodes[0] + 1, 0, (frontier - 1)*sizeof(**nodes));
326 memset(nodes[1] + 1, 0, (frontier - 1)*sizeof(**nodes));
330 p[0] = &c->paths[0][nodes[0][0]->path];
331 p[1] = &c->paths[1][nodes[1][0]->path];
332 for (j = i; j > froze; j--) {
333 dst[j] = p[1]->value << 6 | p[0]->value;
334 p[0] = &c->paths[0][p[0]->prev];
335 p[1] = &c->paths[1][p[1]->prev];
337 c->band[0] = nodes[0][0]->state;
338 c->band[1] = nodes[1][0]->state;
341 static av_always_inline void encode_byte(G722Context *c, uint8_t *dst,
342 const int16_t *samples)
344 int xlow, xhigh, ilow, ihigh;
345 filter_samples(c, samples, &xlow, &xhigh);
346 ihigh = encode_high(&c->band[1], xhigh);
347 ilow = encode_low (&c->band[0], xlow);
348 ff_g722_update_high_predictor(&c->band[1], c->band[1].scale_factor *
349 ff_g722_high_inv_quant[ihigh] >> 10, ihigh);
350 ff_g722_update_low_predictor(&c->band[0], ilow >> 2);
351 *dst = ihigh << 6 | ilow;
354 static void g722_encode_no_trellis(G722Context *c,
355 uint8_t *dst, int nb_samples,
356 const int16_t *samples)
359 for (i = 0; i < nb_samples; i += 2)
360 encode_byte(c, dst++, &samples[i]);
363 static int g722_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
364 const AVFrame *frame, int *got_packet_ptr)
366 G722Context *c = avctx->priv_data;
367 const int16_t *samples = (const int16_t *)frame->data[0];
368 int nb_samples, out_size, ret;
370 out_size = (frame->nb_samples + 1) / 2;
371 if ((ret = ff_alloc_packet2(avctx, avpkt, out_size)))
374 nb_samples = frame->nb_samples - (frame->nb_samples & 1);
377 g722_encode_trellis(c, avctx->trellis, avpkt->data, nb_samples, samples);
379 g722_encode_no_trellis(c, avpkt->data, nb_samples, samples);
381 /* handle last frame with odd frame_size */
382 if (nb_samples < frame->nb_samples) {
383 int16_t last_samples[2] = { samples[nb_samples], samples[nb_samples] };
384 encode_byte(c, &avpkt->data[nb_samples >> 1], last_samples);
387 if (frame->pts != AV_NOPTS_VALUE)
388 avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
393 AVCodec ff_adpcm_g722_encoder = {
395 .type = AVMEDIA_TYPE_AUDIO,
396 .id = AV_CODEC_ID_ADPCM_G722,
397 .priv_data_size = sizeof(G722Context),
398 .init = g722_encode_init,
399 .close = g722_encode_close,
400 .encode2 = g722_encode_frame,
401 .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
402 .long_name = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
403 .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
404 AV_SAMPLE_FMT_NONE },