43 #define OUTPUT_BIT_RATE 48000
45 #define OUTPUT_CHANNELS 2
47 #define OUTPUT_SAMPLE_FORMAT AV_SAMPLE_FMT_S16
56 static char error_buffer[255];
57 av_strerror(error, error_buffer,
sizeof(error_buffer));
72 fprintf(stderr,
"Could not open input file '%s' (error '%s')\n",
74 *input_format_context =
NULL;
80 fprintf(stderr,
"Could not open find stream info (error '%s')\n",
87 if ((*input_format_context)->nb_streams != 1) {
88 fprintf(stderr,
"Expected one audio input stream, but found %d\n",
89 (*input_format_context)->nb_streams);
95 if (!(input_codec =
avcodec_find_decoder((*input_format_context)->streams[0]->codec->codec_id))) {
96 fprintf(stderr,
"Could not find input codec\n");
102 if ((error =
avcodec_open2((*input_format_context)->streams[0]->codec,
103 input_codec,
NULL)) < 0) {
104 fprintf(stderr,
"Could not open input codec (error '%s')\n",
111 *input_codec_context = (*input_format_context)->streams[0]->
codec;
132 if ((error =
avio_open(&output_io_context, filename,
134 fprintf(stderr,
"Could not open output file '%s' (error '%s')\n",
141 fprintf(stderr,
"Could not allocate output format context\n");
146 (*output_format_context)->pb = output_io_context;
151 fprintf(stderr,
"Could not find output file format\n");
155 av_strlcpy((*output_format_context)->filename, filename,
156 sizeof((*output_format_context)->filename));
160 fprintf(stderr,
"Could not find an AAC encoder.\n");
166 fprintf(stderr,
"Could not create new stream\n");
172 *output_codec_context = stream->
codec;
180 (*output_codec_context)->sample_rate = input_codec_context->
sample_rate;
193 fprintf(stderr,
"Could not open output codec (error '%s')\n",
203 *output_format_context =
NULL;
220 fprintf(stderr,
"Could not allocate input frame\n");
245 fprintf(stderr,
"Could not allocate resample context\n");
270 fprintf(stderr,
"Could not open resample context\n");
283 fprintf(stderr,
"Could not allocate FIFO\n");
294 fprintf(stderr,
"Could not write output file header (error '%s')\n",
305 int *data_present,
int *finished)
313 if ((error =
av_read_frame(input_format_context, &input_packet)) < 0) {
318 fprintf(stderr,
"Could not read frame (error '%s')\n",
331 data_present, &input_packet)) < 0) {
332 fprintf(stderr,
"Could not decode frame (error '%s')\n",
342 if (*finished && *data_present)
364 if (!(*converted_input_samples = calloc(output_codec_context->
channels,
365 sizeof(**converted_input_samples)))) {
366 fprintf(stderr,
"Could not allocate converted input sample pointers\n");
379 "Could not allocate converted input samples (error '%s')\n",
381 av_freep(&(*converted_input_samples)[0]);
382 free(*converted_input_samples);
401 frame_size, input_data, 0, frame_size)) < 0) {
402 fprintf(stderr,
"Could not convert input samples (error '%s')\n",
413 fprintf(stderr,
"Converted samples left over\n");
422 uint8_t **converted_input_samples,
432 fprintf(stderr,
"Could not reallocate FIFO\n");
438 frame_size) < frame_size) {
439 fprintf(stderr,
"Could not write data to FIFO\n");
468 input_codec_context, &data_present, finished))
475 if (*finished && !data_present) {
503 if (converted_input_samples) {
504 av_freep(&converted_input_samples[0]);
505 free(converted_input_samples);
524 fprintf(stderr,
"Could not allocate output frame\n");
537 (*frame)->format = output_codec_context->
sample_fmt;
538 (*frame)->sample_rate = output_codec_context->
sample_rate;
545 fprintf(stderr,
"Could allocate output frame samples (error '%s')\n",
570 frame, data_present)) < 0) {
571 fprintf(stderr,
"Could not encode frame (error '%s')\n",
579 if ((error =
av_write_frame(output_format_context, &output_packet)) < 0) {
580 fprintf(stderr,
"Could not write frame (error '%s')\n",
620 fprintf(stderr,
"Could not read data from FIFO\n");
627 output_codec_context, &data_written)) {
640 fprintf(stderr,
"Could not write output file trailer (error '%s')\n",
648 int main(
int argc,
char **argv)
657 fprintf(stderr,
"Usage: %s <input file> <output file>\n", argv[0]);
665 &input_codec_context))
669 &output_format_context, &output_codec_context))
688 const int output_frame_size = output_codec_context->frame_size;
705 output_codec_context,
706 resample_context, &finished))
729 output_codec_context))
741 output_codec_context, &data_written))
743 }
while (data_written);
756 if (resample_context) {
760 if (output_codec_context)
762 if (output_format_context) {
766 if (input_codec_context)
768 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.
uint64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
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.
void avresample_free(AVAudioResampleContext **avr)
Free AVAudioResampleContext and associated AVOption values.
void av_freep(void *arg)
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.
static int output_packet(AVFormatContext *ctx, int flush)
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.
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.
#define AVERROR_EOF
End of file.
static int init_input_frame(AVFrame **frame)
Initialize one audio frame for reading from the input file.
void avresample_close(AVAudioResampleContext *avr)
Close AVAudioResampleContext.
static const uint8_t frame_size[4]
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
static int output_frame(H264Context *h, AVFrame *dst, AVFrame *src)
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.
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
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.
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.
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
AVCodecContext * codec
Codec context associated with this stream.
Context for an Audio FIFO Buffer.
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.
static char *const get_error_text(const int error)
Convert an error code into a text message.
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 avresample_available(AVAudioResampleContext *avr)
Return the number of available samples in the output FIFO.
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...
Libavcodec external API header.
#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.
static int read_decode_convert_and_store(AVAudioFifo *fifo, AVFormatContext *input_format_context, AVCodecContext *input_codec_context, AVCodecContext *output_codec_context, AVAudioResampleContext *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(uint8_t **input_data, uint8_t **converted_data, const int frame_size, AVAudioResampleContext *resample_context)
Convert the input audio samples into the output sample format.
int avresample_convert(AVAudioResampleContext *avr, uint8_t **output, int out_plane_size, int out_samples, uint8_t **input, int in_plane_size, int in_samples)
Convert input samples and write them to the output FIFO.
static int init_resampler(AVCodecContext *input_codec_context, AVCodecContext *output_codec_context, AVAudioResampleContext **resample_context)
Initialize the audio resampler based on the input and output codec settings.
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.
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.
AVAudioResampleContext * avresample_alloc_context(void)
Allocate AVAudioResampleContext and set options.
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
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 avresample_open(AVAudioResampleContext *avr)
Initialize AVAudioResampleContext.
int nb_samples
number of audio samples (per channel) described by this frame
int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.