Convert an input audio file to AAC in an MP4 container using FFmpeg.Formats other than MP4 are supported based on the output file extension.
#include <stdio.h>
#define OUTPUT_BIT_RATE 96000
#define OUTPUT_CHANNELS 2
{
int error;
NULL)) < 0) {
fprintf(stderr, "Could not open input file '%s' (error '%s')\n",
*input_format_context = NULL;
return error;
}
fprintf(stderr, "Could not open find stream info (error '%s')\n",
return error;
}
if ((*input_format_context)->nb_streams != 1) {
fprintf(stderr, "Expected one audio input stream, but found %d\n",
(*input_format_context)->nb_streams);
}
if (!(input_codec =
avcodec_find_decoder((*input_format_context)->streams[0]->codecpar->codec_id))) {
fprintf(stderr, "Could not find input codec\n");
}
if (!avctx) {
fprintf(stderr, "Could not allocate a decoding context\n");
}
if (error < 0) {
return error;
}
fprintf(stderr, "Could not open input codec (error '%s')\n",
return error;
}
*input_codec_context = avctx;
return 0;
}
{
int error;
if ((error =
avio_open(&output_io_context, filename,
fprintf(stderr, "Could not open output file '%s' (error '%s')\n",
return error;
}
fprintf(stderr, "Could not allocate output format context\n");
}
(*output_format_context)->pb = output_io_context;
NULL))) {
fprintf(stderr, "Could not find output file format\n");
goto cleanup;
}
if (!((*output_format_context)->url =
av_strdup(filename))) {
fprintf(stderr, "Could not allocate url.\n");
goto cleanup;
}
fprintf(stderr, "Could not find an AAC encoder.\n");
goto cleanup;
}
fprintf(stderr, "Could not create new stream\n");
goto cleanup;
}
if (!avctx) {
fprintf(stderr, "Could not allocate an encoding context\n");
goto cleanup;
}
fprintf(stderr, "Could not open output codec (error '%s')\n",
goto cleanup;
}
if (error < 0) {
fprintf(stderr, "Could not initialize stream parameters\n");
goto cleanup;
}
*output_codec_context = avctx;
return 0;
cleanup:
*output_format_context = NULL;
}
{
}
{
fprintf(stderr, "Could not allocate input frame\n");
}
return 0;
}
{
int error;
0, NULL);
if (!*resample_context) {
fprintf(stderr, "Could not allocate resample context\n");
}
if ((error =
swr_init(*resample_context)) < 0) {
fprintf(stderr, "Could not open resample context\n");
return error;
}
return 0;
}
{
fprintf(stderr, "Could not allocate FIFO\n");
}
return 0;
}
{
int error;
fprintf(stderr, "Could not write output file header (error '%s')\n",
return error;
}
return 0;
}
int *data_present, int *finished)
{
int error;
if ((error =
av_read_frame(input_format_context, &input_packet)) < 0) {
*finished = 1;
else {
fprintf(stderr, "Could not read frame (error '%s')\n",
return error;
}
}
fprintf(stderr, "Could not send packet for decoding (error '%s')\n",
return error;
}
error = 0;
goto cleanup;
*finished = 1;
error = 0;
goto cleanup;
} else if (error < 0) {
fprintf(stderr, "Could not decode frame (error '%s')\n",
goto cleanup;
} else {
*data_present = 1;
goto cleanup;
}
cleanup:
return error;
}
int frame_size)
{
int error;
if (!(*converted_input_samples = calloc(output_codec_context->
channels,
sizeof(**converted_input_samples)))) {
fprintf(stderr, "Could not allocate converted input sample pointers\n");
}
frame_size,
fprintf(stderr,
"Could not allocate converted input samples (error '%s')\n",
av_freep(&(*converted_input_samples)[0]);
free(*converted_input_samples);
return error;
}
return 0;
}
uint8_t **converted_data, const int frame_size,
{
int error;
converted_data, frame_size,
input_data , frame_size)) < 0) {
fprintf(stderr, "Could not convert input samples (error '%s')\n",
return error;
}
return 0;
}
uint8_t **converted_input_samples,
const int frame_size)
{
int error;
fprintf(stderr, "Could not reallocate FIFO\n");
return error;
}
frame_size) < frame_size) {
fprintf(stderr, "Could not write data to FIFO\n");
}
return 0;
}
int *finished)
{
uint8_t **converted_input_samples = NULL;
int data_present = 0;
goto cleanup;
input_codec_context, &data_present, finished))
goto cleanup;
if (*finished) {
ret = 0;
goto cleanup;
}
if (data_present) {
goto cleanup;
goto cleanup;
goto cleanup;
ret = 0;
}
ret = 0;
cleanup:
if (converted_input_samples) {
free(converted_input_samples);
}
return ret;
}
int frame_size)
{
int error;
fprintf(stderr, "Could not allocate output frame\n");
}
(*frame)->nb_samples = frame_size;
(*frame)->format = output_codec_context->
sample_fmt;
(*frame)->sample_rate = output_codec_context->
sample_rate;
fprintf(stderr, "Could not allocate output frame samples (error '%s')\n",
return error;
}
return 0;
}
int *data_present)
{
int error;
}
error = 0;
goto cleanup;
} else if (error < 0) {
fprintf(stderr, "Could not send packet for encoding (error '%s')\n",
return error;
}
error = 0;
goto cleanup;
error = 0;
goto cleanup;
} else if (error < 0) {
fprintf(stderr, "Could not encode frame (error '%s')\n",
goto cleanup;
} else {
*data_present = 1;
}
if (*data_present &&
(error =
av_write_frame(output_format_context, &output_packet)) < 0) {
fprintf(stderr, "Could not write frame (error '%s')\n",
goto cleanup;
}
cleanup:
return error;
}
{
int data_written;
fprintf(stderr, "Could not read data from FIFO\n");
}
output_codec_context, &data_written)) {
}
return 0;
}
{
int error;
fprintf(stderr, "Could not write output file trailer (error '%s')\n",
return error;
}
return 0;
}
int main(
int argc,
char **argv)
{
AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
AVCodecContext *input_codec_context = NULL, *output_codec_context = NULL;
if (argc != 3) {
fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
exit(1);
}
&input_codec_context))
goto cleanup;
&output_format_context, &output_codec_context))
goto cleanup;
&resample_context))
goto cleanup;
goto cleanup;
goto cleanup;
while (1) {
const int output_frame_size = output_codec_context->frame_size;
int finished = 0;
input_codec_context,
output_codec_context,
resample_context, &finished))
goto cleanup;
if (finished)
break;
}
output_codec_context))
goto cleanup;
if (finished) {
int data_written;
do {
data_written = 0;
output_codec_context, &data_written))
goto cleanup;
} while (data_written);
break;
}
}
goto cleanup;
ret = 0;
cleanup:
if (fifo)
if (output_codec_context)
if (output_format_context) {
}
if (input_codec_context)
if (input_format_context)
return ret;
}
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
#define AVIO_FLAG_WRITE
write-only
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
reference-counted frame API
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
av_warn_unused_result int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples)
Reallocate an AVAudioFifo.
struct AVAudioFifo AVAudioFifo
Context for an Audio FIFO Buffer.
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
#define AVERROR_EOF
End of file.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
void av_freep(void *ptr)
Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family,...
char * av_strdup(const char *s) av_malloc_attrib
Duplicate a string.
int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Allocate a samples buffer for nb_samples samples, and fill data pointers and linesize accordingly.
struct SwrContext SwrContext
The libswresample context.
void swr_free(struct SwrContext **s)
Free the given SwrContext and set the pointer to NULL.
int swr_convert(struct SwrContext *s, uint8_t **out, int out_count, const uint8_t **in, int in_count)
Convert audio.
struct SwrContext * swr_alloc_set_opts(struct SwrContext *s, int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx)
Allocate SwrContext if needed and set/reset common parameters.
int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
main external API structure.
enum AVSampleFormat sample_fmt
audio sample format
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
int64_t bit_rate
the average bitrate
int sample_rate
samples per second
int flags
AV_CODEC_FLAG_*.
int channels
number of audio channels
uint64_t channel_layout
Audio channel layout.
int frame_size
Number of samples per channel in an audio frame.
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
libswresample public header
static void init_packet(AVPacket *packet)
Initialize one data packet for reading or writing.
static int add_samples_to_fifo(AVAudioFifo *fifo, uint8_t **converted_input_samples, const int frame_size)
Add converted input audio samples to the FIFO buffer for later processing.
static int init_input_frame(AVFrame **frame)
Initialize one audio frame for reading from the input file.
int main(int argc, char **argv)
static int encode_audio_frame(AVFrame *frame, AVFormatContext *output_format_context, AVCodecContext *output_codec_context, int *data_present)
Encode one frame worth of audio to the output file.
static int decode_audio_frame(AVFrame *frame, AVFormatContext *input_format_context, AVCodecContext *input_codec_context, int *data_present, int *finished)
Decode one audio frame from the input file.
static int open_output_file(const char *filename, AVCodecContext *input_codec_context, AVFormatContext **output_format_context, AVCodecContext **output_codec_context)
Open an output file and the required encoder.
static int init_resampler(AVCodecContext *input_codec_context, AVCodecContext *output_codec_context, SwrContext **resample_context)
Initialize the audio resampler based on the input and output codec settings.
static int write_output_file_header(AVFormatContext *output_format_context)
Write the header of the output file container.
static int init_output_frame(AVFrame **frame, AVCodecContext *output_codec_context, int frame_size)
Initialize one input frame for writing to the output file.
static int read_decode_convert_and_store(AVAudioFifo *fifo, AVFormatContext *input_format_context, AVCodecContext *input_codec_context, AVCodecContext *output_codec_context, SwrContext *resampler_context, int *finished)
Read one audio frame from the input file, decode, convert and store it in the FIFO buffer.
static int open_input_file(const char *filename, AVFormatContext **input_format_context, AVCodecContext **input_codec_context)
Open an input file and the required decoder.
static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
Initialize a FIFO buffer for the audio samples to be encoded.
static int load_encode_and_write(AVAudioFifo *fifo, AVFormatContext *output_format_context, AVCodecContext *output_codec_context)
Load one audio frame from the FIFO buffer, encode and write it to the output file.
static int write_output_file_trailer(AVFormatContext *output_format_context)
Write the trailer of the output file container.
static int convert_samples(const uint8_t **input_data, uint8_t **converted_data, const int frame_size, SwrContext *resample_context)
Convert the input audio samples into the output sample format.
static int init_converted_samples(uint8_t ***converted_input_samples, AVCodecContext *output_codec_context, int frame_size)
Initialize a temporary storage for the specified number of audio samples.