PeerStreamer

/*

 * FFmpeg main

 * 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

 */

/* needed for usleep() */

#define _XOPEN_SOURCE 600

#include "config.h"

#include <ctype.h>

#include <string.h>

#include <math.h>

#include <stdlib.h>

#include <errno.h>

#include <signal.h>

#include <limits.h>

#include <unistd.h>

#include "libavformat/avformat.h"

#include "libavdevice/avdevice.h"

#include "libswscale/swscale.h"

#include "libavformat/framehook.h"

#include "libavcodec/opt.h"

#include "libavcodec/audioconvert.h"

#include "libavutil/fifo.h"

#include "libavutil/avstring.h"

#include "libavformat/os_support.h"

#if HAVE_SYS_RESOURCE_H

#include <sys/types.h>

#include <sys/resource.h>

#elif HAVE_GETPROCESSTIMES

#include <windows.h>

#endif

#if HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#if HAVE_TERMIOS_H

#include <fcntl.h>

#include <sys/ioctl.h>

#include <sys/time.h>

#include <termios.h>

#elif HAVE_CONIO_H

#include <conio.h>

#endif

#undef time //needed because HAVE_AV_CONFIG_H is defined on top

#include <time.h>

#include "cmdutils.h"

#undef NDEBUG

#include <assert.h>

#undef exit

const char program_name[] = "FFmpeg";

const int program_birth_year = 2000;

/* select an input stream for an output stream */

typedef struct AVStreamMap {

    int file_index;

    int stream_index;

    int sync_file_index;

    int sync_stream_index;

} AVStreamMap;

/** select an input file for an output file */

typedef struct AVMetaDataMap {

    int out_file;

    int in_file;

} AVMetaDataMap;

static const OptionDef options[];

#define MAX_FILES 20

static AVFormatContext *input_files[MAX_FILES];

static int64_t input_files_ts_offset[MAX_FILES];

static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];

static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];

static int nb_input_files = 0;

static int nb_icodecs;

static AVFormatContext *output_files[MAX_FILES];

static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];

static int nb_output_files = 0;

static int nb_ocodecs;

static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];

static int nb_stream_maps;

static AVMetaDataMap meta_data_maps[MAX_FILES];

static int nb_meta_data_maps;

static AVInputFormat *file_iformat;

static AVOutputFormat *file_oformat;

static int frame_width  = 0;

static int frame_height = 0;

static float frame_aspect_ratio = 0;

static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;

static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;

static int frame_padtop  = 0;

static int frame_padbottom = 0;

static int frame_padleft  = 0;

static int frame_padright = 0;

static int padcolor[3] = {16,128,128}; /* default to black */

static int frame_topBand  = 0;

static int frame_bottomBand = 0;

static int frame_leftBand  = 0;

static int frame_rightBand = 0;

static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};

static AVRational frame_rate;

static float video_qscale = 0;

static uint16_t *intra_matrix = NULL;

static uint16_t *inter_matrix = NULL;

#if 0 //experimental, (can be removed)

static float video_rc_qsquish=1.0;

static float video_rc_qmod_amp=0;

static int video_rc_qmod_freq=0;

#endif

static const char *video_rc_override_string=NULL;

static int video_disable = 0;

static int video_discard = 0;

static char *video_codec_name = NULL;

static int video_codec_tag = 0;

static int same_quality = 0;

static int do_deinterlace = 0;

static int top_field_first = -1;

static int me_threshold = 0;

static int intra_dc_precision = 8;

static int loop_input = 0;

static int loop_output = AVFMT_NOOUTPUTLOOP;

static int qp_hist = 0;

static int intra_only = 0;

static int audio_sample_rate = 44100;

static int64_t channel_layout = 0;

#define QSCALE_NONE -99999

static float audio_qscale = QSCALE_NONE;

static int audio_disable = 0;

static int audio_channels = 1;

static char  *audio_codec_name = NULL;

static int audio_codec_tag = 0;

