static void do_video_out(AVFormatContext *s,

                         OutputStream *ost,

                         AVFrame *in_picture,

                         float quality)

{

    int ret, format_video_sync;

    AVPacket pkt;

    AVCodecContext *enc = ost->st->codec;

    int nb_frames;

    double sync_ipts, delta;

    double duration = 0;

    int frame_size = 0;

    InputStream *ist = NULL;



    if (ost->source_index >= 0)

        ist = input_streams[ost->source_index];



    if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)

        duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));



    sync_ipts = in_picture->pts;

    delta = sync_ipts - ost->sync_opts + duration;



    /* by default, we output a single frame */

    nb_frames = 1;



    format_video_sync = video_sync_method;

    if (format_video_sync == VSYNC_AUTO)

        format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;



    switch (format_video_sync) {

    case VSYNC_CFR:

        // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c

        if (delta < -1.1)

            nb_frames = 0;

        else if (delta > 1.1)

            nb_frames = lrintf(delta);

        break;

    case VSYNC_VFR:

        if (delta <= -0.6)

            nb_frames = 0;

        else if (delta > 0.6)

            ost->sync_opts = lrint(sync_ipts);

        break;

    case VSYNC_DROP:

    case VSYNC_PASSTHROUGH:

        ost->sync_opts = lrint(sync_ipts);

        break;

    default:

        av_assert0(0);

    }



    nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);

    if (nb_frames == 0) {

        nb_frames_drop++;

        av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");

        return;

    } else if (nb_frames > 1) {

        if (nb_frames > dts_error_threshold * 30) {

            av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skiping\n", nb_frames - 1);

            nb_frames_drop++;

            return;

        }

        nb_frames_dup += nb_frames - 1;

        av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);

    }





duplicate_frame:

    av_init_packet(&pkt);

    pkt.data = NULL;

    pkt.size = 0;



    in_picture->pts = ost->sync_opts;



    if (!check_recording_time(ost))

        return;



    if (s->oformat->flags & AVFMT_RAWPICTURE &&

        enc->codec->id == CODEC_ID_RAWVIDEO) {

        /* raw pictures are written as AVPicture structure to

           avoid any copies. We support temporarily the older

           method. */

        enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;

        enc->coded_frame->top_field_first  = in_picture->top_field_first;

        pkt.data   = (uint8_t *)in_picture;

        pkt.size   =  sizeof(AVPicture);

        pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);

        pkt.flags |= AV_PKT_FLAG_KEY;



        write_frame(s, &pkt, ost);

        video_size += pkt.size;

    } else {

        int got_packet;

        AVFrame big_picture;



        big_picture = *in_picture;

        /* better than nothing: use input picture interlaced

           settings */

        big_picture.interlaced_frame = in_picture->interlaced_frame;

        if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {

            if (ost->top_field_first == -1)

                big_picture.top_field_first = in_picture->top_field_first;

            else

                big_picture.top_field_first = !!ost->top_field_first;

        }



        /* handles same_quant here. This is not correct because it may

           not be a global option */

        big_picture.quality = quality;

        if (!enc->me_threshold)

            big_picture.pict_type = 0;

        if (ost->forced_kf_index < ost->forced_kf_count &&

            big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {

            big_picture.pict_type = AV_PICTURE_TYPE_I;

            ost->forced_kf_index++;

        }

        update_benchmark(NULL);

        ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);

        update_benchmark("encode_video %d.%d", ost->file_index, ost->index);

        if (ret < 0) {

            av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");

            exit_program(1);

        }



        if (got_packet) {

            if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))

                pkt.pts = ost->sync_opts;



            if (pkt.pts != AV_NOPTS_VALUE)

                pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);

            if (pkt.dts != AV_NOPTS_VALUE)

                pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);



            if (debug_ts) {

                av_log(NULL, AV_LOG_INFO, "encoder -> type:video "

                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",

                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),

                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));

            }



            write_frame(s, &pkt, ost);

            frame_size = pkt.size;

            video_size += pkt.size;

            av_free_packet(&pkt);



            /* if two pass, output log */

            if (ost->logfile && enc->stats_out) {

                fprintf(ost->logfile, "%s", enc->stats_out);

            }

        }

    }

    ost->sync_opts++;

    /*

     * For video, number of frames in == number of packets out.

     * But there may be reordering, so we can't throw away frames on encoder

     * flush, we need to limit them here, before they go into encoder.

     */

    ost->frame_number++;



    if(--nb_frames)

        goto duplicate_frame;



    if (vstats_filename && frame_size)

        do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);

}

