[deb_ffmpeg.git] / ffmpeg / libavcodec / libopencore-amr.c

/*
 * AMR Audio decoder stub
 * Copyright (c) 2003 The FFmpeg Project
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/avstring.h"
#include "libavutil/channel_layout.h"
#include "libavutil/common.h"
#include "libavutil/opt.h"
#include "avcodec.h"
#include "audio_frame_queue.h"
#include "internal.h"

static int amr_decode_fix_avctx(AVCodecContext *avctx)
{
    const int is_amr_wb = 1 + (avctx->codec_id == AV_CODEC_ID_AMR_WB);

    if (!avctx->sample_rate)
        avctx->sample_rate = 8000 * is_amr_wb;

    if (avctx->channels > 1) {
        avpriv_report_missing_feature(avctx, "multi-channel AMR");
        return AVERROR_PATCHWELCOME;
    }

    avctx->channels       = 1;
    avctx->channel_layout = AV_CH_LAYOUT_MONO;
    avctx->sample_fmt     = AV_SAMPLE_FMT_S16;
    return 0;
}

#if CONFIG_LIBOPENCORE_AMRNB

#include <opencore-amrnb/interf_dec.h>
#include <opencore-amrnb/interf_enc.h>

typedef struct AMRContext {
    AVClass *av_class;
    void *dec_state;
    void *enc_state;
    int   enc_bitrate;
    int   enc_mode;
    int   enc_dtx;
    int   enc_last_frame;
    AudioFrameQueue afq;
} AMRContext;

#if CONFIG_LIBOPENCORE_AMRNB_DECODER
static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
{
    AMRContext *s  = avctx->priv_data;
    int ret;

    if ((ret = amr_decode_fix_avctx(avctx)) < 0)
        return ret;

    s->dec_state   = Decoder_Interface_init();
    if (!s->dec_state) {
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
        return -1;
    }

    return 0;
}

static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
{
    AMRContext *s = avctx->priv_data;

    Decoder_Interface_exit(s->dec_state);

    return 0;
}

static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
                               int *got_frame_ptr, AVPacket *avpkt)
{
    AVFrame *frame     = data;
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
    AMRContext *s      = avctx->priv_data;
    static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
    enum Mode dec_mode;
    int packet_size, ret;

    av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
            buf, buf_size, avctx->frame_number);

    /* get output buffer */
    frame->nb_samples = 160;
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
        return ret;

    dec_mode    = (buf[0] >> 3) & 0x000F;
    packet_size = block_size[dec_mode] + 1;

    if (packet_size > buf_size) {
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
               buf_size, packet_size);
        return AVERROR_INVALIDDATA;
    }

    av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
              packet_size, buf[0], buf[1], buf[2], buf[3]);
    /* call decoder */
    Decoder_Interface_Decode(s->dec_state, buf, (short *)frame->data[0], 0);

    *got_frame_ptr = 1;

    return packet_size;
}

AVCodec ff_libopencore_amrnb_decoder = {
    .name           = "libopencore_amrnb",
    .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_AMR_NB,
    .priv_data_size = sizeof(AMRContext),
    .init           = amr_nb_decode_init,
    .close          = amr_nb_decode_close,
    .decode         = amr_nb_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
};
#endif /* CONFIG_LIBOPENCORE_AMRNB_DECODER */

#if CONFIG_LIBOPENCORE_AMRNB_ENCODER
/* Common code for fixed and float version*/
typedef struct AMR_bitrates {
    int       rate;
    enum Mode mode;
} AMR_bitrates;

/* Match desired bitrate */
static int get_bitrate_mode(int bitrate, void *log_ctx)
{
    /* make the correspondance between bitrate and mode */
    static const AMR_bitrates rates[] = {
        { 4750, MR475 }, { 5150, MR515 }, {  5900, MR59  }, {  6700, MR67  },
        { 7400, MR74 },  { 7950, MR795 }, { 10200, MR102 }, { 12200, MR122 }
    };
    int i, best = -1, min_diff = 0;
    char log_buf[200];

    for (i = 0; i < 8; i++) {
        if (rates[i].rate == bitrate)
            return rates[i].mode;
        if (best < 0 || abs(rates[i].rate - bitrate) < min_diff) {
            best     = i;
            min_diff = abs(rates[i].rate - bitrate);
        }
    }
    /* no bitrate matching exactly, log a warning */
    snprintf(log_buf, sizeof(log_buf), "bitrate not supported: use one of ");
    for (i = 0; i < 8; i++)
        av_strlcatf(log_buf, sizeof(log_buf), "%.2fk, ", rates[i].rate    / 1000.f);
    av_strlcatf(log_buf, sizeof(log_buf), "using %.2fk", rates[best].rate / 1000.f);
    av_log(log_ctx, AV_LOG_WARNING, "%s\n", log_buf);

    return best;
}