static char *audio_language = NULL;

static int subtitle_disable = 0;

static char *subtitle_codec_name = NULL;

static char *subtitle_language = NULL;

static float mux_preload= 0.5;

static float mux_max_delay= 0.7;

static int64_t recording_time = INT64_MAX;

static int64_t start_time = 0;

static int64_t rec_timestamp = 0;

static int64_t input_ts_offset = 0;

static int file_overwrite = 0;

static char *str_title = NULL;

static char *str_author = NULL;

static char *str_copyright = NULL;

static char *str_comment = NULL;

static char *str_genre = NULL;

static char *str_album = NULL;

static int do_benchmark = 0;

static int do_hex_dump = 0;

static int do_pkt_dump = 0;

static int do_psnr = 0;

static int do_pass = 0;

static char *pass_logfilename_prefix = NULL;

static int audio_stream_copy = 0;

static int video_stream_copy = 0;

static int subtitle_stream_copy = 0;

static int video_sync_method= -1;

static int audio_sync_method= 0;

static float audio_drift_threshold= 0.1;

static int copy_ts= 0;

static int opt_shortest = 0;

static int video_global_header = 0;

static char *vstats_filename;

static FILE *vstats_file;

static int opt_programid = 0;

static int copy_initial_nonkeyframes = 0;

static int rate_emu = 0;

static int  video_channel = 0;

static char *video_standard;

static int audio_volume = 256;

static int exit_on_error = 0;

static int using_stdin = 0;

static int using_vhook = 0;

static int verbose = 1;

static int thread_count= 1;

static int q_pressed = 0;

static int64_t video_size = 0;

static int64_t audio_size = 0;

static int64_t extra_size = 0;

static int nb_frames_dup = 0;

static int nb_frames_drop = 0;

static int input_sync;

static uint64_t limit_filesize = 0;

static int force_fps = 0;

static int pgmyuv_compatibility_hack=0;

static float dts_delta_threshold = 10;

static unsigned int sws_flags = SWS_BICUBIC;

static int64_t timer_start;

static AVBitStreamFilterContext *video_bitstream_filters=NULL;

static AVBitStreamFilterContext *audio_bitstream_filters=NULL;

static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;

static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];

#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"

struct AVInputStream;

typedef struct AVOutputStream {

    int file_index;          /* file index */

    int index;               /* stream index in the output file */

    int source_index;        /* AVInputStream index */

    AVStream *st;            /* stream in the output file */

    int encoding_needed;     /* true if encoding needed for this stream */

    int frame_number;

    /* input pts and corresponding output pts

       for A/V sync */

    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */

    struct AVInputStream *sync_ist; /* input stream to sync against */

    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number

    /* video only */

    int video_resample;

    AVFrame pict_tmp;      /* temporary image for resampling */

    struct SwsContext *img_resample_ctx; /* for image resampling */

    int resample_height;

    int video_crop;

    int topBand;             /* cropping area sizes */

    int leftBand;

    int video_pad;

    int padtop;              /* padding area sizes */

    int padbottom;

    int padleft;

    int padright;

    /* audio only */

    int audio_resample;

    ReSampleContext *resample; /* for audio resampling */

    int reformat_pair;

    AVAudioConvert *reformat_ctx;

    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */

    FILE *logfile;

} AVOutputStream;

typedef struct AVInputStream {

    int file_index;

    int index;

    AVStream *st;

    int discard;             /* true if stream data should be discarded */

    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */

    int64_t sample_index;      /* current sample */

    int64_t       start;     /* time when read started */

    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts

                                is not defined */

    int64_t       pts;       /* current pts */

    int is_start;            /* is 1 at the start and after a discontinuity */

} AVInputStream;

typedef struct AVInputFile {

    int eof_reached;      /* true if eof reached */

    int ist_index;        /* index of first stream in ist_table */

    int buffer_size;      /* current total buffer size */

    int nb_streams;       /* nb streams we are aware of */

} AVInputFile;