static void do_video_out(AVFormatContext *s,

                         OutputStream *ost,

                         AVFrame *in_picture,

                         float quality)

{

    int ret, format_video_sync;

    AVPacket pkt;

    AVCodecContext *enc = ost->st->codec;

    int nb_frames;

    double sync_ipts, delta;

    double duration = 0;

    int frame_size = 0;

    InputStream *ist = NULL;



    if (ost->source_index >= 0)

        ist = input_streams[ost->source_index];



    if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)

        duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));



    sync_ipts = in_picture->pts;

    delta = sync_ipts - ost->sync_opts + duration;



    

    nb_frames = 1;



    format_video_sync = video_sync_method;

    if (format_video_sync == VSYNC_AUTO)

        format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;



    switch (format_video_sync) {

    case VSYNC_CFR:

        

        if (delta < -1.1)

            nb_frames = 0;

        else if (delta > 1.1)

            nb_frames = lrintf(delta);

        break;

    case VSYNC_VFR:

        if (delta <= -0.6)

            nb_frames = 0;

        else if (delta > 0.6)

            ost->sync_opts = lrint(sync_ipts);

        break;

    case VSYNC_DROP:

    case VSYNC_PASSTHROUGH:

        ost->sync_opts = lrint(sync_ipts);

        break;

    default:

        av_assert0(0);

    }



    nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);

    if (nb_frames == 0) {

        nb_frames_drop++;

        av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");

        return;

    } else if (nb_frames > 1) {

        if (nb_frames > dts_error_threshold * 30) {

            av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skiping\n", nb_frames - 1);

            nb_frames_drop++;

            return;

        }

        nb_frames_dup += nb_frames - 1;

        av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);

    }





duplicate_frame:

    av_init_packet(&pkt);

    pkt.data = NULL;

    pkt.size = 0;



    in_picture->pts = ost->sync_opts;



    if (!check_recording_time(ost))

        return;



    if (s->oformat->flags & AVFMT_RAWPICTURE &&

        enc->codec->id == CODEC_ID_RAWVIDEO) {

        





        enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;

        enc->coded_frame->top_field_first  = in_picture->top_field_first;

        pkt.data   = (uint8_t *)in_picture;

        pkt.size   =  sizeof(AVPicture);

        pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);

        pkt.flags |= AV_PKT_FLAG_KEY;



        write_frame(s, &pkt, ost);

        video_size += pkt.size;

    } else {

        int got_packet;

        AVFrame big_picture;



        big_picture = *in_picture;

        



        big_picture.interlaced_frame = in_picture->interlaced_frame;

        if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {

            if (ost->top_field_first == -1)

                big_picture.top_field_first = in_picture->top_field_first;

            else

                big_picture.top_field_first = !!ost->top_field_first;

        }



        



        big_picture.quality = quality;

        if (!enc->me_threshold)

            big_picture.pict_type = 0;

        if (ost->forced_kf_index < ost->forced_kf_count &&

            big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {

            big_picture.pict_type = AV_PICTURE_TYPE_I;

            ost->forced_kf_index++;

        }

        update_benchmark(NULL);

        ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);

        update_benchmark("encode_video %d.%d", ost->file_index, ost->index);

        if (ret < 0) {

            av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");

            exit_program(1);

        }



        if (got_packet) {

            if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))

                pkt.pts = ost->sync_opts;



            if (pkt.pts != AV_NOPTS_VALUE)

                pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);

            if (pkt.dts != AV_NOPTS_VALUE)

                pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);



            if (debug_ts) {

                av_log(NULL, AV_LOG_INFO, "encoder -> type:video "

                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",

                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),

                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));

            }



            write_frame(s, &pkt, ost);

            frame_size = pkt.size;

            video_size += pkt.size;

            av_free_packet(&pkt);



            

            if (ost->logfile && enc->stats_out) {

                fprintf(ost->logfile, "%s", enc->stats_out);

            }

        }

    }

    ost->sync_opts++;

    









    ost->frame_number++;



    if(--nb_frames)

        goto duplicate_frame;



    if (vstats_filename && frame_size)

        do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);

}

