int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,

                                 AVPacket *pkt, int flush)

{

    AVPacketList *pktl;

    int stream_count = 0;

    int i;



    if (pkt) {

        ff_interleave_add_packet(s, pkt, interleave_compare_dts);

    }



    if (s->max_interleave_delta > 0 && s->packet_buffer && !flush) {

        AVPacket *top_pkt = &s->packet_buffer->pkt;

        int64_t delta_dts = INT64_MIN;

        int64_t top_dts = av_rescale_q(top_pkt->dts,

                                       s->streams[top_pkt->stream_index]->time_base,

                                       AV_TIME_BASE_Q);



        for (i = 0; i < s->nb_streams; i++) {

            int64_t last_dts;

            const AVPacketList *last = s->streams[i]->last_in_packet_buffer;



            if (!last)

                continue;



            last_dts = av_rescale_q(last->pkt.dts,

                                    s->streams[i]->time_base,

                                    AV_TIME_BASE_Q);

            delta_dts = FFMAX(delta_dts, last_dts - top_dts);

            stream_count++;

        }



        if (delta_dts > s->max_interleave_delta) {

            av_log(s, AV_LOG_DEBUG,

                   "Delay between the first packet and last packet in the "

                   "muxing queue is %"PRId64" > %"PRId64": forcing output\n",

                   delta_dts, s->max_interleave_delta);

            flush = 1;

        }

    } else {

        for (i = 0; i < s->nb_streams; i++)

            stream_count += !!s->streams[i]->last_in_packet_buffer;

    }





    if (stream_count && (s->internal->nb_interleaved_streams == stream_count || flush)) {

        pktl = s->packet_buffer;

        *out = pktl->pkt;



        s->packet_buffer = pktl->next;

        if (!s->packet_buffer)

            s->packet_buffer_end = NULL;



        if (s->streams[out->stream_index]->last_in_packet_buffer == pktl)

            s->streams[out->stream_index]->last_in_packet_buffer = NULL;

        av_freep(&pktl);

        return 1;

    } else {

        av_init_packet(out);

        return 0;

    }

}

int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,

                                 AVPacket *pkt, int flush)

{

    AVPacketList *pktl;

    int stream_count = 0;

    int i;



    if (pkt) {

        ff_interleave_add_packet(s, pkt, interleave_compare_dts);

    }



    if (s->max_interleave_delta > 0 && s->packet_buffer && !flush) {

        AVPacket *top_pkt = &s->packet_buffer->pkt;

        int64_t delta_dts = INT64_MIN;

        int64_t top_dts = av_rescale_q(top_pkt->dts,

                                       s->streams[top_pkt->stream_index]->time_base,

                                       AV_TIME_BASE_Q);



        for (i = 0; i < s->nb_streams; i++) {

            int64_t last_dts;

            const AVPacketList *last = s->streams[i]->last_in_packet_buffer;



            if (!last)

                continue;



            last_dts = av_rescale_q(last->pkt.dts,

                                    s->streams[i]->time_base,

                                    AV_TIME_BASE_Q);

            delta_dts = FFMAX(delta_dts, last_dts - top_dts);

            stream_count++;

        }



        if (delta_dts > s->max_interleave_delta) {

            av_log(s, AV_LOG_DEBUG,

                   "Delay between the first packet and last packet in the "

                   "muxing queue is %"PRId64" > %"PRId64": forcing output\n",

                   delta_dts, s->max_interleave_delta);

            flush = 1;

        }

    } else {

        for (i = 0; i < s->nb_streams; i++)

            stream_count += !!s->streams[i]->last_in_packet_buffer;

    }





    if (stream_count && (s->internal->nb_interleaved_streams == stream_count || flush)) {

        pktl = s->packet_buffer;

        *out = pktl->pkt;



        s->packet_buffer = pktl->next;

        if (!s->packet_buffer)

            s->packet_buffer_end = NULL;



        if (s->streams[out->stream_index]->last_in_packet_buffer == pktl)

            s->streams[out->stream_index]->last_in_packet_buffer = NULL;

        av_freep(&pktl);

        return 1;

    } else {

        av_init_packet(out);

        return 0;

    }

}

int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1,

                                 AVPacket *VAR_2, int VAR_3)