#if HAVE_TERMIOS_H

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

static struct termios oldtty;

#endif

static void term_exit(void)

{

#if HAVE_TERMIOS_H

    tcsetattr (0, TCSANOW, &oldtty);

#endif

}

static volatile sig_atomic_t received_sigterm = 0;

static void

sigterm_handler(int sig)

{

    received_sigterm = sig;

    term_exit();

}

static void term_init(void)

{

#if HAVE_TERMIOS_H

    struct termios tty;

    tcgetattr (0, &tty);

    oldtty = tty;

    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

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

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

    /*

    register a function to be called at normal program termination

    */

    atexit(term_exit);

#if CONFIG_BEOS_NETSERVER

    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);

#endif

}

/* read a key without blocking */

static int read_key(void)

{

#if HAVE_TERMIOS_H

    int n = 1;

    unsigned char ch;

#if !CONFIG_BEOS_NETSERVER

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

#endif

    if (n > 0) {

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

        if (n == 1)

            return ch;

        return n;

    }

#elif HAVE_CONIO_H

    if(kbhit())

        return(getch());

#endif

    return -1;

}

static int decode_interrupt_cb(void)

{

    return q_pressed || (q_pressed = read_key() == 'q');

}

static int av_exit(int ret)

{

    int i;

    /* close files */

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

        /* maybe av_close_output_file ??? */

        AVFormatContext *s = output_files[i];

        int j;

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

            url_fclose(s->pb);

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

            av_metadata_free(&s->streams[j]->metadata);

            av_free(s->streams[j]->codec);

            av_free(s->streams[j]);

        }

        for(j=0;j<s->nb_programs;j++) {

            av_metadata_free(&s->programs[j]->metadata);

        }

        for(j=0;j<s->nb_chapters;j++) {

            av_metadata_free(&s->chapters[j]->metadata);

        }

        av_metadata_free(&s->metadata);

        av_free(s);

    }

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

        av_close_input_file(input_files[i]);

    av_free(intra_matrix);

    av_free(inter_matrix);

    if (vstats_file)

        fclose(vstats_file);

    av_free(vstats_filename);

    av_free(opt_names);

    av_free(video_codec_name);

    av_free(audio_codec_name);

    av_free(subtitle_codec_name);

    av_free(video_standard);

#if CONFIG_POWERPC_PERF

    void powerpc_display_perf_report(void);

    powerpc_display_perf_report();

#endif /* CONFIG_POWERPC_PERF */

    if (received_sigterm) {

        fprintf(stderr,

            "Received signal %d: terminating.\n",

            (int) received_sigterm);

        exit (255);

    }

    exit(ret); /* not all OS-es handle main() return value */

    return ret;

}

static int read_ffserver_streams(AVFormatContext *s, const char *filename)

{

    int i, err;

    AVFormatContext *ic;

    int nopts = 0;

    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);

    if (err < 0)

        return err;

    /* copy stream format */

    s->nb_streams = ic->nb_streams;

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

        AVStream *st;

        // FIXME: a more elegant solution is needed

        st = av_mallocz(sizeof(AVStream));

        memcpy(st, ic->streams[i], sizeof(AVStream));

        st->codec = avcodec_alloc_context();

        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));

        s->streams[i] = st;

        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)

            st->stream_copy = 1;

        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)

            st->stream_copy = 1;

        if(!st->codec->thread_count)

            st->codec->thread_count = 1;

        if(st->codec->thread_count>1)

            avcodec_thread_init(st->codec, st->codec->thread_count);

        if(st->codec->flags & CODEC_FLAG_BITEXACT)

            nopts = 1;

    }

    if (!nopts)

        s->timestamp = av_gettime();

    av_close_input_file(ic);

    return 0;

}

static double

get_sync_ipts(const AVOutputStream *ost)

{

    const AVInputStream *ist = ost->sync_ist;

    return (double)(ist->pts - start_time)/AV_TIME_BASE;

}

