Subversion Repositories Kolibri OS

/*

 * Copyright (c) 2000-2003 Fabrice Bellard

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

/**

 * @file

 * multimedia converter based on the FFmpeg libraries

 */

#include "config.h"

#include 

#include 

#include 

#include 

#include 

#include 

#if HAVE_ISATTY

#if HAVE_IO_H

#include 

#endif

#if HAVE_UNISTD_H

#include 

#endif

#endif

#include "libavformat/avformat.h"

#include "libavdevice/avdevice.h"

#include "libswscale/swscale.h"

#include "libswresample/swresample.h"

#include "libavutil/opt.h"

#include "libavutil/channel_layout.h"

#include "libavutil/parseutils.h"

#include "libavutil/samplefmt.h"

#include "libavutil/fifo.h"

#include "libavutil/intreadwrite.h"

#include "libavutil/dict.h"

#include "libavutil/mathematics.h"

#include "libavutil/pixdesc.h"

#include "libavutil/avstring.h"

#include "libavutil/libm.h"

#include "libavutil/imgutils.h"

#include "libavutil/timestamp.h"

#include "libavutil/bprint.h"

#include "libavutil/time.h"

#include "libavformat/os_support.h"

#include "libavformat/ffm.h" // not public API

# include "libavfilter/avcodec.h"

# include "libavfilter/avfilter.h"

# include "libavfilter/buffersrc.h"

# include "libavfilter/buffersink.h"

#if HAVE_SYS_RESOURCE_H

#include 

#include 

#include 

#elif HAVE_GETPROCESSTIMES

#include 

#endif

#if HAVE_GETPROCESSMEMORYINFO

#include 

#include 

#endif

#if HAVE_SYS_SELECT_H

#include 

#endif

#if HAVE_TERMIOS_H

#include 

#include 

#include 

#include 

#elif HAVE_KBHIT

#include 

#endif

#if HAVE_PTHREADS

#include 

#endif

#include 

#include "ffmpeg.h"

#include "cmdutils.h"

#include "libavutil/avassert.h"

const char program_name[] = "ffmpeg";

const int program_birth_year = 2000;

static FILE *vstats_file;

const char *const forced_keyframes_const_names[] = {

    "n",

    "n_forced",

    "prev_forced_n",

    "prev_forced_t",

    "t",

    NULL

};

static void do_video_stats(OutputStream *ost, int frame_size);

static int64_t getutime(void);

static int64_t getmaxrss(void);

static int run_as_daemon  = 0;

static int64_t video_size = 0;

static int64_t audio_size = 0;

static int64_t subtitle_size = 0;

static int64_t extra_size = 0;

static int nb_frames_dup = 0;

static int nb_frames_drop = 0;

static int64_t decode_error_stat[2];

static int current_time;

AVIOContext *progress_avio = NULL;

static uint8_t *subtitle_out;

#if HAVE_PTHREADS

/* signal to input threads that they should exit; set by the main thread */

static int transcoding_finished;

#endif

#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"

InputStream **input_streams = NULL;

int        nb_input_streams = 0;

InputFile   **input_files   = NULL;

int        nb_input_files   = 0;

OutputStream **output_streams = NULL;

int         nb_output_streams = 0;

OutputFile   **output_files   = NULL;

int         nb_output_files   = 0;

FilterGraph **filtergraphs;

int        nb_filtergraphs;

#if HAVE_TERMIOS_H

/* init terminal so that we can grab keys */

static struct termios oldtty;

static int restore_tty;

#endif

static void free_input_threads(void);

/* sub2video hack:

   Convert subtitles to video with alpha to insert them in filter graphs.

   This is a temporary solution until libavfilter gets real subtitles support.

 */

static int sub2video_get_blank_frame(InputStream *ist)

{

    int ret;

    AVFrame *frame = ist->sub2video.frame;

    av_frame_unref(frame);

    ist->sub2video.frame->width  = ist->sub2video.w;

    ist->sub2video.frame->height = ist->sub2video.h;

    ist->sub2video.frame->format = AV_PIX_FMT_RGB32;

    if ((ret = av_frame_get_buffer(frame, 32)) < 0)

        return ret;

    memset(frame->data[0], 0, frame->height * frame->linesize[0]);

    return 0;

}