static const AVOption options[] = {
    { "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 },
    { NULL }
};

static const AVClass amrnb_class = {
    "libopencore_amrnb", av_default_item_name, options, LIBAVUTIL_VERSION_INT
};

static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
{
    AMRContext *s = avctx->priv_data;

    if (avctx->sample_rate != 8000 && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
        return AVERROR(ENOSYS);
    }

    if (avctx->channels != 1) {
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
        return AVERROR(ENOSYS);
    }

    avctx->frame_size  = 160;
    avctx->initial_padding = 50;
    ff_af_queue_init(avctx, &s->afq);

    s->enc_state = Encoder_Interface_init(s->enc_dtx);
    if (!s->enc_state) {
        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
        return -1;
    }

    s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
    s->enc_bitrate = avctx->bit_rate;

    return 0;
}

static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
{
    AMRContext *s = avctx->priv_data;

    Encoder_Interface_exit(s->enc_state);
    ff_af_queue_close(&s->afq);
    return 0;
}

static int amr_nb_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
                               const AVFrame *frame, int *got_packet_ptr)
{
    AMRContext *s = avctx->priv_data;
    int written, ret;
    int16_t *flush_buf = NULL;
    const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;

    if (s->enc_bitrate != avctx->bit_rate) {
        s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
        s->enc_bitrate = avctx->bit_rate;
    }

    if ((ret = ff_alloc_packet2(avctx, avpkt, 32)) < 0)
        return ret;

    if (frame) {
        if (frame->nb_samples < avctx->frame_size) {
            flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
            if (!flush_buf)
                return AVERROR(ENOMEM);
            memcpy(flush_buf, samples, frame->nb_samples * sizeof(*flush_buf));
            samples = flush_buf;
            if (frame->nb_samples < avctx->frame_size - avctx->initial_padding)
                s->enc_last_frame = -1;
        }
        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) {
            av_freep(&flush_buf);
            return ret;
        }
    } else {
        if (s->enc_last_frame < 0)
            return 0;
        flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
        if (!flush_buf)
            return AVERROR(ENOMEM);
        samples = flush_buf;
        s->enc_last_frame = -1;
    }

    written = Encoder_Interface_Encode(s->enc_state, s->enc_mode, samples,
                                       avpkt->data, 0);
    av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
            written, s->enc_mode, avpkt->data[0]);

    /* Get the next frame pts/duration */
    ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
                       &avpkt->duration);

    avpkt->size = written;
    *got_packet_ptr = 1;
    av_freep(&flush_buf);
    return 0;
}

AVCodec ff_libopencore_amrnb_encoder = {
    .name           = "libopencore_amrnb",
    .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_AMR_NB,
    .priv_data_size = sizeof(AMRContext),
    .init           = amr_nb_encode_init,
    .encode2        = amr_nb_encode_frame,
    .close          = amr_nb_encode_close,
    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_SMALL_LAST_FRAME,
    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
                                                     AV_SAMPLE_FMT_NONE },
    .priv_class     = &amrnb_class,
};
#endif /* CONFIG_LIBOPENCORE_AMRNB_ENCODER */

#endif /* CONFIG_LIBOPENCORE_AMRNB */

/* -----------AMR wideband ------------*/
#if CONFIG_LIBOPENCORE_AMRWB_DECODER

#include <opencore-amrwb/dec_if.h>
#include <opencore-amrwb/if_rom.h>

typedef struct AMRWBContext {
    void  *state;
} AMRWBContext;

static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
{
    AMRWBContext *s = avctx->priv_data;
    int ret;

    if ((ret = amr_decode_fix_avctx(avctx)) < 0)
        return ret;

    s->state        = D_IF_init();

    return 0;
}

static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
                               int *got_frame_ptr, AVPacket *avpkt)
{
    AVFrame *frame     = data;
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
    AMRWBContext *s    = avctx->priv_data;
    int mode, ret;
    int packet_size;
    static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};

    /* get output buffer */
    frame->nb_samples = 320;
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
        return ret;

    mode        = (buf[0] >> 3) & 0x000F;
    packet_size = block_size[mode];

    if (packet_size > buf_size) {
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
               buf_size, packet_size + 1);
        return AVERROR_INVALIDDATA;
    }
    if (!packet_size) {
        av_log(avctx, AV_LOG_ERROR, "amr packet_size invalid\n");
        return AVERROR_INVALIDDATA;
    }

    D_IF_decode(s->state, buf, (short *)frame->data[0], _good_frame);

    *got_frame_ptr = 1;

    return packet_size;
}

