我正在复用视频和音频流。视频流来自生成的图像数据。音频流来自 aac 文件。一些音频文件比我设置的总视频时间长，所以我的策略是在其时间大于总视频时间(我通过编码视频帧数控制的最后一个)时停止音频流复用器。

我不会把整个设置代码放在这里，但它类似于 muxing.c来自最新的 FFMPEG 存储库的示例。唯一的区别是，正如我所说，我使用来自文件的音频流，而不是来自综合生成的编码帧。我很确定问题出在复用器循环期间我的错误同步。这就是我所做的:

void AudioSetup(const char* audioInFileName)
{
    AVOutputFormat* outputF = mOutputFormatContext->oformat;
    auto audioCodecId = outputF->audio_codec;

    if (audioCodecId == AV_CODEC_ID_NONE) {
        return false;
    }

    audio_codec = avcodec_find_encoder(audioCodecId);

    avformat_open_input(&mInputAudioFormatContext,
    audioInFileName, 0, 0);
    avformat_find_stream_info(mInputAudioFormatContext, 0);

    av_dump_format(mInputAudioFormatContext, 0, audioInFileName, 0);


    for (size_t i = 0; i < mInputAudioFormatContext->nb_streams; i++) {
        if (mInputAudioFormatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            inAudioStream = mInputAudioFormatContext->streams[i];

            AVCodecParameters *in_codecpar = inAudioStream->codecpar;
            mAudioOutStream.st = avformat_new_stream(mOutputFormatContext, NULL);
            mAudioOutStream.st->id = mOutputFormatContext->nb_streams - 1;
            AVCodecContext* c = avcodec_alloc_context3(audio_codec);
            mAudioOutStream.enc = c;
            c->sample_fmt = audio_codec->sample_fmts[0];
            avcodec_parameters_to_context(c, inAudioStream->codecpar);
            //copyparams from input to autput audio stream:
            avcodec_parameters_copy(mAudioOutStream.st->codecpar, inAudioStream->codecpar);

            mAudioOutStream.st->time_base.num = 1;
            mAudioOutStream.st->time_base.den = c->sample_rate;

            c->time_base = mAudioOutStream.st->time_base;

            if (mOutputFormatContext->oformat->flags & AVFMT_GLOBALHEADER) {
                c->flags |= CODEC_FLAG_GLOBAL_HEADER;
            }
            break;
        }
    }
}

void Encode()
{
    int cc = av_compare_ts(mVideoOutStream.next_pts, mVideoOutStream.enc->time_base,
    mAudioOutStream.next_pts, mAudioOutStream.enc->time_base);

    if (mAudioOutStream.st == NULL || cc <= 0) {
        uint8_t* data = GetYUVFrame();//returns ready video YUV frame to work with
        int ret = 0;
        AVPacket pkt = { 0 };
        av_init_packet(&pkt);
        pkt.size = packet->dataSize;
        pkt.data = data;
        const int64_t duration = av_rescale_q(1, mVideoOutStream.enc->time_base, mVideoOutStream.st->time_base);

        pkt.duration = duration;
        pkt.pts = mVideoOutStream.next_pts;
        pkt.dts = mVideoOutStream.next_pts;
        mVideoOutStream.next_pts += duration;

        pkt.stream_index = mVideoOutStream.st->index;
        ret = av_interleaved_write_frame(mOutputFormatContext, &pkt);
    } else
    if(audio_time <  video_time) {
        //5 -  duration of video in seconds
        AVRational r = {  60, 1 };

        auto cmp= av_compare_ts(mAudioOutStream.next_pts, mAudioOutStream.enc->time_base, 5, r);
        if (cmp >= 0) {
            mAudioOutStream.next_pts = (int64_t)std::numeric_limits<int64_t>::max();
            return true; //don't mux audio anymore
        }

        AVPacket a_pkt = { 0 };
        av_init_packet(&a_pkt);

        int ret = 0;
        ret = av_read_frame(mInputAudioFormatContext, &a_pkt);
        //if audio file is shorter than stop muxing when at the end of the file
        if (ret == AVERROR_EOF) {
            mAudioOutStream.next_pts = (int64_t)std::numeric_limits<int64_t>::max(); 
            return true;
        }
        a_pkt.stream_index = mAudioOutStream.st->index;

        av_packet_rescale_ts(&a_pkt, inAudioStream->time_base, mAudioOutStream.st->time_base);
        mAudioOutStream.next_pts += a_pkt.pts;

        ret = av_interleaved_write_frame(mOutputFormatContext, &a_pkt);
    }
}

现在，视频部分完美无缺。但是，如果音轨比视频持续时间长，我的总视频长度会增加大约 5% 到 20%，很明显，音频在其中起到了作用，因为视频帧正好在应该在的地方完成。

我最接近的'hack'是这部分:

AVRational r = {  60 ,1 };
auto cmp= av_compare_ts(mAudioOutStream.next_pts, mAudioOutStream.enc->time_base, 5, r);
if (cmp >= 0) {
    mAudioOutStream.next_pts = (int64_t)std::numeric_limits<int64_t>::max();
    return true;
} 