static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,

                                AVSubtitleRect *r)

{

    uint32_t *pal, *dst2;

    uint8_t *src, *src2;

    int x, y;

    if (r->type != SUBTITLE_BITMAP) {

        av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");

        return;

    }

    if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {

        av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle overflowing\n");

        return;

    }

    dst += r->y * dst_linesize + r->x * 4;

    src = r->pict.data[0];

    pal = (uint32_t *)r->pict.data[1];

    for (y = 0; y < r->h; y++) {

        dst2 = (uint32_t *)dst;

        src2 = src;

        for (x = 0; x < r->w; x++)

            *(dst2++) = pal[*(src2++)];

        dst += dst_linesize;

        src += r->pict.linesize[0];

    }

}

static void sub2video_push_ref(InputStream *ist, int64_t pts)

{

    AVFrame *frame = ist->sub2video.frame;

    int i;

    av_assert1(frame->data[0]);

    ist->sub2video.last_pts = frame->pts = pts;

    for (i = 0; i < ist->nb_filters; i++)

        av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,

                                     AV_BUFFERSRC_FLAG_KEEP_REF |

                                     AV_BUFFERSRC_FLAG_PUSH);

}

static void sub2video_update(InputStream *ist, AVSubtitle *sub)

{

    int w = ist->sub2video.w, h = ist->sub2video.h;

    AVFrame *frame = ist->sub2video.frame;

    int8_t *dst;

    int     dst_linesize;

    int num_rects, i;

    int64_t pts, end_pts;

    if (!frame)

        return;

    if (sub) {

        pts       = av_rescale_q(sub->pts + sub->start_display_time * 1000,

                                 AV_TIME_BASE_Q, ist->st->time_base);

        end_pts   = av_rescale_q(sub->pts + sub->end_display_time   * 1000,

                                 AV_TIME_BASE_Q, ist->st->time_base);

        num_rects = sub->num_rects;

    } else {

        pts       = ist->sub2video.end_pts;

        end_pts   = INT64_MAX;

        num_rects = 0;

    }

    if (sub2video_get_blank_frame(ist) < 0) {

        av_log(ist->st->codec, AV_LOG_ERROR,

               "Impossible to get a blank canvas.\n");

        return;

    }

    dst          = frame->data    [0];

    dst_linesize = frame->linesize[0];

    for (i = 0; i < num_rects; i++)

        sub2video_copy_rect(dst, dst_linesize, w, h, sub->rects[i]);

    sub2video_push_ref(ist, pts);

    ist->sub2video.end_pts = end_pts;

}

static void sub2video_heartbeat(InputStream *ist, int64_t pts)

{

    InputFile *infile = input_files[ist->file_index];

    int i, j, nb_reqs;

    int64_t pts2;

    /* When a frame is read from a file, examine all sub2video streams in

       the same file and send the sub2video frame again. Otherwise, decoded

       video frames could be accumulating in the filter graph while a filter

       (possibly overlay) is desperately waiting for a subtitle frame. */

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

        InputStream *ist2 = input_streams[infile->ist_index + i];

        if (!ist2->sub2video.frame)

            continue;

        /* subtitles seem to be usually muxed ahead of other streams;

           if not, substracting a larger time here is necessary */

        pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;

        /* do not send the heartbeat frame if the subtitle is already ahead */

        if (pts2 <= ist2->sub2video.last_pts)

            continue;

        if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])

            sub2video_update(ist2, NULL);

        for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)

            nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);

        if (nb_reqs)

            sub2video_push_ref(ist2, pts2);

    }

}

static void sub2video_flush(InputStream *ist)

{

    int i;

    for (i = 0; i < ist->nb_filters; i++)

        av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);

}

/* end of sub2video hack */

void term_exit(void)

