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 "avcodec.h" 23 24static 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 = 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 43static 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*/ 47typedef struct AMR_bitrates { 48 int rate; 49 enum Mode mode; 50} AMR_bitrates; 51 52/* Match desired bitrate */ 53static int getBitrateMode(int bitrate) 54{ 55 /* make the correspondance between bitrate and mode */ 56 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 73typedef struct AMRContext { 74 int frameCount; 75 void *decState; 76 int *enstate; 77 int enc_bitrate; 78} AMRContext; 79 80static 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\r\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 -1; 96 } 97 98 return 0; 99} 100 101static 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 109static int amr_nb_decode_frame(AVCodecContext *avctx, void *data, 110 int *data_size, 111 const uint8_t *buf, int buf_size) 112{ 113 AMRContext *s = avctx->priv_data; 114 const uint8_t *amrData = buf; 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_log(NULL, AV_LOG_DEBUG, "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 -1; 129 } 130 131 s->frameCount++; 132 /* av_log(NULL, AV_LOG_DEBUG, "packet_size=%d amrData= 0x%X %X %X %X\n", 133 packet_size, amrData[0], amrData[1], amrData[2], amrData[3]); */ 134 /* call decoder */ 135 Decoder_Interface_Decode(s->decState, amrData, data, 0); 136 *data_size = 160 * 2; 137 138 return packet_size; 139} 140 141AVCodec libopencore_amrnb_decoder = { 142 "libopencore_amrnb", 143 CODEC_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 153static 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 -1; 162 } 163 164 if (avctx->channels != 1) { 165 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); 166 return -1; 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 -1; 181 } 182 183 return 0; 184} 185 186static 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 195static 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 -1; 205 } 206 207 written = Encoder_Interface_Encode(s->enstate, s->enc_bitrate, data, 208 frame, 0); 209 /* av_log(NULL, AV_LOG_DEBUG, "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 215AVCodec libopencore_amrnb_encoder = { 216 "libopencore_amrnb", 217 CODEC_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 = (enum SampleFormat[]){SAMPLE_FMT_S16,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#ifdef _TYPEDEF_H 234//To avoid duplicate typedefs from typedef in amr-nb 235#define typedef_h 236#endif 237 238#include <opencore-amrwb/dec_if.h> 239#include <opencore-amrwb/if_rom.h> 240 241static const char wb_bitrate_unsupported[] = 242 "bitrate not supported: use one of 6.6k, 8.85k, 12.65k, 14.25k, 15.85k, 18.25k, 19.85k, 23.05k, or 23.85k\n"; 243 244/* Common code for fixed and float version*/ 245typedef struct AMRWB_bitrates { 246 int rate; 247 int mode; 248} AMRWB_bitrates; 249 250typedef struct AMRWBContext { 251 int frameCount; 252 void *state; 253 int mode; 254 Word16 allow_dtx; 255} AMRWBContext; 256 257static av_cold int amr_wb_decode_init(AVCodecContext *avctx) 258{ 259 AMRWBContext *s = avctx->priv_data; 260 261 s->frameCount = 0; 262 s->state = D_IF_init(); 263 264 amr_decode_fix_avctx(avctx); 265 266 if (avctx->channels > 1) { 267 av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n"); 268 return -1; 269 } 270 271 return 0; 272} 273 274static int amr_wb_decode_frame(AVCodecContext *avctx, 275 void *data, int *data_size, 276 const uint8_t *buf, int buf_size) 277{ 278 AMRWBContext *s = avctx->priv_data; 279 const uint8_t *amrData = buf; 280 int mode; 281 int packet_size; 282 static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1}; 283 284 if (!buf_size) 285 /* nothing to do */ 286 return 0; 287 288 mode = (amrData[0] >> 3) & 0x000F; 289 packet_size = block_size[mode]; 290 291 if (packet_size > buf_size) { 292 av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", 293 buf_size, packet_size + 1); 294 return -1; 295 } 296 297 s->frameCount++; 298 D_IF_decode(s->state, amrData, data, _good_frame); 299 *data_size = 320 * 2; 300 return packet_size; 301} 302 303static int amr_wb_decode_close(AVCodecContext *avctx) 304{ 305 AMRWBContext *s = avctx->priv_data; 306 307 D_IF_exit(s->state); 308 return 0; 309} 310 311AVCodec libopencore_amrwb_decoder = { 312 "libopencore_amrwb", 313 CODEC_TYPE_AUDIO, 314 CODEC_ID_AMR_WB, 315 sizeof(AMRWBContext), 316 amr_wb_decode_init, 317 NULL, 318 amr_wb_decode_close, 319 amr_wb_decode_frame, 320 .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"), 321}; 322 323#endif /* CONFIG_LIBOPENCORE_AMRWB */ 324