libavcodec/libopencore-amr.c

   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
  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 = 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     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     int  *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\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
 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     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
 142 AVCodec libopencore_amrnb_decoder = {
 143     "libopencore_amrnb",
 144     CODEC_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
 154 static 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
 187 static 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
 196 static 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
 216 AVCodec libopencore_amrnb_encoder = {
 217     "libopencore_amrnb",
 218     CODEC_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 = (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
 242 static 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*/
 246 typedef struct AMRWB_bitrates {
 247     int rate;
 248     int mode;
 249 } AMRWB_bitrates;
 250
 251 typedef struct AMRWBContext {
 252     int    frameCount;
 253     void  *state;
 254     int    mode;
 255     Word16 allow_dtx;
 256 } AMRWBContext;
 257
 258 static 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
 275 static 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
 305 static 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
 313 AVCodec libopencore_amrwb_decoder = {
 314     "libopencore_amrwb",
 315     CODEC_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 */