{

    av_log(NULL, AV_LOG_QUIET, "%s", "");

#if HAVE_TERMIOS_H

    if(restore_tty)

        tcsetattr (0, TCSANOW, &oldtty);

#endif

}

static volatile int received_sigterm = 0;

static volatile int received_nb_signals = 0;

static void

sigterm_handler(int sig)

{

    received_sigterm = sig;

    received_nb_signals++;

    term_exit();

    if(received_nb_signals > 3)

        exit_program(123);

}

void term_init(void)

{

#if HAVE_TERMIOS_H

    if(!run_as_daemon){

        struct termios tty;

        int istty = 1;

#if HAVE_ISATTY

        istty = isatty(0) && isatty(2);

#endif

        if (istty && tcgetattr (0, &tty) == 0) {

            oldtty = tty;

            restore_tty = 1;

            tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP

                             |INLCR|IGNCR|ICRNL|IXON);

            tty.c_oflag |= OPOST;

            tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);

            tty.c_cflag &= ~(CSIZE|PARENB);

            tty.c_cflag |= CS8;

            tty.c_cc[VMIN] = 1;

            tty.c_cc[VTIME] = 0;

            tcsetattr (0, TCSANOW, &tty);

        }

        signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */

    }

#endif

    avformat_network_deinit();

    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */

    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */

#ifdef SIGXCPU

    signal(SIGXCPU, sigterm_handler);

#endif

}

/* read a key without blocking */

static int read_key(void)

{

    unsigned char ch;

#if HAVE_TERMIOS_H

    int n = 1;

    struct timeval tv;

    fd_set rfds;

    FD_ZERO(&rfds);

    FD_SET(0, &rfds);

    tv.tv_sec = 0;

    tv.tv_usec = 0;

    n = select(1, &rfds, NULL, NULL, &tv);

    if (n > 0) {

        n = read(0, &ch, 1);

        if (n == 1)

            return ch;

        return n;

    }

#elif HAVE_KBHIT

#    if HAVE_PEEKNAMEDPIPE

    static int is_pipe;

    static HANDLE input_handle;

    DWORD dw, nchars;

    if(!input_handle){

        input_handle = GetStdHandle(STD_INPUT_HANDLE);

        is_pipe = !GetConsoleMode(input_handle, &dw);

    }

    if (stdin->_cnt > 0) {

        read(0, &ch, 1);

        return ch;

    }

    if (is_pipe) {

        /* When running under a GUI, you will end here. */

        if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {

            // input pipe may have been closed by the program that ran ffmpeg

            return -1;

        }

        //Read it

        if(nchars != 0) {

            read(0, &ch, 1);

            return ch;

        }else{

            return -1;

        }

    }

#    endif

    if(kbhit())

        return(getch());

#endif

    return -1;

}

static int decode_interrupt_cb(void *ctx)

{

    return received_nb_signals > 1;

}

const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };

static void ffmpeg_cleanup(int ret)

{

    int i, j;

    if (do_benchmark) {

        int maxrss = getmaxrss() / 1024;

        printf("bench: maxrss=%ikB\n", maxrss);

    }

    for (i = 0; i < nb_filtergraphs; i++) {

        avfilter_graph_free(&filtergraphs[i]->graph);

        for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {

            av_freep(&filtergraphs[i]->inputs[j]->name);

            av_freep(&filtergraphs[i]->inputs[j]);

        }

        av_freep(&filtergraphs[i]->inputs);

        for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {

            av_freep(&filtergraphs[i]->outputs[j]->name);

            av_freep(&filtergraphs[i]->outputs[j]);

        }

        av_freep(&filtergraphs[i]->outputs);

        av_freep(&filtergraphs[i]->graph_desc);

        av_freep(&filtergraphs[i]);

    }

    av_freep(&filtergraphs);

    av_freep(&subtitle_out);

    /* close files */

    for (i = 0; i < nb_output_files; i++) {

        AVFormatContext *s = output_files[i]->ctx;

        if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb)

            avio_close(s->pb);

        avformat_free_context(s);

        av_dict_free(&output_files[i]->opts);

        av_freep(&output_files[i]);

    }

    for (i = 0; i < nb_output_streams; i++) {

        AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;

        while (bsfc) {

            AVBitStreamFilterContext *next = bsfc->next;

            av_bitstream_filter_close(bsfc);

            bsfc = next;

        }

        output_streams[i]->bitstream_filters = NULL;

        avcodec_free_frame(&output_streams[i]->filtered_frame);

        av_freep(&output_streams[i]->forced_keyframes);

        av_expr_free(output_streams[i]->forced_keyframes_pexpr);

        av_freep(&output_streams[i]->avfilter);

        av_freep(&output_streams[i]->logfile_prefix);

        av_freep(&output_streams[i]);

    }

