ffmpeg系列-解决ffmpeg获取aac音频文件duration不准

您好！对于解决FFmpeg获取AAC音频文件duration不准确的问题，可以尝试以下几个方法：

1. 使用FFprobe进行音频文件信息获取：FFprobe是FFmpeg的一个附属工具，可以用来获取音视频文件的详细信息。通过使用FFprobe获取AAC音频文件的duration信息，可能会比直接使用FFmpeg更准确。您可以通过命令行执行以下命令：`ffprobe -i input.aac -show_entries format=duration -v quiet -of csv="p=0"`

2. 检查音频文件的元数据：有时候，AAC音频文件的duration信息可能与实际不符合是因为文件的元数据有误。您可以使用FFprobe或其他音频文件分析工具，检查音频文件的元数据信息，并确保其与实际时长一致。

3. 更新FFmpeg版本：如果您使用的是旧版本的FFmpeg，可能会存在一些bug或问题，导致获取AAC音频文件duration不准确。建议您尝试更新到最新版本的FFmpeg，并重新测试。

4. 使用其他工具进行验证：如果仍然无法解决问题，可以尝试使用其他音频处理工具或库来获取AAC音频文件的duration信息，比如使用Python的音频处理库pydub等。

希望以上方法可以帮助您解决问题！如有任何疑问，请随时向我提问。

相关问题

ffmpeg录像没有Duration

你好！关于您提到的问题，如果使用FFmpeg录像时没有显示Duration（持续时间），可能是由于几种原因导致的。以下是一些可能的解决方案：

1. 确认输入文件是否完整：确保您的输入文件是完整的，没有任何损坏或缺失的部分。您可以尝试使用其他播放器或媒体工具来验证文件是否正常播放。

2. 更新FFmpeg版本：如果您使用的是较旧的FFmpeg版本，可能会遇到某些问题。尝试更新到最新版本，以确保您使用的是最新的功能和修复了可能存在的问题。

3. 检查媒体文件的元数据：使用FFmpeg的"-i"选项来检查媒体文件的元数据信息。在终端中运行以下命令可以获取详细信息：

ffmpeg -i your_video_file

这将显示与输入文件相关的详细信息，包括持续时间。如果在此输出中没有看到Duration字段，可能是因为输入文件本身没有正确的元数据。

4. 尝试重新编码文件：如果您确定输入文件完整且元数据正确，但仍然无法显示持续时间，可以尝试将文件重新编码为另一种格式。使用以下命令将文件重新编码为MP4格式：

ffmpeg -i input_file.avi -c:v libx264 -c:a aac output_file.mp4

这将使用H.264视频编解码器和AAC音频编解码器将文件重新编码为MP4格式。重新编码后的文件可能会恢复丢失的元数据信息。

请注意，这些解决方案可能因您的具体情况而有所不同。如果问题仍然存在，请提供更多详细信息，以便我们能够更好地帮助您解决问题。

编写一个基于ffmpeg的读取MP3文件输出rtsp音频流的c++例子

好的，下面是一个基于FFmpeg的读取MP3文件输出RTSP音频流的C例子：

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/avutil.h>
#include <libavutil/opt.h>
#include <libavutil/time.h>

#define INBUF_SIZE 4096
#define AUDIO_CODEC_ID AV_CODEC_ID_AAC