static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){

    int ret;

    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 & PKT_FLAG_KEY);

        if(a>0){

            av_free_packet(pkt);

            new_pkt.destruct= av_destruct_packet;

        } else if(a<0){

            fprintf(stderr, "%s failed for stream %d, codec %s",

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

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

            print_error("", a);

            if (exit_on_error)

                av_exit(1);

        }

        *pkt= new_pkt;

        bsfc= bsfc->next;

    }

    ret= av_interleaved_write_frame(s, pkt);

    if(ret < 0){

        print_error("av_interleaved_write_frame()", ret);

        av_exit(1);

    }

}

#define MAX_AUDIO_PACKET_SIZE (128 * 1024)

static void do_audio_out(AVFormatContext *s,

                         AVOutputStream *ost,

                         AVInputStream *ist,

                         unsigned char *buf, int size)

{

    uint8_t *buftmp;

    static uint8_t *audio_buf = NULL;

    static uint8_t *audio_out = NULL;

    static uint8_t *audio_out2 = NULL;

    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;

    int size_out, frame_bytes, ret;

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

    AVCodecContext *dec= ist->st->codec;

    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;

    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;

    /* SC: dynamic allocation of buffers */

    if (!audio_buf)

        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);

    if (!audio_out)

        audio_out = av_malloc(audio_out_size);

    if (!audio_buf || !audio_out)

        return;               /* Should signal an error ! */

    if (enc->channels != dec->channels)

        ost->audio_resample = 1;

    if (ost->audio_resample && !ost->resample) {

        if (dec->sample_fmt != SAMPLE_FMT_S16) {

            fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");

            av_exit(1);

        }

        ost->resample = audio_resample_init(enc->channels,    dec->channels,

                                            enc->sample_rate, dec->sample_rate);

        if (!ost->resample) {

            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",

                    dec->channels, dec->sample_rate,

                    enc->channels, enc->sample_rate);

            av_exit(1);

        }

    }

#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))

    if (dec->sample_fmt!=enc->sample_fmt &&

        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {

        if (!audio_out2)

            audio_out2 = av_malloc(audio_out_size);

        if (!audio_out2)

            av_exit(1);

        if (ost->reformat_ctx)

            av_audio_convert_free(ost->reformat_ctx);

        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,

                                                   dec->sample_fmt, 1, NULL, 0);

        if (!ost->reformat_ctx) {

            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",

                avcodec_get_sample_fmt_name(dec->sample_fmt),

                avcodec_get_sample_fmt_name(enc->sample_fmt));

            av_exit(1);

        }

        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);

    }

    if(audio_sync_method){

        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts

                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);

        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;

        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;

        //FIXME resample delay

        if(fabs(delta) > 50){

            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){

                if(byte_delta < 0){

                    byte_delta= FFMAX(byte_delta, -size);

                    size += byte_delta;

                    buf  -= byte_delta;

                    if(verbose > 2)

                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);

                    if(!size)

                        return;

                    ist->is_start=0;

                }else{

                    static uint8_t *input_tmp= NULL;

                    input_tmp= av_realloc(input_tmp, byte_delta + size);

                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)

                        ist->is_start=0;

                    else

                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;

                    memset(input_tmp, 0, byte_delta);

                    memcpy(input_tmp + byte_delta, buf, size);

                    buf= input_tmp;

                    size += byte_delta;

                    if(verbose > 2)

                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);

                }

            }else if(audio_sync_method>1){

                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);

                assert(ost->audio_resample);

                if(verbose > 2)

                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);

