FFMPEG: мультиплексирование потоков с разной продолжительностью

Я мультиплексирую видео и аудиопотоки. Видеопоток поступает из сгенерированных данных изображения. Аудиопоток поступает из файла 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%, и ясно, что звук способствует этому, поскольку видеофрагменты закончены именно там, где они должны были быть.

Самый близкий "хак", с которым я пришел, - это эта часть:

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 аудиопотока. По крайней мере, это то, что я считаю. С этим взломом я получаю очень небольшое отклонение от правильной длины видео при использовании стандартных файлов AAC, с частотой дискретизации 44100, стерео. Но если я тестирую более проблемные образцы, такие как частота выборки AAC 16000, моно - тогда видеофайл добавляет почти целую секунду к его размеру. Я буду признателен, если кто-то может указать, что я делаю неправильно здесь.

Важное примечание. Я не устанавливаю продолжительность для любого из контекстов. Я контролирую завершение сеанса мультиплексирования, который основан на подсчете видеокадров. Конечно, поток аудиовхода имеет длительность, но это не помогает мне, поскольку продолжительность видео - это то, что определяет длину фильма.

ОБНОВИТЬ:

Это вторая попытка щедрости.

ОБНОВЛЕНИЕ 2:

На самом деле, моя звуковая метка {den, num} была неправильной, в то время как {1,1} действительно способ пойти, как объясняется ответ. То, что мешало ему работать, было ошибкой в этой строке (мой плохой):

     mAudioOutStream.next_pts += a_pkt.pts;

Что должно быть:

     mAudioOutStream.next_pts = a_pkt.pts;

Ошибка привела к экспоненциальному приращению pts, что привело к очень раннему достижению конца потока (в терминах pts) и, следовательно, вызвало прекращение аудиопотока намного раньше, чем предполагалось.

Ответ 1

Проблема в том, что вы говорите ему сравнить данное время звука с 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 на следующую строку. (Я не буду копировать все тело функции для av_rescale_rnd поскольку он довольно длинный, но вы можете посмотреть на него здесь.)

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.