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, AVPacket *avpkt) 111{ 112 const uint8_t *buf = avpkt->data; 113 int buf_size = avpkt->size; 114 AMRContext *s = avctx->priv_data; 115 const uint8_t *amrData = buf; 116 static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 }; 117 enum Mode dec_mode; 118 int packet_size; 119 120 /* av_log(NULL, AV_LOG_DEBUG, "amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n", 121 buf, buf_size, s->frameCount); */ 122 123 dec_mode = (buf[0] >> 3) & 0x000F; 124 packet_size = block_size[dec_mode] + 1; 125 126 if (packet_size > buf_size) { 127 av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", 128 buf_size, packet_size); 129 return -1; 130 } 131 132 s->frameCount++; 133 /* av_log(NULL, AV_LOG_DEBUG, "packet_size=%d amrData= 0x%X %X %X %X\n", 134 packet_size, amrData[0], amrData[1], amrData[2], amrData[3]); */ 135 /* call decoder */ 136 Decoder_Interface_Decode(s->decState, amrData, data, 0); 137 *data_size = 160 * 2; 138 139 return packet_size; 140} 141 142AVCodec libopencore_amrnb_decoder = { 143 "libopencore_amrnb", 144 AVMEDIA_TYPE_AUDIO, 145 CODEC_ID_AMR_NB, 146 sizeof(AMRContext), 147 amr_nb_decode_init, 148 NULL, 149 amr_nb_decode_close, 150 amr_nb_decode_frame, 151 .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"), 152}; 153 154static av_cold int amr_nb_encode_init(AVCodecContext *avctx) 155{ 156 AMRContext *s = avctx->priv_data; 157 158 s->frameCount = 0; 159 160 if (avctx->sample_rate != 8000) { 161 av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n"); 162 return -1; 163 } 164 165 if (avctx->channels != 1) { 166 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); 167 return -1; 168 } 169 170 avctx->frame_size = 160; 171 avctx->coded_frame = avcodec_alloc_frame(); 172 173 s->enstate=Encoder_Interface_init(0); 174 if (!s->enstate) { 175 av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n"); 176 return -1; 177 } 178 179 if ((s->enc_bitrate = getBitrateMode(avctx->bit_rate)) < 0) { 180 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported); 181 return -1; 182 } 183 184 return 0; 185} 186 187static av_cold int amr_nb_encode_close(AVCodecContext *avctx) 188{ 189 AMRContext *s = avctx->priv_data; 190 191 Encoder_Interface_exit(s->enstate); 192 av_freep(&avctx->coded_frame); 193 return 0; 194} 195 196static int amr_nb_encode_frame(AVCodecContext *avctx, 197 unsigned char *frame/*out*/, 198 int buf_size, void *data/*in*/) 199{ 200 AMRContext *s = avctx->priv_data; 201 int written; 202 203 if ((s->enc_bitrate = getBitrateMode(avctx->bit_rate)) < 0) { 204 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported); 205 return -1; 206 } 207 208 written = Encoder_Interface_Encode(s->enstate, s->enc_bitrate, data, 209 frame, 0); 210 /* av_log(NULL, AV_LOG_DEBUG, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n", 211 written, s->enc_bitrate, frame[0] ); */ 212 213 return written; 214} 215 216AVCodec libopencore_amrnb_encoder = { 217 "libopencore_amrnb", 218 AVMEDIA_TYPE_AUDIO, 219 CODEC_ID_AMR_NB, 220 sizeof(AMRContext), 221 amr_nb_encode_init, 222 amr_nb_encode_frame, 223 amr_nb_encode_close, 224 NULL, 225 .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, 226 .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"), 227}; 228 229#endif 230 231/* -----------AMR wideband ------------*/ 232#if CONFIG_LIBOPENCORE_AMRWB 233 234#ifdef _TYPEDEF_H 235//To avoid duplicate typedefs from typedef in amr-nb 236#define typedef_h 237#endif 238 239#include <opencore-amrwb/dec_if.h> 240#include <opencore-amrwb/if_rom.h> 241 242static const char wb_bitrate_unsupported[] = 243 "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"; 244 245/* Common code for fixed and float version*/ 246typedef struct AMRWB_bitrates { 247 int rate; 248 int mode; 249} AMRWB_bitrates; 250 251typedef struct AMRWBContext { 252 int frameCount; 253 void *state; 254 int mode; 255 Word16 allow_dtx; 256} AMRWBContext; 257 258static av_cold int amr_wb_decode_init(AVCodecContext *avctx) 259{ 260 AMRWBContext *s = avctx->priv_data; 261 262 s->frameCount = 0; 263 s->state = D_IF_init(); 264 265 amr_decode_fix_avctx(avctx); 266 267 if (avctx->channels > 1) { 268 av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n"); 269 return -1; 270 } 271 272 return 0; 273} 274 275static int amr_wb_decode_frame(AVCodecContext *avctx, void *data, 276 int *data_size, AVPacket *avpkt) 277{ 278 const uint8_t *buf = avpkt->data; 279 int buf_size = avpkt->size; 280 AMRWBContext *s = avctx->priv_data; 281 const uint8_t *amrData = buf; 282 int mode; 283 int packet_size; 284 static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1}; 285 286 if (!buf_size) 287 /* nothing to do */ 288 return 0; 289 290 mode = (amrData[0] >> 3) & 0x000F; 291 packet_size = block_size[mode]; 292 293 if (packet_size > buf_size) { 294 av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", 295 buf_size, packet_size + 1); 296 return -1; 297 } 298 299 s->frameCount++; 300 D_IF_decode(s->state, amrData, data, _good_frame); 301 *data_size = 320 * 2; 302 return packet_size; 303} 304 305static int amr_wb_decode_close(AVCodecContext *avctx) 306{ 307 AMRWBContext *s = avctx->priv_data; 308 309 D_IF_exit(s->state); 310 return 0; 311} 312 313AVCodec libopencore_amrwb_decoder = { 314 "libopencore_amrwb", 315 AVMEDIA_TYPE_AUDIO, 316 CODEC_ID_AMR_WB, 317 sizeof(AMRWBContext), 318 amr_wb_decode_init, 319 NULL, 320 amr_wb_decode_close, 321 amr_wb_decode_frame, 322 .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"), 323}; 324 325#endif /* CONFIG_LIBOPENCORE_AMRWB */ 326