//                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));

                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);

            }

        }

    }else

        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)

                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong

    if (ost->audio_resample) {

        buftmp = audio_buf;

        size_out = audio_resample(ost->resample,

                                  (short *)buftmp, (short *)buf,

                                  size / (ist->st->codec->channels * isize));

        size_out = size_out * enc->channels * osize;

    } else {

        buftmp = buf;

        size_out = size;

    }

    if (dec->sample_fmt!=enc->sample_fmt) {

        const void *ibuf[6]= {buftmp};

        void *obuf[6]= {audio_out2};

        int istride[6]= {isize};

        int ostride[6]= {osize};

        int len= size_out/istride[0];

        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

            printf("av_audio_convert() failed\n");

            if (exit_on_error)

                av_exit(1);

            return;

        }

        buftmp = audio_out2;

        size_out = len*osize;

    }

    /* now encode as many frames as possible */

    if (enc->frame_size > 1) {

        /* output resampled raw samples */

        if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {

            fprintf(stderr, "av_fifo_realloc2() failed\n");

            av_exit(1);

        }

        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);

        frame_bytes = enc->frame_size * osize * enc->channels;

        while (av_fifo_size(&ost->fifo) >= frame_bytes) {

            AVPacket pkt;

            av_init_packet(&pkt);

            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);

            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,

                                       (short *)audio_buf);

            if (ret < 0) {

                fprintf(stderr, "Audio encoding failed\n");

                av_exit(1);

            }

            audio_size += ret;

            pkt.stream_index= ost->index;

            pkt.data= audio_out;

            pkt.size= ret;

            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

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

            pkt.flags |= PKT_FLAG_KEY;

            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

            ost->sync_opts += enc->frame_size;

        }

    } else {

        AVPacket pkt;

        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;

        av_init_packet(&pkt);

        ost->sync_opts += size_out / (osize * enc->channels);

        /* output a pcm frame */

        /* determine the size of the coded buffer */

        size_out /= osize;

        if (coded_bps)

            size_out *= coded_bps;

        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

        ret = avcodec_encode_audio(enc, audio_out, size_out,

                                   (short *)buftmp);

        if (ret < 0) {

            fprintf(stderr, "Audio encoding failed\n");

            av_exit(1);

        }

        audio_size += ret;

        pkt.stream_index= ost->index;

        pkt.data= audio_out;

        pkt.size= ret;

        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

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

        pkt.flags |= PKT_FLAG_KEY;

        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

    }

}

static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)

{

    AVCodecContext *dec;

    AVPicture *picture2;

    AVPicture picture_tmp;

    uint8_t *buf = 0;

    dec = ist->st->codec;

    /* deinterlace : must be done before any resize */

    if (do_deinterlace || using_vhook) {

        int size;

        /* create temporary picture */

        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);

        buf = av_malloc(size);

        if (!buf)

            return;

        picture2 = &picture_tmp;

        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

        if (do_deinterlace){

            if(avpicture_deinterlace(picture2, picture,

                                     dec->pix_fmt, dec->width, dec->height) < 0) {

                /* if error, do not deinterlace */

                fprintf(stderr, "Deinterlacing failed\n");

                av_free(buf);

                buf = NULL;

                picture2 = picture;

            }

        } else {

            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);

        }

    } else {

        picture2 = picture;

    }

    if (CONFIG_VHOOK)

        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,

                           1000000 * ist->pts / AV_TIME_BASE);

    if (picture != picture2)

        *picture = *picture2;

    *bufp = buf;

}

/* we begin to correct av delay at this threshold */

#define AV_DELAY_MAX 0.100

static void do_subtitle_out(AVFormatContext *s,

                            AVOutputStream *ost,

                            AVInputStream *ist,

                            AVSubtitle *sub,

                            int64_t pts)

{

    static uint8_t *subtitle_out = NULL;

    int subtitle_out_max_size = 65536;

    int subtitle_out_size, nb, i;

    AVCodecContext *enc;

    AVPacket pkt;

    if (pts == AV_NOPTS_VALUE) {

        fprintf(stderr, "Subtitle packets must have a pts\n");

        if (exit_on_error)

            av_exit(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 == CODEC_ID_DVB_SUBTITLE)

        nb = 2;

    else

        nb = 1;

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

        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,

                                                    subtitle_out_max_size, sub);

        av_init_packet(&pkt);

        pkt.stream_index = ost->index;

        pkt.data = subtitle_out;

        pkt.size = subtitle_out_size;

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

        if (enc->codec_id == 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;

        }

        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

    }

}