static void FUNC_0(AVFormatContext *VAR_0,

                         OutputStream *VAR_1,

                         AVFrame *VAR_2,

                         float VAR_3)

{

    int VAR_4, VAR_5;

    AVPacket pkt;

    AVCodecContext *enc = VAR_1->st->codec;

    int VAR_6;

    double VAR_7, VAR_8;

    double VAR_9 = 0;

    int VAR_10 = 0;

    InputStream *ist = NULL;



    if (VAR_1->source_index >= 0)

        ist = input_streams[VAR_1->source_index];



    if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && VAR_1->frame_rate.num)

        VAR_9 = 1/(av_q2d(VAR_1->frame_rate) * av_q2d(enc->time_base));



    VAR_7 = VAR_2->pts;

    VAR_8 = VAR_7 - VAR_1->sync_opts + VAR_9;



    

    VAR_6 = 1;



    VAR_5 = video_sync_method;

    if (VAR_5 == VSYNC_AUTO)

        VAR_5 = (VAR_0->oformat->flags & AVFMT_VARIABLE_FPS) ? ((VAR_0->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;



    switch (VAR_5) {

    case VSYNC_CFR:

        

        if (VAR_8 < -1.1)

            VAR_6 = 0;

        else if (VAR_8 > 1.1)

            VAR_6 = lrintf(VAR_8);

        break;

    case VSYNC_VFR:

        if (VAR_8 <= -0.6)

            VAR_6 = 0;

        else if (VAR_8 > 0.6)

            VAR_1->sync_opts = lrint(VAR_7);

        break;

    case VSYNC_DROP:

    case VSYNC_PASSTHROUGH:

        VAR_1->sync_opts = lrint(VAR_7);

        break;

    default:

        av_assert0(0);

    }



    VAR_6 = FFMIN(VAR_6, VAR_1->max_frames - VAR_1->frame_number);

    if (VAR_6 == 0) {

        nb_frames_drop++;

        av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");

        return;

    } else if (VAR_6 > 1) {

        if (VAR_6 > dts_error_threshold * 30) {

            av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skiping\n", VAR_6 - 1);

            nb_frames_drop++;

            return;

        }

        nb_frames_dup += VAR_6 - 1;

        av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", VAR_6 - 1);

    }





duplicate_frame:

    av_init_packet(&pkt);

    pkt.data = NULL;

    pkt.size = 0;



    VAR_2->pts = VAR_1->sync_opts;



    if (!check_recording_time(VAR_1))

        return;



    if (VAR_0->oformat->flags & AVFMT_RAWPICTURE &&

        enc->codec->id == CODEC_ID_RAWVIDEO) {

        





        enc->coded_frame->interlaced_frame = VAR_2->interlaced_frame;

        enc->coded_frame->top_field_first  = VAR_2->top_field_first;

        pkt.data   = (uint8_t *)VAR_2;

        pkt.size   =  sizeof(AVPicture);

        pkt.pts    = av_rescale_q(VAR_2->pts, enc->time_base, VAR_1->st->time_base);

        pkt.flags |= AV_PKT_FLAG_KEY;



        write_frame(VAR_0, &pkt, VAR_1);

        video_size += pkt.size;

    } else {

        int VAR_11;

        AVFrame big_picture;



        big_picture = *VAR_2;

        



        big_picture.interlaced_frame = VAR_2->interlaced_frame;

        if (VAR_1->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {

            if (VAR_1->top_field_first == -1)

                big_picture.top_field_first = VAR_2->top_field_first;

            else

                big_picture.top_field_first = !!VAR_1->top_field_first;

        }



        



        big_picture.VAR_3 = VAR_3;

        if (!enc->me_threshold)

            big_picture.pict_type = 0;

        if (VAR_1->forced_kf_index < VAR_1->forced_kf_count &&

            big_picture.pts >= VAR_1->forced_kf_pts[VAR_1->forced_kf_index]) {

            big_picture.pict_type = AV_PICTURE_TYPE_I;

            VAR_1->forced_kf_index++;

        }

        update_benchmark(NULL);

        VAR_4 = avcodec_encode_video2(enc, &pkt, &big_picture, &VAR_11);

        update_benchmark("encode_video %d.%d", VAR_1->file_index, VAR_1->index);

        if (VAR_4 < 0) {

            av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");

            exit_program(1);

        }



        if (VAR_11) {

            if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))

                pkt.pts = VAR_1->sync_opts;



            if (pkt.pts != AV_NOPTS_VALUE)

                pkt.pts = av_rescale_q(pkt.pts, enc->time_base, VAR_1->st->time_base);

            if (pkt.dts != AV_NOPTS_VALUE)

                pkt.dts = av_rescale_q(pkt.dts, enc->time_base, VAR_1->st->time_base);



            if (debug_ts) {

                av_log(NULL, AV_LOG_INFO, "encoder -> type:video "

                    "pkt_pts:%VAR_0 pkt_pts_time:%VAR_0 pkt_dts:%VAR_0 pkt_dts_time:%VAR_0\n",

                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &VAR_1->st->time_base),

                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &VAR_1->st->time_base));

            }



            write_frame(VAR_0, &pkt, VAR_1);

            VAR_10 = pkt.size;

            video_size += pkt.size;

            av_free_packet(&pkt);



            

            if (VAR_1->logfile && enc->stats_out) {

                fprintf(VAR_1->logfile, "%VAR_0", enc->stats_out);

            }

        }

    }

    VAR_1->sync_opts++;

    









    VAR_1->frame_number++;



    if(--VAR_6)

        goto duplicate_frame;



    if (vstats_filename && VAR_10)

        do_video_stats(output_files[VAR_1->file_index]->ctx, VAR_1, VAR_10);

}