#if HAVE_PTHREADS

    free_input_threads();

#endif

    for (i = 0; i < nb_input_files; i++) {

        avformat_close_input(&input_files[i]->ctx);

        av_freep(&input_files[i]);

    }

    for (i = 0; i < nb_input_streams; i++) {

        av_frame_free(&input_streams[i]->decoded_frame);

        av_frame_free(&input_streams[i]->filter_frame);

        av_dict_free(&input_streams[i]->opts);

        avsubtitle_free(&input_streams[i]->prev_sub.subtitle);

        av_frame_free(&input_streams[i]->sub2video.frame);

        av_freep(&input_streams[i]->filters);

        av_freep(&input_streams[i]);

    }

    if (vstats_file)

        fclose(vstats_file);

    av_free(vstats_filename);

    av_freep(&input_streams);

    av_freep(&input_files);

    av_freep(&output_streams);

    av_freep(&output_files);

    uninit_opts();

    avformat_network_deinit();

    if (received_sigterm) {

        av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",

               (int) received_sigterm);

    }

    term_exit();

}

void assert_avoptions(AVDictionary *m)

{

    AVDictionaryEntry *t;

    if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {

        av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);

        exit_program(1);

    }

}

static void abort_codec_experimental(AVCodec *c, int encoder)

{

    exit_program(1);

}

static void update_benchmark(const char *fmt, ...)

{

    if (do_benchmark_all) {

        int64_t t = getutime();

        va_list va;

        char buf[1024];

        if (fmt) {

            va_start(va, fmt);

            vsnprintf(buf, sizeof(buf), fmt, va);

            va_end(va);

            printf("bench: %8"PRIu64" %s \n", t - current_time, buf);

        }

        current_time = t;

    }

}

static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)

