FFmpeg  4.4.4
libopencore-amr.c
Go to the documentation of this file.
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 <inttypes.h>
23 
24 #include "libavutil/avstring.h"
26 #include "libavutil/common.h"
27 #include "libavutil/opt.h"
28 #include "avcodec.h"
29 #include "audio_frame_queue.h"
30 #include "internal.h"
31 
32 #if CONFIG_LIBOPENCORE_AMRNB_DECODER || CONFIG_LIBOPENCORE_AMRWB_DECODER
33 static int amr_decode_fix_avctx(AVCodecContext *avctx)
34 {
35  const int is_amr_wb = 1 + (avctx->codec_id == AV_CODEC_ID_AMR_WB);
36 
37  if (!avctx->sample_rate)
38  avctx->sample_rate = 8000 * is_amr_wb;
39 
40  if (avctx->channels > 1) {
41  avpriv_report_missing_feature(avctx, "multi-channel AMR");
42  return AVERROR_PATCHWELCOME;
43  }
44 
45  avctx->channels = 1;
48  return 0;
49 }
50 #endif
51 
52 #if CONFIG_LIBOPENCORE_AMRNB
53 
54 #include <opencore-amrnb/interf_dec.h>
55 #include <opencore-amrnb/interf_enc.h>
56 
57 typedef struct AMRContext {
59  void *dec_state;
60  void *enc_state;
61  int enc_bitrate;
62  int enc_mode;
63  int enc_dtx;
64  int enc_last_frame;
65  AudioFrameQueue afq;
66 } AMRContext;
67 
68 #if CONFIG_LIBOPENCORE_AMRNB_DECODER
69 static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
70 {
71  AMRContext *s = avctx->priv_data;
72  int ret;
73 
74  if ((ret = amr_decode_fix_avctx(avctx)) < 0)
75  return ret;
76 
77  s->dec_state = Decoder_Interface_init();
78  if (!s->dec_state) {
79  av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
80  return -1;
81  }
82 
83  return 0;
84 }
85 
86 static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
87 {
88  AMRContext *s = avctx->priv_data;
89 
90  Decoder_Interface_exit(s->dec_state);
91 
92  return 0;
93 }
94 
95 static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
96  int *got_frame_ptr, AVPacket *avpkt)
97 {
98  AVFrame *frame = data;
99  const uint8_t *buf = avpkt->data;
100  int buf_size = avpkt->size;
101  AMRContext *s = avctx->priv_data;
102  static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
103  enum Mode dec_mode;
104  int packet_size, ret;
105 
106  ff_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
107  buf, buf_size, avctx->frame_number);
108 
109  /* get output buffer */
110  frame->nb_samples = 160;
111  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
112  return ret;
113 
114  dec_mode = (buf[0] >> 3) & 0x000F;
115  packet_size = block_size[dec_mode] + 1;
116 
117  if (packet_size > buf_size) {
118  av_log(avctx, AV_LOG_ERROR, "AMR frame too short (%d, should be %d)\n",
119  buf_size, packet_size);
120  return AVERROR_INVALIDDATA;
121  }
122 
123  ff_dlog(avctx, "packet_size=%d buf= 0x%"PRIx8" %"PRIx8" %"PRIx8" %"PRIx8"\n",
124  packet_size, buf[0], buf[1], buf[2], buf[3]);
125  /* call decoder */
126  Decoder_Interface_Decode(s->dec_state, buf, (short *)frame->data[0], 0);
127 
128  *got_frame_ptr = 1;
129 
130  return packet_size;
131 }
132 
134  .name = "libopencore_amrnb",
135  .long_name = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
136  .type = AVMEDIA_TYPE_AUDIO,
137  .id = AV_CODEC_ID_AMR_NB,
138  .priv_data_size = sizeof(AMRContext),
139  .init = amr_nb_decode_init,
140  .close = amr_nb_decode_close,
141  .decode = amr_nb_decode_frame,
143 };
144 #endif /* CONFIG_LIBOPENCORE_AMRNB_DECODER */
145 
146 #if CONFIG_LIBOPENCORE_AMRNB_ENCODER
147 /* Common code for fixed and float version*/
148 typedef struct AMR_bitrates {
149  int rate;
150  enum Mode mode;
151 } AMR_bitrates;
152 
153 /* Match desired bitrate */
154 static int get_bitrate_mode(int bitrate, void *log_ctx)
155 {
156  /* make the correspondence between bitrate and mode */
157  static const AMR_bitrates rates[] = {
158  { 4750, MR475 }, { 5150, MR515 }, { 5900, MR59 }, { 6700, MR67 },
159  { 7400, MR74 }, { 7950, MR795 }, { 10200, MR102 }, { 12200, MR122 }
160  };
161  int i, best = -1, min_diff = 0;
162  char log_buf[200];
163 
164  for (i = 0; i < 8; i++) {
165  if (rates[i].rate == bitrate)
166  return rates[i].mode;
167  if (best < 0 || abs(rates[i].rate - bitrate) < min_diff) {
168  best = i;
169  min_diff = abs(rates[i].rate - bitrate);
170  }
171  }
172  /* no bitrate matching exactly, log a warning */
173  snprintf(log_buf, sizeof(log_buf), "bitrate not supported: use one of ");
174  for (i = 0; i < 8; i++)
175  av_strlcatf(log_buf, sizeof(log_buf), "%.2fk, ", rates[i].rate / 1000.f);
176  av_strlcatf(log_buf, sizeof(log_buf), "using %.2fk", rates[best].rate / 1000.f);
177  av_log(log_ctx, AV_LOG_WARNING, "%s\n", log_buf);
178 
179  return best;
180 }
181 
182 static const AVOption options[] = {
183  { "dtx", "Allow DTX (generate comfort noise)", offsetof(AMRContext, enc_dtx), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
184  { NULL }
185 };
186 
187 static const AVClass amrnb_class = {
188  .class_name = "libopencore_amrnb",
189  .item_name = av_default_item_name,
190  .option = options,
191  .version = LIBAVUTIL_VERSION_INT,
192 };
193 
194 static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
195 {
196  AMRContext *s = avctx->priv_data;
197 
198  if (avctx->sample_rate != 8000 && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
199  av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
200  return AVERROR(ENOSYS);
201  }
202 
203  if (avctx->channels != 1) {
204  av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
205  return AVERROR(ENOSYS);
206  }
207 
208  avctx->frame_size = 160;
209  avctx->initial_padding = 50;
210  ff_af_queue_init(avctx, &s->afq);
211 
212  s->enc_state = Encoder_Interface_init(s->enc_dtx);
213  if (!s->enc_state) {
214  av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
215  return -1;
216  }
217 
218  s->enc_mode = get_bitrate_mode(avctx->bit_rate, avctx);
219  s->enc_bitrate = avctx->bit_rate;
220 
221  return 0;
222 }
223 
224 static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
225 {
226  AMRContext *s = avctx->priv_data;
227 
228  Encoder_Interface_exit(s->enc_state);
229  ff_af_queue_close(&s->afq);
230  return 0;
231 }
232 
233 static int amr_nb_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
234  const AVFrame *frame, int *got_packet_ptr)
235 {
236  AMRContext *s = avctx->priv_data;
237  int written, ret;
238  int16_t *flush_buf = NULL;
239  const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;
240 
241  if (s->enc_bitrate != avctx->bit_rate) {
242  s->enc_mode = get_bitrate_mode(avctx->bit_rate, avctx);
243  s->enc_bitrate = avctx->bit_rate;
244  }
245 
246  if ((ret = ff_alloc_packet2(avctx, avpkt, 32, 0)) < 0)
247  return ret;
248 
249  if (frame) {
250  if (frame->nb_samples < avctx->frame_size) {
251  flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
252  if (!flush_buf)
253  return AVERROR(ENOMEM);
254  memcpy(flush_buf, samples, frame->nb_samples * sizeof(*flush_buf));
255  samples = flush_buf;
256  if (frame->nb_samples < avctx->frame_size - avctx->initial_padding)
257  s->enc_last_frame = -1;
258  }
259  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) {
260  av_freep(&flush_buf);
261  return ret;
262  }
263  } else {
264  if (s->enc_last_frame < 0)
265  return 0;
266  flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
267  if (!flush_buf)
268  return AVERROR(ENOMEM);
269  samples = flush_buf;
270  s->enc_last_frame = -1;
271  }
272 
273  written = Encoder_Interface_Encode(s->enc_state, s->enc_mode, samples,
274  avpkt->data, 0);
275  ff_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
276  written, s->enc_mode, avpkt->data[0]);
277 
278  /* Get the next frame pts/duration */
279  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
280  &avpkt->duration);
281 
282  avpkt->size = written;
283  *got_packet_ptr = 1;
284  av_freep(&flush_buf);
285  return 0;
286 }
287 
289  .name = "libopencore_amrnb",
290  .long_name = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
291  .type = AVMEDIA_TYPE_AUDIO,
292  .id = AV_CODEC_ID_AMR_NB,
293  .priv_data_size = sizeof(AMRContext),
294  .init = amr_nb_encode_init,
295  .encode2 = amr_nb_encode_frame,
296  .close = amr_nb_encode_close,
298  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
300  .priv_class = &amrnb_class,
301 };
302 #endif /* CONFIG_LIBOPENCORE_AMRNB_ENCODER */
303 
304 #endif /* CONFIG_LIBOPENCORE_AMRNB */
305 
306 /* -----------AMR wideband ------------*/
307 #if CONFIG_LIBOPENCORE_AMRWB_DECODER
308 
309 #include <opencore-amrwb/dec_if.h>
310 #include <opencore-amrwb/if_rom.h>
311 
312 typedef struct AMRWBContext {
313  void *state;
314 } AMRWBContext;
315 
316 static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
317 {
318  AMRWBContext *s = avctx->priv_data;
319  int ret;
320 
321  if ((ret = amr_decode_fix_avctx(avctx)) < 0)
322  return ret;
323 
324  s->state = D_IF_init();
325 
326  return 0;
327 }
328 
329 static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
330  int *got_frame_ptr, AVPacket *avpkt)
331 {
332  AVFrame *frame = data;
333  const uint8_t *buf = avpkt->data;
334  int buf_size = avpkt->size;
335  AMRWBContext *s = avctx->priv_data;
336  int mode, ret;
337  int packet_size;
338  static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
339 
340  /* get output buffer */
341  frame->nb_samples = 320;
342  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
343  return ret;
344 
345  mode = (buf[0] >> 3) & 0x000F;
346  packet_size = block_size[mode];
347 
348  if (packet_size > buf_size) {
349  av_log(avctx, AV_LOG_ERROR, "AMR frame too short (%d, should be %d)\n",
350  buf_size, packet_size + 1);
351  return AVERROR_INVALIDDATA;
352  }
353  if (!packet_size) {
354  av_log(avctx, AV_LOG_ERROR, "amr packet_size invalid\n");
355  return AVERROR_INVALIDDATA;
356  }
357 
358  D_IF_decode(s->state, buf, (short *)frame->data[0], _good_frame);
359 
360  *got_frame_ptr = 1;
361 
362  return packet_size;
363 }
364 
365 static int amr_wb_decode_close(AVCodecContext *avctx)
366 {
367  AMRWBContext *s = avctx->priv_data;
368 
369  D_IF_exit(s->state);
370  return 0;
371 }
372 
374  .name = "libopencore_amrwb",
375  .long_name = NULL_IF_CONFIG_SMALL("OpenCORE AMR-WB (Adaptive Multi-Rate Wide-Band)"),
376  .type = AVMEDIA_TYPE_AUDIO,
377  .id = AV_CODEC_ID_AMR_WB,
378  .priv_data_size = sizeof(AMRWBContext),
379  .init = amr_wb_decode_init,
380  .close = amr_wb_decode_close,
381  .decode = amr_wb_decode_frame,
383  .wrapper_name = "libopencore_amrwb",
384 };
385 
386 #endif /* CONFIG_LIBOPENCORE_AMRWB_DECODER */
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
AVCodec ff_libopencore_amrnb_encoder
AVCodec ff_libopencore_amrnb_decoder
AVCodec ff_libopencore_amrwb_decoder
Mode
Frame type (Table 1a in 3GPP TS 26.101)
Definition: amrnbdata.h:39
#define av_cold
Definition: attributes.h:88
uint8_t
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Libavcodec external API header.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1605
static const int rates[]
Definition: avresample.c:176
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
#define s(width, name)
Definition: cbs_vp9.c:257
audio channel layout utility functions
common internal and external API header
#define NULL
Definition: coverity.c:32
#define abs(x)
Definition: cuda_runtime.h:35
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
const OptionDef options[]
@ AV_OPT_TYPE_INT
Definition: opt.h:225
#define AV_CH_LAYOUT_MONO
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:82
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:406
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:407
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int i
Definition: input.c:407
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static const AVClass av_class
Definition: options.c:134
const char data[16]
Definition: mxf.c:142
AVOptions.
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:280
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
#define snprintf
Definition: snprintf.h:34
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
main external API structure.
Definition: avcodec.h:536
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
int initial_padding
Audio only.
Definition: avcodec.h:2062
int sample_rate
samples per second
Definition: avcodec.h:1196
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1227
int channels
number of audio channels
Definition: avcodec.h:1197
enum AVCodecID codec_id
Definition: avcodec.h:546
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
#define ff_dlog(a,...)
#define av_freep(p)
#define av_log(a,...)
int64_t bitrate
Definition: h264_levels.c:131
if(ret< 0)
Definition: vf_mcdeint.c:282