FFMPEG: flux de multiplexage de durée différente

je multiplie les flux vidéo et audio. Le flux vidéo provient des données d'image générées. Le flux audio provient du fichier aac. Certains fichiers audio sont plus longs que le temps total de vidéo que j'ai défini de sorte que ma stratégie pour arrêter audio stream muxer lorsque son temps devient plus grand que le temps total de vidéo(le dernier que je contrôle par nombre de cadres vidéo encodés).

Je ne mettrai pas ici tout le code de configuration, mais il est similaire à multiplexage.c exemple du dernier rapport FFMPEG. La seule la différence est que j'utilise le flux audio à partir du fichier,comme je l'ai dit, pas à partir d'un cadre encodé de façon synthétique. Je suis presque sûr que le problème est dans ma mauvaise synchronisation pendant la boucle muxer.Voici ce que je fais:

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);
    }
}

Maintenant, la partie vidéo est impeccable. Mais si la piste audio est plus longue que la durée de la vidéo, je vais obtenir la longueur totale de la vidéo plus d'environ 5% - 20%, et il est clair que l'audio contribue à cela que les cadres vidéo sont finis exactement où il est censé pour être.

Le plus proche de "hack" je suis venu avec cette partie:

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;
} 

Ici j'ai essayé de comparer next_pts du flux audio avec le temps total défini pour le fichier vidéo,qui est de 5 secondes. Par le paramètre r = {60,1} je convertis ces secondes par la time_base du flux audio. Du moins, c'est ce que je crois que je fais. Avec ce hack, Je m'écarte très légèrement de la bonne longueur de film en utilisant des fichiers AAC standard,c'est un taux d'échantillon de 44100,stéréo. Mais si je tester avec des échantillons plus problématiques,comme L'AAC taux d'échantillonnage 16000, mono - puis le fichier vidéo ajoute presque une seconde entière à sa taille. J'apprécierai si quelqu'un peut me faire remarquer ce que je fais de mal ici.

Note importante: Je ne fixe pas la durée pour aucun des contextes. Je contrôle la fin de la session de mixage, qui est basée sur le comptage des images vidéo.Le flux d'entrée audio a la durée, bien sûr, mais cela ne m'aide pas car la durée de la vidéo est ce qui définit la longueur du film.

mise à jour:

c'est la deuxième tentative de prime.

UPDATE 2:

en fait, mon horodatage audio de {den, num} était erroné, alors que {1,1} est en effet le chemin à suivre, comme expliqué par la réponse. Ce qui l'empêchait de fonctionner était un bug dans cette ligne (ma mauvaise):

     mAudioOutStream.next_pts += a_pkt.pts;

Qui doit être:

     mAudioOutStream.next_pts = a_pkt.pts;

le bogue a entraîné une augmentation exponentielle de pts, ce qui a causé une atteinte très précoce à l'extrémité du cours d'eau (en termes de pts) et par conséquent, le flux audio a été terminé beaucoup plus tôt que prévu.