{

    AVBitStreamFilterContext *bsfc = ost->bitstream_filters;

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

    int ret;

    if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||

        (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))

        pkt->pts = pkt->dts = AV_NOPTS_VALUE;

    /*

     * Audio encoders may split the packets --  #frames in != #packets out.

     * But there is no reordering, so we can limit the number of output packets

     * by simply dropping them here.

     * Counting encoded video frames needs to be done separately because of

     * reordering, see do_video_out()

     */

    if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {

        if (ost->frame_number >= ost->max_frames) {

            av_free_packet(pkt);

            return;

        }

        ost->frame_number++;

    }

    while (bsfc) {

        AVPacket new_pkt = *pkt;

        int a = av_bitstream_filter_filter(bsfc, avctx, NULL,

                                           &new_pkt.data, &new_pkt.size,

                                           pkt->data, pkt->size,

                                           pkt->flags & AV_PKT_FLAG_KEY);

        if(a == 0 && new_pkt.data != pkt->data && new_pkt.destruct) {

            uint8_t *t = av_malloc(new_pkt.size + FF_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow

            if(t) {

                memcpy(t, new_pkt.data, new_pkt.size);

                memset(t + new_pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

                new_pkt.data = t;

                new_pkt.buf = NULL;

                a = 1;

            } else

                a = AVERROR(ENOMEM);

        }

        if (a > 0) {

            av_free_packet(pkt);

            new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,

                                           av_buffer_default_free, NULL, 0);

            if (!new_pkt.buf)

                exit_program(1);

        } else if (a < 0) {

            av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",

                   bsfc->filter->name, pkt->stream_index,

                   avctx->codec ? avctx->codec->name : "copy");

            print_error("", a);

            if (exit_on_error)

                exit_program(1);

        }

        *pkt = new_pkt;

        bsfc = bsfc->next;

    }

    if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&

        (avctx->codec_type == AVMEDIA_TYPE_AUDIO || avctx->codec_type == AVMEDIA_TYPE_VIDEO) &&

        pkt->dts != AV_NOPTS_VALUE &&

        ost->last_mux_dts != AV_NOPTS_VALUE) {

      int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);

      if (pkt->dts < max) {

        int loglevel = max - pkt->dts > 2 || avctx->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;

        av_log(s, loglevel, "Non-monotonous DTS in output stream "

               "%d:%d; previous: %"PRId64", current: %"PRId64"; ",

               ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);

        if (exit_on_error) {

            av_log(NULL, AV_LOG_FATAL, "aborting.\n");

            exit_program(1);

        }

        av_log(s, loglevel, "changing to %"PRId64". This may result "

               "in incorrect timestamps in the output file.\n",

               max);

        if(pkt->pts >= pkt->dts)

            pkt->pts = FFMAX(pkt->pts, max);

        pkt->dts = max;

      }

    }

    ost->last_mux_dts = pkt->dts;

    pkt->stream_index = ost->index;

    if (debug_ts) {

        av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "

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

                av_get_media_type_string(ost->st->codec->codec_type),

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

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

                pkt->size

              );

    }

    ret = av_interleaved_write_frame(s, pkt);

    if (ret < 0) {

        print_error("av_interleaved_write_frame()", ret);

        exit_program(1);

    }

}

static void close_output_stream(OutputStream *ost)

{

    OutputFile *of = output_files[ost->file_index];

    ost->finished = 1;

    if (of->shortest) {

        int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, AV_TIME_BASE_Q);

        of->recording_time = FFMIN(of->recording_time, end);

    }

}

static int check_recording_time(OutputStream *ost)

{

    OutputFile *of = output_files[ost->file_index];

    if (of->recording_time != INT64_MAX &&

        av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,

                      AV_TIME_BASE_Q) >= 0) {

        close_output_stream(ost);

        return 0;

    }

    return 1;

}

static void do_audio_out(AVFormatContext *s, OutputStream *ost,

                         AVFrame *frame)

{

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

    AVPacket pkt;

    int got_packet = 0;

    av_init_packet(&pkt);

    pkt.data = NULL;

    pkt.size = 0;

    if (!check_recording_time(ost))

        return;

    if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)

        frame->pts = ost->sync_opts;

    ost->sync_opts = frame->pts + frame->nb_samples;

    av_assert0(pkt.size || !pkt.data);

    update_benchmark(NULL);

    if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {

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

        exit_program(1);

    }

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

    if (got_packet) {

        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 (pkt.duration > 0)

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

        if (debug_ts) {

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

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

        }

        audio_size += pkt.size;

        write_frame(s, &pkt, ost);

        av_free_packet(&pkt);

    }

}

static void do_subtitle_out(AVFormatContext *s,

                            OutputStream *ost,

                            InputStream *ist,

                            AVSubtitle *sub)