int main(int argc, char **argv)
{
    AVFrame *frame = NULL;
    AVCodecContext *ctx = NULL;
    AVOutputFormat *ofmt = NULL;
    AVFormatContext *outctx = NULL;
    AVPacket pkt;
    uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
    int ret, i, out_size;

    av_register_all();
    avcodec_register_all();

    const char *input_file_name = "input.mp3";
    const char *output_file_name = "output.sdp";
    const char *output_format_name = "rtsp";

    AVFormatContext *inctx = NULL;
    ret = avformat_open_input(&inctx, input_file_name, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open input file %s\n", input_file_name);
        return 1;
    }

    ret = avformat_find_stream_info(inctx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not find stream information\n");
        return 1;
    }

    av_dump_format(inctx, 0, input_file_name, 0);

    AVStream *in_audio_stream = NULL;
    for (i = 0; i < inctx->nb_streams; i++) {
        AVStream *stream = inctx->streams[i];
        if (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            in_audio_stream = stream;
            break;
        }
    }

    if (!in_audio_stream) {
        fprintf(stderr, "Could not find input audio stream\n");
        return 1;
    }

    AVCodec *decoder = avcodec_find_decoder(in_audio_stream->codecpar->codec_id);
    if (!decoder) {
        fprintf(stderr, "Codec not found\n");
        return 1;
    }

    ctx = avcodec_alloc_context3(decoder);
    if (!ctx) {
        fprintf(stderr, "Could not allocate codec context\n");
        return 1;
    }

    ret = avcodec_parameters_to_context(ctx, in_audio_stream->codecpar);
    if (ret < 0) {
        fprintf(stderr, "Could not copy codec parameters to context\n");
        return 1;
    }

    ret = avcodec_open2(ctx, decoder, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open codec\n");
        return 1;
    }

    frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate video frame\n");
        return 1;
    }

    avformat_alloc_output_context2(&outctx, NULL, output_format_name, output_file_name);
    if (!outctx) {
        fprintf(stderr, "Could not create output context\n");
        return 1;
    }

    AVStream *out_audio_stream = avformat_new_stream(outctx, NULL);
    if (!out_audio_stream) {
        fprintf(stderr, "Could not create output audio stream\n");
        return 1;
    }

    out_audio_stream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
    out_audio_stream->codecpar->codec_id = AUDIO_CODEC_ID;
    out_audio_stream->codecpar->sample_rate = in_audio_stream->codecpar->sample_rate;
    out_audio_stream->codecpar->channels = in_audio_stream->codecpar->channels;
    out_audio_stream->codecpar->channel_layout = in_audio_stream->codecpar->channel_layout;
    out_audio_stream->codecpar->bit_rate = in_audio_stream->codecpar->bit_rate;

    AVCodec *encoder = avcodec_find_encoder(AUDIO_CODEC_ID);
    if (!encoder) {
        fprintf(stderr, "Encoder not found\n");
        return 1;
    }

    ctx = avcodec_alloc_context3(encoder);
    if (!ctx) {
        fprintf(stderr, "Could not allocate codec context\n");
        return 1;
    }

    ret = avcodec_parameters_to_context(ctx, out_audio_stream->codecpar);
    if (ret < 0) {
        fprintf(stderr, "Could not copy codec parameters to context\n");
        return 1;
    }

    av_opt_set(ctx->priv_data, "preset", "ultrafast", 0);
    av_opt_set(ctx->priv_data, "tune", "zerolatency", 0);

    ret = avcodec_open2(ctx, encoder, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open codec\n");
        return 1;
    }

    ofmt = outctx->oformat;

    ret = avio_open(&outctx->pb, output_file_name, AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Could not open output file %s\n", output_file_name);
        return 1;
    }

    ret = avformat_write_header(outctx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not write header\n");
        return 1;
    }

    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;

    AVBitStreamFilterContext *bsfc = av_bitstream_filter_init("aac_adtstoasc");
    if (!bsfc) {
        fprintf(stderr, "Could not create bitstream filter\n");
        return 1;
    }

    while (av_read_frame(inctx, &pkt) >= 0) {
        if (pkt.stream_index == in_audio_stream->index) {
            ret = avcodec_send_packet(ctx, &pkt);
            if (ret < 0) {
                fprintf(stderr, "Error sending a packet to the decoder\n");
                return 1;
            }

            while (ret >= 0) {
                ret = avcodec_receive_frame(ctx, frame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    break;
                } else if (ret < 0) {
                    fprintf(stderr, "Error during decoding\n");
                    return 1;
                }

                ret = av_frame_make_writable(frame);
                if (ret < 0) {
                    fprintf(stderr, "Error making frame writable\n");
                    return 1;
                }

                ret = avcodec_send_frame(ctx, frame);
                if (ret < 0) {
                    fprintf(stderr, "Error sending a frame to the encoder\n");
                    return 1;
                }

                while (ret >= 0) {
                    AVPacket enc_pkt;
                    enc_pkt.data = NULL;
                    enc_pkt.size = 0;
                    av_init_packet(&enc_pkt);

                    ret = avcodec_receive_packet(ctx, &enc_pkt);
                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                        break;
                    } else if (ret < 0) {
                        fprintf(stderr, "Error encoding audio frame\n");
                        return 1;
                    }

                    av_bitstream_filter_filter(bsfc, out_audio_stream->codec, NULL, &enc_pkt.data, &enc_pkt.size, enc_pkt.data, enc_pkt.size, 0);

                    enc_pkt.stream_index = out_audio_stream->index;
                    enc_pkt.pts = av_rescale_q(frame->pts, in_audio_stream->time_base, out_audio_stream->time_base);
                    enc_pkt.dts = av_rescale_q(frame->pts, in_audio_stream->time_base, out_audio_stream->time_base);
                    enc_pkt.duration = av_rescale_q(frame->nb_samples, in_audio_stream->codecpar->sample_rate, out_audio_stream->codecpar->sample_rate);

                    ret = av_write_frame(outctx, &enc_pkt);
                    if (ret < 0) {
                        fprintf(stderr, "Error writing audio frame to output\n");
                        return 1;
                    }

                    av_packet_unref(&enc_pkt);
                }
            }
        }

        av_packet_unref(&pkt);
    }

    av_write_trailer(outctx);

    av_bitstream_filter_close(bsfc);
    avcodec_free_context(&ctx);
    avformat_close_input(&inctx);
    avformat_free_context(outctx);

    return 0;
}

这个例子使用了FFmpeg库来读取一个MP3文件，并将其转换为一个RTSP音频流。代码中首先使用avformat_open_input函数打开输入文件，然后使用avformat_find_stream_info函数获取文件的流信息。之后代码遍历每个流，找到第一个音频流。然后找到该音频流使用的解码器，为其分配一个解码器上下文，打开解码器。

之后代码创建一个新的输出文件，并为其创建一个新的音频流。使用avcodec_find_encoder函数查找指定的编码器，为其创建一个编码器上下文，并打开编码器。之后代码循环读取输入文件的AVPacket，对于音频流的AVPacket，先解码，再编码，最后写入输出文件。

最后，代码释放所有资源，完成转换过程。