这里我试图比较音频流的 next_pts 和为视频文件设置的总时间，即 5 秒。通过设置 r = {60,1} 我正在通过音频流的 time_base 转换这些秒数。至少那是我相信我正在做的事情。有了这个 hack，当使用标准 AAC 文件时，我与正确的电影长度的偏差非常小，即 44100 的采样率，立体声。但是，如果我使用更多有问题的样本进行测试，例如 AAC 采样率 16000，单声道 - 那么视频文件的大小几乎会增加一整秒。 如果有人能指出我在这里做错了什么，我将不胜感激。

重要提示:我没有为任何上下文设置持续时间。我根据视频帧数控制多路复用 session 的终止。音频输入流当然有持续时间，但它对我没有帮助，因为视频持续时间是定义电影长度的因素。

更新:

这是第二次赏金尝试。

更新 2:

实际上，我的 {den,num} 音频时间戳是错误的，而 {1,1} 确实是要走的路，正如答案所解释的那样。阻止它工作的是这一行中的一个错误(我的错):

     mAudioOutStream.next_pts += a_pkt.pts;

必须是:

     mAudioOutStream.next_pts = a_pkt.pts;

该错误导致 pts 呈指数增长，这导致非常早地到达流的末尾(以 pts 而言)，因此导致音频流比预期的更早终止。

最佳答案

问题是你告诉它比较给定的音频时间和 5报价 60 seconds per tick .我真的很惊讶它在某些情况下有效，但我想这真的取决于具体的 time_base给定的音频流。

假设音频有 time_base的 1/25并且流在6秒，比你想要的多，所以你想要 av_compare_ts返回 0或 1 .鉴于这些条件，您将获得以下值:

mAudioOutStream.next_pts = 150
mAudioOutStream.enc->time_base = 1/25

因此您调用 av_compare_ts具有以下参数:

ts_a = 150
tb_a = 1/25
ts_b = 5
tb_b = 60/1

现在让我们看看av_compare_ts的实现:

int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
{
    int64_t a = tb_a.num * (int64_t)tb_b.den;
    int64_t b = tb_b.num * (int64_t)tb_a.den;
    if ((FFABS(ts_a)|a|FFABS(ts_b)|b) <= INT_MAX)
        return (ts_a*a > ts_b*b) - (ts_a*a < ts_b*b);
    if (av_rescale_rnd(ts_a, a, b, AV_ROUND_DOWN) < ts_b)
        return -1;
    if (av_rescale_rnd(ts_b, b, a, AV_ROUND_DOWN) < ts_a)
        return 1;
    return 0;
}

给定上面的值，你得到:

a = 1 * 1 = 1
b = 60 * 25 = 1500

然后 av_rescale_rnd使用这些参数调用:

a = 150
b = 1
c = 1500
rnd = AV_ROUND_DOWN

给定我们的参数，我们实际上可以剥离整个函数 av_rescale_rnd到下一行。 (av_rescale_rnd 的函数体比较长，我不会复制整个函数体，你可以看一下 here。)

return (a * b) / c;

这将返回 (150 * 1) / 1500 ，即 0 .

因此 av_rescale_rnd(ts_a, a, b, AV_ROUND_DOWN) < ts_b将解析为 true , 因为 0小于 ts_b ( 5 )，等等 av_compare_ts将返回 -1 ，这完全不是你想要的。

如果您更改 r至1/1它应该可以工作，因为现在你的 5实际上将被视为 5 seconds :

ts_a = 150
tb_a = 1/25
ts_b = 5
tb_b = 1/1

在 av_compare_ts我们现在得到:

a = 1 * 1 = 1
b = 1 * 25 = 25

然后 av_rescale_rnd使用这些参数调用:

a = 150
b = 1
c = 25
rnd = AV_ROUND_DOWN

这将返回 (150 * 1) / 25 ，即 6 .

6大于 5 ，条件失败，av_rescale_rnd再次调用，这次是:

a = 5
b = 25
c = 1
rnd = AV_ROUND_DOWN

这将返回 (5 * 25) / 1 ，即 125 .小于 150 ，因此 1被退回，瞧你的问题就解决了。

如果 step_size 大于 1

如果 step_size您的音频流不是 1 ，你需要修改你的r考虑到这一点，例如step_size = 1024 :

r = { 1, 1024 };

让我们快速回顾一下现在发生的事情:

大约 6 秒:

mAudioOutStream.next_pts = 282
mAudioOutStream.enc->time_base = 1/48000

av_compare_ts获取以下参数:

ts_a = 282
tb_a = 1/48000
ts_b = 5
tb_b = 1/1024

因此:

a = 1 * 1024 = 1024
b = 1 * 48000 = 48000

在 av_rescale_rnd :

a = 282
b = 1024
c = 48000
rnd = AV_ROUND_DOWN

(a * b) / c会给(282 * 1024) / 48000 = 288768 / 48000这是6 .

与 r={1,1}你会得到0再次，因为它会计算 (281 * 1) / 48000 .

关于c++ - FFMPEG:多路复用不同持续时间的流，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49342379/