libopencore-amr: Cosmetics: Rewrap and align
[ffmpeg.git] / libavcodec / libopencore-amr.c
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
24 static void amr_decode_fix_avctx(AVCodecContext *avctx)
25 {
26     const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
27
28     if (!avctx->sample_rate)
29         avctx->sample_rate = 8000 * is_amr_wb;
30
31     if (!avctx->channels)
32         avctx->channels = 1;
33
34     avctx->frame_size = 160 * is_amr_wb;
35     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
36 }
37
38 #if CONFIG_LIBOPENCORE_AMRNB
39
40 #include <opencore-amrnb/interf_dec.h>
41 #include <opencore-amrnb/interf_enc.h>
42
43 static const char nb_bitrate_unsupported[] =
44     "bitrate not supported: use one of 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k\n";
45
46 /* Common code for fixed and float version*/
47 typedef struct AMR_bitrates {
48     int       rate;
49     enum Mode mode;
50 } AMR_bitrates;
51
52 /* Match desired bitrate */
53 static int get_bitrate_mode(int bitrate)
54 {
55     /* make the correspondance between bitrate and mode */
56     static const AMR_bitrates rates[] = {
57         { 4750, MR475 }, { 5150, MR515 }, {  5900, MR59  }, {  6700, MR67  },
58         { 7400, MR74 },  { 7950, MR795 }, { 10200, MR102 }, { 12200, MR122 }
59     };
60     int i;
61
62     for (i = 0; i < 8; i++)
63         if (rates[i].rate == bitrate)
64             return rates[i].mode;
65     /* no bitrate matching, return an error */
66     return -1;
67 }
68
69 typedef struct AMRContext {
70     int   frame_count;
71     void *dec_state;
72     void *enc_state;
73     int   enc_bitrate;
74 } AMRContext;
75
76 static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
77 {
78     AMRContext *s  = avctx->priv_data;
79
80     s->frame_count = 0;
81     s->dec_state   = Decoder_Interface_init();
82     if (!s->dec_state) {
83         av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
84         return -1;
85     }
86
87     amr_decode_fix_avctx(avctx);
88
89     if (avctx->channels > 1) {
90         av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
91         return AVERROR(ENOSYS);
92     }
93
94     return 0;
95 }
96
97 static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
98 {
99     AMRContext *s = avctx->priv_data;
100
101     Decoder_Interface_exit(s->dec_state);
102     return 0;
103 }
104
105 static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
106                                int *data_size, AVPacket *avpkt)
107 {
108     const uint8_t *buf = avpkt->data;
109     int buf_size       = avpkt->size;
110     AMRContext *s      = avctx->priv_data;
111     static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
112     enum Mode dec_mode;
113     int packet_size;
114
115     av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
116             buf, buf_size, s->frame_count);
117
118     dec_mode    = (buf[0] >> 3) & 0x000F;
119     packet_size = block_size[dec_mode] + 1;
120
121     if (packet_size > buf_size) {
122         av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
123                buf_size, packet_size);
124         return AVERROR_INVALIDDATA;
125     }
126
127     s->frame_count++;
128     av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
129               packet_size, buf[0], buf[1], buf[2], buf[3]);
130     /* call decoder */
131     Decoder_Interface_Decode(s->dec_state, buf, data, 0);
132     *data_size = 160 * 2;
133
134     return packet_size;
135 }
136
137 AVCodec ff_libopencore_amrnb_decoder = {
138     "libopencore_amrnb",
139     AVMEDIA_TYPE_AUDIO,
140     CODEC_ID_AMR_NB,
141     sizeof(AMRContext),
142     amr_nb_decode_init,
143     NULL,
144     amr_nb_decode_close,
145     amr_nb_decode_frame,
146     .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
147 };
148
149 static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
150 {
151     AMRContext *s = avctx->priv_data;
152
153     s->frame_count = 0;
154
155     if (avctx->sample_rate != 8000) {
156         av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
157         return AVERROR(ENOSYS);
158     }
159
160     if (avctx->channels != 1) {
161         av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
162         return AVERROR(ENOSYS);
163     }
164
165     avctx->frame_size  = 160;
166     avctx->coded_frame = avcodec_alloc_frame();
167
168     s->enc_state = Encoder_Interface_init(0);
169     if (!s->enc_state) {
170         av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
171         return -1;
172     }
173
174     if ((s->enc_bitrate = get_bitrate_mode(avctx->bit_rate)) < 0) {
175         av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
176         return AVERROR(ENOSYS);
177     }
178
179     return 0;
180 }
181
182 static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
183 {
184     AMRContext *s = avctx->priv_data;
185
186     Encoder_Interface_exit(s->enc_state);
187     av_freep(&avctx->coded_frame);
188     return 0;
189 }
190
191 static int amr_nb_encode_frame(AVCodecContext *avctx,
192                                unsigned char *frame/*out*/,
193                                int buf_size, void *data/*in*/)
194 {
195     AMRContext *s = avctx->priv_data;
196     int written;
197
198     if ((s->enc_bitrate = get_bitrate_mode(avctx->bit_rate)) < 0) {
199         av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
200         return AVERROR(ENOSYS);
201     }
202
203     written = Encoder_Interface_Encode(s->enc_state, s->enc_bitrate, data,
204                                        frame, 0);
205     av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
206             written, s->enc_bitrate, frame[0]);
207
208     return written;
209 }
210
211 AVCodec ff_libopencore_amrnb_encoder = {
212     "libopencore_amrnb",
213     AVMEDIA_TYPE_AUDIO,
214     CODEC_ID_AMR_NB,
215     sizeof(AMRContext),
216     amr_nb_encode_init,
217     amr_nb_encode_frame,
218     amr_nb_encode_close,
219     NULL,
220     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
221     .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
222 };
223
224 #endif
225
226 /* -----------AMR wideband ------------*/
227 #if CONFIG_LIBOPENCORE_AMRWB
228
229 #include <opencore-amrwb/dec_if.h>
230 #include <opencore-amrwb/if_rom.h>
231
232 typedef struct AMRWBContext {
233     void  *state;
234 } AMRWBContext;
235
236 static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
237 {
238     AMRWBContext *s = avctx->priv_data;
239
240     s->state        = D_IF_init();
241
242     amr_decode_fix_avctx(avctx);
243
244     if (avctx->channels > 1) {
245         av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
246         return AVERROR(ENOSYS);
247     }
248
249     return 0;
250 }
251
252 static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
253                                int *data_size, AVPacket *avpkt)
254 {
255     const uint8_t *buf = avpkt->data;
256     int buf_size       = avpkt->size;
257     AMRWBContext *s    = avctx->priv_data;
258     int mode;
259     int packet_size;
260     static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
261
262     if (!buf_size)
263         /* nothing to do */
264         return 0;
265
266     mode        = (buf[0] >> 3) & 0x000F;
267     packet_size = block_size[mode];
268
269     if (packet_size > buf_size) {
270         av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
271                buf_size, packet_size + 1);
272         return AVERROR_INVALIDDATA;
273     }
274
275     D_IF_decode(s->state, buf, data, _good_frame);
276     *data_size = 320 * 2;
277     return packet_size;
278 }
279
280 static int amr_wb_decode_close(AVCodecContext *avctx)
281 {
282     AMRWBContext *s = avctx->priv_data;
283
284     D_IF_exit(s->state);
285     return 0;
286 }
287
288 AVCodec ff_libopencore_amrwb_decoder = {
289     "libopencore_amrwb",
290     AVMEDIA_TYPE_AUDIO,
291     CODEC_ID_AMR_WB,
292     sizeof(AMRWBContext),
293     amr_wb_decode_init,
294     NULL,
295     amr_wb_decode_close,
296     amr_wb_decode_frame,
297     .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),
298 };
299
300 #endif /* CONFIG_LIBOPENCORE_AMRWB */