1/*
2 * AMR Audio decoder stub
3 * Copyright (c) 2003 the ffmpeg project
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "libavutil/avstring.h"
23#include "libavutil/channel_layout.h"
24#include "libavutil/common.h"
25#include "libavutil/opt.h"
26#include "avcodec.h"
27#include "audio_frame_queue.h"
28#include "internal.h"
29
30static int amr_decode_fix_avctx(AVCodecContext *avctx)
31{
32    const int is_amr_wb = 1 + (avctx->codec_id == AV_CODEC_ID_AMR_WB);
33
34    if (!avctx->sample_rate)
35        avctx->sample_rate = 8000 * is_amr_wb;
36
37    if (avctx->channels > 1) {
38        avpriv_report_missing_feature(avctx, "multi-channel AMR");
39        return AVERROR_PATCHWELCOME;
40    }
41
42    avctx->channels       = 1;
43    avctx->channel_layout = AV_CH_LAYOUT_MONO;
44    avctx->sample_fmt     = AV_SAMPLE_FMT_S16;
45    return 0;
46}
47
48#if CONFIG_LIBOPENCORE_AMRNB
49
50#include <opencore-amrnb/interf_dec.h>
51#include <opencore-amrnb/interf_enc.h>
52
53typedef struct AMRContext {
54    AVClass *av_class;
55    void *dec_state;
56    void *enc_state;
57    int   enc_bitrate;
58    int   enc_mode;
59    int   enc_dtx;
60    int   enc_last_frame;
61    AudioFrameQueue afq;
62} AMRContext;
63
64#if CONFIG_LIBOPENCORE_AMRNB_DECODER
65static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
66{
67    AMRContext *s  = avctx->priv_data;
68    int ret;
69
70    if ((ret = amr_decode_fix_avctx(avctx)) < 0)
71        return ret;
72
73    s->dec_state   = Decoder_Interface_init();
74    if (!s->dec_state) {
75        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
76        return -1;
77    }
78
79    return 0;
80}
81
82static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
83{
84    AMRContext *s = avctx->priv_data;
85
86    Decoder_Interface_exit(s->dec_state);
87
88    return 0;
89}
90
91static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
92                               int *got_frame_ptr, AVPacket *avpkt)
93{
94    AVFrame *frame     = data;
95    const uint8_t *buf = avpkt->data;
96    int buf_size       = avpkt->size;
97    AMRContext *s      = avctx->priv_data;
98    static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
99    enum Mode dec_mode;
100    int packet_size, ret;
101
102    av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
103            buf, buf_size, avctx->frame_number);
104
105    /* get output buffer */
106    frame->nb_samples = 160;
107    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
108        return ret;
109
110    dec_mode    = (buf[0] >> 3) & 0x000F;
111    packet_size = block_size[dec_mode] + 1;
112
113    if (packet_size > buf_size) {
114        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
115               buf_size, packet_size);
116        return AVERROR_INVALIDDATA;
117    }
118
119    av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
120              packet_size, buf[0], buf[1], buf[2], buf[3]);
121    /* call decoder */
122    Decoder_Interface_Decode(s->dec_state, buf, (short *)frame->data[0], 0);
123
124    *got_frame_ptr = 1;
125
126    return packet_size;
127}
128
129AVCodec ff_libopencore_amrnb_decoder = {
130    .name           = "libopencore_amrnb",
131    .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
132    .type           = AVMEDIA_TYPE_AUDIO,
133    .id             = AV_CODEC_ID_AMR_NB,
134    .priv_data_size = sizeof(AMRContext),
135    .init           = amr_nb_decode_init,
136    .close          = amr_nb_decode_close,
137    .decode         = amr_nb_decode_frame,
138    .capabilities   = CODEC_CAP_DR1,
139};
140#endif /* CONFIG_LIBOPENCORE_AMRNB_DECODER */
141
142#if CONFIG_LIBOPENCORE_AMRNB_ENCODER
143/* Common code for fixed and float version*/
144typedef struct AMR_bitrates {
145    int       rate;
146    enum Mode mode;
147} AMR_bitrates;
148
149/* Match desired bitrate */
150static int get_bitrate_mode(int bitrate, void *log_ctx)
151{
152    /* make the correspondance between bitrate and mode */
153    static const AMR_bitrates rates[] = {
154        { 4750, MR475 }, { 5150, MR515 }, {  5900, MR59  }, {  6700, MR67  },
155        { 7400, MR74 },  { 7950, MR795 }, { 10200, MR102 }, { 12200, MR122 }
156    };
157    int i, best = -1, min_diff = 0;
158    char log_buf[200];
159
160    for (i = 0; i < 8; i++) {
161        if (rates[i].rate == bitrate)
162            return rates[i].mode;
163        if (best < 0 || abs(rates[i].rate - bitrate) < min_diff) {
164            best     = i;
165            min_diff = abs(rates[i].rate - bitrate);
166        }
167    }
168    /* no bitrate matching exactly, log a warning */
169    snprintf(log_buf, sizeof(log_buf), "bitrate not supported: use one of ");
170    for (i = 0; i < 8; i++)
171        av_strlcatf(log_buf, sizeof(log_buf), "%.2fk, ", rates[i].rate    / 1000.f);
172    av_strlcatf(log_buf, sizeof(log_buf), "using %.2fk", rates[best].rate / 1000.f);
173    av_log(log_ctx, AV_LOG_WARNING, "%s\n", log_buf);
174
175    return best;
176}
177
178static const AVOption options[] = {
179    { "dtx", "Allow DTX (generate comfort noise)", offsetof(AMRContext, enc_dtx), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
180    { NULL }
181};
182
183static const AVClass amrnb_class = {
184    "libopencore_amrnb", av_default_item_name, options, LIBAVUTIL_VERSION_INT
185};
186
187static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
188{
189    AMRContext *s = avctx->priv_data;
190
191    if (avctx->sample_rate != 8000 && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
192        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
193        return AVERROR(ENOSYS);
194    }
195
196    if (avctx->channels != 1) {
197        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
198        return AVERROR(ENOSYS);
199    }
200
201    avctx->frame_size  = 160;
202    avctx->delay       =  50;
203    ff_af_queue_init(avctx, &s->afq);
204
205    s->enc_state = Encoder_Interface_init(s->enc_dtx);
206    if (!s->enc_state) {
207        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
208        return -1;
209    }
210
211    s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
212    s->enc_bitrate = avctx->bit_rate;
213
214    return 0;
215}
216
217static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
218{
219    AMRContext *s = avctx->priv_data;
220
221    Encoder_Interface_exit(s->enc_state);
222    ff_af_queue_close(&s->afq);
223    return 0;
224}
225
226static int amr_nb_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
227                               const AVFrame *frame, int *got_packet_ptr)
228{
229    AMRContext *s = avctx->priv_data;
230    int written, ret;
231    int16_t *flush_buf = NULL;
232    const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;
233
234    if (s->enc_bitrate != avctx->bit_rate) {
235        s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
236        s->enc_bitrate = avctx->bit_rate;
237    }
238
239    if ((ret = ff_alloc_packet2(avctx, avpkt, 32)) < 0)
240        return ret;
241
242    if (frame) {
243        if (frame->nb_samples < avctx->frame_size) {
244            flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
245            if (!flush_buf)
246                return AVERROR(ENOMEM);
247            memcpy(flush_buf, samples, frame->nb_samples * sizeof(*flush_buf));
248            samples = flush_buf;
249            if (frame->nb_samples < avctx->frame_size - avctx->delay)
250                s->enc_last_frame = -1;
251        }
252        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) {
253            av_freep(&flush_buf);
254            return ret;
255        }
256    } else {
257        if (s->enc_last_frame < 0)
258            return 0;
259        flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
260        if (!flush_buf)
261            return AVERROR(ENOMEM);
262        samples = flush_buf;
263        s->enc_last_frame = -1;
264    }
265
266    written = Encoder_Interface_Encode(s->enc_state, s->enc_mode, samples,
267                                       avpkt->data, 0);
268    av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
269            written, s->enc_mode, avpkt->data[0]);
270
271    /* Get the next frame pts/duration */
272    ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
273                       &avpkt->duration);
274
275    avpkt->size = written;
276    *got_packet_ptr = 1;
277    av_freep(&flush_buf);
278    return 0;
279}
280
281AVCodec ff_libopencore_amrnb_encoder = {
282    .name           = "libopencore_amrnb",
283    .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
284    .type           = AVMEDIA_TYPE_AUDIO,
285    .id             = AV_CODEC_ID_AMR_NB,
286    .priv_data_size = sizeof(AMRContext),
287    .init           = amr_nb_encode_init,
288    .encode2        = amr_nb_encode_frame,
289    .close          = amr_nb_encode_close,
290    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_SMALL_LAST_FRAME,
291    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
292                                                     AV_SAMPLE_FMT_NONE },
293    .priv_class     = &amrnb_class,
294};
295#endif /* CONFIG_LIBOPENCORE_AMRNB_ENCODER */
296
297#endif /* CONFIG_LIBOPENCORE_AMRNB */
298
299/* -----------AMR wideband ------------*/
300#if CONFIG_LIBOPENCORE_AMRWB_DECODER
301
302#include <opencore-amrwb/dec_if.h>
303#include <opencore-amrwb/if_rom.h>
304
305typedef struct AMRWBContext {
306    void  *state;
307} AMRWBContext;
308
309static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
310{
311    AMRWBContext *s = avctx->priv_data;
312    int ret;
313
314    if ((ret = amr_decode_fix_avctx(avctx)) < 0)
315        return ret;
316
317    s->state        = D_IF_init();
318
319    return 0;
320}
321
322static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
323                               int *got_frame_ptr, AVPacket *avpkt)
324{
325    AVFrame *frame     = data;
326    const uint8_t *buf = avpkt->data;
327    int buf_size       = avpkt->size;
328    AMRWBContext *s    = avctx->priv_data;
329    int mode, ret;
330    int packet_size;
331    static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
332
333    /* get output buffer */
334    frame->nb_samples = 320;
335    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
336        return ret;
337
338    mode        = (buf[0] >> 3) & 0x000F;
339    packet_size = block_size[mode];
340
341    if (packet_size > buf_size) {
342        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
343               buf_size, packet_size + 1);
344        return AVERROR_INVALIDDATA;
345    }
346    if (!packet_size) {
347        av_log(avctx, AV_LOG_ERROR, "amr packet_size invalid\n");
348        return AVERROR_INVALIDDATA;
349    }
350
351    D_IF_decode(s->state, buf, (short *)frame->data[0], _good_frame);
352
353    *got_frame_ptr = 1;
354
355    return packet_size;
356}
357
358static int amr_wb_decode_close(AVCodecContext *avctx)
359{
360    AMRWBContext *s = avctx->priv_data;
361
362    D_IF_exit(s->state);
363    return 0;
364}
365
366AVCodec ff_libopencore_amrwb_decoder = {
367    .name           = "libopencore_amrwb",
368    .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-WB (Adaptive Multi-Rate Wide-Band)"),
369    .type           = AVMEDIA_TYPE_AUDIO,
370    .id             = AV_CODEC_ID_AMR_WB,
371    .priv_data_size = sizeof(AMRWBContext),
372    .init           = amr_wb_decode_init,
373    .close          = amr_wb_decode_close,
374    .decode         = amr_wb_decode_frame,
375    .capabilities   = CODEC_CAP_DR1,
376};
377
378#endif /* CONFIG_LIBOPENCORE_AMRWB_DECODER */
379