static int bit_buffer_size= 1024*256;

static uint8_t *bit_buffer= NULL;

static void do_video_out(AVFormatContext *s,

                         AVOutputStream *ost,

                         AVInputStream *ist,

                         AVFrame *in_picture,

                         int *frame_size)

{

    int nb_frames, i, ret;

    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;

    AVFrame picture_crop_temp, picture_pad_temp;

    AVCodecContext *enc, *dec;

    avcodec_get_frame_defaults(&picture_crop_temp);

    avcodec_get_frame_defaults(&picture_pad_temp);

    enc = ost->st->codec;

    dec = ist->st->codec;

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

    nb_frames = 1;

    *frame_size = 0;

    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){

        double vdelta;

        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;

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

        if (vdelta < -1.1)

            nb_frames = 0;

        else if (video_sync_method == 2)

            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));

        else if (vdelta > 1.1)

            nb_frames = lrintf(vdelta);

//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);

        if (nb_frames == 0){

            ++nb_frames_drop;

            if (verbose>2)

                fprintf(stderr, "*** drop!\n");

        }else if (nb_frames > 1) {

            nb_frames_dup += nb_frames;

            if (verbose>2)

                fprintf(stderr, "*** %d dup!\n", nb_frames-1);

        }

    }else

        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));

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

    if (nb_frames <= 0)

        return;

    if (ost->video_crop) {

        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {

            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");

            if (exit_on_error)

                av_exit(1);

            return;

        }

        formatted_picture = &picture_crop_temp;

    } else {

        formatted_picture = in_picture;

    }

    final_picture = formatted_picture;

    padding_src = formatted_picture;

    resampling_dst = &ost->pict_tmp;

    if (ost->video_pad) {

        final_picture = &ost->pict_tmp;

        if (ost->video_resample) {

            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {

                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");

                if (exit_on_error)

                    av_exit(1);

                return;

            }

            resampling_dst = &picture_pad_temp;

        }

    }

    if (ost->video_resample) {

        padding_src = NULL;

        final_picture = &ost->pict_tmp;

        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,

              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);

    }

    if (ost->video_pad) {

        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,

                enc->height, enc->width, enc->pix_fmt,

                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);

    }

    /* duplicates frame if needed */

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

        AVPacket pkt;

        av_init_packet(&pkt);

        pkt.stream_index= ost->index;

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

            /* raw pictures are written as AVPicture structure to

               avoid any copies. We support temorarily the older

               method. */

            AVFrame* old_frame = enc->coded_frame;

            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack

            pkt.data= (uint8_t *)final_picture;

            pkt.size=  sizeof(AVPicture);

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

            pkt.flags |= PKT_FLAG_KEY;

            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

            enc->coded_frame = old_frame;

        } else {

            AVFrame big_picture;

            big_picture= *final_picture;

            /* better than nothing: use input picture interlaced

               settings */

            big_picture.interlaced_frame = in_picture->interlaced_frame;

            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){

                if(top_field_first == -1)

                    big_picture.top_field_first = in_picture->top_field_first;

                else

                    big_picture.top_field_first = top_field_first;

            }

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

               not be a global option */

            if (same_quality) {

                big_picture.quality = ist->st->quality;

            }else

                big_picture.quality = ost->st->quality;

            if(!me_threshold)

                big_picture.pict_type = 0;

//            big_picture.pts = AV_NOPTS_VALUE;

            big_picture.pts= ost->sync_opts;

//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);

