aacsbr: prevent multiple ff_aac_sbr_ctx_init()
[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  * G.722 ADPCM audio codec
30  *
31  * This G.722 decoder is a bit-exact implementation of the ITU G.722
32  * specification for all three specified bitrates - 64000bps, 56000bps
33  * and 48000bps. It passes the ITU tests.
34  *
35  * @note For the 56000bps and 48000bps bitrates, the lowest 1 or 2 bits
36  *       respectively of each byte are ignored.
37  */
38
39 #include "avcodec.h"
40 #include "mathops.h"
41 #include "get_bits.h"
42
43 #define PREV_SAMPLES_BUF_SIZE 1024
44
45 #define FREEZE_INTERVAL 128
46
47 typedef struct {
48     int16_t prev_samples[PREV_SAMPLES_BUF_SIZE]; ///< memory of past decoded samples
49     int     prev_samples_pos;        ///< the number of values in prev_samples
50
51     /**
52      * The band[0] and band[1] correspond respectively to the lower band and higher band.
53      */
54     struct G722Band {
55         int16_t s_predictor;         ///< predictor output value
56         int32_t s_zero;              ///< previous output signal from zero predictor
57         int8_t  part_reconst_mem[2]; ///< signs of previous partially reconstructed signals
58         int16_t prev_qtzd_reconst;   ///< previous quantized reconstructed signal (internal value, using low_inv_quant4)
59         int16_t pole_mem[2];         ///< second-order pole section coefficient buffer
60         int32_t diff_mem[6];         ///< quantizer difference signal memory
61         int16_t zero_mem[6];         ///< Seventh-order zero section coefficient buffer
62         int16_t log_factor;          ///< delayed 2-logarithmic quantizer factor
63         int16_t scale_factor;        ///< delayed quantizer scale factor
64     } band[2];
65
66     struct TrellisNode {
67         struct G722Band state;
68         uint32_t ssd;
69         int path;
70     } *node_buf[2], **nodep_buf[2];
71
72     struct TrellisPath {
73         int value;
74         int prev;
75     } *paths[2];
76 } G722Context;
77
78
79 static const int8_t sign_lookup[2] = { -1, 1 };
80
81 static const int16_t inv_log2_table[32] = {
82     2048, 2093, 2139, 2186, 2233, 2282, 2332, 2383,
83     2435, 2489, 2543, 2599, 2656, 2714, 2774, 2834,
84     2896, 2960, 3025, 3091, 3158, 3228, 3298, 3371,
85     3444, 3520, 3597, 3676, 3756, 3838, 3922, 4008
86 };
87 static const int16_t high_log_factor_step[2] = { 798, -214 };
88 static const int16_t high_inv_quant[4] = { -926, -202, 926, 202 };
89 /**
90  * low_log_factor_step[index] == wl[rl42[index]]
91  */
92 static const int16_t low_log_factor_step[16] = {
93      -60, 3042, 1198, 538, 334, 172,  58, -30,
94     3042, 1198,  538, 334, 172,  58, -30, -60
95 };
96 static const int16_t low_inv_quant4[16] = {
97        0, -2557, -1612, -1121,  -786,  -530,  -323,  -150,
98     2557,  1612,  1121,   786,   530,   323,   150,     0
99 };
100 static const int16_t low_inv_quant6[64] = {
101      -17,   -17,   -17,   -17, -3101, -2738, -2376, -2088,
102    -1873, -1689, -1535, -1399, -1279, -1170, -1072,  -982,
103     -899,  -822,  -750,  -682,  -618,  -558,  -501,  -447,
104     -396,  -347,  -300,  -254,  -211,  -170,  -130,   -91,
105     3101,  2738,  2376,  2088,  1873,  1689,  1535,  1399,
106     1279,  1170,  1072,   982,   899,   822,   750,   682,
107      618,   558,   501,   447,   396,   347,   300,   254,
108      211,   170,   130,    91,    54,    17,   -54,   -17
109 };
110
111 /**
112  * quadrature mirror filter (QMF) coefficients
113  *
114  * ITU-T G.722 Table 11
115  */
116 static const int16_t qmf_coeffs[12] = {
117     3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11,
118 };
119
120
121 /**
122  * adaptive predictor
123  *
124  * @param cur_diff the dequantized and scaled delta calculated from the
125  *                 current codeword
126  */
127 static void do_adaptive_prediction(struct G722Band *band, const int cur_diff)
128 {
129     int sg[2], limit, i, cur_qtzd_reconst;
130
131     const int cur_part_reconst = band->s_zero + cur_diff < 0;
132
133     sg[0] = sign_lookup[cur_part_reconst != band->part_reconst_mem[0]];
134     sg[1] = sign_lookup[cur_part_reconst == band->part_reconst_mem[1]];
135     band->part_reconst_mem[1] = band->part_reconst_mem[0];
136     band->part_reconst_mem[0] = cur_part_reconst;
137
138     band->pole_mem[1] = av_clip((sg[0] * av_clip(band->pole_mem[0], -8191, 8191) >> 5) +
139                                 (sg[1] << 7) + (band->pole_mem[1] * 127 >> 7), -12288, 12288);
140
141     limit = 15360 - band->pole_mem[1];
142     band->pole_mem[0] = av_clip(-192 * sg[0] + (band->pole_mem[0] * 255 >> 8), -limit, limit);
143
144
145     if (cur_diff) {
146         for (i = 0; i < 6; i++)
147             band->zero_mem[i] = ((band->zero_mem[i]*255) >> 8) +
148                                 ((band->diff_mem[i]^cur_diff) < 0 ? -128 : 128);
149     } else
150         for (i = 0; i < 6; i++)
151             band->zero_mem[i] = (band->zero_mem[i]*255) >> 8;
152
153     for (i = 5; i > 0; i--)
154         band->diff_mem[i] = band->diff_mem[i-1];
155     band->diff_mem[0] = av_clip_int16(cur_diff << 1);
156
157     band->s_zero = 0;
158     for (i = 5; i >= 0; i--)
159         band->s_zero += (band->zero_mem[i]*band->diff_mem[i]) >> 15;
160
161
162     cur_qtzd_reconst = av_clip_int16((band->s_predictor + cur_diff) << 1);
163     band->s_predictor = av_clip_int16(band->s_zero +
164                                       (band->pole_mem[0] * cur_qtzd_reconst >> 15) +
165                                       (band->pole_mem[1] * band->prev_qtzd_reconst >> 15));
166     band->prev_qtzd_reconst = cur_qtzd_reconst;
167 }
168
169 static int inline linear_scale_factor(const int log_factor)
170 {
171     const int wd1 = inv_log2_table[(log_factor >> 6) & 31];
172     const int shift = log_factor >> 11;
173     return shift < 0 ? wd1 >> -shift : wd1 << shift;
174 }
175
176 static void update_low_predictor(struct G722Band *band, const int ilow)
177 {
178     do_adaptive_prediction(band,
179                            band->scale_factor * low_inv_quant4[ilow] >> 10);
180
181     // quantizer adaptation
182     band->log_factor   = av_clip((band->log_factor * 127 >> 7) +
183                                  low_log_factor_step[ilow], 0, 18432);
184     band->scale_factor = linear_scale_factor(band->log_factor - (8 << 11));
185 }
186
187 static void update_high_predictor(struct G722Band *band, const int dhigh,
188                                   const int ihigh)
189 {
190     do_adaptive_prediction(band, dhigh);
191
192     // quantizer adaptation
193     band->log_factor   = av_clip((band->log_factor * 127 >> 7) +
194                                  high_log_factor_step[ihigh&1], 0, 22528);
195     band->scale_factor = linear_scale_factor(band->log_factor - (10 << 11));
196 }
197
198 static void apply_qmf(const int16_t *prev_samples, int *xout1, int *xout2)
199 {
200     int i;
201
202     *xout1 = 0;
203     *xout2 = 0;
204     for (i = 0; i < 12; i++) {
205         MAC16(*xout2, prev_samples[2*i  ], qmf_coeffs[i   ]);
206         MAC16(*xout1, prev_samples[2*i+1], qmf_coeffs[11-i]);
207     }
208 }
209
210 static av_cold int g722_init(AVCodecContext * avctx)
211 {
212     G722Context *c = avctx->priv_data;
213
214     if (avctx->channels != 1) {
215         av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n");
216         return AVERROR_INVALIDDATA;
217     }
218     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
219
220     switch (avctx->bits_per_coded_sample) {
221     case 8:
222     case 7:
223     case 6:
224         break;
225     default:
226         av_log(avctx, AV_LOG_WARNING, "Unsupported bits_per_coded_sample [%d], "
227                                       "assuming 8\n",
228                                       avctx->bits_per_coded_sample);
229     case 0:
230         avctx->bits_per_coded_sample = 8;
231         break;
232     }
233
234     c->band[0].scale_factor = 8;
235     c->band[1].scale_factor = 2;
236     c->prev_samples_pos = 22;
237
238     if (avctx->lowres)
239         avctx->sample_rate /= 2;
240
241     if (avctx->trellis) {
242         int frontier = 1 << avctx->trellis;
243         int max_paths = frontier * FREEZE_INTERVAL;
244         int i;
245         for (i = 0; i < 2; i++) {
246             c->paths[i] = av_mallocz(max_paths * sizeof(**c->paths));
247             c->node_buf[i] = av_mallocz(2 * frontier * sizeof(**c->node_buf));
248             c->nodep_buf[i] = av_mallocz(2 * frontier * sizeof(**c->nodep_buf));
249         }
250     }
251
252     return 0;
253 }
254
255 static av_cold int g722_close(AVCodecContext *avctx)
256 {
257     G722Context *c = avctx->priv_data;
258     int i;
259     for (i = 0; i < 2; i++) {
260         av_freep(&c->paths[i]);
261         av_freep(&c->node_buf[i]);
262         av_freep(&c->nodep_buf[i]);
263     }
264     return 0;
265 }
266
267 #if CONFIG_ADPCM_G722_DECODER
268 static const int16_t low_inv_quant5[32] = {
269      -35,   -35, -2919, -2195, -1765, -1458, -1219, -1023,
270     -858,  -714,  -587,  -473,  -370,  -276,  -190,  -110,
271     2919,  2195,  1765,  1458,  1219,  1023,   858,   714,
272      587,   473,   370,   276,   190,   110,    35,   -35
273 };
274
275 static const int16_t *low_inv_quants[3] = { low_inv_quant6, low_inv_quant5,
276                                  low_inv_quant4 };
277
278 static int g722_decode_frame(AVCodecContext *avctx, void *data,
279                              int *data_size, AVPacket *avpkt)
280 {
281     G722Context *c = avctx->priv_data;
282     int16_t *out_buf = data;
283     int j, out_len = 0;
284     const int skip = 8 - avctx->bits_per_coded_sample;
285     const int16_t *quantizer_table = low_inv_quants[skip];
286     GetBitContext gb;
287
288     init_get_bits(&gb, avpkt->data, avpkt->size * 8);
289
290     for (j = 0; j < avpkt->size; j++) {
291         int ilow, ihigh, rlow;
292
293         ihigh = get_bits(&gb, 2);
294         ilow = get_bits(&gb, 6 - skip);
295         skip_bits(&gb, skip);
296
297         rlow = av_clip((c->band[0].scale_factor * quantizer_table[ilow] >> 10)
298                       + c->band[0].s_predictor, -16384, 16383);
299
300         update_low_predictor(&c->band[0], ilow >> (2 - skip));
301
302         if (!avctx->lowres) {
303             const int dhigh = c->band[1].scale_factor *
304                               high_inv_quant[ihigh] >> 10;
305             const int rhigh = av_clip(dhigh + c->band[1].s_predictor,
306                                       -16384, 16383);
307             int xout1, xout2;
308
309             update_high_predictor(&c->band[1], dhigh, ihigh);
310
311             c->prev_samples[c->prev_samples_pos++] = rlow + rhigh;
312             c->prev_samples[c->prev_samples_pos++] = rlow - rhigh;
313             apply_qmf(c->prev_samples + c->prev_samples_pos - 24,
314                       &xout1, &xout2);
315             out_buf[out_len++] = av_clip_int16(xout1 >> 12);
316             out_buf[out_len++] = av_clip_int16(xout2 >> 12);
317             if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
318                 memmove(c->prev_samples,
319                         c->prev_samples + c->prev_samples_pos - 22,
320                         22 * sizeof(c->prev_samples[0]));
321                 c->prev_samples_pos = 22;
322             }
323         } else
324             out_buf[out_len++] = rlow;
325     }
326     *data_size = out_len << 1;
327     return avpkt->size;
328 }
329
330 AVCodec ff_adpcm_g722_decoder = {
331     .name           = "g722",
332     .type           = AVMEDIA_TYPE_AUDIO,
333     .id             = CODEC_ID_ADPCM_G722,
334     .priv_data_size = sizeof(G722Context),
335     .init           = g722_init,
336     .decode         = g722_decode_frame,
337     .long_name      = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
338     .max_lowres     = 1,
339 };
340 #endif
341
342 #if CONFIG_ADPCM_G722_ENCODER
343 static const int16_t low_quant[33] = {
344       35,   72,  110,  150,  190,  233,  276,  323,
345      370,  422,  473,  530,  587,  650,  714,  786,
346      858,  940, 1023, 1121, 1219, 1339, 1458, 1612,
347     1765, 1980, 2195, 2557, 2919
348 };
349
350 static inline void filter_samples(G722Context *c, const int16_t *samples,
351                                   int *xlow, int *xhigh)
352 {
353     int xout1, xout2;
354     c->prev_samples[c->prev_samples_pos++] = samples[0];
355     c->prev_samples[c->prev_samples_pos++] = samples[1];
356     apply_qmf(c->prev_samples + c->prev_samples_pos - 24, &xout1, &xout2);
357     *xlow  = xout1 + xout2 >> 13;
358     *xhigh = xout1 - xout2 >> 13;
359     if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
360         memmove(c->prev_samples,
361                 c->prev_samples + c->prev_samples_pos - 22,
362                 22 * sizeof(c->prev_samples[0]));
363         c->prev_samples_pos = 22;
364     }
365 }
366
367 static inline int encode_high(const struct G722Band *state, int xhigh)
368 {
369     int diff = av_clip_int16(xhigh - state->s_predictor);
370     int pred = 141 * state->scale_factor >> 8;
371            /* = diff >= 0 ? (diff < pred) + 2 : diff >= -pred */
372     return ((diff ^ (diff >> (sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
373 }
374
375 static inline int encode_low(const struct G722Band* state, int xlow)
376 {
377     int diff  = av_clip_int16(xlow - state->s_predictor);
378            /* = diff >= 0 ? diff : -(diff + 1) */
379     int limit = diff ^ (diff >> (sizeof(diff)*8-1));
380     int i = 0;
381     limit = limit + 1 << 10;
382     if (limit > low_quant[8] * state->scale_factor)
383         i = 9;
384     while (i < 29 && limit > low_quant[i] * state->scale_factor)
385         i++;
386     return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
387 }
388
389 static int g722_encode_trellis(AVCodecContext *avctx,
390                                uint8_t *dst, int buf_size, void *data)
391 {
392     G722Context *c = avctx->priv_data;
393     const int16_t *samples = data;
394     int i, j, k;
395     int frontier = 1 << avctx->trellis;
396     struct TrellisNode **nodes[2];
397     struct TrellisNode **nodes_next[2];
398     int pathn[2] = {0, 0}, froze = -1;
399     struct TrellisPath *p[2];
400
401     for (i = 0; i < 2; i++) {
402         nodes[i] = c->nodep_buf[i];
403         nodes_next[i] = c->nodep_buf[i] + frontier;
404         memset(c->nodep_buf[i], 0, 2 * frontier * sizeof(*c->nodep_buf));
405         nodes[i][0] = c->node_buf[i] + frontier;
406         nodes[i][0]->ssd = 0;
407         nodes[i][0]->path = 0;
408         nodes[i][0]->state = c->band[i];
409     }
410
411     for (i = 0; i < buf_size >> 1; i++) {
412         int xlow, xhigh;
413         struct TrellisNode *next[2];
414         int heap_pos[2] = {0, 0};
415
416         for (j = 0; j < 2; j++) {
417             next[j] = c->node_buf[j] + frontier*(i & 1);
418             memset(nodes_next[j], 0, frontier * sizeof(**nodes_next));
419         }
420
421         filter_samples(c, &samples[2*i], &xlow, &xhigh);
422
423         for (j = 0; j < frontier && nodes[0][j]; j++) {
424             /* Only k >> 2 affects the future adaptive state, therefore testing
425              * small steps that don't change k >> 2 is useless, the orignal
426              * value from encode_low is better than them. Since we step k
427              * in steps of 4, make sure range is a multiple of 4, so that
428              * we don't miss the original value from encode_low. */
429             int range = j < frontier/2 ? 4 : 0;
430             struct TrellisNode *cur_node = nodes[0][j];
431
432             int ilow = encode_low(&cur_node->state, xlow);
433
434             for (k = ilow - range; k <= ilow + range && k <= 63; k += 4) {
435                 int decoded, dec_diff, pos;
436                 uint32_t ssd;
437                 struct TrellisNode* node;
438
439                 if (k < 0)
440                     continue;
441
442                 decoded = av_clip((cur_node->state.scale_factor *
443                                   low_inv_quant6[k] >> 10)
444                                 + cur_node->state.s_predictor, -16384, 16383);
445                 dec_diff = xlow - decoded;
446
447 #define STORE_NODE(index, UPDATE, VALUE)\
448                 ssd = cur_node->ssd + dec_diff*dec_diff;\
449                 /* Check for wraparound. Using 64 bit ssd counters would \
450                  * be simpler, but is slower on x86 32 bit. */\
451                 if (ssd < cur_node->ssd)\
452                     continue;\
453                 if (heap_pos[index] < frontier) {\
454                     pos = heap_pos[index]++;\
455                     assert(pathn[index] < FREEZE_INTERVAL * frontier);\
456                     node = nodes_next[index][pos] = next[index]++;\
457                     node->path = pathn[index]++;\
458                 } else {\
459                     /* Try to replace one of the leaf nodes with the new \
460                      * one, but not always testing the same leaf position */\
461                     pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
462                     if (ssd >= nodes_next[index][pos]->ssd)\
463                         continue;\
464                     heap_pos[index]++;\
465                     node = nodes_next[index][pos];\
466                 }\
467                 node->ssd = ssd;\
468                 node->state = cur_node->state;\
469                 UPDATE;\
470                 c->paths[index][node->path].value = VALUE;\
471                 c->paths[index][node->path].prev = cur_node->path;\
472                 /* Sift the newly inserted node up in the heap to restore \
473                  * the heap property */\
474                 while (pos > 0) {\
475                     int parent = (pos - 1) >> 1;\
476                     if (nodes_next[index][parent]->ssd <= ssd)\
477                         break;\
478                     FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
479                                                 nodes_next[index][pos]);\
480                     pos = parent;\
481                 }
482                 STORE_NODE(0, update_low_predictor(&node->state, k >> 2), k);
483             }
484         }
485
486         for (j = 0; j < frontier && nodes[1][j]; j++) {
487             int ihigh;
488             struct TrellisNode *cur_node = nodes[1][j];
489
490             /* We don't try to get any initial guess for ihigh via
491              * encode_high - since there's only 4 possible values, test
492              * them all. Testing all of these gives a much, much larger
493              * gain than testing a larger range around ilow. */
494             for (ihigh = 0; ihigh < 4; ihigh++) {
495                 int dhigh, decoded, dec_diff, pos;
496                 uint32_t ssd;
497                 struct TrellisNode* node;
498
499                 dhigh = cur_node->state.scale_factor *
500                         high_inv_quant[ihigh] >> 10;
501                 decoded = av_clip(dhigh + cur_node->state.s_predictor,
502                                   -16384, 16383);
503                 dec_diff = xhigh - decoded;
504
505                 STORE_NODE(1, update_high_predictor(&node->state, dhigh, ihigh), ihigh);
506             }
507         }
508
509         for (j = 0; j < 2; j++) {
510             FFSWAP(struct TrellisNode**, nodes[j], nodes_next[j]);
511
512             if (nodes[j][0]->ssd > (1 << 16)) {
513                 for (k = 1; k < frontier && nodes[j][k]; k++)
514                     nodes[j][k]->ssd -= nodes[j][0]->ssd;
515                 nodes[j][0]->ssd = 0;
516             }
517         }
518
519         if (i == froze + FREEZE_INTERVAL) {
520             p[0] = &c->paths[0][nodes[0][0]->path];
521             p[1] = &c->paths[1][nodes[1][0]->path];
522             for (j = i; j > froze; j--) {
523                 dst[j] = p[1]->value << 6 | p[0]->value;
524                 p[0] = &c->paths[0][p[0]->prev];
525                 p[1] = &c->paths[1][p[1]->prev];
526             }
527             froze = i;
528             pathn[0] = pathn[1] = 0;
529             memset(nodes[0] + 1, 0, (frontier - 1)*sizeof(**nodes));
530             memset(nodes[1] + 1, 0, (frontier - 1)*sizeof(**nodes));
531         }
532     }
533
534     p[0] = &c->paths[0][nodes[0][0]->path];
535     p[1] = &c->paths[1][nodes[1][0]->path];
536     for (j = i; j > froze; j--) {
537         dst[j] = p[1]->value << 6 | p[0]->value;
538         p[0] = &c->paths[0][p[0]->prev];
539         p[1] = &c->paths[1][p[1]->prev];
540     }
541     c->band[0] = nodes[0][0]->state;
542     c->band[1] = nodes[1][0]->state;
543
544     return i;
545 }
546
547 static int g722_encode_frame(AVCodecContext *avctx,
548                              uint8_t *dst, int buf_size, void *data)
549 {
550     G722Context *c = avctx->priv_data;
551     const int16_t *samples = data;
552     int i;
553
554     if (avctx->trellis)
555         return g722_encode_trellis(avctx, dst, buf_size, data);
556
557     for (i = 0; i < buf_size >> 1; i++) {
558         int xlow, xhigh, ihigh, ilow;
559         filter_samples(c, &samples[2*i], &xlow, &xhigh);
560         ihigh = encode_high(&c->band[1], xhigh);
561         ilow  = encode_low(&c->band[0], xlow);
562         update_high_predictor(&c->band[1], c->band[1].scale_factor *
563                               high_inv_quant[ihigh] >> 10, ihigh);
564         update_low_predictor(&c->band[0], ilow >> 2);
565         *dst++ = ihigh << 6 | ilow;
566     }
567     return i;
568 }
569
570 AVCodec ff_adpcm_g722_encoder = {
571     .name           = "g722",
572     .type           = AVMEDIA_TYPE_AUDIO,
573     .id             = CODEC_ID_ADPCM_G722,
574     .priv_data_size = sizeof(G722Context),
575     .init           = g722_init,
576     .close          = g722_close,
577     .encode         = g722_encode_frame,
578     .long_name      = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
579     .sample_fmts    = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
580 };
581 #endif
582