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

Question

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

Answer 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 как это довольно долго, но вы можете посмотреть на это здесь.)

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,