//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);

            ret = avcodec_encode_video(enc,

                                       bit_buffer, bit_buffer_size,

                                       &big_picture);

            if (ret < 0) {

                fprintf(stderr, "Video encoding failed\n");

                av_exit(1);

            }

            //enc->frame_number = enc->real_pict_num;

            if(ret>0){

                pkt.data= bit_buffer;

                pkt.size= ret;

                if(enc->coded_frame->pts != AV_NOPTS_VALUE)

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

/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",

   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,

   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/

                if(enc->coded_frame->key_frame)

                    pkt.flags |= PKT_FLAG_KEY;

                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);

                *frame_size = ret;

                video_size += ret;

                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",

                //        enc->frame_number-1, enc->real_pict_num, ret,

                //        enc->pict_type);

                /* if two pass, output log */

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

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

                }

            }

        }

        ost->sync_opts++;

        ost->frame_number++;

    }

}

static double psnr(double d){

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

}

static void do_video_stats(AVFormatContext *os, AVOutputStream *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");

            av_exit(1);

        }

    }

    enc = ost->st->codec;

    if (enc->codec_type == CODEC_TYPE_VIDEO) {

        frame_number = ost->frame_number;

        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->sync_opts * 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_pict_type_char(enc->coded_frame->pict_type));

    }

}

static void print_report(AVFormatContext **output_files,

                         AVOutputStream **ost_table, int nb_ostreams,

                         int is_last_report)

{

    char buf[1024];

    AVOutputStream *ost;

    AVFormatContext *oc, *os;

    int64_t total_size;

    AVCodecContext *enc;

    int frame_number, vid, i;

    double bitrate, ti1, pts;

    static int64_t last_time = -1;

    static int qp_histogram[52];

    if (!is_last_report) {

        int64_t cur_time;

        /* display the report every 0.5 seconds */

        cur_time = av_gettime();

        if (last_time == -1) {

            last_time = cur_time;

            return;

        }

        if ((cur_time - last_time) < 500000)

            return;

        last_time = cur_time;

    }

    oc = output_files[0];

    total_size = url_fsize(oc->pb);

    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too

        total_size= url_ftell(oc->pb);

    buf[0] = '\0';

    ti1 = 1e10;

    vid = 0;

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

        ost = ost_table[i];

        os = output_files[ost->file_index];

        enc = ost->st->codec;

        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {

            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",

                     !ost->st->stream_copy ?

                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);

        }

        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {

            float t = (av_gettime()-timer_start) / 1000000.0;

            frame_number = ost->frame_number;

            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",

                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,

                     !ost->st->stream_copy ?

                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);

            if(is_last_report)

                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");

            if(qp_hist){

                int j;

                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);

                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))

                    qp_histogram[qp]++;

                for(j=0; j<32; j++)

                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));

            }

            if (enc->flags&CODEC_FLAG_PSNR){

                int j;

                double error, error_sum=0;

                double scale, scale_sum=0;

                char type[3]= {'Y','U','V'};

                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");

                for(j=0; j<3; j++){

                    if(is_last_report){

                        error= enc->error[j];

                        scale= enc->width*enc->height*255.0*255.0*frame_number;

                    }else{

                        error= enc->coded_frame->error[j];

                        scale= enc->width*enc->height*255.0*255.0;

                    }

                    if(j) scale/=4;

                    error_sum += error;

                    scale_sum += scale;

                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));

                }

                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));

            }

            vid = 1;

        }

        /* compute min output value */

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

        if ((pts < ti1) && (pts > 0))

            ti1 = pts;

    }

    if (ti1 < 0.01)

        ti1 = 0.01;

    if (verbose || is_last_report) {

        bitrate = (double)(total_size * 8) / ti1 / 1000.0;

        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),

            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",

            (double)total_size / 1024, ti1, bitrate);

        if (verbose > 1)

          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",

                  nb_frames_dup, nb_frames_drop);

        if (verbose >= 0)

            fprintf(stderr, "%s    \r", buf);

        fflush(stderr);

    }

    if (is_last_report && verbose >= 0){

        int64_t raw= audio_size + video_size + extra_size;

        fprintf(stderr, "\n");

        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",

                video_size/1024.0,

                audio_size/1024.0,

                extra_size/1024.0,

                100.0*(total_size - raw)/raw

        );

    }

}