static void FUNC_0(AVFormatContext *VAR_0,
OutputStream *VAR_1,
AVFrame *VAR_2,
float VAR_3)
{ int VAR_4, VAR_5; AVPacket pkt; AVCodecContext *enc = VAR_1->st->codec; int VAR_6; double VAR_7, VAR_8; double VAR_9 = 0; int VAR_10 = 0; InputStream *ist = NULL; if (VAR_1->source_index >= 0)
ist = input_streams[VAR_1->source_index]; if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && VAR_1->frame_rate.num)
VAR_9 = 1/(av_q2d(VAR_1->frame_rate) * av_q2d(enc->time_base)); VAR_7 = VAR_2->pts; VAR_8 = VAR_7 - VAR_1->sync_opts + VAR_9; VAR_6 = 1; VAR_5 = video_sync_method; if (VAR_5 == VSYNC_AUTO)
VAR_5 = (VAR_0->oformat->flags & AVFMT_VARIABLE_FPS) ? ((VAR_0->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1; switch (VAR_5) { case VSYNC_CFR:
if (VAR_8 < -1.1)
VAR_6 = 0; else if (VAR_8 > 1.1)
VAR_6 = lrintf(VAR_8); break; case VSYNC_VFR:
if (VAR_8 <= -0.6)
VAR_6 = 0; else if (VAR_8 > 0.6)
VAR_1->sync_opts = lrint(VAR_7); break; case VSYNC_DROP:
case VSYNC_PASSTHROUGH:
VAR_1->sync_opts = lrint(VAR_7); break; default:
av_assert0(0); } VAR_6 = FFMIN(VAR_6, VAR_1->max_frames - VAR_1->frame_number); if (VAR_6 == 0) { nb_frames_drop++; av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n"); return; } else if (VAR_6 > 1) { if (VAR_6 > dts_error_threshold * 30) { av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skiping\n", VAR_6 - 1); nb_frames_drop++; return; } nb_frames_dup += VAR_6 - 1; av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", VAR_6 - 1); } duplicate_frame:
av_init_packet(&pkt); pkt.data = NULL; pkt.size = 0; VAR_2->pts = VAR_1->sync_opts; if (!check_recording_time(VAR_1))
return; if (VAR_0->oformat->flags & AVFMT_RAWPICTURE &&
enc->codec->id == CODEC_ID_RAWVIDEO) { enc->coded_frame->interlaced_frame = VAR_2->interlaced_frame; enc->coded_frame->top_field_first  = VAR_2->top_field_first; pkt.data   = (uint8_t *)VAR_2; pkt.size   =  sizeof(AVPicture); pkt.pts    = av_rescale_q(VAR_2->pts, enc->time_base, VAR_1->st->time_base); pkt.flags |= AV_PKT_FLAG_KEY; write_frame(VAR_0, &pkt, VAR_1); video_size += pkt.size; } else { int VAR_11; AVFrame big_picture; big_picture = *VAR_2; big_picture.interlaced_frame = VAR_2->interlaced_frame; if (VAR_1->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) { if (VAR_1->top_field_first == -1)
big_picture.top_field_first = VAR_2->top_field_first; else
big_picture.top_field_first = !!VAR_1->top_field_first; } big_picture.VAR_3 = VAR_3; if (!enc->me_threshold)
big_picture.pict_type = 0; if (VAR_1->forced_kf_index < VAR_1->forced_kf_count &&
big_picture.pts >= VAR_1->forced_kf_pts[VAR_1->forced_kf_index]) { big_picture.pict_type = AV_PICTURE_TYPE_I; VAR_1->forced_kf_index++; } update_benchmark(NULL); VAR_4 = avcodec_encode_video2(enc, &pkt, &big_picture, &VAR_11); update_benchmark("encode_video %d.%d", VAR_1->file_index, VAR_1->index); if (VAR_4 < 0) { av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n"); exit_program(1); } if (VAR_11) { if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
pkt.pts = VAR_1->sync_opts; if (pkt.pts != AV_NOPTS_VALUE)
pkt.pts = av_rescale_q(pkt.pts, enc->time_base, VAR_1->st->time_base); if (pkt.dts != AV_NOPTS_VALUE)
pkt.dts = av_rescale_q(pkt.dts, enc->time_base, VAR_1->st->time_base); if (debug_ts) { av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
"pkt_pts:%VAR_0 pkt_pts_time:%VAR_0 pkt_dts:%VAR_0 pkt_dts_time:%VAR_0\n",
av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &VAR_1->st->time_base),
av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &VAR_1->st->time_base)); } write_frame(VAR_0, &pkt, VAR_1); VAR_10 = pkt.size; video_size += pkt.size; av_free_packet(&pkt); if (VAR_1->logfile && enc->stats_out) { fprintf(VAR_1->logfile, "%VAR_0", enc->stats_out); } } } VAR_1->sync_opts++; VAR_1->frame_number++; if(--VAR_6)
goto duplicate_frame; if (vstats_filename && VAR_10)
do_video_stats(output_files[VAR_1->file_index]->ctx, VAR_1, VAR_10); }