static int amr_wb_decode_close(AVCodecContext *avctx)
{
    AMRWBContext *s = avctx->priv_data;

    D_IF_exit(s->state);
    return 0;
}

AVCodec ff_libopencore_amrwb_decoder = {
    .name           = "libopencore_amrwb",
    .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-WB (Adaptive Multi-Rate Wide-Band)"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_AMR_WB,
    .priv_data_size = sizeof(AMRWBContext),
    .init           = amr_wb_decode_init,
    .close          = amr_wb_decode_close,
    .decode         = amr_wb_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
};

#endif /* CONFIG_LIBOPENCORE_AMRWB_DECODER */
Commit	Line	Data
2ba45a60 DM	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 "libavutil/avstring.h"
	23	#include "libavutil/channel_layout.h"
	24	#include "libavutil/common.h"
	25	#include "libavutil/opt.h"
	26	#include "avcodec.h"
	27	#include "audio_frame_queue.h"
	28	#include "internal.h"
	29
	30	static int amr_decode_fix_avctx(AVCodecContext *avctx)
	31	{
	32	const int is_amr_wb = 1 + (avctx->codec_id == AV_CODEC_ID_AMR_WB);
	33
	34	if (!avctx->sample_rate)
	35	avctx->sample_rate = 8000 * is_amr_wb;
	36
	37	if (avctx->channels > 1) {
	38	avpriv_report_missing_feature(avctx, "multi-channel AMR");
	39	return AVERROR_PATCHWELCOME;
	40	}
	41
	42	avctx->channels = 1;
	43	avctx->channel_layout = AV_CH_LAYOUT_MONO;
	44	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
	45	return 0;
	46	}
	47
	48	#if CONFIG_LIBOPENCORE_AMRNB
	49
	50	#include <opencore-amrnb/interf_dec.h>
	51	#include <opencore-amrnb/interf_enc.h>
	52
	53	typedef struct AMRContext {
	54	AVClass *av_class;
	55	void *dec_state;
	56	void *enc_state;
	57	int enc_bitrate;
	58	int enc_mode;
	59	int enc_dtx;
	60	int enc_last_frame;
	61	AudioFrameQueue afq;
	62	} AMRContext;
	63
	64	#if CONFIG_LIBOPENCORE_AMRNB_DECODER