/* pkt = NULL means EOF (needed to flush decoder buffers) */

static int output_packet(AVInputStream *ist, int ist_index,

                         AVOutputStream **ost_table, int nb_ostreams,

                         const AVPacket *pkt)

{

    AVFormatContext *os;

    AVOutputStream *ost;

    uint8_t *ptr;

    int len, ret, i;

    uint8_t *data_buf;

    int data_size, got_picture;

    AVFrame picture;

    void *buffer_to_free;

    static unsigned int samples_size= 0;

    static short *samples= NULL;

    AVSubtitle subtitle, *subtitle_to_free;

    int got_subtitle;

    if(ist->next_pts == AV_NOPTS_VALUE)

        ist->next_pts= ist->pts;

    if (pkt == NULL) {

        /* EOF handling */

        ptr = NULL;

        len = 0;

        goto handle_eof;

    }

    if(pkt->dts != AV_NOPTS_VALUE)

        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);

    len = pkt->size;

    ptr = pkt->data;

    //while we have more to decode or while the decoder did output something on EOF

    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {

    handle_eof:

        ist->pts= ist->next_pts;

        if(len && len != pkt->size && verbose>0)

            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);

        /* decode the packet if needed */

        data_buf = NULL; /* fail safe */

        data_size = 0;

        subtitle_to_free = NULL;

        if (ist->decoding_needed) {

            switch(ist->st->codec->codec_type) {

            case CODEC_TYPE_AUDIO:{

                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {

                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);

                    av_free(samples);

                    samples= av_malloc(samples_size);

                }

                data_size= samples_size;

                    /* XXX: could avoid copy if PCM 16 bits with same

                       endianness as CPU */

                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,

                                           ptr, len);

                if (ret < 0)

                    goto fail_decode;

                ptr += ret;

                len -= ret;

                /* Some bug in mpeg audio decoder gives */

                /* data_size < 0, it seems they are overflows */

                if (data_size <= 0) {

                    /* no audio frame */

                    continue;

                }

                data_buf = (uint8_t *)samples;

                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /

                    (ist->st->codec->sample_rate * ist->st->codec->channels);

                break;}

            case CODEC_TYPE_VIDEO:

                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;

                    /* XXX: allocate picture correctly */

                    avcodec_get_frame_defaults(&picture);

                    ret = avcodec_decode_video(ist->st->codec,

                                               &picture, &got_picture, ptr, len);

                    ist->st->quality= picture.quality;

                    if (ret < 0)

                        goto fail_decode;

                    if (!got_picture) {

                        /* no picture yet */

                        goto discard_packet;

                    }

                    if (ist->st->codec->time_base.num != 0) {

                        ist->next_pts += ((int64_t)AV_TIME_BASE *

                                          ist->st->codec->time_base.num) /

                            ist->st->codec->time_base.den;

                    }

                    len = 0;

                    break;

            case CODEC_TYPE_SUBTITLE:

                ret = avcodec_decode_subtitle(ist->st->codec,

                                              &subtitle, &got_subtitle, ptr, len);

                if (ret < 0)

                    goto fail_decode;

                if (!got_subtitle) {

                    goto discard_packet;

                }

                subtitle_to_free = &subtitle;

                len = 0;

                break;

            default:

                goto fail_decode;

            }

        } else {

            switch(ist->st->codec->codec_type) {

            case CODEC_TYPE_AUDIO:

                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /

                    ist->st->codec->sample_rate;

                break;

            case CODEC_TYPE_VIDEO:

                if (ist->st->codec->time_base.num != 0) {

                    ist->next_pts += ((int64_t)AV_TIME_BASE *

                                      ist->st->codec->time_base.num) /

                        ist->st->codec->time_base.den;

                }

                break;

            }

            data_buf = ptr;

            data_size = len;

            ret = len;

            len = 0;