{

    AVPacketList *pktl;

    int VAR_4 = 0;

    int VAR_5;



    if (VAR_2) {

        ff_interleave_add_packet(VAR_0, VAR_2, interleave_compare_dts);

    }



    if (VAR_0->max_interleave_delta > 0 && VAR_0->packet_buffer && !VAR_3) {

        AVPacket *top_pkt = &VAR_0->packet_buffer->VAR_2;

        int64_t delta_dts = INT64_MIN;

        int64_t top_dts = av_rescale_q(top_pkt->dts,

                                       VAR_0->streams[top_pkt->stream_index]->time_base,

                                       AV_TIME_BASE_Q);



        for (VAR_5 = 0; VAR_5 < VAR_0->nb_streams; VAR_5++) {

            int64_t last_dts;

            const AVPacketList *last = VAR_0->streams[VAR_5]->last_in_packet_buffer;



            if (!last)

                continue;



            last_dts = av_rescale_q(last->VAR_2.dts,

                                    VAR_0->streams[VAR_5]->time_base,

                                    AV_TIME_BASE_Q);

            delta_dts = FFMAX(delta_dts, last_dts - top_dts);

            VAR_4++;

        }



        if (delta_dts > VAR_0->max_interleave_delta) {

            av_log(VAR_0, AV_LOG_DEBUG,

                   "Delay between the first packet and last packet in the "

                   "muxing queue is %"PRId64" > %"PRId64": forcing output\n",

                   delta_dts, VAR_0->max_interleave_delta);

            VAR_3 = 1;

        }

    } else {

        for (VAR_5 = 0; VAR_5 < VAR_0->nb_streams; VAR_5++)

            VAR_4 += !!VAR_0->streams[VAR_5]->last_in_packet_buffer;

    }





    if (VAR_4 && (VAR_0->internal->nb_interleaved_streams == VAR_4 || VAR_3)) {

        pktl = VAR_0->packet_buffer;

        *VAR_1 = pktl->VAR_2;



        VAR_0->packet_buffer = pktl->next;

        if (!VAR_0->packet_buffer)

            VAR_0->packet_buffer_end = NULL;



        if (VAR_0->streams[VAR_1->stream_index]->last_in_packet_buffer == pktl)

            VAR_0->streams[VAR_1->stream_index]->last_in_packet_buffer = NULL;

        av_freep(&pktl);

        return 1;

    } else {

        av_init_packet(VAR_1);

        return 0;

    }

}

int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1,
AVPacket *VAR_2, int VAR_3)
{ AVPacketList *pktl; int VAR_4 = 0; int VAR_5; if (VAR_2) { ff_interleave_add_packet(VAR_0, VAR_2, interleave_compare_dts); } if (VAR_0->max_interleave_delta > 0 && VAR_0->packet_buffer && !VAR_3) { AVPacket *top_pkt = &VAR_0->packet_buffer->VAR_2; int64_t delta_dts = INT64_MIN; int64_t top_dts = av_rescale_q(top_pkt->dts,
VAR_0->streams[top_pkt->stream_index]->time_base,
AV_TIME_BASE_Q); for (VAR_5 = 0; VAR_5 < VAR_0->nb_streams; VAR_5++) { int64_t last_dts; const AVPacketList *last = VAR_0->streams[VAR_5]->last_in_packet_buffer; if (!last)
continue; last_dts = av_rescale_q(last->VAR_2.dts,
VAR_0->streams[VAR_5]->time_base,
AV_TIME_BASE_Q); delta_dts = FFMAX(delta_dts, last_dts - top_dts); VAR_4++; } if (delta_dts > VAR_0->max_interleave_delta) { av_log(VAR_0, AV_LOG_DEBUG,
"Delay between the first packet and last packet in the "
"muxing queue is %"PRId64" > %"PRId64": forcing output\n",
delta_dts, VAR_0->max_interleave_delta); VAR_3 = 1; } } else { for (VAR_5 = 0; VAR_5 < VAR_0->nb_streams; VAR_5++) VAR_4 += !!VAR_0->streams[VAR_5]->last_in_packet_buffer; } if (VAR_4 && (VAR_0->internal->nb_interleaved_streams == VAR_4 || VAR_3)) { pktl = VAR_0->packet_buffer; *VAR_1 = pktl->VAR_2; VAR_0->packet_buffer = pktl->next; if (!VAR_0->packet_buffer)
VAR_0->packet_buffer_end = NULL; if (VAR_0->streams[VAR_1->stream_index]->last_in_packet_buffer == pktl)
VAR_0->streams[VAR_1->stream_index]->last_in_packet_buffer = NULL; av_freep(&pktl); return 1; } else { av_init_packet(VAR_1); return 0; } }