44 #define OUTPUT_BIT_RATE 48000
46 #define OUTPUT_CHANNELS 2
48 #define OUTPUT_SAMPLE_FORMAT AV_SAMPLE_FMT_S16
57 static char error_buffer[255];
58 av_strerror(error, error_buffer,
sizeof(error_buffer));
73 fprintf(stderr,
"Could not open input file '%s' (error '%s')\n",
75 *input_format_context = NULL;
81 fprintf(stderr,
"Could not open find stream info (error '%s')\n",
88 if ((*input_format_context)->nb_streams != 1) {
89 fprintf(stderr,
"Expected one audio input stream, but found %d\n",
90 (*input_format_context)->nb_streams);
96 if (!(input_codec =
avcodec_find_decoder((*input_format_context)->streams[0]->codec->codec_id))) {
97 fprintf(stderr,
"Could not find input codec\n");
103 if ((error =
avcodec_open2((*input_format_context)->streams[0]->codec,
104 input_codec, NULL)) < 0) {
105 fprintf(stderr,
"Could not open input codec (error '%s')\n",
112 *input_codec_context = (*input_format_context)->streams[0]->
codec;
133 if ((error =
avio_open(&output_io_context, filename,
135 fprintf(stderr,
"Could not open output file '%s' (error '%s')\n",
142 fprintf(stderr,
"Could not allocate output format context\n");
147 (*output_format_context)->pb = output_io_context;
150 if (!((*output_format_context)->oformat =
av_guess_format(NULL, filename,
152 fprintf(stderr,
"Could not find output file format\n");
156 av_strlcpy((*output_format_context)->filename, filename,
157 sizeof((*output_format_context)->filename));
161 fprintf(stderr,
"Could not find an AAC encoder.\n");
167 fprintf(stderr,
"Could not create new stream\n");
173 *output_codec_context = stream->
codec;
181 (*output_codec_context)->sample_rate = input_codec_context->
sample_rate;
193 if ((error =
avcodec_open2(*output_codec_context, output_codec, NULL)) < 0) {
194 fprintf(stderr,
"Could not open output codec (error '%s')\n",
204 *output_format_context = NULL;
221 fprintf(stderr,
"Could not allocate input frame\n");
253 if (!*resample_context) {
254 fprintf(stderr,
"Could not allocate resample context\n");
265 if ((error =
swr_init(*resample_context)) < 0) {
266 fprintf(stderr,
"Could not open resample context\n");
278 fprintf(stderr,
"Could not allocate FIFO\n");
289 fprintf(stderr,
"Could not write output file header (error '%s')\n",
300 int *data_present,
int *finished)
308 if ((error =
av_read_frame(input_format_context, &input_packet)) < 0) {
313 fprintf(stderr,
"Could not read frame (error '%s')\n",
326 data_present, &input_packet)) < 0) {
327 fprintf(stderr,
"Could not decode frame (error '%s')\n",
337 if (*finished && *data_present)
359 if (!(*converted_input_samples = calloc(output_codec_context->
channels,
360 sizeof(**converted_input_samples)))) {
361 fprintf(stderr,
"Could not allocate converted input sample pointers\n");
374 "Could not allocate converted input samples (error '%s')\n",
376 av_freep(&(*converted_input_samples)[0]);
377 free(*converted_input_samples);
389 uint8_t **converted_data,
const int frame_size,
396 converted_data, frame_size,
397 input_data , frame_size)) < 0) {
398 fprintf(stderr,
"Could not convert input samples (error '%s')\n",
408 uint8_t **converted_input_samples,
409 const int frame_size)
418 fprintf(stderr,
"Could not reallocate FIFO\n");
424 frame_size) < frame_size) {
425 fprintf(stderr,
"Could not write data to FIFO\n");
445 uint8_t **converted_input_samples = NULL;
454 input_codec_context, &data_present, finished))
461 if (*finished && !data_present) {
489 if (converted_input_samples) {
490 av_freep(&converted_input_samples[0]);
491 free(converted_input_samples);
510 fprintf(stderr,
"Could not allocate output frame\n");
521 (*frame)->nb_samples = frame_size;
523 (*frame)->format = output_codec_context->
sample_fmt;
524 (*frame)->sample_rate = output_codec_context->
sample_rate;
531 fprintf(stderr,
"Could allocate output frame samples (error '%s')\n",
556 frame, data_present)) < 0) {
557 fprintf(stderr,
"Could not encode frame (error '%s')\n",
565 if ((error =
av_write_frame(output_format_context, &output_packet)) < 0) {
566 fprintf(stderr,
"Could not write frame (error '%s')\n",
606 fprintf(stderr,
"Could not read data from FIFO\n");
613 output_codec_context, &data_written)) {
626 fprintf(stderr,
"Could not write output file trailer (error '%s')\n",
634 int main(
int argc,
char **argv)
636 AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
637 AVCodecContext *input_codec_context = NULL, *output_codec_context = NULL;
643 fprintf(stderr,
"Usage: %s <input file> <output file>\n", argv[0]);
651 &input_codec_context))
655 &output_format_context, &output_codec_context))
674 const int output_frame_size = output_codec_context->frame_size;
691 output_codec_context,
692 resample_context, &finished))
715 output_codec_context))
727 output_codec_context, &data_written))
729 }
while (data_written);
743 if (output_codec_context)
745 if (output_format_context) {
749 if (input_codec_context)
751 if (input_format_context)
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
const struct AVCodec * codec
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
void av_free_packet(AVPacket *pkt)
Free a packet.
This structure describes decoded (raw) audio or video data.
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
int main(int argc, char **argv)
Convert an audio file to an AAC file in an MP4 container.
int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
#define AVIO_FLAG_WRITE
write-only
int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of audio.
static void init_packet(AVPacket *packet)
Initialize one data packet for reading or writing.
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.
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
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 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.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
enum AVSampleFormat sample_fmt
audio sample format
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
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, decodes, converts and stores it in the FIFO buffer...
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.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
#define OUTPUT_SAMPLE_FORMAT
The audio sample output format.
int swr_convert(struct SwrContext *s, uint8_t **out, int out_count, const uint8_t **in, int in_count)
Convert audio.
#define AVERROR_EOF
End of file.
static int init_input_frame(AVFrame **frame)
Initialize one audio frame for reading from the input file.
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
libswresample public header
static int write_output_file_header(AVFormatContext *output_format_context)
Write the header of the output file container.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
simple assert() macros that are a bit more flexible than ISO C assert().
struct AVAudioFifo AVAudioFifo
Context for an Audio FIFO Buffer.
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.
Libavcodec external API header.
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
struct SwrContext SwrContext
The libswresample context.
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
AVCodecContext * codec
Codec context associated with this stream.
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
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 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.
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 avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
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...
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.
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
int frame_size
Number of samples per channel in an audio frame.
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...
#define OUTPUT_BIT_RATE
The output bit rate in kbit/s.
int sample_rate
samples per second
static int init_fifo(AVAudioFifo **fifo)
Initialize a FIFO buffer for the audio samples to be encoded.
main external API structure.
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
void swr_free(struct SwrContext **s)
Free the given SwrContext and set the pointer to NULL.
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
static const char * get_error_text(const int error)
Convert an error code into a text message.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
#define OUTPUT_CHANNELS
The number of output channels.
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples)
Reallocate an AVAudioFifo.
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
static int write_output_file_trailer(AVFormatContext *output_format_context)
Write the trailer of the output file container.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
int channels
number of audio channels
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
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.
static int init_output_frame(AVFrame **frame, AVCodecContext *output_codec_context, int frame_size)
Initialize one input frame for writing to the output file.
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
void av_register_all(void)
Initialize libavformat and register all the muxers, demuxers and protocols.
int nb_samples
number of audio samples (per channel) described by this frame
int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.