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