65	static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
66	{
67	AMRContext *s = avctx->priv_data;
68	int ret;
69
70	if ((ret = amr_decode_fix_avctx(avctx)) < 0)
71	return ret;
72
73	s->dec_state = Decoder_Interface_init();
74	if (!s->dec_state) {
75	av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
76	return -1;
77	}
78
79	return 0;
80	}
81
82	static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
83	{
84	AMRContext *s = avctx->priv_data;
85
86	Decoder_Interface_exit(s->dec_state);
87
88	return 0;
89	}
90
91	static int amr_nb_decode_frame(AVCodecContext avctx, void data,
92	int got_frame_ptr, AVPacket avpkt)
93	{
94	AVFrame *frame = data;
95	const uint8_t *buf = avpkt->data;
96	int buf_size = avpkt->size;
97	AMRContext *s = avctx->priv_data;
98	static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
99	enum Mode dec_mode;
100	int packet_size, ret;
101
102	av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
103	buf, buf_size, avctx->frame_number);
104
105	/* get output buffer */
106	frame->nb_samples = 160;
107	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
108	return ret;
109
110	dec_mode = (buf[0] >> 3) & 0x000F;
111	packet_size = block_size[dec_mode] + 1;
112
113	if (packet_size > buf_size) {
114	av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
115	buf_size, packet_size);
116	return AVERROR_INVALIDDATA;
117	}
118
119	av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
120	packet_size, buf[0], buf[1], buf[2], buf[3]);
121	/* call decoder */
122	Decoder_Interface_Decode(s->dec_state, buf, (short *)frame->data[0], 0);
123
124	*got_frame_ptr = 1;
125
126	return packet_size;
127	}
128
129	AVCodec ff_libopencore_amrnb_decoder = {
130	.name = "libopencore_amrnb",
131	.long_name = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
132	.type = AVMEDIA_TYPE_AUDIO,
133	.id = AV_CODEC_ID_AMR_NB,
134	.priv_data_size = sizeof(AMRContext),
135	.init = amr_nb_decode_init,
136	.close = amr_nb_decode_close,
137	.decode = amr_nb_decode_frame,
138	.capabilities = CODEC_CAP_DR1,
139	};
140	#endif /* CONFIG_LIBOPENCORE_AMRNB_DECODER */
141
142	#if CONFIG_LIBOPENCORE_AMRNB_ENCODER
143	/* Common code for fixed and float version*/
144	typedef struct AMR_bitrates {
145	int rate;
146	enum Mode mode;
147	} AMR_bitrates;
148
149	/* Match desired bitrate */
150	static int get_bitrate_mode(int bitrate, void *log_ctx)
151	{
152	/* make the correspondance between bitrate and mode */
153	static const AMR_bitrates rates[] = {
154	{ 4750, MR475 }, { 5150, MR515 }, { 5900, MR59 }, { 6700, MR67 },
155	{ 7400, MR74 }, { 7950, MR795 }, { 10200, MR102 }, { 12200, MR122 }
156	};
157	int i, best = -1, min_diff = 0;
158	char log_buf[200];
159
160	for (i = 0; i < 8; i++) {
161	if (rates[i].rate == bitrate)
162	return rates[i].mode;
163	if (best < 0 \|\| abs(rates[i].rate - bitrate) < min_diff) {
164	best = i;
165	min_diff = abs(rates[i].rate - bitrate);
166	}
167	}
168	/* no bitrate matching exactly, log a warning */
169	snprintf(log_buf, sizeof(log_buf), "bitrate not supported: use one of ");
170	for (i = 0; i < 8; i++)
171	av_strlcatf(log_buf, sizeof(log_buf), "%.2fk, ", rates[i].rate / 1000.f);
172	av_strlcatf(log_buf, sizeof(log_buf), "using %.2fk", rates[best].rate / 1000.f);
173	av_log(log_ctx, AV_LOG_WARNING, "%s\n", log_buf);
174
175	return best;
176	}
177
178	static const AVOption options[] = {
179	{ "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 },
180	{ NULL }
181	};
182
183	static const AVClass amrnb_class = {
184	"libopencore_amrnb", av_default_item_name, options, LIBAVUTIL_VERSION_INT
185	};
186
187	static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
188	{
189	AMRContext *s = avctx->priv_data;
190
191	if (avctx->sample_rate != 8000 && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
192	av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
193	return AVERROR(ENOSYS);
194	}
195
196	if (avctx->channels != 1) {
197	av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
198	return AVERROR(ENOSYS);
199	}
200
201	avctx->frame_size = 160;
f6fa7814	202	avctx->initial_padding = 50;
2ba45a60 DM	203	ff_af_queue_init(avctx, &s->afq);
	204
	205	s->enc_state = Encoder_Interface_init(s->enc_dtx);
	206	if (!s->enc_state) {
	207	av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
	208	return -1;
	209	}
	210
	211	s->enc_mode = get_bitrate_mode(avctx->bit_rate, avctx);
	212	s->enc_bitrate = avctx->bit_rate;
	213
	214	return 0;
	215	}
	216
	217	static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
	218	{
	219	AMRContext *s = avctx->priv_data;
	220
	221	Encoder_Interface_exit(s->enc_state);
	222	ff_af_queue_close(&s->afq);
	223	return 0;
	224	}
	225
	226	static int amr_nb_encode_frame(AVCodecContext avctx, AVPacket avpkt,
	227	const AVFrame frame, int got_packet_ptr)
	228	{
	229	AMRContext *s = avctx->priv_data;
	230	int written, ret;
	231	int16_t *flush_buf = NULL;
	232	const int16_t samples = frame ? (const int16_t )frame->data[0] : NULL;
	233
	234	if (s->enc_bitrate != avctx->bit_rate) {
	235	s->enc_mode = get_bitrate_mode(avctx->bit_rate, avctx);
	236	s->enc_bitrate = avctx->bit_rate;
	237	}
	238
	239	if ((ret = ff_alloc_packet2(avctx, avpkt, 32)) < 0)
	240	return ret;
	241
	242	if (frame) {
	243	if (frame->nb_samples < avctx->frame_size) {
	244	flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
	245	if (!flush_buf)
	246	return AVERROR(ENOMEM);
	247	memcpy(flush_buf, samples, frame->nb_samples * sizeof(*flush_buf));
	248	samples = flush_buf;
f6fa7814	249	if (frame->nb_samples < avctx->frame_size - avctx->initial_padding)
2ba45a60 DM	250	s->enc_last_frame = -1;
	251	}
	252	if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) {
	253	av_freep(&flush_buf);
	254	return ret;
	255	}
	256	} else {
	257	if (s->enc_last_frame < 0)
	258	return 0;
	259	flush_buf = av_mallocz_array(avctx->frame_size, sizeof(*flush_buf));
	260	if (!flush_buf)
	261	return AVERROR(ENOMEM);
	262	samples = flush_buf;
	263	s->enc_last_frame = -1;
	264	}
	265
	266	written = Encoder_Interface_Encode(s->enc_state, s->enc_mode, samples,
	267	avpkt->data, 0);
	268	av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
	269	written, s->enc_mode, avpkt->data[0]);
	270
	271	/* Get the next frame pts/duration */
	272	ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
	273	&avpkt->duration);
	274
	275	avpkt->size = written;
	276	*got_packet_ptr = 1;
	277	av_freep(&flush_buf);
	278	return 0;
	279	}
	280
	281	AVCodec ff_libopencore_amrnb_encoder = {
	282	.name = "libopencore_amrnb",
	283	.long_name = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
	284	.type = AVMEDIA_TYPE_AUDIO,
	285	.id = AV_CODEC_ID_AMR_NB,
	286	.priv_data_size = sizeof(AMRContext),
	287	.init = amr_nb_encode_init,
	288	.encode2 = amr_nb_encode_frame,
	289	.close = amr_nb_encode_close,
	290	.capabilities = CODEC_CAP_DELAY \| CODEC_CAP_SMALL_LAST_FRAME,
	291	.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
	292	AV_SAMPLE_FMT_NONE },
	293	.priv_class = &amrnb_class,
	294	};
	295	#endif /* CONFIG_LIBOPENCORE_AMRNB_ENCODER */
	296
	297	#endif /* CONFIG_LIBOPENCORE_AMRNB */
	298
	299	/* -----------AMR wideband ------------*/
	300	#if CONFIG_LIBOPENCORE_AMRWB_DECODER
	301
	302	#include <opencore-amrwb/dec_if.h>
	303	#include <opencore-amrwb/if_rom.h>
	304
	305	typedef struct AMRWBContext {
	306	void *state;
	307	} AMRWBContext;
	308
	309	static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
	310	{
	311	AMRWBContext *s = avctx->priv_data;
	312	int ret;
	313
314	if ((ret = amr_decode_fix_avctx(avctx)) < 0)
315	return ret;
316
317	s->state = D_IF_init();
318
319	return 0;
320	}
321
322	static int amr_wb_decode_frame(AVCodecContext avctx, void data,
323	int got_frame_ptr, AVPacket avpkt)
324	{
325	AVFrame *frame = data;
326	const uint8_t *buf = avpkt->data;
327	int buf_size = avpkt->size;
328	AMRWBContext *s = avctx->priv_data;
329	int mode, ret;
330	int packet_size;
331	static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
332
333	/* get output buffer */
334	frame->nb_samples = 320;
335	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
336	return ret;
337
338	mode = (buf[0] >> 3) & 0x000F;
339	packet_size = block_size[mode];
340
341	if (packet_size > buf_size) {
342	av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
343	buf_size, packet_size + 1);
344	return AVERROR_INVALIDDATA;
345	}
346	if (!packet_size) {
347	av_log(avctx, AV_LOG_ERROR, "amr packet_size invalid\n");
348	return AVERROR_INVALIDDATA;
349	}
350
351	D_IF_decode(s->state, buf, (short *)frame->data[0], _good_frame);
352
353	*got_frame_ptr = 1;
354
355	return packet_size;
356	}
357
358	static int amr_wb_decode_close(AVCodecContext *avctx)
359	{
360	AMRWBContext *s = avctx->priv_data;
361
362	D_IF_exit(s->state);
363	return 0;
364	}
365
366	AVCodec ff_libopencore_amrwb_decoder = {
367	.name = "libopencore_amrwb",
368	.long_name = NULL_IF_CONFIG_SMALL("OpenCORE AMR-WB (Adaptive Multi-Rate Wide-Band)"),
369	.type = AVMEDIA_TYPE_AUDIO,
370	.id = AV_CODEC_ID_AMR_WB,
371	.priv_data_size = sizeof(AMRWBContext),
372	.init = amr_wb_decode_init,
373	.close = amr_wb_decode_close,
374	.decode = amr_wb_decode_frame,
375	.capabilities = CODEC_CAP_DR1,
376	};
377
378	#endif /* CONFIG_LIBOPENCORE_AMRWB_DECODER */