1 /*
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
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg 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.
14 *
15 * FFmpeg 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.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /**
26 * @file
27 * G.722 ADPCM audio encoder
28 */
29
30 #include "libavutil/avassert.h"
31 #include "avcodec.h"
32 #include "internal.h"
33 #include "g722.h"
34 #include "libavutil/common.h"
35
36 #define FREEZE_INTERVAL 128
37
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
41
42 /* We clip the value of avctx->trellis to prevent data type overflows and
43 undefined behavior. Using larger values is insanely slow anyway. */
44 #define MIN_TRELLIS 0
45 #define MAX_TRELLIS 16
46
g722_encode_close(AVCodecContext * avctx)47 static av_cold int g722_encode_close(AVCodecContext *avctx)
48 {
49 G722Context *c = avctx->priv_data;
50 int i;
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]);
55 }
56 return 0;
57 }
58
g722_encode_init(AVCodecContext * avctx)59 static av_cold int g722_encode_init(AVCodecContext * avctx)
60 {
61 G722Context *c = avctx->priv_data;
62 int ret;
63
64 c->band[0].scale_factor = 8;
65 c->band[1].scale_factor = 2;
66 c->prev_samples_pos = 22;
67
68 if (avctx->trellis) {
69 int frontier = 1 << avctx->trellis;
70 int max_paths = frontier * FREEZE_INTERVAL;
71 int i;
72 for (i = 0; i < 2; i++) {
73 c->paths[i] = av_mallocz_array(max_paths, sizeof(**c->paths));
74 c->node_buf[i] = av_mallocz_array(frontier, 2 * sizeof(**c->node_buf));
75 c->nodep_buf[i] = av_mallocz_array(frontier, 2 * sizeof(**c->nodep_buf));
76 if (!c->paths[i] || !c->node_buf[i] || !c->nodep_buf[i]) {
77 ret = AVERROR(ENOMEM);
78 goto error;
79 }
80 }
81 }
82
83 if (avctx->frame_size) {
84 /* validate frame size */
85 if (avctx->frame_size & 1 || avctx->frame_size > MAX_FRAME_SIZE) {
86 int new_frame_size;
87
88 if (avctx->frame_size == 1)
89 new_frame_size = 2;
90 else if (avctx->frame_size > MAX_FRAME_SIZE)
91 new_frame_size = MAX_FRAME_SIZE;
92 else
93 new_frame_size = avctx->frame_size - 1;
94
95 av_log(avctx, AV_LOG_WARNING, "Requested frame size is not "
96 "allowed. Using %d instead of %d\n", new_frame_size,
97 avctx->frame_size);
98 avctx->frame_size = new_frame_size;
99 }
100 } else {
101 /* This is arbitrary. We use 320 because it's 20ms @ 16kHz, which is
102 a common packet size for VoIP applications */
103 avctx->frame_size = 320;
104 }
105 avctx->initial_padding = 22;
106
107 if (avctx->trellis) {
108 /* validate trellis */
109 if (avctx->trellis < MIN_TRELLIS || avctx->trellis > MAX_TRELLIS) {
110 int new_trellis = av_clip(avctx->trellis, MIN_TRELLIS, MAX_TRELLIS);
111 av_log(avctx, AV_LOG_WARNING, "Requested trellis value is not "
112 "allowed. Using %d instead of %d\n", new_trellis,
113 avctx->trellis);
114 avctx->trellis = new_trellis;
115 }
116 }
117
118 ff_g722dsp_init(&c->dsp);
119
120 return 0;
121 error:
122 g722_encode_close(avctx);
123 return ret;
124 }
125
126 static const int16_t low_quant[33] = {
127 35, 72, 110, 150, 190, 233, 276, 323,
128 370, 422, 473, 530, 587, 650, 714, 786,
129 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
130 1765, 1980, 2195, 2557, 2919
131 };
132
filter_samples(G722Context * c,const int16_t * samples,int * xlow,int * xhigh)133 static inline void filter_samples(G722Context *c, const int16_t *samples,
134 int *xlow, int *xhigh)
135 {
136 int xout[2];
137 c->prev_samples[c->prev_samples_pos++] = samples[0];
138 c->prev_samples[c->prev_samples_pos++] = samples[1];
139 c->dsp.apply_qmf(c->prev_samples + c->prev_samples_pos - 24, xout);
140 *xlow = xout[0] + xout[1] >> 14;
141 *xhigh = xout[0] - xout[1] >> 14;
142 if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
143 memmove(c->prev_samples,
144 c->prev_samples + c->prev_samples_pos - 22,
145 22 * sizeof(c->prev_samples[0]));
146 c->prev_samples_pos = 22;
147 }
148 }
149
encode_high(const struct G722Band * state,int xhigh)150 static inline int encode_high(const struct G722Band *state, int xhigh)
151 {
152 int diff = av_clip_int16(xhigh - state->s_predictor);
153 int pred = 141 * state->scale_factor >> 8;
154 /* = diff >= 0 ? (diff < pred) + 2 : diff >= -pred */
155 return ((diff ^ (diff >> (sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
156 }
157
encode_low(const struct G722Band * state,int xlow)158 static inline int encode_low(const struct G722Band* state, int xlow)
159 {
160 int diff = av_clip_int16(xlow - state->s_predictor);
161 /* = diff >= 0 ? diff : -(diff + 1) */
162 int limit = diff ^ (diff >> (sizeof(diff)*8-1));
163 int i = 0;
164 limit = limit + 1 << 10;
165 if (limit > low_quant[8] * state->scale_factor)
166 i = 9;
167 while (i < 29 && limit > low_quant[i] * state->scale_factor)
168 i++;
169 return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
170 }
171
g722_encode_trellis(G722Context * c,int trellis,uint8_t * dst,int nb_samples,const int16_t * samples)172 static void g722_encode_trellis(G722Context *c, int trellis,
173 uint8_t *dst, int nb_samples,
174 const int16_t *samples)
175 {
176 int i, j, k;
177 int frontier = 1 << trellis;
178 struct TrellisNode **nodes[2];
179 struct TrellisNode **nodes_next[2];
180 int pathn[2] = {0, 0}, froze = -1;
181 struct TrellisPath *p[2];
182
183 for (i = 0; i < 2; i++) {
184 nodes[i] = c->nodep_buf[i];
185 nodes_next[i] = c->nodep_buf[i] + frontier;
186 memset(c->nodep_buf[i], 0, 2 * frontier * sizeof(*c->nodep_buf[i]));
187 nodes[i][0] = c->node_buf[i] + frontier;
188 nodes[i][0]->ssd = 0;
189 nodes[i][0]->path = 0;
190 nodes[i][0]->state = c->band[i];
191 }
192
193 for (i = 0; i < nb_samples >> 1; i++) {
194 int xlow, xhigh;
195 struct TrellisNode *next[2];
196 int heap_pos[2] = {0, 0};
197
198 for (j = 0; j < 2; j++) {
199 next[j] = c->node_buf[j] + frontier*(i & 1);
200 memset(nodes_next[j], 0, frontier * sizeof(**nodes_next));
201 }
202
203 filter_samples(c, &samples[2*i], &xlow, &xhigh);
204
205 for (j = 0; j < frontier && nodes[0][j]; j++) {
206 /* Only k >> 2 affects the future adaptive state, therefore testing
207 * small steps that don't change k >> 2 is useless, the original
208 * value from encode_low is better than them. Since we step k
209 * in steps of 4, make sure range is a multiple of 4, so that
210 * we don't miss the original value from encode_low. */
211 int range = j < frontier/2 ? 4 : 0;
212 struct TrellisNode *cur_node = nodes[0][j];
213
214 int ilow = encode_low(&cur_node->state, xlow);
215
216 for (k = ilow - range; k <= ilow + range && k <= 63; k += 4) {
217 int decoded, dec_diff, pos;
218 uint32_t ssd;
219 struct TrellisNode* node;
220
221 if (k < 0)
222 continue;
223
224 decoded = av_clip_intp2((cur_node->state.scale_factor *
225 ff_g722_low_inv_quant6[k] >> 10)
226 + cur_node->state.s_predictor, 14);
227 dec_diff = xlow - decoded;
228
229 #define STORE_NODE(index, UPDATE, VALUE)\
230 ssd = cur_node->ssd + dec_diff*dec_diff;\
231 /* Check for wraparound. Using 64 bit ssd counters would \
232 * be simpler, but is slower on x86 32 bit. */\
233 if (ssd < cur_node->ssd)\
234 continue;\
235 if (heap_pos[index] < frontier) {\
236 pos = heap_pos[index]++;\
237 av_assert2(pathn[index] < FREEZE_INTERVAL * frontier);\
238 node = nodes_next[index][pos] = next[index]++;\
239 node->path = pathn[index]++;\
240 } else {\
241 /* Try to replace one of the leaf nodes with the new \
242 * one, but not always testing the same leaf position */\
243 pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
244 if (ssd >= nodes_next[index][pos]->ssd)\
245 continue;\
246 heap_pos[index]++;\
247 node = nodes_next[index][pos];\
248 }\
249 node->ssd = ssd;\
250 node->state = cur_node->state;\
251 UPDATE;\
252 c->paths[index][node->path].value = VALUE;\
253 c->paths[index][node->path].prev = cur_node->path;\
254 /* Sift the newly inserted node up in the heap to restore \
255 * the heap property */\
256 while (pos > 0) {\
257 int parent = (pos - 1) >> 1;\
258 if (nodes_next[index][parent]->ssd <= ssd)\
259 break;\
260 FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
261 nodes_next[index][pos]);\
262 pos = parent;\
263 }
264 STORE_NODE(0, ff_g722_update_low_predictor(&node->state, k >> 2), k);
265 }
266 }
267
268 for (j = 0; j < frontier && nodes[1][j]; j++) {
269 int ihigh;
270 struct TrellisNode *cur_node = nodes[1][j];
271
272 /* We don't try to get any initial guess for ihigh via
273 * encode_high - since there's only 4 possible values, test
274 * them all. Testing all of these gives a much, much larger
275 * gain than testing a larger range around ilow. */
276 for (ihigh = 0; ihigh < 4; ihigh++) {
277 int dhigh, decoded, dec_diff, pos;
278 uint32_t ssd;
279 struct TrellisNode* node;
280
281 dhigh = cur_node->state.scale_factor *
282 ff_g722_high_inv_quant[ihigh] >> 10;
283 decoded = av_clip_intp2(dhigh + cur_node->state.s_predictor, 14);
284 dec_diff = xhigh - decoded;
285
286 STORE_NODE(1, ff_g722_update_high_predictor(&node->state, dhigh, ihigh), ihigh);
287 }
288 }
289
290 for (j = 0; j < 2; j++) {
291 FFSWAP(struct TrellisNode**, nodes[j], nodes_next[j]);
292
293 if (nodes[j][0]->ssd > (1 << 16)) {
294 for (k = 1; k < frontier && nodes[j][k]; k++)
295 nodes[j][k]->ssd -= nodes[j][0]->ssd;
296 nodes[j][0]->ssd = 0;
297 }
298 }
299
300 if (i == froze + FREEZE_INTERVAL) {
301 p[0] = &c->paths[0][nodes[0][0]->path];
302 p[1] = &c->paths[1][nodes[1][0]->path];
303 for (j = i; j > froze; j--) {
304 dst[j] = p[1]->value << 6 | p[0]->value;
305 p[0] = &c->paths[0][p[0]->prev];
306 p[1] = &c->paths[1][p[1]->prev];
307 }
308 froze = i;
309 pathn[0] = pathn[1] = 0;
310 memset(nodes[0] + 1, 0, (frontier - 1)*sizeof(**nodes));
311 memset(nodes[1] + 1, 0, (frontier - 1)*sizeof(**nodes));
312 }
313 }
314
315 p[0] = &c->paths[0][nodes[0][0]->path];
316 p[1] = &c->paths[1][nodes[1][0]->path];
317 for (j = i; j > froze; j--) {
318 dst[j] = p[1]->value << 6 | p[0]->value;
319 p[0] = &c->paths[0][p[0]->prev];
320 p[1] = &c->paths[1][p[1]->prev];
321 }
322 c->band[0] = nodes[0][0]->state;
323 c->band[1] = nodes[1][0]->state;
324 }
325
encode_byte(G722Context * c,uint8_t * dst,const int16_t * samples)326 static av_always_inline void encode_byte(G722Context *c, uint8_t *dst,
327 const int16_t *samples)
328 {
329 int xlow, xhigh, ilow, ihigh;
330 filter_samples(c, samples, &xlow, &xhigh);
331 ihigh = encode_high(&c->band[1], xhigh);
332 ilow = encode_low (&c->band[0], xlow);
333 ff_g722_update_high_predictor(&c->band[1], c->band[1].scale_factor *
334 ff_g722_high_inv_quant[ihigh] >> 10, ihigh);
335 ff_g722_update_low_predictor(&c->band[0], ilow >> 2);
336 *dst = ihigh << 6 | ilow;
337 }
338
g722_encode_no_trellis(G722Context * c,uint8_t * dst,int nb_samples,const int16_t * samples)339 static void g722_encode_no_trellis(G722Context *c,
340 uint8_t *dst, int nb_samples,
341 const int16_t *samples)
342 {
343 int i;
344 for (i = 0; i < nb_samples; i += 2)
345 encode_byte(c, dst++, &samples[i]);
346 }
347
g722_encode_frame(AVCodecContext * avctx,AVPacket * avpkt,const AVFrame * frame,int * got_packet_ptr)348 static int g722_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
349 const AVFrame *frame, int *got_packet_ptr)
350 {
351 G722Context *c = avctx->priv_data;
352 const int16_t *samples = (const int16_t *)frame->data[0];
353 int nb_samples, out_size, ret;
354
355 out_size = (frame->nb_samples + 1) / 2;
356 if ((ret = ff_alloc_packet2(avctx, avpkt, out_size, 0)) < 0)
357 return ret;
358
359 nb_samples = frame->nb_samples - (frame->nb_samples & 1);
360
361 if (avctx->trellis)
362 g722_encode_trellis(c, avctx->trellis, avpkt->data, nb_samples, samples);
363 else
364 g722_encode_no_trellis(c, avpkt->data, nb_samples, samples);
365
366 /* handle last frame with odd frame_size */
367 if (nb_samples < frame->nb_samples) {
368 int16_t last_samples[2] = { samples[nb_samples], samples[nb_samples] };
369 encode_byte(c, &avpkt->data[nb_samples >> 1], last_samples);
370 }
371
372 if (frame->pts != AV_NOPTS_VALUE)
373 avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
374 *got_packet_ptr = 1;
375 return 0;
376 }
377
378 AVCodec ff_adpcm_g722_encoder = {
379 .name = "g722",
380 .long_name = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
381 .type = AVMEDIA_TYPE_AUDIO,
382 .id = AV_CODEC_ID_ADPCM_G722,
383 .priv_data_size = sizeof(G722Context),
384 .init = g722_encode_init,
385 .close = g722_encode_close,
386 .encode2 = g722_encode_frame,
387 .capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME,
388 .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },
389 .channel_layouts = (const uint64_t[]){ AV_CH_LAYOUT_MONO, 0 },
390 };
391