1/*
2 * AMR Audio decoder stub
3 * Copyright (c) 2003 the ffmpeg project
4 *
5 * This file is part of Libav.
6 *
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "avcodec.h"
23#include "libavutil/avstring.h"
24#include "libavutil/opt.h"
25
26static void amr_decode_fix_avctx(AVCodecContext *avctx)
27{
28    const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
29
30    if (!avctx->sample_rate)
31        avctx->sample_rate = 8000 * is_amr_wb;
32
33    if (!avctx->channels)
34        avctx->channels = 1;
35
36    avctx->frame_size = 160 * is_amr_wb;
37    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
38}
39
40#if CONFIG_LIBOPENCORE_AMRNB
41
42#include <opencore-amrnb/interf_dec.h>
43#include <opencore-amrnb/interf_enc.h>
44
45/* Common code for fixed and float version*/
46typedef struct AMR_bitrates {
47    int       rate;
48    enum Mode mode;
49} AMR_bitrates;
50
51/* Match desired bitrate */
52static int get_bitrate_mode(int bitrate, void *log_ctx)
53{
54    /* make the correspondance between bitrate and mode */
55    static const AMR_bitrates rates[] = {
56        { 4750, MR475 }, { 5150, MR515 }, {  5900, MR59  }, {  6700, MR67  },
57        { 7400, MR74 },  { 7950, MR795 }, { 10200, MR102 }, { 12200, MR122 }
58    };
59    int i, best = -1, min_diff = 0;
60    char log_buf[200];
61
62    for (i = 0; i < 8; i++) {
63        if (rates[i].rate == bitrate)
64            return rates[i].mode;
65        if (best < 0 || abs(rates[i].rate - bitrate) < min_diff) {
66            best     = i;
67            min_diff = abs(rates[i].rate - bitrate);
68        }
69    }
70    /* no bitrate matching exactly, log a warning */
71    snprintf(log_buf, sizeof(log_buf), "bitrate not supported: use one of ");
72    for (i = 0; i < 8; i++)
73        av_strlcatf(log_buf, sizeof(log_buf), "%.2fk, ", rates[i].rate    / 1000.f);
74    av_strlcatf(log_buf, sizeof(log_buf), "using %.2fk", rates[best].rate / 1000.f);
75    av_log(log_ctx, AV_LOG_WARNING, "%s\n", log_buf);
76
77    return best;
78}
79
80typedef struct AMRContext {
81    AVClass *av_class;
82    AVFrame frame;
83    void *dec_state;
84    void *enc_state;
85    int   enc_bitrate;
86    int   enc_mode;
87    int   enc_dtx;
88} AMRContext;
89
90static const AVOption options[] = {
91    { "dtx", "Allow DTX (generate comfort noise)", offsetof(AMRContext, enc_dtx), AV_OPT_TYPE_INT, { 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
92    { NULL }
93};
94
95static const AVClass class = {
96    "libopencore_amrnb", av_default_item_name, options, LIBAVUTIL_VERSION_INT
97};
98
99static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
100{
101    AMRContext *s  = avctx->priv_data;
102
103    s->dec_state   = Decoder_Interface_init();
104    if (!s->dec_state) {
105        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
106        return -1;
107    }
108
109    amr_decode_fix_avctx(avctx);
110
111    if (avctx->channels > 1) {
112        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
113        return AVERROR(ENOSYS);
114    }
115
116    avcodec_get_frame_defaults(&s->frame);
117    avctx->coded_frame = &s->frame;
118
119    return 0;
120}
121
122static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
123{
124    AMRContext *s = avctx->priv_data;
125
126    Decoder_Interface_exit(s->dec_state);
127
128    return 0;
129}
130
131static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
132                               int *got_frame_ptr, AVPacket *avpkt)
133{
134    const uint8_t *buf = avpkt->data;
135    int buf_size       = avpkt->size;
136    AMRContext *s      = avctx->priv_data;
137    static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
138    enum Mode dec_mode;
139    int packet_size, ret;
140
141    av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
142            buf, buf_size, avctx->frame_number);
143
144    /* get output buffer */
145    s->frame.nb_samples = 160;
146    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
147        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
148        return ret;
149    }
150
151    dec_mode    = (buf[0] >> 3) & 0x000F;
152    packet_size = block_size[dec_mode] + 1;
153
154    if (packet_size > buf_size) {
155        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
156               buf_size, packet_size);
157        return AVERROR_INVALIDDATA;
158    }
159
160    av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
161              packet_size, buf[0], buf[1], buf[2], buf[3]);
162    /* call decoder */
163    Decoder_Interface_Decode(s->dec_state, buf, (short *)s->frame.data[0], 0);
164
165    *got_frame_ptr   = 1;
166    *(AVFrame *)data = s->frame;
167
168    return packet_size;
169}
170
171AVCodec ff_libopencore_amrnb_decoder = {
172    .name           = "libopencore_amrnb",
173    .type           = AVMEDIA_TYPE_AUDIO,
174    .id             = CODEC_ID_AMR_NB,
175    .priv_data_size = sizeof(AMRContext),
176    .init           = amr_nb_decode_init,
177    .close          = amr_nb_decode_close,
178    .decode         = amr_nb_decode_frame,
179    .capabilities   = CODEC_CAP_DR1,
180    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
181};
182
183static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
184{
185    AMRContext *s = avctx->priv_data;
186
187    if (avctx->sample_rate != 8000) {
188        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
189        return AVERROR(ENOSYS);
190    }
191
192    if (avctx->channels != 1) {
193        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
194        return AVERROR(ENOSYS);
195    }
196
197    avctx->frame_size  = 160;
198    avctx->coded_frame = avcodec_alloc_frame();
199
200    s->enc_state = Encoder_Interface_init(s->enc_dtx);
201    if (!s->enc_state) {
202        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
203        return -1;
204    }
205
206    s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
207    s->enc_bitrate = avctx->bit_rate;
208
209    return 0;
210}
211
212static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
213{
214    AMRContext *s = avctx->priv_data;
215
216    Encoder_Interface_exit(s->enc_state);
217    av_freep(&avctx->coded_frame);
218    return 0;
219}
220
221static int amr_nb_encode_frame(AVCodecContext *avctx,
222                               unsigned char *frame/*out*/,
223                               int buf_size, void *data/*in*/)
224{
225    AMRContext *s = avctx->priv_data;
226    int written;
227
228    if (s->enc_bitrate != avctx->bit_rate) {
229        s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
230        s->enc_bitrate = avctx->bit_rate;
231    }
232
233    written = Encoder_Interface_Encode(s->enc_state, s->enc_mode, data,
234                                       frame, 0);
235    av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
236            written, s->enc_mode, frame[0]);
237
238    return written;
239}
240
241AVCodec ff_libopencore_amrnb_encoder = {
242    .name           = "libopencore_amrnb",
243    .type           = AVMEDIA_TYPE_AUDIO,
244    .id             = CODEC_ID_AMR_NB,
245    .priv_data_size = sizeof(AMRContext),
246    .init           = amr_nb_encode_init,
247    .encode         = amr_nb_encode_frame,
248    .close          = amr_nb_encode_close,
249    .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
250    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
251    .priv_class = &class,
252};
253
254#endif
255
256/* -----------AMR wideband ------------*/
257#if CONFIG_LIBOPENCORE_AMRWB
258
259#include <opencore-amrwb/dec_if.h>
260#include <opencore-amrwb/if_rom.h>
261
262typedef struct AMRWBContext {
263    AVFrame frame;
264    void  *state;
265} AMRWBContext;
266
267static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
268{
269    AMRWBContext *s = avctx->priv_data;
270
271    s->state        = D_IF_init();
272
273    amr_decode_fix_avctx(avctx);
274
275    if (avctx->channels > 1) {
276        av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
277        return AVERROR(ENOSYS);
278    }
279
280    avcodec_get_frame_defaults(&s->frame);
281    avctx->coded_frame = &s->frame;
282
283    return 0;
284}
285
286static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
287                               int *got_frame_ptr, AVPacket *avpkt)
288{
289    const uint8_t *buf = avpkt->data;
290    int buf_size       = avpkt->size;
291    AMRWBContext *s    = avctx->priv_data;
292    int mode, ret;
293    int packet_size;
294    static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
295
296    /* get output buffer */
297    s->frame.nb_samples = 320;
298    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
299        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
300        return ret;
301    }
302
303    mode        = (buf[0] >> 3) & 0x000F;
304    packet_size = block_size[mode];
305
306    if (packet_size > buf_size) {
307        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
308               buf_size, packet_size + 1);
309        return AVERROR_INVALIDDATA;
310    }
311
312    D_IF_decode(s->state, buf, (short *)s->frame.data[0], _good_frame);
313
314    *got_frame_ptr   = 1;
315    *(AVFrame *)data = s->frame;
316
317    return packet_size;
318}
319
320static int amr_wb_decode_close(AVCodecContext *avctx)
321{
322    AMRWBContext *s = avctx->priv_data;
323
324    D_IF_exit(s->state);
325    return 0;
326}
327
328AVCodec ff_libopencore_amrwb_decoder = {
329    .name           = "libopencore_amrwb",
330    .type           = AVMEDIA_TYPE_AUDIO,
331    .id             = CODEC_ID_AMR_WB,
332    .priv_data_size = sizeof(AMRWBContext),
333    .init           = amr_wb_decode_init,
334    .close          = amr_wb_decode_close,
335    .decode         = amr_wb_decode_frame,
336    .capabilities   = CODEC_CAP_DR1,
337    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),
338};
339
340#endif /* CONFIG_LIBOPENCORE_AMRWB */
341