{

    int subtitle_out_max_size = 1024 * 1024;

    int subtitle_out_size, nb, i;

    AVCodecContext *enc;

    AVPacket pkt;

    int64_t pts;

    if (sub->pts == AV_NOPTS_VALUE) {

        av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");

        if (exit_on_error)

            exit_program(1);

        return;

    }

    enc = ost->st->codec;

    if (!subtitle_out) {

        subtitle_out = av_malloc(subtitle_out_max_size);

    }

    /* Note: DVB subtitle need one packet to draw them and one other

       packet to clear them */

    /* XXX: signal it in the codec context ? */

    if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)

        nb = 2;

    else

        nb = 1;

    /* shift timestamp to honor -ss and make check_recording_time() work with -t */

    pts = sub->pts;

    if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)

        pts -= output_files[ost->file_index]->start_time;

    for (i = 0; i < nb; i++) {

        ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);

        if (!check_recording_time(ost))

            return;

        sub->pts = pts;

        // start_display_time is required to be 0

        sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);

        sub->end_display_time  -= sub->start_display_time;

        sub->start_display_time = 0;

        if (i == 1)

            sub->num_rects = 0;

        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,

                                                    subtitle_out_max_size, sub);

        if (subtitle_out_size < 0) {

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

            exit_program(1);

        }

        av_init_packet(&pkt);

        pkt.data = subtitle_out;

        pkt.size = subtitle_out_size;

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

        pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);

        if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {

            /* XXX: the pts correction is handled here. Maybe handling

               it in the codec would be better */

            if (i == 0)

                pkt.pts += 90 * sub->start_display_time;

            else

                pkt.pts += 90 * sub->end_display_time;

        }

        subtitle_size += pkt.size;

        write_frame(s, &pkt, ost);

    }

}

static void do_video_out(AVFormatContext *s,

                         OutputStream *ost,

                         AVFrame *in_picture)

{

    int ret, format_video_sync;

    AVPacket pkt;

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

    int nb_frames, i;

    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) : VSYNC_CFR;

        if (   ist

            && format_video_sync == VSYNC_CFR

            && input_files[ist->file_index]->ctx->nb_streams == 1

            && input_files[ist->file_index]->input_ts_offset == 0) {

            format_video_sync = VSYNC_VSCFR;

        }

    }

    switch (format_video_sync) {

    case VSYNC_VSCFR:

        if (ost->frame_number == 0 && delta - duration >= 0.5) {

            av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta - duration));

            delta = duration;

            ost->sync_opts = lrint(sync_ipts);

        }

    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, skipping\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);

    }

  /* duplicates frame if needed */

  for (i = 0; i < nb_frames; i++) {

    av_init_packet(&pkt);

    pkt.data = NULL;

    pkt.size = 0;

    in_picture->pts = ost->sync_opts;

#if 1

    if (!check_recording_time(ost))

#else

    if (ost->frame_number >= ost->max_frames)

#endif

        return;

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

        enc->codec->id == AV_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;

        if (enc->coded_frame->interlaced_frame)

            enc->field_order = enc->coded_frame->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;

        else

            enc->field_order = AV_FIELD_PROGRESSIVE;

        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;

        video_size += pkt.size;

        write_frame(s, &pkt, ost);

    } else {

        int got_packet, forced_keyframe = 0;

        double pts_time;

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

            ost->top_field_first >= 0)

            in_picture->top_field_first = !!ost->top_field_first;

        if (in_picture->interlaced_frame) {

            if (enc->codec->id == AV_CODEC_ID_MJPEG)

                enc->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;

            else

                enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;

        } else

            enc->field_order = AV_FIELD_PROGRESSIVE;

        in_picture->quality = ost->st->codec->global_quality;

        if (!enc->me_threshold)

            in_picture->pict_type = 0;

        pts_time = in_picture->pts != AV_NOPTS_VALUE ?

            in_picture->pts * av_q2d(enc->time_base) : NAN;

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

            in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {

            ost->forced_kf_index++;

            forced_keyframe = 1;

        } else if (ost->forced_keyframes_pexpr) {

            double res;

            ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;

            res = av_expr_eval(ost->forced_keyframes_pexpr,

                               ost->forced_keyframes_expr_const_values, NULL);

            av_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",

                    ost->forced_keyframes_expr_const_values[FKF_N],

                    ost->forced_keyframes_expr_const_values[FKF_N_FORCED],

                    ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],

                    ost->forced_keyframes_expr_const_values[FKF_T],

                    ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],

                    res);

            if (res) {

                forced_keyframe = 1;

                ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =

                    ost->forced_keyframes_expr_const_values[FKF_N];

                ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =

                    ost->forced_keyframes_expr_const_values[FKF_T];

                ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;

            }

            ost->forced_keyframes_expr_const_values[FKF_N] += 1;

        }

        if (forced_keyframe) {

            in_picture->pict_type = AV_PICTURE_TYPE_I;

            av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);

        }

        update_benchmark(NULL);

        ret = avcodec_encode_video2(enc, &pkt, in_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));

            }

            frame_size = pkt.size;

            video_size += pkt.size;

            write_frame(s, &pkt, ost);

            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 (vstats_filename && frame_size)

        do_video_stats(ost, frame_size);

  }

}

static double psnr(double d)

{

    return -10.0 * log(d) / log(10.0);

}

static void do_video_stats(OutputStream *ost, int frame_size)

{

    AVCodecContext *enc;

    int frame_number;

    double ti1, bitrate, avg_bitrate;

    /* this is executed just the first time do_video_stats is called */

    if (!vstats_file) {

        vstats_file = fopen(vstats_filename, "w");

        if (!vstats_file) {

            perror("fopen");

            exit_program(1);

        }

    }

    enc = ost->st->codec;

    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {

        frame_number = ost->st->nb_frames;

        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);

        if (enc->flags&CODEC_FLAG_PSNR)

            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));

        fprintf(vstats_file,"f_size= %6d ", frame_size);

        /* compute pts value */

        ti1 = ost->st->pts.val * av_q2d(enc->time_base);

        if (ti1 < 0.01)

            ti1 = 0.01;

        bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;

        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;

        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",

               (double)video_size / 1024, ti1, bitrate, avg_bitrate);

        fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));

    }

}

/**

 * Get and encode new output from any of the filtergraphs, without causing

 * activity.

 *

 * @return  0 for success, <0 for severe errors

 */

static int reap_filters(void)

{

    AVFrame *filtered_frame = NULL;

    int i;

    int64_t frame_pts;

    /* Reap all buffers present in the buffer sinks */

    for (i = 0; i < nb_output_streams; i++) {

        OutputStream *ost = output_streams[i];

        OutputFile    *of = output_files[ost->file_index];

        int ret = 0;

        if (!ost->filter)

            continue;

        if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {

            return AVERROR(ENOMEM);

        } else

            avcodec_get_frame_defaults(ost->filtered_frame);

        filtered_frame = ost->filtered_frame;

        while (1) {

            ret = av_buffersink_get_frame_flags(ost->filter->filter, filtered_frame,

                                               AV_BUFFERSINK_FLAG_NO_REQUEST);

            if (ret < 0) {

                if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {

                    av_log(NULL, AV_LOG_WARNING,

                           "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));

                }

                break;

            }

            frame_pts = AV_NOPTS_VALUE;

            if (filtered_frame->pts != AV_NOPTS_VALUE) {

                int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;

                filtered_frame->pts = frame_pts = av_rescale_q(filtered_frame->pts,

                                                ost->filter->filter->inputs[0]->time_base,

                                                ost->st->codec->time_base) -

                                    av_rescale_q(start_time,

                                                AV_TIME_BASE_Q,

                                                ost->st->codec->time_base);

            }

            //if (ost->source_index >= 0)

            //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold

            switch (ost->filter->filter->inputs[0]->type) {

            case AVMEDIA_TYPE_VIDEO:

                filtered_frame->pts = frame_pts;

                if (!ost->frame_aspect_ratio.num)

                    ost->st->codec->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;

                do_video_out(of->ctx, ost, filtered_frame);

                break;

            case AVMEDIA_TYPE_AUDIO:

                filtered_frame->pts = frame_pts;

                if (!(ost->st->codec->codec->capabilities & CODEC_CAP_PARAM_CHANGE) &&

                    ost->st->codec->channels != av_frame_get_channels(filtered_frame)) {

                    av_log(NULL, AV_LOG_ERROR,

                           "Audio filter graph output is not normalized and encoder does not support parameter changes\n");

                    break;

                }

                do_audio_out(of->ctx, ost, filtered_frame);

                break;

            default:

                // TODO support subtitle filters

                av_assert0(0);

            }

            av_frame_unref(filtered_frame);

        }

    }