git.sesse.net Git - ffmpeg/blob - ffmpeg.c

   1 /*
   2  * ffmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include <unistd.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavdevice/avdevice.h"
  33 #include "libswscale/swscale.h"
  34 #include "libavutil/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/audioconvert.h"
  37 #include "libavutil/parseutils.h"
  38 #include "libavutil/samplefmt.h"
  39 #include "libavutil/colorspace.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/dict.h"
  43 #include "libavutil/mathematics.h"
  44 #include "libavutil/pixdesc.h"
  45 #include "libavutil/avstring.h"
  46 #include "libavutil/libm.h"
  47 #include "libavformat/os_support.h"
  48
  49 #include "libavformat/ffm.h" // not public API
  50
  51 #if CONFIG_AVFILTER
  52 # include "libavfilter/avcodec.h"
  53 # include "libavfilter/avfilter.h"
  54 # include "libavfilter/avfiltergraph.h"
  55 # include "libavfilter/vsink_buffer.h"
  56 # include "libavfilter/vsrc_buffer.h"
  57 #endif
  58
  59 #if HAVE_SYS_RESOURCE_H
  60 #include <sys/types.h>
  61 #include <sys/time.h>
  62 #include <sys/resource.h>
  63 #elif HAVE_GETPROCESSTIMES
  64 #include <windows.h>
  65 #endif
  66 #if HAVE_GETPROCESSMEMORYINFO
  67 #include <windows.h>
  68 #include <psapi.h>
  69 #endif
  70
  71 #if HAVE_SYS_SELECT_H
  72 #include <sys/select.h>
  73 #endif
  74
  75 #if HAVE_TERMIOS_H
  76 #include <fcntl.h>
  77 #include <sys/ioctl.h>
  78 #include <sys/time.h>
  79 #include <termios.h>
  80 #elif HAVE_KBHIT
  81 #include <conio.h>
  82 #endif
  83 #include <time.h>
  84
  85 #include "cmdutils.h"
  86
  87 #include "libavutil/avassert.h"
  88
  89 const char program_name[] = "ffmpeg";
  90 const int program_birth_year = 2000;
  91
  92 /* select an input stream for an output stream */
  93 typedef struct StreamMap {
  94     int disabled;           /** 1 is this mapping is disabled by a negative map */
  95     int file_index;
  96     int stream_index;
  97     int sync_file_index;
  98     int sync_stream_index;
  99 } StreamMap;
 100
 101 /**
 102  * select an input file for an output file
 103  */
 104 typedef struct MetadataMap {
 105     int  file;      ///< file index
 106     char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
 107     int  index;     ///< stream/chapter/program number
 108 } MetadataMap;
 109
 110 static const OptionDef options[];
 111
 112 #define MAX_FILES 100
 113 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 114 static const char *last_asked_format = NULL;
 115 static double *ts_scale;
 116 static int  nb_ts_scale;
 117
 118 static AVFormatContext *output_files[MAX_FILES];
 119 static AVDictionary *output_opts[MAX_FILES];
 120 static int nb_output_files = 0;
 121
 122 static StreamMap *stream_maps = NULL;
 123 static int nb_stream_maps;
 124
 125 static AVDictionary *codec_names;
 126
 127 /* first item specifies output metadata, second is input */
 128 static MetadataMap (*meta_data_maps)[2] = NULL;
 129 static int nb_meta_data_maps;
 130 static int metadata_global_autocopy   = 1;
 131 static int metadata_streams_autocopy  = 1;
 132 static int metadata_chapters_autocopy = 1;
 133
 134 static int chapters_input_file = INT_MAX;
 135
 136 /* indexed by output file stream index */
 137 static int *streamid_map = NULL;
 138 static int nb_streamid_map = 0;
 139
 140 static int frame_width  = 0;
 141 static int frame_height = 0;
 142 static float frame_aspect_ratio = 0;
 143 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 144 static int frame_bits_per_raw_sample = 0;
 145 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
 146 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 147 static AVRational frame_rate;
 148 static float video_qscale = 0;
 149 static uint16_t *intra_matrix = NULL;
 150 static uint16_t *inter_matrix = NULL;
 151 static const char *video_rc_override_string=NULL;
 152 static int video_disable = 0;
 153 static int video_discard = 0;
 154 static unsigned int video_codec_tag = 0;
 155 static char *video_language = NULL;
 156 static int same_quant = 0;
 157 static int do_deinterlace = 0;
 158 static int top_field_first = -1;
 159 static int me_threshold = 0;
 160 static int intra_dc_precision = 8;
 161 static int loop_input = 0;
 162 static int loop_output = AVFMT_NOOUTPUTLOOP;
 163 static int qp_hist = 0;
 164 #if CONFIG_AVFILTER
 165 static char *vfilters = NULL;
 166 #endif
 167
 168 static int intra_only = 0;
 169 static int audio_sample_rate = 0;
 170 #define QSCALE_NONE -99999
 171 static float audio_qscale = QSCALE_NONE;
 172 static int audio_disable = 0;
 173 static int audio_channels = 0;
 174 static unsigned int audio_codec_tag = 0;
 175 static char *audio_language = NULL;
 176
 177 static int subtitle_disable = 0;
 178 static char *subtitle_language = NULL;
 179 static unsigned int subtitle_codec_tag = 0;
 180
 181 static int data_disable = 0;
 182 static unsigned int data_codec_tag = 0;
 183
 184 static float mux_preload= 0.5;
 185 static float mux_max_delay= 0.7;
 186
 187 static int64_t recording_time = INT64_MAX;
 188 static int64_t start_time = 0;
 189 static int64_t input_ts_offset = 0;
 190 static int file_overwrite = 0;
 191 static AVDictionary *metadata;
 192 static int do_benchmark = 0;
 193 static int do_hex_dump = 0;
 194 static int do_pkt_dump = 0;
 195 static int do_psnr = 0;
 196 static int do_pass = 0;
 197 static const char *pass_logfilename_prefix;
 198 static int video_sync_method= -1;
 199 static int audio_sync_method= 0;
 200 static float audio_drift_threshold= 0.1;
 201 static int copy_ts= 0;
 202 static int copy_tb= 0;
 203 static int opt_shortest = 0;
 204 static char *vstats_filename;
 205 static FILE *vstats_file;
 206 static int opt_programid = 0;
 207 static int copy_initial_nonkeyframes = 0;
 208
 209 static int rate_emu = 0;
 210
 211 static int audio_volume = 256;
 212
 213 static int exit_on_error = 0;
 214 static int using_stdin = 0;
 215 static int verbose = 1;
 216 static int run_as_daemon  = 0;
 217 static int thread_count= 1;
 218 static int q_pressed = 0;
 219 static int64_t video_size = 0;
 220 static int64_t audio_size = 0;
 221 static int64_t extra_size = 0;
 222 static int nb_frames_dup = 0;
 223 static int nb_frames_drop = 0;
 224 static int input_sync;
 225 static uint64_t limit_filesize = 0;
 226 static int force_fps = 0;
 227 static char *forced_key_frames = NULL;
 228
 229 static float dts_delta_threshold = 10;
 230
 231 static int64_t timer_start;
 232
 233 static uint8_t *audio_buf;
 234 static uint8_t *audio_out;
 235 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 236
 237 static short *samples;
 238
 239 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 240 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 241 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 242
 243 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 244
 245 struct InputStream;
 246
 247 typedef struct OutputStream {
 248     int file_index;          /* file index */
 249     int index;               /* stream index in the output file */
 250     int source_index;        /* InputStream index */
 251     AVStream *st;            /* stream in the output file */
 252     int encoding_needed;     /* true if encoding needed for this stream */
 253     int frame_number;
 254     /* input pts and corresponding output pts
 255        for A/V sync */
 256     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 257     struct InputStream *sync_ist; /* input stream to sync against */
 258     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 259     AVBitStreamFilterContext *bitstream_filters;
 260     AVCodec *enc;
 261
 262     /* video only */
 263     int video_resample;
 264     AVFrame resample_frame;              /* temporary frame for image resampling */
 265     struct SwsContext *img_resample_ctx; /* for image resampling */
 266     int resample_height;
 267     int resample_width;
 268     int resample_pix_fmt;
 269     AVRational frame_rate;
 270
 271     float frame_aspect_ratio;
 272
 273     /* forced key frames */
 274     int64_t *forced_kf_pts;
 275     int forced_kf_count;
 276     int forced_kf_index;
 277
 278     /* audio only */
 279     int audio_resample;
 280     ReSampleContext *resample; /* for audio resampling */
 281     int resample_sample_fmt;
 282     int resample_channels;
 283     int resample_sample_rate;
 284     int reformat_pair;
 285     AVAudioConvert *reformat_ctx;
 286     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 287     FILE *logfile;
 288
 289 #if CONFIG_AVFILTER
 290     AVFilterContext *output_video_filter;
 291     AVFilterContext *input_video_filter;
 292     AVFilterBufferRef *picref;
 293     char *avfilter;
 294     AVFilterGraph *graph;
 295 #endif
 296
 297    int sws_flags;
 298    AVDictionary *opts;
 299 } OutputStream;
 300
 301 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
 302 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
 303
 304 typedef struct InputStream {
 305     int file_index;
 306     AVStream *st;
 307     int discard;             /* true if stream data should be discarded */
 308     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 309     AVCodec *dec;
 310
 311     int64_t       start;     /* time when read started */
 312     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 313                                 is not defined */
 314     int64_t       pts;       /* current pts */
 315     double ts_scale;
 316     int is_start;            /* is 1 at the start and after a discontinuity */
 317     int showed_multi_packet_warning;
 318     int is_past_recording_time;
 319     AVDictionary *opts;
 320 } InputStream;
 321
 322 typedef struct InputFile {
 323     AVFormatContext *ctx;
 324     int eof_reached;      /* true if eof reached */
 325     int ist_index;        /* index of first stream in ist_table */
 326     int buffer_size;      /* current total buffer size */
 327     int nb_streams;
 328     int64_t ts_offset;
 329 } InputFile;
 330
 331 #if HAVE_TERMIOS_H
 332
 333 /* init terminal so that we can grab keys */
 334 static struct termios oldtty;
 335 #endif
 336
 337 static InputStream *input_streams = NULL;
 338 static int         nb_input_streams = 0;
 339 static InputFile   *input_files   = NULL;
 340 static int         nb_input_files   = 0;
 341
 342 #if CONFIG_AVFILTER
 343
 344 static int configure_video_filters(InputStream *ist, OutputStream *ost)
 345 {
 346     AVFilterContext *last_filter, *filter;
 347     /** filter graph containing all filters including input & output */
 348     AVCodecContext *codec = ost->st->codec;
 349     AVCodecContext *icodec = ist->st->codec;
 350     enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
 351     AVRational sample_aspect_ratio;
 352     char args[255];
 353     int ret;
 354
 355     ost->graph = avfilter_graph_alloc();
 356
 357     if (ist->st->sample_aspect_ratio.num){
 358         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 359     }else
 360         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 361
 362     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 363              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 364              sample_aspect_ratio.num, sample_aspect_ratio.den);
 365
 366     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
 367                                        "src", args, NULL, ost->graph);
 368     if (ret < 0)
 369         return ret;
 370     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
 371                                        "out", NULL, pix_fmts, ost->graph);
 372     if (ret < 0)
 373         return ret;
 374     last_filter = ost->input_video_filter;
 375
 376     if (codec->width  != icodec->width || codec->height != icodec->height) {
 377         snprintf(args, 255, "%d:%d:flags=0x%X",
 378                  codec->width,
 379                  codec->height,
 380                  ost->sws_flags);
 381         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 382                                                 NULL, args, NULL, ost->graph)) < 0)
 383             return ret;
 384         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 385             return ret;
 386         last_filter = filter;
 387     }
 388
 389     snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
 390     ost->graph->scale_sws_opts = av_strdup(args);
 391
 392     if (ost->avfilter) {
 393         AVFilterInOut *outputs = avfilter_inout_alloc();
 394         AVFilterInOut *inputs  = avfilter_inout_alloc();
 395
 396         outputs->name    = av_strdup("in");
 397         outputs->filter_ctx = last_filter;
 398         outputs->pad_idx = 0;
 399         outputs->next    = NULL;
 400
 401         inputs->name    = av_strdup("out");
 402         inputs->filter_ctx = ost->output_video_filter;
 403         inputs->pad_idx = 0;
 404         inputs->next    = NULL;
 405
 406         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
 407             return ret;
 408         av_freep(&ost->avfilter);
 409     } else {
 410         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
 411             return ret;
 412     }
 413
 414     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
 415         return ret;
 416
 417     codec->width  = ost->output_video_filter->inputs[0]->w;
 418     codec->height = ost->output_video_filter->inputs[0]->h;
 419     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 420         ost->frame_aspect_ratio ? // overriden by the -aspect cli option
 421         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
 422         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
 423
 424     return 0;
 425 }
 426 #endif /* CONFIG_AVFILTER */
 427
 428 static void term_exit(void)
 429 {
 430     av_log(NULL, AV_LOG_QUIET, "%s", "");
 431 #if HAVE_TERMIOS_H
 432     if(!run_as_daemon)
 433         tcsetattr (0, TCSANOW, &oldtty);
 434 #endif
 435 }
 436
 437 static volatile int received_sigterm = 0;
 438
 439 static void
 440 sigterm_handler(int sig)
 441 {
 442     received_sigterm = sig;
 443     q_pressed++;
 444     term_exit();
 445 }
 446
 447 static void term_init(void)
 448 {
 449 #if HAVE_TERMIOS_H
 450     if(!run_as_daemon){
 451     struct termios tty;
 452
 453     tcgetattr (0, &tty);
 454     oldtty = tty;
 455     atexit(term_exit);
 456
 457     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 458                           |INLCR|IGNCR|ICRNL|IXON);
 459     tty.c_oflag |= OPOST;
 460     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 461     tty.c_cflag &= ~(CSIZE|PARENB);
 462     tty.c_cflag |= CS8;
 463     tty.c_cc[VMIN] = 1;
 464     tty.c_cc[VTIME] = 0;
 465
 466     tcsetattr (0, TCSANOW, &tty);
 467     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 468     }
 469 #endif
 470
 471     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 472     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 473 #ifdef SIGXCPU
 474     signal(SIGXCPU, sigterm_handler);
 475 #endif
 476 }
 477
 478 /* read a key without blocking */
 479 static int read_key(void)
 480 {
 481 #if HAVE_TERMIOS_H
 482     int n = 1;
 483     unsigned char ch;
 484     struct timeval tv;
 485     fd_set rfds;
 486
 487     if(run_as_daemon)
 488         return -1;
 489
 490     FD_ZERO(&rfds);
 491     FD_SET(0, &rfds);
 492     tv.tv_sec = 0;
 493     tv.tv_usec = 0;
 494     n = select(1, &rfds, NULL, NULL, &tv);
 495     if (n > 0) {
 496         n = read(0, &ch, 1);
 497         if (n == 1)
 498             return ch;
 499
 500         return n;
 501     }
 502 #elif HAVE_KBHIT
 503     if(kbhit())
 504         return(getch());
 505 #endif
 506     return -1;
 507 }
 508
 509 static int decode_interrupt_cb(void)
 510 {
 511     q_pressed += read_key() == 'q';
 512     return q_pressed > 1;
 513 }
 514
 515 static int exit_program(int ret)
 516 {
 517     int i;
 518
 519     /* close files */
 520     for(i=0;i<nb_output_files;i++) {
 521         AVFormatContext *s = output_files[i];
 522         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 523             avio_close(s->pb);
 524         avformat_free_context(s);
 525         av_free(output_streams_for_file[i]);
 526         av_dict_free(&output_opts[i]);
 527     }
 528     for(i=0;i<nb_input_files;i++) {
 529         av_close_input_file(input_files[i].ctx);
 530     }
 531     for (i = 0; i < nb_input_streams; i++)
 532         av_dict_free(&input_streams[i].opts);
 533
 534     av_free(intra_matrix);
 535     av_free(inter_matrix);
 536
 537     if (vstats_file)
 538         fclose(vstats_file);
 539     av_free(vstats_filename);
 540
 541     av_free(streamid_map);
 542     av_free(meta_data_maps);
 543
 544     av_freep(&input_streams);
 545     av_freep(&input_files);
 546
 547     uninit_opts();
 548     av_free(audio_buf);
 549     av_free(audio_out);
 550     allocated_audio_buf_size= allocated_audio_out_size= 0;
 551     av_free(samples);
 552
 553 #if CONFIG_AVFILTER
 554     avfilter_uninit();
 555 #endif
 556
 557     if (received_sigterm) {
 558         fprintf(stderr,
 559             "Received signal %d: terminating.\n",
 560             (int) received_sigterm);
 561         exit (255);
 562     }
 563
 564     exit(ret); /* not all OS-es handle main() return value */
 565     return ret;
 566 }
 567
 568 static void assert_avoptions(AVDictionary *m)
 569 {
 570     AVDictionaryEntry *t;
 571     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 572         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
 573         exit_program(1);
 574     }
 575 }
 576
 577 static void assert_codec_experimental(AVCodecContext *c, int encoder)
 578 {
 579     const char *codec_string = encoder ? "encoder" : "decoder";
 580     AVCodec *codec;
 581     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
 582         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 583         av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
 584                 "results.\nAdd '-strict experimental' if you want to use it.\n",
 585                 codec_string, c->codec->name);
 586         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
 587         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
 588             av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
 589                    codec_string, codec->name);
 590         exit_program(1);
 591     }
 592 }
 593
 594 /* similar to ff_dynarray_add() and av_fast_realloc() */
 595 static void *grow_array(void *array, int elem_size, int *size, int new_size)
 596 {
 597     if (new_size >= INT_MAX / elem_size) {
 598         fprintf(stderr, "Array too big.\n");
 599         exit_program(1);
 600     }
 601     if (*size < new_size) {
 602         uint8_t *tmp = av_realloc(array, new_size*elem_size);
 603         if (!tmp) {
 604             fprintf(stderr, "Could not alloc buffer.\n");
 605             exit_program(1);
 606         }
 607         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
 608         *size = new_size;
 609         return tmp;
 610     }
 611     return array;
 612 }
 613
 614 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
 615 {
 616     if(codec && codec->sample_fmts){
 617         const enum AVSampleFormat *p= codec->sample_fmts;
 618         for(; *p!=-1; p++){
 619             if(*p == st->codec->sample_fmt)
 620                 break;
 621         }
 622         if (*p == -1) {
 623             if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
 624                 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
 625             if(av_get_sample_fmt_name(st->codec->sample_fmt))
 626             av_log(NULL, AV_LOG_WARNING,
 627                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 628                    av_get_sample_fmt_name(st->codec->sample_fmt),
 629                    codec->name,
 630                    av_get_sample_fmt_name(codec->sample_fmts[0]));
 631             st->codec->sample_fmt = codec->sample_fmts[0];
 632         }
 633     }
 634 }
 635
 636 static void choose_sample_rate(AVStream *st, AVCodec *codec)
 637 {
 638     if(codec && codec->supported_samplerates){
 639         const int *p= codec->supported_samplerates;
 640         int best=0;
 641         int best_dist=INT_MAX;
 642         for(; *p; p++){
 643             int dist= abs(st->codec->sample_rate - *p);
 644             if(dist < best_dist){
 645                 best_dist= dist;
 646                 best= *p;
 647             }
 648         }
 649         if(best_dist){
 650             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
 651         }
 652         st->codec->sample_rate= best;
 653     }
 654 }
 655
 656 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
 657 {
 658     if(codec && codec->pix_fmts){
 659         const enum PixelFormat *p= codec->pix_fmts;
 660         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
 661             if(st->codec->codec_id==CODEC_ID_MJPEG){
 662                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
 663             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
 664                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
 665             }
 666         }
 667         for(; *p!=-1; p++){
 668             if(*p == st->codec->pix_fmt)
 669                 break;
 670         }
 671         if (*p == -1) {
 672             if(st->codec->pix_fmt != PIX_FMT_NONE)
 673                 av_log(NULL, AV_LOG_WARNING,
 674                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 675                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,
 676                         codec->name,
 677                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
 678             st->codec->pix_fmt = codec->pix_fmts[0];
 679         }
 680     }
 681 }
 682
 683 static double
 684 get_sync_ipts(const OutputStream *ost)
 685 {
 686     const InputStream *ist = ost->sync_ist;
 687     return (double)(ist->pts - start_time)/AV_TIME_BASE;
 688 }
 689
 690 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 691     int ret;
 692
 693     while(bsfc){
 694         AVPacket new_pkt= *pkt;
 695         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 696                                           &new_pkt.data, &new_pkt.size,
 697                                           pkt->data, pkt->size,
 698                                           pkt->flags & AV_PKT_FLAG_KEY);
 699         if(a>0){
 700             av_free_packet(pkt);
 701             new_pkt.destruct= av_destruct_packet;
 702         } else if(a<0){
 703             fprintf(stderr, "%s failed for stream %d, codec %s",
 704                     bsfc->filter->name, pkt->stream_index,
 705                     avctx->codec ? avctx->codec->name : "copy");
 706             print_error("", a);
 707             if (exit_on_error)
 708                 exit_program(1);
 709         }
 710         *pkt= new_pkt;
 711
 712         bsfc= bsfc->next;
 713     }
 714
 715     ret= av_interleaved_write_frame(s, pkt);
 716     if(ret < 0){
 717         print_error("av_interleaved_write_frame()", ret);
 718         exit_program(1);
 719     }
 720 }
 721
 722 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 723
 724 static void do_audio_out(AVFormatContext *s,
 725                          OutputStream *ost,
 726                          InputStream *ist,
 727                          unsigned char *buf, int size)
 728 {
 729     uint8_t *buftmp;
 730     int64_t audio_out_size, audio_buf_size;
 731     int64_t allocated_for_size= size;
 732
 733     int size_out, frame_bytes, ret, resample_changed;
 734     AVCodecContext *enc= ost->st->codec;
 735     AVCodecContext *dec= ist->st->codec;
 736     int osize = av_get_bytes_per_sample(enc->sample_fmt);
 737     int isize = av_get_bytes_per_sample(dec->sample_fmt);
 738     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 739
 740 need_realloc:
 741     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
 742     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
 743     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
 744     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
 745     audio_buf_size*= osize*enc->channels;
 746
 747     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
 748     if(coded_bps > 8*osize)
 749         audio_out_size= audio_out_size * coded_bps / (8*osize);
 750     audio_out_size += FF_MIN_BUFFER_SIZE;
 751
 752     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
 753         fprintf(stderr, "Buffer sizes too large\n");
 754         exit_program(1);
 755     }
 756
 757     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
 758     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
 759     if (!audio_buf || !audio_out){
 760         fprintf(stderr, "Out of memory in do_audio_out\n");
 761         exit_program(1);
 762     }
 763
 764     if (enc->channels != dec->channels)
 765         ost->audio_resample = 1;
 766
 767     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
 768                        ost->resample_channels    != dec->channels   ||
 769                        ost->resample_sample_rate != dec->sample_rate;
 770
 771     if ((ost->audio_resample && !ost->resample) || resample_changed) {
 772         if (resample_changed) {
 773             av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
 774                    ist->file_index, ist->st->index,
 775                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
 776                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
 777             ost->resample_sample_fmt  = dec->sample_fmt;
 778             ost->resample_channels    = dec->channels;
 779             ost->resample_sample_rate = dec->sample_rate;
 780             if (ost->resample)
 781                 audio_resample_close(ost->resample);
 782         }
 783         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
 784         if (audio_sync_method <= 1 &&
 785             ost->resample_sample_fmt  == enc->sample_fmt &&
 786             ost->resample_channels    == enc->channels   &&
 787             ost->resample_sample_rate == enc->sample_rate) {
 788             ost->resample = NULL;
 789             ost->audio_resample = 0;
 790         } else {
 791             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
 792                 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
 793             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
 794                                                    enc->sample_rate, dec->sample_rate,
 795                                                    enc->sample_fmt,  dec->sample_fmt,
 796                                                    16, 10, 0, 0.8);
 797             if (!ost->resample) {
 798                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 799                         dec->channels, dec->sample_rate,
 800                         enc->channels, enc->sample_rate);
 801                 exit_program(1);
 802             }
 803         }
 804     }
 805
 806 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
 807     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
 808         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
 809         if (ost->reformat_ctx)
 810             av_audio_convert_free(ost->reformat_ctx);
 811         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
 812                                                    dec->sample_fmt, 1, NULL, 0);
 813         if (!ost->reformat_ctx) {
 814             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
 815                 av_get_sample_fmt_name(dec->sample_fmt),
 816                 av_get_sample_fmt_name(enc->sample_fmt));
 817             exit_program(1);
 818         }
 819         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
 820     }
 821
 822     if(audio_sync_method){
 823         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 824                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
 825         double idelta= delta*dec->sample_rate / enc->sample_rate;
 826         int byte_delta= ((int)idelta)*2*dec->channels;
 827
 828         //FIXME resample delay
 829         if(fabs(delta) > 50){
 830             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 831                 if(byte_delta < 0){
 832                     byte_delta= FFMAX(byte_delta, -size);
 833                     size += byte_delta;
 834                     buf  -= byte_delta;
 835                     if(verbose > 2)
 836                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 837                     if(!size)
 838                         return;
 839                     ist->is_start=0;
 840                 }else{
 841                     static uint8_t *input_tmp= NULL;
 842                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 843
 844                     if(byte_delta > allocated_for_size - size){
 845                         allocated_for_size= byte_delta + (int64_t)size;
 846                         goto need_realloc;
 847                     }
 848                     ist->is_start=0;
 849
 850                     memset(input_tmp, 0, byte_delta);
 851                     memcpy(input_tmp + byte_delta, buf, size);
 852                     buf= input_tmp;
 853                     size += byte_delta;
 854                     if(verbose > 2)
 855                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 856                 }
 857             }else if(audio_sync_method>1){
 858                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 859                 av_assert0(ost->audio_resample);
 860                 if(verbose > 2)
 861                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 862 //                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));
 863                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 864             }
 865         }
 866     }else
 867         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 868                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
 869
 870     if (ost->audio_resample) {
 871         buftmp = audio_buf;
 872         size_out = audio_resample(ost->resample,
 873                                   (short *)buftmp, (short *)buf,
 874                                   size / (dec->channels * isize));
 875         size_out = size_out * enc->channels * osize;
 876     } else {
 877         buftmp = buf;
 878         size_out = size;
 879     }
 880
 881     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
 882         const void *ibuf[6]= {buftmp};
 883         void *obuf[6]= {audio_buf};
 884         int istride[6]= {isize};
 885         int ostride[6]= {osize};
 886         int len= size_out/istride[0];
 887         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
 888             printf("av_audio_convert() failed\n");
 889             if (exit_on_error)
 890                 exit_program(1);
 891             return;
 892         }
 893         buftmp = audio_buf;
 894         size_out = len*osize;
 895     }
 896
 897     /* now encode as many frames as possible */
 898     if (enc->frame_size > 1) {
 899         /* output resampled raw samples */
 900         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
 901             fprintf(stderr, "av_fifo_realloc2() failed\n");
 902             exit_program(1);
 903         }
 904         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
 905
 906         frame_bytes = enc->frame_size * osize * enc->channels;
 907
 908         while (av_fifo_size(ost->fifo) >= frame_bytes) {
 909             AVPacket pkt;
 910             av_init_packet(&pkt);
 911
 912             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
 913
 914             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 915
 916             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 917                                        (short *)audio_buf);
 918             if (ret < 0) {
 919                 fprintf(stderr, "Audio encoding failed\n");
 920                 exit_program(1);
 921             }
 922             audio_size += ret;
 923             pkt.stream_index= ost->index;
 924             pkt.data= audio_out;
 925             pkt.size= ret;
 926             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 927                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 928             pkt.flags |= AV_PKT_FLAG_KEY;
 929             write_frame(s, &pkt, enc, ost->bitstream_filters);
 930
 931             ost->sync_opts += enc->frame_size;
 932         }
 933     } else {
 934         AVPacket pkt;
 935         av_init_packet(&pkt);
 936
 937         ost->sync_opts += size_out / (osize * enc->channels);
 938
 939         /* output a pcm frame */
 940         /* determine the size of the coded buffer */
 941         size_out /= osize;
 942         if (coded_bps)
 943             size_out = size_out*coded_bps/8;
 944
 945         if(size_out > audio_out_size){
 946             fprintf(stderr, "Internal error, buffer size too small\n");
 947             exit_program(1);
 948         }
 949
 950         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 951         ret = avcodec_encode_audio(enc, audio_out, size_out,
 952                                    (short *)buftmp);
 953         if (ret < 0) {
 954             fprintf(stderr, "Audio encoding failed\n");
 955             exit_program(1);
 956         }
 957         audio_size += ret;
 958         pkt.stream_index= ost->index;
 959         pkt.data= audio_out;
 960         pkt.size= ret;
 961         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 962             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 963         pkt.flags |= AV_PKT_FLAG_KEY;
 964         write_frame(s, &pkt, enc, ost->bitstream_filters);
 965     }
 966 }
 967
 968 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
 969 {
 970     AVCodecContext *dec;
 971     AVPicture *picture2;
 972     AVPicture picture_tmp;
 973     uint8_t *buf = 0;
 974
 975     dec = ist->st->codec;
 976
 977     /* deinterlace : must be done before any resize */
 978     if (do_deinterlace) {
 979         int size;
 980
 981         /* create temporary picture */
 982         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 983         buf = av_malloc(size);
 984         if (!buf)
 985             return;
 986
 987         picture2 = &picture_tmp;
 988         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 989
 990         if(avpicture_deinterlace(picture2, picture,
 991                                  dec->pix_fmt, dec->width, dec->height) < 0) {
 992             /* if error, do not deinterlace */
 993             fprintf(stderr, "Deinterlacing failed\n");
 994             av_free(buf);
 995             buf = NULL;
 996             picture2 = picture;
 997         }
 998     } else {
 999         picture2 = picture;
1000     }
1001
1002     if (picture != picture2)
1003         *picture = *picture2;
1004     *bufp = buf;
1005 }
1006
1007 /* we begin to correct av delay at this threshold */
1008 #define AV_DELAY_MAX 0.100
1009
1010 static void do_subtitle_out(AVFormatContext *s,
1011                             OutputStream *ost,
1012                             InputStream *ist,
1013                             AVSubtitle *sub,
1014                             int64_t pts)
1015 {
1016     static uint8_t *subtitle_out = NULL;
1017     int subtitle_out_max_size = 1024 * 1024;
1018     int subtitle_out_size, nb, i;
1019     AVCodecContext *enc;
1020     AVPacket pkt;
1021
1022     if (pts == AV_NOPTS_VALUE) {
1023         fprintf(stderr, "Subtitle packets must have a pts\n");
1024         if (exit_on_error)
1025             exit_program(1);
1026         return;
1027     }
1028
1029     enc = ost->st->codec;
1030
1031     if (!subtitle_out) {
1032         subtitle_out = av_malloc(subtitle_out_max_size);
1033     }
1034
1035     /* Note: DVB subtitle need one packet to draw them and one other
1036        packet to clear them */
1037     /* XXX: signal it in the codec context ? */
1038     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1039         nb = 2;
1040     else
1041         nb = 1;
1042
1043     for(i = 0; i < nb; i++) {
1044         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1045         // start_display_time is required to be 0
1046         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1047         sub->end_display_time -= sub->start_display_time;
1048         sub->start_display_time = 0;
1049         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1050                                                     subtitle_out_max_size, sub);
1051         if (subtitle_out_size < 0) {
1052             fprintf(stderr, "Subtitle encoding failed\n");
1053             exit_program(1);
1054         }
1055
1056         av_init_packet(&pkt);
1057         pkt.stream_index = ost->index;
1058         pkt.data = subtitle_out;
1059         pkt.size = subtitle_out_size;
1060         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1061         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1062             /* XXX: the pts correction is handled here. Maybe handling
1063                it in the codec would be better */
1064             if (i == 0)
1065                 pkt.pts += 90 * sub->start_display_time;
1066             else
1067                 pkt.pts += 90 * sub->end_display_time;
1068         }
1069         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1070     }
1071 }
1072
1073 static int bit_buffer_size= 1024*256;
1074 static uint8_t *bit_buffer= NULL;
1075
1076 static void do_video_out(AVFormatContext *s,
1077                          OutputStream *ost,
1078                          InputStream *ist,
1079                          AVFrame *in_picture,
1080                          int *frame_size, float quality)
1081 {
1082     int nb_frames, i, ret, av_unused resample_changed;
1083     AVFrame *final_picture, *formatted_picture;
1084     AVCodecContext *enc, *dec;
1085     double sync_ipts;
1086
1087     enc = ost->st->codec;
1088     dec = ist->st->codec;
1089
1090     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1091
1092     /* by default, we output a single frame */
1093     nb_frames = 1;
1094
1095     *frame_size = 0;
1096
1097     if(video_sync_method){
1098         double vdelta = sync_ipts - ost->sync_opts;
1099         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1100         if (vdelta < -1.1)
1101             nb_frames = 0;
1102         else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1103             if(vdelta<=-0.6){
1104                 nb_frames=0;
1105             }else if(vdelta>0.6)
1106                 ost->sync_opts= lrintf(sync_ipts);
1107         }else if (vdelta > 1.1)
1108             nb_frames = lrintf(vdelta);
1109 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1110         if (nb_frames == 0){
1111             ++nb_frames_drop;
1112             if (verbose>2)
1113                 fprintf(stderr, "*** drop!\n");
1114         }else if (nb_frames > 1) {
1115             nb_frames_dup += nb_frames - 1;
1116             if (verbose>2)
1117                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1118         }
1119     }else
1120         ost->sync_opts= lrintf(sync_ipts);
1121
1122     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1123     if (nb_frames <= 0)
1124         return;
1125
1126     formatted_picture = in_picture;
1127     final_picture = formatted_picture;
1128
1129 #if !CONFIG_AVFILTER
1130     resample_changed = ost->resample_width   != dec->width  ||
1131                        ost->resample_height  != dec->height ||
1132                        ost->resample_pix_fmt != dec->pix_fmt;
1133
1134     if (resample_changed) {
1135         av_log(NULL, AV_LOG_INFO,
1136                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1137                ist->file_index, ist->st->index,
1138                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1139                dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
1140         ost->resample_width   = dec->width;
1141         ost->resample_height  = dec->height;
1142         ost->resample_pix_fmt = dec->pix_fmt;
1143     }
1144
1145     ost->video_resample = dec->width   != enc->width  ||
1146                           dec->height  != enc->height ||
1147                           dec->pix_fmt != enc->pix_fmt;
1148
1149     if (ost->video_resample) {
1150         final_picture = &ost->resample_frame;
1151         if (!ost->img_resample_ctx || resample_changed) {
1152             /* initialize the destination picture */
1153             if (!ost->resample_frame.data[0]) {
1154                 avcodec_get_frame_defaults(&ost->resample_frame);
1155                 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1156                                     enc->width, enc->height)) {
1157                     fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1158                     exit_program(1);
1159                 }
1160             }
1161             /* initialize a new scaler context */
1162             sws_freeContext(ost->img_resample_ctx);
1163             ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1164                                                    enc->width, enc->height, enc->pix_fmt,
1165                                                    ost->sws_flags, NULL, NULL, NULL);
1166             if (ost->img_resample_ctx == NULL) {
1167                 fprintf(stderr, "Cannot get resampling context\n");
1168                 exit_program(1);
1169             }
1170         }
1171         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1172               0, ost->resample_height, final_picture->data, final_picture->linesize);
1173     }
1174 #endif
1175
1176     /* duplicates frame if needed */
1177     for(i=0;i<nb_frames;i++) {
1178         AVPacket pkt;
1179         av_init_packet(&pkt);
1180         pkt.stream_index= ost->index;
1181
1182         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1183             /* raw pictures are written as AVPicture structure to
1184                avoid any copies. We support temorarily the older
1185                method. */
1186             AVFrame* old_frame = enc->coded_frame;
1187             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1188             pkt.data= (uint8_t *)final_picture;
1189             pkt.size=  sizeof(AVPicture);
1190             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1191             pkt.flags |= AV_PKT_FLAG_KEY;
1192
1193             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1194             enc->coded_frame = old_frame;
1195         } else {
1196             AVFrame big_picture;
1197
1198             big_picture= *final_picture;
1199             /* better than nothing: use input picture interlaced
1200                settings */
1201             big_picture.interlaced_frame = in_picture->interlaced_frame;
1202             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1203                 if(top_field_first == -1)
1204                     big_picture.top_field_first = in_picture->top_field_first;
1205                 else
1206                     big_picture.top_field_first = top_field_first;
1207             }
1208
1209             /* handles same_quant here. This is not correct because it may
1210                not be a global option */
1211             big_picture.quality = quality;
1212             if(!me_threshold)
1213                 big_picture.pict_type = 0;
1214 //            big_picture.pts = AV_NOPTS_VALUE;
1215             big_picture.pts= ost->sync_opts;
1216 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1217 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1218             if (ost->forced_kf_index < ost->forced_kf_count &&
1219                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1220                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1221                 ost->forced_kf_index++;
1222             }
1223             ret = avcodec_encode_video(enc,
1224                                        bit_buffer, bit_buffer_size,
1225                                        &big_picture);
1226             if (ret < 0) {
1227                 fprintf(stderr, "Video encoding failed\n");
1228                 exit_program(1);
1229             }
1230
1231             if(ret>0){
1232                 pkt.data= bit_buffer;
1233                 pkt.size= ret;
1234                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1235                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1236 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1237    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1238    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1239
1240                 if(enc->coded_frame->key_frame)
1241                     pkt.flags |= AV_PKT_FLAG_KEY;
1242                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1243                 *frame_size = ret;
1244                 video_size += ret;
1245                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1246                 //        enc->frame_number-1, ret, enc->pict_type);
1247                 /* if two pass, output log */
1248                 if (ost->logfile && enc->stats_out) {
1249                     fprintf(ost->logfile, "%s", enc->stats_out);
1250                 }
1251             }
1252         }
1253         ost->sync_opts++;
1254         ost->frame_number++;
1255     }
1256 }
1257
1258 static double psnr(double d){
1259     return -10.0*log(d)/log(10.0);
1260 }
1261
1262 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1263                            int frame_size)
1264 {
1265     AVCodecContext *enc;
1266     int frame_number;
1267     double ti1, bitrate, avg_bitrate;
1268
1269     /* this is executed just the first time do_video_stats is called */
1270     if (!vstats_file) {
1271         vstats_file = fopen(vstats_filename, "w");
1272         if (!vstats_file) {
1273             perror("fopen");
1274             exit_program(1);
1275         }
1276     }
1277
1278     enc = ost->st->codec;
1279     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1280         frame_number = ost->frame_number;
1281         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1282         if (enc->flags&CODEC_FLAG_PSNR)
1283             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1284
1285         fprintf(vstats_file,"f_size= %6d ", frame_size);
1286         /* compute pts value */
1287         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1288         if (ti1 < 0.01)
1289             ti1 = 0.01;
1290
1291         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1292         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1293         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1294             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1295         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1296     }
1297 }
1298
1299 static void print_report(AVFormatContext **output_files,
1300                          OutputStream **ost_table, int nb_ostreams,
1301                          int is_last_report)
1302 {
1303     char buf[1024];
1304     OutputStream *ost;
1305     AVFormatContext *oc;
1306     int64_t total_size;
1307     AVCodecContext *enc;
1308     int frame_number, vid, i;
1309     double bitrate;
1310     int64_t pts = INT64_MAX;
1311     static int64_t last_time = -1;
1312     static int qp_histogram[52];
1313
1314     if (!is_last_report) {
1315         int64_t cur_time;
1316         /* display the report every 0.5 seconds */
1317         cur_time = av_gettime();
1318         if (last_time == -1) {
1319             last_time = cur_time;
1320             return;
1321         }
1322         if ((cur_time - last_time) < 500000)
1323             return;
1324         last_time = cur_time;
1325     }
1326
1327
1328     oc = output_files[0];
1329
1330     total_size = avio_size(oc->pb);
1331     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1332         total_size= avio_tell(oc->pb);
1333
1334     buf[0] = '\0';
1335     vid = 0;
1336     for(i=0;i<nb_ostreams;i++) {
1337         float q = -1;
1338         ost = ost_table[i];
1339         enc = ost->st->codec;
1340         if (!ost->st->stream_copy && enc->coded_frame)
1341             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1342         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1343             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1344         }
1345         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346             float t = (av_gettime()-timer_start) / 1000000.0;
1347
1348             frame_number = ost->frame_number;
1349             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1350                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1351             if(is_last_report)
1352                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1353             if(qp_hist){
1354                 int j;
1355                 int qp = lrintf(q);
1356                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1357                     qp_histogram[qp]++;
1358                 for(j=0; j<32; j++)
1359                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1360             }
1361             if (enc->flags&CODEC_FLAG_PSNR){
1362                 int j;
1363                 double error, error_sum=0;
1364                 double scale, scale_sum=0;
1365                 char type[3]= {'Y','U','V'};
1366                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1367                 for(j=0; j<3; j++){
1368                     if(is_last_report){
1369                         error= enc->error[j];
1370                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1371                     }else{
1372                         error= enc->coded_frame->error[j];
1373                         scale= enc->width*enc->height*255.0*255.0;
1374                     }
1375                     if(j) scale/=4;
1376                     error_sum += error;
1377                     scale_sum += scale;
1378                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1379                 }
1380                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1381             }
1382             vid = 1;
1383         }
1384         /* compute min output value */
1385         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1386                                       ost->st->time_base, AV_TIME_BASE_Q));
1387     }
1388
1389     if (verbose > 0 || is_last_report) {
1390         int hours, mins, secs, us;
1391         secs = pts / AV_TIME_BASE;
1392         us = pts % AV_TIME_BASE;
1393         mins = secs / 60;
1394         secs %= 60;
1395         hours = mins / 60;
1396         mins %= 60;
1397
1398         bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1399
1400         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1401                  "size=%8.0fkB time=", total_size / 1024.0);
1402         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1403                  "%02d:%02d:%02d.%02d ", hours, mins, secs,
1404                  (100 * us) / AV_TIME_BASE);
1405         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1406                  "bitrate=%6.1fkbits/s", bitrate);
1407
1408         if (nb_frames_dup || nb_frames_drop)
1409           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1410                   nb_frames_dup, nb_frames_drop);
1411
1412         if (verbose >= 0)
1413             fprintf(stderr, "%s    \r", buf);
1414
1415         fflush(stderr);
1416     }
1417
1418     if (is_last_report && verbose >= 0){
1419         int64_t raw= audio_size + video_size + extra_size;
1420         fprintf(stderr, "\n");
1421         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1422                 video_size/1024.0,
1423                 audio_size/1024.0,
1424                 extra_size/1024.0,
1425                 100.0*(total_size - raw)/raw
1426         );
1427     }
1428 }
1429
1430 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1431 {
1432     int fill_char = 0x00;
1433     if (sample_fmt == AV_SAMPLE_FMT_U8)
1434         fill_char = 0x80;
1435     memset(buf, fill_char, size);
1436 }
1437
1438 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1439 static int output_packet(InputStream *ist, int ist_index,
1440                          OutputStream **ost_table, int nb_ostreams,
1441                          const AVPacket *pkt)
1442 {
1443     AVFormatContext *os;
1444     OutputStream *ost;
1445     int ret, i;
1446     int got_output;
1447     AVFrame picture;
1448     void *buffer_to_free = NULL;
1449     static unsigned int samples_size= 0;
1450     AVSubtitle subtitle, *subtitle_to_free;
1451     int64_t pkt_pts = AV_NOPTS_VALUE;
1452 #if CONFIG_AVFILTER
1453     int frame_available;
1454 #endif
1455     float quality;
1456
1457     AVPacket avpkt;
1458     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1459
1460     if(ist->next_pts == AV_NOPTS_VALUE)
1461         ist->next_pts= ist->pts;
1462
1463     if (pkt == NULL) {
1464         /* EOF handling */
1465         av_init_packet(&avpkt);
1466         avpkt.data = NULL;
1467         avpkt.size = 0;
1468         goto handle_eof;
1469     } else {
1470         avpkt = *pkt;
1471     }
1472
1473     if(pkt->dts != AV_NOPTS_VALUE)
1474         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1475     if(pkt->pts != AV_NOPTS_VALUE)
1476         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1477
1478     //while we have more to decode or while the decoder did output something on EOF
1479     while (avpkt.size > 0 || (!pkt && got_output)) {
1480         uint8_t *data_buf, *decoded_data_buf;
1481         int data_size, decoded_data_size;
1482     handle_eof:
1483         ist->pts= ist->next_pts;
1484
1485         if(avpkt.size && avpkt.size != pkt->size &&
1486            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1487             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1488             ist->showed_multi_packet_warning=1;
1489         }
1490
1491         /* decode the packet if needed */
1492         decoded_data_buf = NULL; /* fail safe */
1493         decoded_data_size= 0;
1494         data_buf  = avpkt.data;
1495         data_size = avpkt.size;
1496         subtitle_to_free = NULL;
1497         if (ist->decoding_needed) {
1498             switch(ist->st->codec->codec_type) {
1499             case AVMEDIA_TYPE_AUDIO:{
1500                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1501                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1502                     av_free(samples);
1503                     samples= av_malloc(samples_size);
1504                 }
1505                 decoded_data_size= samples_size;
1506                     /* XXX: could avoid copy if PCM 16 bits with same
1507                        endianness as CPU */
1508                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1509                                             &avpkt);
1510                 if (ret < 0)
1511                     return ret;
1512                 avpkt.data += ret;
1513                 avpkt.size -= ret;
1514                 data_size   = ret;
1515                 got_output  = decoded_data_size > 0;
1516                 /* Some bug in mpeg audio decoder gives */
1517                 /* decoded_data_size < 0, it seems they are overflows */
1518                 if (!got_output) {
1519                     /* no audio frame */
1520                     continue;
1521                 }
1522                 decoded_data_buf = (uint8_t *)samples;
1523                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1524                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1525                 break;}
1526             case AVMEDIA_TYPE_VIDEO:
1527                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1528                     /* XXX: allocate picture correctly */
1529                     avcodec_get_frame_defaults(&picture);
1530                     avpkt.pts = pkt_pts;
1531                     avpkt.dts = ist->pts;
1532                     pkt_pts = AV_NOPTS_VALUE;
1533
1534                     ret = avcodec_decode_video2(ist->st->codec,
1535                                                 &picture, &got_output, &avpkt);
1536                     quality = same_quant ? picture.quality : 0;
1537                     if (ret < 0)
1538                         return ret;
1539                     if (!got_output) {
1540                         /* no picture yet */
1541                         goto discard_packet;
1542                     }
1543                     ist->next_pts = ist->pts = picture.best_effort_timestamp;
1544                     if (ist->st->codec->time_base.num != 0) {
1545                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1546                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1547                                           ist->st->codec->time_base.num * ticks) /
1548                             ist->st->codec->time_base.den;
1549                     }
1550                     avpkt.size = 0;
1551                     buffer_to_free = NULL;
1552                     pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1553                     break;
1554             case AVMEDIA_TYPE_SUBTITLE:
1555                 ret = avcodec_decode_subtitle2(ist->st->codec,
1556                                                &subtitle, &got_output, &avpkt);
1557                 if (ret < 0)
1558                     return ret;
1559                 if (!got_output) {
1560                     goto discard_packet;
1561                 }
1562                 subtitle_to_free = &subtitle;
1563                 avpkt.size = 0;
1564                 break;
1565             default:
1566                 return -1;
1567             }
1568         } else {
1569             switch(ist->st->codec->codec_type) {
1570             case AVMEDIA_TYPE_AUDIO:
1571                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1572                     ist->st->codec->sample_rate;
1573                 break;
1574             case AVMEDIA_TYPE_VIDEO:
1575                 if (ist->st->codec->time_base.num != 0) {
1576                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1577                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1578                                       ist->st->codec->time_base.num * ticks) /
1579                         ist->st->codec->time_base.den;
1580                 }
1581                 break;
1582             }
1583             ret = avpkt.size;
1584             avpkt.size = 0;
1585         }
1586
1587 #if CONFIG_AVFILTER
1588         if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1589         if (start_time == 0 || ist->pts >= start_time) {
1590             for(i=0;i<nb_ostreams;i++) {
1591                 ost = ost_table[i];
1592                 if (ost->input_video_filter && ost->source_index == ist_index) {
1593                     if (!picture.sample_aspect_ratio.num)
1594                         picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1595                     picture.pts = ist->pts;
1596
1597                     av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1598                 }
1599             }
1600         }
1601 #endif
1602
1603         // preprocess audio (volume)
1604         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1605             if (audio_volume != 256) {
1606                 short *volp;
1607                 volp = samples;
1608                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1609                     int v = ((*volp) * audio_volume + 128) >> 8;
1610                     if (v < -32768) v = -32768;
1611                     if (v >  32767) v = 32767;
1612                     *volp++ = v;
1613                 }
1614             }
1615         }
1616
1617         /* frame rate emulation */
1618         if (rate_emu) {
1619             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1620             int64_t now = av_gettime() - ist->start;
1621             if (pts > now)
1622                 usleep(pts - now);
1623         }
1624         /* if output time reached then transcode raw format,
1625            encode packets and output them */
1626         if (start_time == 0 || ist->pts >= start_time)
1627             for(i=0;i<nb_ostreams;i++) {
1628                 int frame_size;
1629
1630                 ost = ost_table[i];
1631
1632                 /* finish if recording time exhausted */
1633                 if (recording_time != INT64_MAX &&
1634                         av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
1635                     >= 0) {
1636                     ist->is_past_recording_time = 1;
1637                     continue;
1638                 }
1639                 if (ost->source_index == ist_index) {
1640 #if CONFIG_AVFILTER
1641                 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1642                     !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1643                 while (frame_available) {
1644                     if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1645                         AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1646                         if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1647                             goto cont;
1648                         if (ost->picref) {
1649                             avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1650                             ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1651                         }
1652                     }
1653 #endif
1654                     os = output_files[ost->file_index];
1655
1656                     /* set the input output pts pairs */
1657                     //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1658
1659                     if (ost->encoding_needed) {
1660                         av_assert0(ist->decoding_needed);
1661                         switch(ost->st->codec->codec_type) {
1662                         case AVMEDIA_TYPE_AUDIO:
1663                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1664                             break;
1665                         case AVMEDIA_TYPE_VIDEO:
1666 #if CONFIG_AVFILTER
1667                             if (ost->picref->video && !ost->frame_aspect_ratio)
1668                                 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1669 #endif
1670                             do_video_out(os, ost, ist, &picture, &frame_size,
1671                                          same_quant ? quality : ost->st->codec->global_quality);
1672                             if (vstats_filename && frame_size)
1673                                 do_video_stats(os, ost, frame_size);
1674                             break;
1675                         case AVMEDIA_TYPE_SUBTITLE:
1676                             do_subtitle_out(os, ost, ist, &subtitle,
1677                                             pkt->pts);
1678                             break;
1679                         default:
1680                             abort();
1681                         }
1682                     } else {
1683                         AVFrame avframe; //FIXME/XXX remove this
1684                         AVPicture pict;
1685                         AVPacket opkt;
1686                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1687
1688                         av_init_packet(&opkt);
1689
1690                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1691 #if !CONFIG_AVFILTER
1692                             continue;
1693 #else
1694                             goto cont;
1695 #endif
1696
1697                         /* no reencoding needed : output the packet directly */
1698                         /* force the input stream PTS */
1699
1700                         avcodec_get_frame_defaults(&avframe);
1701                         ost->st->codec->coded_frame= &avframe;
1702                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1703
1704                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1705                             audio_size += data_size;
1706                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1707                             video_size += data_size;
1708                             ost->sync_opts++;
1709                         }
1710
1711                         opkt.stream_index= ost->index;
1712                         if(pkt->pts != AV_NOPTS_VALUE)
1713                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1714                         else
1715                             opkt.pts= AV_NOPTS_VALUE;
1716
1717                         if (pkt->dts == AV_NOPTS_VALUE)
1718                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1719                         else
1720                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1721                         opkt.dts -= ost_tb_start_time;
1722
1723                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1724                         opkt.flags= pkt->flags;
1725
1726                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1727                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1728                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1729                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1730                            ) {
1731                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1732                                 opkt.destruct= av_destruct_packet;
1733                         } else {
1734                             opkt.data = data_buf;
1735                             opkt.size = data_size;
1736                         }
1737
1738                         if (os->oformat->flags & AVFMT_RAWPICTURE) {
1739                             /* store AVPicture in AVPacket, as expected by the output format */
1740                             avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1741                             opkt.data = (uint8_t *)&pict;
1742                             opkt.size = sizeof(AVPicture);
1743                             opkt.flags |= AV_PKT_FLAG_KEY;
1744                         }
1745                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1746                         ost->st->codec->frame_number++;
1747                         ost->frame_number++;
1748                         av_free_packet(&opkt);
1749                     }
1750 #if CONFIG_AVFILTER
1751                     cont:
1752                     frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1753                                        ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1754                     avfilter_unref_buffer(ost->picref);
1755                 }
1756 #endif
1757                 }
1758             }
1759
1760         av_free(buffer_to_free);
1761         /* XXX: allocate the subtitles in the codec ? */
1762         if (subtitle_to_free) {
1763             avsubtitle_free(subtitle_to_free);
1764             subtitle_to_free = NULL;
1765         }
1766     }
1767  discard_packet:
1768     if (pkt == NULL) {
1769         /* EOF handling */
1770
1771         for(i=0;i<nb_ostreams;i++) {
1772             ost = ost_table[i];
1773             if (ost->source_index == ist_index) {
1774                 AVCodecContext *enc= ost->st->codec;
1775                 os = output_files[ost->file_index];
1776
1777                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1778                     continue;
1779                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1780                     continue;
1781
1782                 if (ost->encoding_needed) {
1783                     for(;;) {
1784                         AVPacket pkt;
1785                         int fifo_bytes;
1786                         av_init_packet(&pkt);
1787                         pkt.stream_index= ost->index;
1788
1789                         switch(ost->st->codec->codec_type) {
1790                         case AVMEDIA_TYPE_AUDIO:
1791                             fifo_bytes = av_fifo_size(ost->fifo);
1792                             ret = 0;
1793                             /* encode any samples remaining in fifo */
1794                             if (fifo_bytes > 0) {
1795                                 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1796                                 int fs_tmp = enc->frame_size;
1797
1798                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1799                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1800                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1801                                 } else { /* pad */
1802                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1803                                     if (allocated_audio_buf_size < frame_bytes)
1804                                         exit_program(1);
1805                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1806                                 }
1807
1808                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1809                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1810                                                           ost->st->time_base.num, enc->sample_rate);
1811                                 enc->frame_size = fs_tmp;
1812                             }
1813                             if(ret <= 0) {
1814                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1815                             }
1816                             if (ret < 0) {
1817                                 fprintf(stderr, "Audio encoding failed\n");
1818                                 exit_program(1);
1819                             }
1820                             audio_size += ret;
1821                             pkt.flags |= AV_PKT_FLAG_KEY;
1822                             break;
1823                         case AVMEDIA_TYPE_VIDEO:
1824                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1825                             if (ret < 0) {
1826                                 fprintf(stderr, "Video encoding failed\n");
1827                                 exit_program(1);
1828                             }
1829                             video_size += ret;
1830                             if(enc->coded_frame && enc->coded_frame->key_frame)
1831                                 pkt.flags |= AV_PKT_FLAG_KEY;
1832                             if (ost->logfile && enc->stats_out) {
1833                                 fprintf(ost->logfile, "%s", enc->stats_out);
1834                             }
1835                             break;
1836                         default:
1837                             ret=-1;
1838                         }
1839
1840                         if(ret<=0)
1841                             break;
1842                         pkt.data= bit_buffer;
1843                         pkt.size= ret;
1844                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1845                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1846                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1847                     }
1848                 }
1849             }
1850         }
1851     }
1852
1853     return 0;
1854 }
1855
1856 static void print_sdp(AVFormatContext **avc, int n)
1857 {
1858     char sdp[2048];
1859
1860     av_sdp_create(avc, n, sdp, sizeof(sdp));
1861     printf("SDP:\n%s\n", sdp);
1862     fflush(stdout);
1863 }
1864
1865 /*
1866  * The following code is the main loop of the file converter
1867  */
1868 static int transcode(AVFormatContext **output_files,
1869                      int nb_output_files,
1870                      InputFile *input_files,
1871                      int nb_input_files)
1872 {
1873     int ret = 0, i, j, k, n, nb_ostreams = 0, step;
1874
1875     AVFormatContext *is, *os;
1876     AVCodecContext *codec, *icodec;
1877     OutputStream *ost, **ost_table = NULL;
1878     InputStream *ist;
1879     char error[1024];
1880     int key;
1881     int want_sdp = 1;
1882     uint8_t no_packet[MAX_FILES]={0};
1883     int no_packet_count=0;
1884     int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1885     int nb_streams[AVMEDIA_TYPE_NB]={0};
1886
1887     if (rate_emu)
1888         for (i = 0; i < nb_input_streams; i++)
1889             input_streams[i].start = av_gettime();
1890
1891     /* output stream init */
1892     nb_ostreams = 0;
1893     for(i=0;i<nb_output_files;i++) {
1894         os = output_files[i];
1895         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1896             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1897             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1898             ret = AVERROR(EINVAL);
1899             goto fail;
1900         }
1901         nb_ostreams += os->nb_streams;
1902     }
1903
1904     ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
1905     if (!ost_table)
1906         goto fail;
1907
1908     for(k=0;k<nb_output_files;k++) {
1909         os = output_files[k];
1910         for(i=0;i<os->nb_streams;i++,n++) {
1911             nb_streams[os->streams[i]->codec->codec_type]++;
1912         }
1913     }
1914     for(step=1<<30; step; step>>=1){
1915         int found_streams[AVMEDIA_TYPE_NB]={0};
1916         for(j=0; j<AVMEDIA_TYPE_NB; j++)
1917             nb_frame_threshold[j] += step;
1918
1919         for(j=0; j<nb_input_streams; j++) {
1920             int skip=0;
1921             ist = &input_streams[j];
1922             if(opt_programid){
1923                 int pi,si;
1924                 AVFormatContext *f= input_files[ ist->file_index ].ctx;
1925                 skip=1;
1926                 for(pi=0; pi<f->nb_programs; pi++){
1927                     AVProgram *p= f->programs[pi];
1928                     if(p->id == opt_programid)
1929                         for(si=0; si<p->nb_stream_indexes; si++){
1930                             if(f->streams[ p->stream_index[si] ] == ist->st)
1931                                 skip=0;
1932                         }
1933                 }
1934             }
1935             if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
1936                 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
1937                 found_streams[ist->st->codec->codec_type]++;
1938             }
1939         }
1940         for(j=0; j<AVMEDIA_TYPE_NB; j++)
1941             if(found_streams[j] < nb_streams[j])
1942                 nb_frame_threshold[j] -= step;
1943     }
1944     n = 0;
1945     for(k=0;k<nb_output_files;k++) {
1946         os = output_files[k];
1947         for (i = 0; i < os->nb_streams; i++, n++)
1948             ost_table[n] = output_streams_for_file[k][i];
1949     }
1950
1951     /* for each output stream, we compute the right encoding parameters */
1952     for(i=0;i<nb_ostreams;i++) {
1953         ost = ost_table[i];
1954         os = output_files[ost->file_index];
1955         ist = &input_streams[ost->source_index];
1956
1957         codec = ost->st->codec;
1958         icodec = ist->st->codec;
1959
1960         ost->st->disposition = ist->st->disposition;
1961         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1962         codec->chroma_sample_location = icodec->chroma_sample_location;
1963
1964         if (ost->st->stream_copy) {
1965             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1966
1967             if (extra_size > INT_MAX)
1968                 goto fail;
1969
1970             /* if stream_copy is selected, no need to decode or encode */
1971             codec->codec_id = icodec->codec_id;
1972             codec->codec_type = icodec->codec_type;
1973
1974             if(!codec->codec_tag){
1975                 if(   !os->oformat->codec_tag
1976                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1977                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1978                     codec->codec_tag = icodec->codec_tag;
1979             }
1980
1981             codec->bit_rate = icodec->bit_rate;
1982             codec->rc_max_rate    = icodec->rc_max_rate;
1983             codec->rc_buffer_size = icodec->rc_buffer_size;
1984             codec->extradata= av_mallocz(extra_size);
1985             if (!codec->extradata)
1986                 goto fail;
1987             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1988             codec->extradata_size= icodec->extradata_size;
1989
1990             codec->time_base = ist->st->time_base;
1991             if(!strcmp(os->oformat->name, "avi")) {
1992                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
1993                     codec->time_base = icodec->time_base;
1994                     codec->time_base.num *= icodec->ticks_per_frame;
1995                     codec->time_base.den *= 2;
1996                 }
1997             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
1998                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
1999                     codec->time_base = icodec->time_base;
2000                     codec->time_base.num *= icodec->ticks_per_frame;
2001                 }
2002             }
2003             av_reduce(&codec->time_base.num, &codec->time_base.den,
2004                         codec->time_base.num, codec->time_base.den, INT_MAX);
2005
2006             switch(codec->codec_type) {
2007             case AVMEDIA_TYPE_AUDIO:
2008                 if(audio_volume != 256) {
2009                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2010                     exit_program(1);
2011                 }
2012                 codec->channel_layout = icodec->channel_layout;
2013                 codec->sample_rate = icodec->sample_rate;
2014                 codec->channels = icodec->channels;
2015                 codec->frame_size = icodec->frame_size;
2016                 codec->audio_service_type = icodec->audio_service_type;
2017                 codec->block_align= icodec->block_align;
2018                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2019                     codec->block_align= 0;
2020                 if(codec->codec_id == CODEC_ID_AC3)
2021                     codec->block_align= 0;
2022                 break;
2023             case AVMEDIA_TYPE_VIDEO:
2024                 codec->pix_fmt = icodec->pix_fmt;
2025                 codec->width = icodec->width;
2026                 codec->height = icodec->height;
2027                 codec->has_b_frames = icodec->has_b_frames;
2028                 if (!codec->sample_aspect_ratio.num) {
2029                     codec->sample_aspect_ratio =
2030                     ost->st->sample_aspect_ratio =
2031                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2032                         ist->st->codec->sample_aspect_ratio.num ?
2033                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2034                 }
2035                 break;
2036             case AVMEDIA_TYPE_SUBTITLE:
2037                 codec->width = icodec->width;
2038                 codec->height = icodec->height;
2039                 break;
2040             case AVMEDIA_TYPE_DATA:
2041                 break;
2042             default:
2043                 abort();
2044             }
2045         } else {
2046             if (!ost->enc)
2047                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2048             switch(codec->codec_type) {
2049             case AVMEDIA_TYPE_AUDIO:
2050                 ost->fifo= av_fifo_alloc(1024);
2051                 if(!ost->fifo)
2052                     goto fail;
2053                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2054                 if (!codec->sample_rate) {
2055                     codec->sample_rate = icodec->sample_rate;
2056                 }
2057                 choose_sample_rate(ost->st, ost->enc);
2058                 codec->time_base = (AVRational){1, codec->sample_rate};
2059                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2060                     codec->sample_fmt = icodec->sample_fmt;
2061                 choose_sample_fmt(ost->st, ost->enc);
2062                 if (!codec->channels) {
2063                     codec->channels = icodec->channels;
2064                     codec->channel_layout = icodec->channel_layout;
2065                 }
2066                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2067                     codec->channel_layout = 0;
2068                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2069                 icodec->request_channels = codec->channels;
2070                 ist->decoding_needed = 1;
2071                 ost->encoding_needed = 1;
2072                 ost->resample_sample_fmt  = icodec->sample_fmt;
2073                 ost->resample_sample_rate = icodec->sample_rate;
2074                 ost->resample_channels    = icodec->channels;
2075                 break;
2076             case AVMEDIA_TYPE_VIDEO:
2077                 if (codec->pix_fmt == PIX_FMT_NONE)
2078                     codec->pix_fmt = icodec->pix_fmt;
2079                 choose_pixel_fmt(ost->st, ost->enc);
2080
2081                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2082                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2083                     exit_program(1);
2084                 }
2085
2086                 if (!codec->width || !codec->height) {
2087                     codec->width  = icodec->width;
2088                     codec->height = icodec->height;
2089                 }
2090
2091                 ost->video_resample = codec->width   != icodec->width  ||
2092                                       codec->height  != icodec->height ||
2093                                       codec->pix_fmt != icodec->pix_fmt;
2094                 if (ost->video_resample) {
2095                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2096                 }
2097
2098                 ost->resample_height = icodec->height;
2099                 ost->resample_width  = icodec->width;
2100                 ost->resample_pix_fmt= icodec->pix_fmt;
2101                 ost->encoding_needed = 1;
2102                 ist->decoding_needed = 1;
2103
2104                 if (!ost->frame_rate.num)
2105                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2106                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2107                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2108                     ost->frame_rate = ost->enc->supported_framerates[idx];
2109                 }
2110                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2111                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2112                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2113                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2114                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2115                 }
2116
2117 #if CONFIG_AVFILTER
2118                 if (configure_video_filters(ist, ost)) {
2119                     fprintf(stderr, "Error opening filters!\n");
2120                     exit(1);
2121                 }
2122 #endif
2123                 break;
2124             case AVMEDIA_TYPE_SUBTITLE:
2125                 ost->encoding_needed = 1;
2126                 ist->decoding_needed = 1;
2127                 break;
2128             default:
2129                 abort();
2130                 break;
2131             }
2132             /* two pass mode */
2133             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2134                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2135                 char logfilename[1024];
2136                 FILE *f;
2137
2138                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2139                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2140                          i);
2141                 if (codec->flags & CODEC_FLAG_PASS1) {
2142                     f = fopen(logfilename, "wb");
2143                     if (!f) {
2144                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2145                         exit_program(1);
2146                     }
2147                     ost->logfile = f;
2148                 } else {
2149                     char  *logbuffer;
2150                     size_t logbuffer_size;
2151                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2152                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2153                         exit_program(1);
2154                     }
2155                     codec->stats_in = logbuffer;
2156                 }
2157             }
2158         }
2159         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2160             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2161             int size= codec->width * codec->height;
2162             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2163         }
2164     }
2165
2166     if (!bit_buffer)
2167         bit_buffer = av_malloc(bit_buffer_size);
2168     if (!bit_buffer) {
2169         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2170                 bit_buffer_size);
2171         ret = AVERROR(ENOMEM);
2172         goto fail;
2173     }
2174
2175     /* open each encoder */
2176     for(i=0;i<nb_ostreams;i++) {
2177         ost = ost_table[i];
2178         if (ost->encoding_needed) {
2179             AVCodec *codec = ost->enc;
2180             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2181             if (!codec) {
2182                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2183                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2184                 ret = AVERROR(EINVAL);
2185                 goto dump_format;
2186             }
2187             if (dec->subtitle_header) {
2188                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2189                 if (!ost->st->codec->subtitle_header) {
2190                     ret = AVERROR(ENOMEM);
2191                     goto dump_format;
2192                 }
2193                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2194                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2195             }
2196             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2197                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2198                         ost->file_index, ost->index);
2199                 ret = AVERROR(EINVAL);
2200                 goto dump_format;
2201             }
2202             assert_codec_experimental(ost->st->codec, 1);
2203             assert_avoptions(ost->opts);
2204             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2205                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2206                                              "It takes bits/s as argument, not kbits/s\n");
2207             extra_size += ost->st->codec->extradata_size;
2208         }
2209     }
2210
2211     /* open each decoder */
2212     for (i = 0; i < nb_input_streams; i++) {
2213         ist = &input_streams[i];
2214         if (ist->decoding_needed) {
2215             AVCodec *codec = ist->dec;
2216             if (!codec)
2217                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2218             if (!codec) {
2219                 snprintf(error, sizeof(error), "Decoder (codec %s) not found for input stream #%d.%d",
2220                         avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2221                 ret = AVERROR(EINVAL);
2222                 goto dump_format;
2223             }
2224             if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2225                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2226                         ist->file_index, ist->st->index);
2227                 ret = AVERROR(EINVAL);
2228                 goto dump_format;
2229             }
2230             assert_codec_experimental(ist->st->codec, 0);
2231             assert_avoptions(ost->opts);
2232         }
2233     }
2234
2235     /* init pts */
2236     for (i = 0; i < nb_input_streams; i++) {
2237         AVStream *st;
2238         ist = &input_streams[i];
2239         st= ist->st;
2240         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2241         ist->next_pts = AV_NOPTS_VALUE;
2242         ist->is_start = 1;
2243     }
2244
2245     /* open files and write file headers */
2246     for(i=0;i<nb_output_files;i++) {
2247         os = output_files[i];
2248         if (avformat_write_header(os, &output_opts[i]) < 0) {
2249             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2250             ret = AVERROR(EINVAL);
2251             goto dump_format;
2252         }
2253 //        assert_avoptions(output_opts[i]);
2254         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2255             want_sdp = 0;
2256         }
2257     }
2258
2259  dump_format:
2260     /* dump the file output parameters - cannot be done before in case
2261        of stream copy */
2262     for(i=0;i<nb_output_files;i++) {
2263         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2264     }
2265
2266     /* dump the stream mapping */
2267     if (verbose >= 0) {
2268         fprintf(stderr, "Stream mapping:\n");
2269         for(i=0;i<nb_ostreams;i++) {
2270             ost = ost_table[i];
2271             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2272                     input_streams[ost->source_index].file_index,
2273                     input_streams[ost->source_index].st->index,
2274                     ost->file_index,
2275                     ost->index);
2276             if (ost->sync_ist != &input_streams[ost->source_index])
2277                 fprintf(stderr, " [sync #%d.%d]",
2278                         ost->sync_ist->file_index,
2279                         ost->sync_ist->st->index);
2280             if(ost->encoding_needed)
2281                 fprintf(stderr, ": %s -> %s",
2282                     input_streams[ost->source_index].dec ?
2283                         input_streams[ost->source_index].dec->name : "?",
2284                     ost->enc ? ost->enc->name : "?");
2285             else
2286                 fprintf(stderr, ": copy");
2287             fprintf(stderr, "\n");
2288         }
2289     }
2290
2291     if (ret) {
2292         fprintf(stderr, "%s\n", error);
2293         goto fail;
2294     }
2295
2296     if (want_sdp) {
2297         print_sdp(output_files, nb_output_files);
2298     }
2299
2300     if (!using_stdin) {
2301         if(verbose >= 0)
2302             fprintf(stderr, "Press [q] to stop, [?] for help\n");
2303         avio_set_interrupt_cb(decode_interrupt_cb);
2304     }
2305     term_init();
2306
2307     timer_start = av_gettime();
2308
2309     for(; received_sigterm == 0;) {
2310         int file_index, ist_index;
2311         AVPacket pkt;
2312         double ipts_min;
2313         double opts_min;
2314
2315     redo:
2316         ipts_min= 1e100;
2317         opts_min= 1e100;
2318         /* if 'q' pressed, exits */
2319         if (!using_stdin) {
2320             if (q_pressed)
2321                 break;
2322             /* read_key() returns 0 on EOF */
2323             key = read_key();
2324             if (key == 'q')
2325                 break;
2326             if (key == '+') verbose++;
2327             if (key == '-') verbose--;
2328             if (key == 's') qp_hist     ^= 1;
2329             if (key == 'h'){
2330                 if (do_hex_dump){
2331                     do_hex_dump = do_pkt_dump = 0;
2332                 } else if(do_pkt_dump){
2333                     do_hex_dump = 1;
2334                 } else
2335                     do_pkt_dump = 1;
2336                 av_log_set_level(AV_LOG_DEBUG);
2337             }
2338             if (key == 'c' || key == 'C'){
2339                 char ret[4096], target[64], cmd[256], arg[256]={0};
2340                 double ts;
2341                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2342                 if(scanf("%4095[^\n\r]%*c", ret) == 1 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2343                     for(i=0;i<nb_ostreams;i++) {
2344                         int r;
2345                         ost = ost_table[i];
2346                         if(ost->graph){
2347                             if(ts<0){
2348                                 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2349                                 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2350                             }else{
2351                                 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2352                             }
2353                         }
2354                     }
2355                 }else{
2356                     fprintf(stderr, "Parse error\n");
2357                 }
2358             }
2359             if (key == 'd' || key == 'D'){
2360                 int debug=0;
2361                 if(key == 'D') {
2362                     debug = input_streams[0].st->codec->debug<<1;
2363                     if(!debug) debug = 1;
2364                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2365                         debug += debug;
2366                 }else
2367                     scanf("%d", &debug);
2368                 for(i=0;i<nb_input_streams;i++) {
2369                     input_streams[i].st->codec->debug = debug;
2370                 }
2371                 for(i=0;i<nb_ostreams;i++) {
2372                     ost = ost_table[i];
2373                     ost->st->codec->debug = debug;
2374                 }
2375                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2376                 fprintf(stderr,"debug=%d\n", debug);
2377             }
2378             if (key == '?'){
2379                 fprintf(stderr, "key    function\n"
2380                                 "?      show this help\n"
2381                                 "+      increase verbosity\n"
2382                                 "-      decrease verbosity\n"
2383                                 "c      Send command to filtergraph\n"
2384                                 "D      cycle through available debug modes\n"
2385                                 "h      dump packets/hex press to cycle through the 3 states\n"
2386                                 "q      quit\n"
2387                                 "s      Show QP histogram\n"
2388                 );
2389             }
2390         }
2391
2392         /* select the stream that we must read now by looking at the
2393            smallest output pts */
2394         file_index = -1;
2395         for(i=0;i<nb_ostreams;i++) {
2396             double ipts, opts;
2397             ost = ost_table[i];
2398             os = output_files[ost->file_index];
2399             ist = &input_streams[ost->source_index];
2400             if(ist->is_past_recording_time || no_packet[ist->file_index])
2401                 continue;
2402                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2403             ipts = (double)ist->pts;
2404             if (!input_files[ist->file_index].eof_reached){
2405                 if(ipts < ipts_min) {
2406                     ipts_min = ipts;
2407                     if(input_sync ) file_index = ist->file_index;
2408                 }
2409                 if(opts < opts_min) {
2410                     opts_min = opts;
2411                     if(!input_sync) file_index = ist->file_index;
2412                 }
2413             }
2414             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2415                 file_index= -1;
2416                 break;
2417             }
2418         }
2419         /* if none, if is finished */
2420         if (file_index < 0) {
2421             if(no_packet_count){
2422                 no_packet_count=0;
2423                 memset(no_packet, 0, sizeof(no_packet));
2424                 usleep(10000);
2425                 continue;
2426             }
2427             break;
2428         }
2429
2430         /* finish if limit size exhausted */
2431         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2432             break;
2433
2434         /* read a frame from it and output it in the fifo */
2435         is = input_files[file_index].ctx;
2436         ret= av_read_frame(is, &pkt);
2437         if(ret == AVERROR(EAGAIN)){
2438             no_packet[file_index]=1;
2439             no_packet_count++;
2440             continue;
2441         }
2442         if (ret < 0) {
2443             input_files[file_index].eof_reached = 1;
2444             if (opt_shortest)
2445                 break;
2446             else
2447                 continue;
2448         }
2449
2450         no_packet_count=0;
2451         memset(no_packet, 0, sizeof(no_packet));
2452
2453         if (do_pkt_dump) {
2454             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2455                              is->streams[pkt.stream_index]);
2456         }
2457         /* the following test is needed in case new streams appear
2458            dynamically in stream : we ignore them */
2459         if (pkt.stream_index >= input_files[file_index].nb_streams)
2460             goto discard_packet;
2461         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2462         ist = &input_streams[ist_index];
2463         if (ist->discard)
2464             goto discard_packet;
2465
2466         if (pkt.dts != AV_NOPTS_VALUE)
2467             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2468         if (pkt.pts != AV_NOPTS_VALUE)
2469             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2470
2471         if (ist->ts_scale) {
2472             if(pkt.pts != AV_NOPTS_VALUE)
2473                 pkt.pts *= ist->ts_scale;
2474             if(pkt.dts != AV_NOPTS_VALUE)
2475                 pkt.dts *= ist->ts_scale;
2476         }
2477
2478 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2479         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2480             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2481             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2482             int64_t delta= pkt_dts - ist->next_pts;
2483             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2484                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2485                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2486                 pkt_dts+1<ist->pts)&& !copy_ts){
2487                 input_files[ist->file_index].ts_offset -= delta;
2488                 if (verbose > 2)
2489                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2490                             delta, input_files[ist->file_index].ts_offset);
2491                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2492                 if(pkt.pts != AV_NOPTS_VALUE)
2493                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2494             }
2495         }
2496
2497         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2498         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2499
2500             if (verbose >= 0)
2501                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2502                         ist->file_index, ist->st->index);
2503             if (exit_on_error)
2504                 exit_program(1);
2505             av_free_packet(&pkt);
2506             goto redo;
2507         }
2508
2509     discard_packet:
2510         av_free_packet(&pkt);
2511
2512         /* dump report by using the output first video and audio streams */
2513         print_report(output_files, ost_table, nb_ostreams, 0);
2514     }
2515
2516     /* at the end of stream, we must flush the decoder buffers */
2517     for (i = 0; i < nb_input_streams; i++) {
2518         ist = &input_streams[i];
2519         if (ist->decoding_needed) {
2520             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2521         }
2522     }
2523
2524     term_exit();
2525
2526     /* write the trailer if needed and close file */
2527     for(i=0;i<nb_output_files;i++) {
2528         os = output_files[i];
2529         av_write_trailer(os);
2530     }
2531
2532     /* dump report by using the first video and audio streams */
2533     print_report(output_files, ost_table, nb_ostreams, 1);
2534
2535     /* close each encoder */
2536     for(i=0;i<nb_ostreams;i++) {
2537         ost = ost_table[i];
2538         if (ost->encoding_needed) {
2539             av_freep(&ost->st->codec->stats_in);
2540             avcodec_close(ost->st->codec);
2541         }
2542 #if CONFIG_AVFILTER
2543         avfilter_graph_free(&ost->graph);
2544 #endif
2545     }
2546
2547     /* close each decoder */
2548     for (i = 0; i < nb_input_streams; i++) {
2549         ist = &input_streams[i];
2550         if (ist->decoding_needed) {
2551             avcodec_close(ist->st->codec);
2552         }
2553     }
2554
2555     /* finished ! */
2556     ret = 0;
2557
2558  fail:
2559     av_freep(&bit_buffer);
2560
2561     if (ost_table) {
2562         for(i=0;i<nb_ostreams;i++) {
2563             ost = ost_table[i];
2564             if (ost) {
2565                 if (ost->st->stream_copy)
2566                     av_freep(&ost->st->codec->extradata);
2567                 if (ost->logfile) {
2568                     fclose(ost->logfile);
2569                     ost->logfile = NULL;
2570                 }
2571                 av_fifo_free(ost->fifo); /* works even if fifo is not
2572                                              initialized but set to zero */
2573                 av_freep(&ost->st->codec->subtitle_header);
2574                 av_free(ost->resample_frame.data[0]);
2575                 av_free(ost->forced_kf_pts);
2576                 if (ost->video_resample)
2577                     sws_freeContext(ost->img_resample_ctx);
2578                 if (ost->resample)
2579                     audio_resample_close(ost->resample);
2580                 if (ost->reformat_ctx)
2581                     av_audio_convert_free(ost->reformat_ctx);
2582                 av_dict_free(&ost->opts);
2583                 av_free(ost);
2584             }
2585         }
2586         av_free(ost_table);
2587     }
2588     return ret;
2589 }
2590
2591 static int opt_format(const char *opt, const char *arg)
2592 {
2593     last_asked_format = arg;
2594     return 0;
2595 }
2596
2597 static int opt_video_rc_override_string(const char *opt, const char *arg)
2598 {
2599     video_rc_override_string = arg;
2600     return 0;
2601 }
2602
2603 static int opt_me_threshold(const char *opt, const char *arg)
2604 {
2605     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2606     return 0;
2607 }
2608
2609 static int opt_verbose(const char *opt, const char *arg)
2610 {
2611     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2612     return 0;
2613 }
2614
2615 static int opt_frame_rate(const char *opt, const char *arg)
2616 {
2617     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2618         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2619         exit_program(1);
2620     }
2621     return 0;
2622 }
2623
2624 static int opt_frame_crop(const char *opt, const char *arg)
2625 {
2626     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2627     return AVERROR(EINVAL);
2628 }
2629
2630 static int opt_frame_size(const char *opt, const char *arg)
2631 {
2632     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2633         fprintf(stderr, "Incorrect frame size\n");
2634         return AVERROR(EINVAL);
2635     }
2636     return 0;
2637 }
2638
2639 static int opt_pad(const char *opt, const char *arg) {
2640     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2641     return -1;
2642 }
2643
2644 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2645 {
2646     if (strcmp(arg, "list")) {
2647         frame_pix_fmt = av_get_pix_fmt(arg);
2648         if (frame_pix_fmt == PIX_FMT_NONE) {
2649             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2650             return AVERROR(EINVAL);
2651         }
2652     } else {
2653         opt_pix_fmts(NULL, NULL);
2654         exit_program(0);
2655     }
2656     return 0;
2657 }
2658
2659 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2660 {
2661     int x = 0, y = 0;
2662     double ar = 0;
2663     const char *p;
2664     char *end;
2665
2666     p = strchr(arg, ':');
2667     if (p) {
2668         x = strtol(arg, &end, 10);
2669         if (end == p)
2670             y = strtol(end+1, &end, 10);
2671         if (x > 0 && y > 0)
2672             ar = (double)x / (double)y;
2673     } else
2674         ar = strtod(arg, NULL);
2675
2676     if (!ar) {
2677         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2678         return AVERROR(EINVAL);
2679     }
2680     frame_aspect_ratio = ar;
2681     return 0;
2682 }
2683
2684 static int opt_metadata(const char *opt, const char *arg)
2685 {
2686     char *mid= strchr(arg, '=');
2687
2688     if(!mid){
2689         fprintf(stderr, "Missing =\n");
2690         exit_program(1);
2691     }
2692     *mid++= 0;
2693
2694     av_dict_set(&metadata, arg, mid, 0);
2695
2696     return 0;
2697 }
2698
2699 static int opt_qscale(const char *opt, const char *arg)
2700 {
2701     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2702     if (video_qscale <= 0 || video_qscale > 255) {
2703         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2704         return AVERROR(EINVAL);
2705     }
2706     return 0;
2707 }
2708
2709 static int opt_top_field_first(const char *opt, const char *arg)
2710 {
2711     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2712     return opt_default(opt, arg);
2713 }
2714
2715 static int opt_thread_count(const char *opt, const char *arg)
2716 {
2717     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2718 #if !HAVE_THREADS
2719     if (verbose >= 0)
2720         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2721 #endif
2722     return 0;
2723 }
2724
2725 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2726 {
2727     if (strcmp(arg, "list")) {
2728         audio_sample_fmt = av_get_sample_fmt(arg);
2729         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2730             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2731             return AVERROR(EINVAL);
2732         }
2733     } else {
2734         int i;
2735         char fmt_str[128];
2736         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2737             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2738         exit_program(0);
2739     }
2740     return 0;
2741 }
2742
2743 static int opt_audio_rate(const char *opt, const char *arg)
2744 {
2745     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2746     return 0;
2747 }
2748
2749 static int opt_audio_channels(const char *opt, const char *arg)
2750 {
2751     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2752     return 0;
2753 }
2754
2755 static int opt_video_channel(const char *opt, const char *arg)
2756 {
2757     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2758     return opt_default("channel", arg);
2759 }
2760
2761 static int opt_video_standard(const char *opt, const char *arg)
2762 {
2763     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2764     return opt_default("standard", arg);
2765 }
2766
2767 static int opt_codec(const char *opt, const char *arg)
2768 {
2769     return av_dict_set(&codec_names, opt, arg, 0);
2770 }
2771
2772 static int opt_audio_codec(const char *opt, const char *arg)
2773 {
2774     return opt_codec("codec:a", arg);
2775 }
2776
2777 static int opt_video_codec(const char *opt, const char *arg)
2778 {
2779     return opt_codec("codec:v", arg);
2780 }
2781
2782 static int opt_subtitle_codec(const char *opt, const char *arg)
2783 {
2784     return opt_codec("codec:s", arg);
2785 }
2786
2787 static int opt_data_codec(const char *opt, const char *arg)
2788 {
2789     return opt_codec("codec:d", arg);
2790 }
2791
2792 static int opt_codec_tag(const char *opt, const char *arg)
2793 {
2794     char *tail;
2795     uint32_t *codec_tag;
2796
2797     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2798                 !strcmp(opt, "vtag") ? &video_codec_tag :
2799                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2800     if (!codec_tag)
2801         return -1;
2802
2803     *codec_tag = strtol(arg, &tail, 0);
2804     if (!tail || *tail)
2805         *codec_tag = AV_RL32(arg);
2806
2807     return 0;
2808 }
2809
2810 static int opt_map(const char *opt, const char *arg)
2811 {
2812     StreamMap *m = NULL;
2813     int i, negative = 0, file_idx;
2814     int sync_file_idx = -1, sync_stream_idx;
2815     char *p, *sync;
2816     char *map;
2817
2818     if (*arg == '-') {
2819         negative = 1;
2820         arg++;
2821     }
2822     map = av_strdup(arg);
2823
2824     /* parse sync stream first, just pick first matching stream */
2825     if (sync = strchr(map, ',')) {
2826         *sync = 0;
2827         sync_file_idx = strtol(sync + 1, &sync, 0);
2828         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2829             av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2830             exit_program(1);
2831         }
2832         if (*sync)
2833             sync++;
2834         for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2835             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2836                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2837                 sync_stream_idx = i;
2838                 break;
2839             }
2840         if (i == input_files[sync_file_idx].ctx->nb_streams) {
2841             av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2842                                        "match any streams.\n", arg);
2843             exit_program(1);
2844         }
2845     }
2846
2847
2848     file_idx = strtol(map, &p, 0);
2849     if (file_idx >= nb_input_files || file_idx < 0) {
2850         av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2851         exit_program(1);
2852     }
2853     if (negative)
2854         /* disable some already defined maps */
2855         for (i = 0; i < nb_stream_maps; i++) {
2856             m = &stream_maps[i];
2857             if (check_stream_specifier(input_files[m->file_index].ctx,
2858                                        input_files[m->file_index].ctx->streams[m->stream_index],
2859                                        *p == ':' ? p + 1 : p) > 0)
2860                 m->disabled = 1;
2861         }
2862     else
2863         for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2864             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2865                         *p == ':' ? p + 1 : p) <= 0)
2866                 continue;
2867             stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2868             m = &stream_maps[nb_stream_maps - 1];
2869
2870             m->file_index   = file_idx;
2871             m->stream_index = i;
2872
2873             if (sync_file_idx >= 0) {
2874                 m->sync_file_index   = sync_file_idx;
2875                 m->sync_stream_index = sync_stream_idx;
2876             } else {
2877                 m->sync_file_index   = file_idx;
2878                 m->sync_stream_index = i;
2879             }
2880         }
2881
2882     if (!m) {
2883         av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2884         exit_program(1);
2885     }
2886
2887     av_freep(&map);
2888     return 0;
2889 }
2890
2891 static void parse_meta_type(char *arg, char *type, int *index)
2892 {
2893     if (*arg == ':') {
2894         *type = *(++arg);
2895         switch (*arg) {
2896         case 'g':
2897             break;
2898         case 's':
2899         case 'c':
2900         case 'p':
2901             if (*(++arg) == ':')
2902                 *index = strtol(++arg, NULL, 0);
2903             break;
2904         default:
2905             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2906             exit_program(1);
2907         }
2908     } else
2909         *type = 'g';
2910 }
2911
2912 static int opt_map_metadata(const char *opt, const char *arg)
2913 {
2914     MetadataMap *m, *m1;
2915     char *p;
2916
2917     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2918                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2919
2920     m = &meta_data_maps[nb_meta_data_maps - 1][1];
2921     m->file = strtol(arg, &p, 0);
2922     parse_meta_type(p, &m->type, &m->index);
2923
2924     m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2925     if (p = strchr(opt, ':'))
2926         parse_meta_type(p, &m1->type, &m1->index);
2927     else
2928         m1->type = 'g';
2929
2930     if (m->type == 'g' || m1->type == 'g')
2931         metadata_global_autocopy = 0;
2932     if (m->type == 's' || m1->type == 's')
2933         metadata_streams_autocopy = 0;
2934     if (m->type == 'c' || m1->type == 'c')
2935         metadata_chapters_autocopy = 0;
2936
2937     return 0;
2938 }
2939
2940 static int opt_map_meta_data(const char *opt, const char *arg)
2941 {
2942     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2943                     "Use -map_metadata instead.\n");
2944     return opt_map_metadata(opt, arg);
2945 }
2946
2947 static int opt_input_ts_scale(const char *opt, const char *arg)
2948 {
2949     unsigned int stream;
2950     double scale;
2951     char *p;
2952
2953     stream = strtol(arg, &p, 0);
2954     if (*p)
2955         p++;
2956     scale= strtod(p, &p);
2957
2958     if(stream >= MAX_STREAMS)
2959         exit_program(1);
2960
2961     ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
2962     ts_scale[stream] = scale;
2963     return 0;
2964 }
2965
2966 static int opt_recording_time(const char *opt, const char *arg)
2967 {
2968     recording_time = parse_time_or_die(opt, arg, 1);
2969     return 0;
2970 }
2971
2972 static int opt_start_time(const char *opt, const char *arg)
2973 {
2974     start_time = parse_time_or_die(opt, arg, 1);
2975     return 0;
2976 }
2977
2978 static int opt_recording_timestamp(const char *opt, const char *arg)
2979 {
2980     char buf[128];
2981     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2982     struct tm time = *gmtime((time_t*)&recording_timestamp);
2983     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2984     opt_metadata("metadata", buf);
2985
2986     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2987                                  "tag instead.\n", opt);
2988     return 0;
2989 }
2990
2991 static int opt_input_ts_offset(const char *opt, const char *arg)
2992 {
2993     input_ts_offset = parse_time_or_die(opt, arg, 1);
2994     return 0;
2995 }
2996
2997 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2998 {
2999     const char *codec_string = encoder ? "encoder" : "decoder";
3000     AVCodec *codec;
3001
3002     if(!name)
3003         return CODEC_ID_NONE;
3004     codec = encoder ?
3005         avcodec_find_encoder_by_name(name) :
3006         avcodec_find_decoder_by_name(name);
3007     if(!codec) {
3008         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
3009         exit_program(1);
3010     }
3011     if(codec->type != type) {
3012         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
3013         exit_program(1);
3014     }
3015     return codec->id;
3016 }
3017
3018 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
3019 {
3020     AVDictionaryEntry *e = NULL;
3021     char *codec_name = NULL;
3022     int ret;
3023
3024     while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
3025         char *p = strchr(e->key, ':');
3026
3027         if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
3028             codec_name = e->value;
3029         else if (ret < 0)
3030             exit_program(1);
3031     }
3032
3033     if (!codec_name) {
3034         if (s->oformat) {
3035             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
3036             return avcodec_find_encoder(st->codec->codec_id);
3037         }
3038     } else if (!strcmp(codec_name, "copy"))
3039         st->stream_copy = 1;
3040     else {
3041         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
3042         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
3043                             avcodec_find_decoder_by_name(codec_name);
3044     }
3045
3046     return NULL;
3047 }
3048
3049 static int opt_input_file(const char *opt, const char *filename)
3050 {
3051     AVFormatContext *ic;
3052     AVInputFormat *file_iformat = NULL;
3053     int err, i, ret, rfps, rfps_base;
3054     int64_t timestamp;
3055     uint8_t buf[128];
3056     AVDictionary **opts;
3057     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3058
3059     if (last_asked_format) {
3060         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3061             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3062             exit_program(1);
3063         }
3064         last_asked_format = NULL;
3065     }
3066
3067     if (!strcmp(filename, "-"))
3068         filename = "pipe:";
3069
3070     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3071                     !strcmp(filename, "/dev/stdin");
3072
3073     /* get default parameters from command line */
3074     ic = avformat_alloc_context();
3075     if (!ic) {
3076         print_error(filename, AVERROR(ENOMEM));
3077         exit_program(1);
3078     }
3079     if (audio_sample_rate) {
3080         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3081         av_dict_set(&format_opts, "sample_rate", buf, 0);
3082     }
3083     if (audio_channels) {
3084         snprintf(buf, sizeof(buf), "%d", audio_channels);
3085         av_dict_set(&format_opts, "channels", buf, 0);
3086     }
3087     if (frame_rate.num) {
3088         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3089         av_dict_set(&format_opts, "framerate", buf, 0);
3090     }
3091     if (frame_width && frame_height) {
3092         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3093         av_dict_set(&format_opts, "video_size", buf, 0);
3094     }
3095     if (frame_pix_fmt != PIX_FMT_NONE)
3096         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3097
3098     ic->flags |= AVFMT_FLAG_NONBLOCK;
3099
3100     if (loop_input) {
3101         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3102         ic->loop_input = loop_input;
3103     }
3104
3105     /* open the input file with generic libav function */
3106     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3107     if (err < 0) {
3108         print_error(filename, err);
3109         exit_program(1);
3110     }
3111     assert_avoptions(format_opts);
3112
3113     if(opt_programid) {
3114         int i, j;
3115         int found=0;
3116         for(i=0; i<ic->nb_streams; i++){
3117             ic->streams[i]->discard= AVDISCARD_ALL;
3118         }
3119         for(i=0; i<ic->nb_programs; i++){
3120             AVProgram *p= ic->programs[i];
3121             if(p->id != opt_programid){
3122                 p->discard = AVDISCARD_ALL;
3123             }else{
3124                 found=1;
3125                 for(j=0; j<p->nb_stream_indexes; j++){
3126                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3127                 }
3128             }
3129         }
3130         if(!found){
3131             fprintf(stderr, "Specified program id not found\n");
3132             exit_program(1);
3133         }
3134         opt_programid=0;
3135     }
3136
3137     /* apply forced codec ids */
3138     for (i = 0; i < ic->nb_streams; i++)
3139         choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3140
3141     /* Set AVCodecContext options for avformat_find_stream_info */
3142     opts = setup_find_stream_info_opts(ic, codec_opts);
3143     orig_nb_streams = ic->nb_streams;
3144
3145     /* If not enough info to get the stream parameters, we decode the
3146        first frames to get it. (used in mpeg case for example) */
3147     ret = avformat_find_stream_info(ic, opts);
3148     if (ret < 0 && verbose >= 0) {
3149         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3150         av_close_input_file(ic);
3151         exit_program(1);
3152     }
3153
3154     timestamp = start_time;
3155     /* add the stream start time */
3156     if (ic->start_time != AV_NOPTS_VALUE)
3157         timestamp += ic->start_time;
3158
3159     /* if seeking requested, we execute it */
3160     if (start_time != 0) {
3161         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3162         if (ret < 0) {
3163             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3164                     filename, (double)timestamp / AV_TIME_BASE);
3165         }
3166         /* reset seek info */
3167         start_time = 0;
3168     }
3169
3170     /* update the current parameters so that they match the one of the input stream */
3171     for(i=0;i<ic->nb_streams;i++) {
3172         AVStream *st = ic->streams[i];
3173         AVCodecContext *dec = st->codec;
3174         InputStream *ist;
3175
3176         dec->thread_count = thread_count;
3177
3178         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3179         ist = &input_streams[nb_input_streams - 1];
3180         ist->st = st;
3181         ist->file_index = nb_input_files;
3182         ist->discard = 1;
3183         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3184
3185         if (i < nb_ts_scale)
3186             ist->ts_scale = ts_scale[i];
3187
3188         ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
3189
3190         switch (dec->codec_type) {
3191         case AVMEDIA_TYPE_AUDIO:
3192             if(!ist->dec)
3193                 ist->dec = avcodec_find_decoder(dec->codec_id);
3194             if(audio_disable)
3195                 st->discard= AVDISCARD_ALL;
3196             break;
3197         case AVMEDIA_TYPE_VIDEO:
3198             if(!ist->dec)
3199                 ist->dec = avcodec_find_decoder(dec->codec_id);
3200             rfps      = ic->streams[i]->r_frame_rate.num;
3201             rfps_base = ic->streams[i]->r_frame_rate.den;
3202             if (dec->lowres) {
3203                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3204             }
3205             if(me_threshold)
3206                 dec->debug |= FF_DEBUG_MV;
3207
3208             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3209
3210                 if (verbose >= 0)
3211                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3212                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3213
3214                     (float)rfps / rfps_base, rfps, rfps_base);
3215             }
3216
3217             if(video_disable)
3218                 st->discard= AVDISCARD_ALL;
3219             else if(video_discard)
3220                 st->discard= video_discard;
3221             break;
3222         case AVMEDIA_TYPE_DATA:
3223             break;
3224         case AVMEDIA_TYPE_SUBTITLE:
3225             if(!ist->dec)
3226                 ist->dec = avcodec_find_decoder(dec->codec_id);
3227             if(subtitle_disable)
3228                 st->discard = AVDISCARD_ALL;
3229             break;
3230         case AVMEDIA_TYPE_ATTACHMENT:
3231         case AVMEDIA_TYPE_UNKNOWN:
3232             break;
3233         default:
3234             abort();
3235         }
3236     }
3237
3238     /* dump the file content */
3239     if (verbose >= 0)
3240         av_dump_format(ic, nb_input_files, filename, 0);
3241
3242     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3243     input_files[nb_input_files - 1].ctx        = ic;
3244     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3245     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3246     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3247
3248     top_field_first = -1;
3249     frame_rate    = (AVRational){0, 0};
3250     frame_pix_fmt = PIX_FMT_NONE;
3251     frame_height = 0;
3252     frame_width  = 0;
3253     audio_sample_rate = 0;
3254     audio_channels    = 0;
3255     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3256     av_freep(&ts_scale);
3257     nb_ts_scale = 0;
3258
3259     for (i = 0; i < orig_nb_streams; i++)
3260         av_dict_free(&opts[i]);
3261     av_freep(&opts);
3262     av_dict_free(&codec_names);
3263     uninit_opts();
3264     init_opts();
3265     return 0;
3266 }
3267
3268 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3269                                     AVCodecContext *avctx)
3270 {
3271     char *p;
3272     int n = 1, i;
3273     int64_t t;
3274
3275     for (p = kf; *p; p++)
3276         if (*p == ',')
3277             n++;
3278     ost->forced_kf_count = n;
3279     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3280     if (!ost->forced_kf_pts) {
3281         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3282         exit_program(1);
3283     }
3284     for (i = 0; i < n; i++) {
3285         p = i ? strchr(p, ',') + 1 : kf;
3286         t = parse_time_or_die("force_key_frames", p, 1);
3287         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3288     }
3289 }
3290
3291 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3292 {
3293     OutputStream *ost;
3294     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3295     int idx      = oc->nb_streams - 1;
3296
3297     if (!st) {
3298         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3299         exit_program(1);
3300     }
3301
3302     output_streams_for_file[nb_output_files] =
3303         grow_array(output_streams_for_file[nb_output_files],
3304                    sizeof(*output_streams_for_file[nb_output_files]),
3305                    &nb_output_streams_for_file[nb_output_files],
3306                    oc->nb_streams);
3307     ost = output_streams_for_file[nb_output_files][idx] =
3308         av_mallocz(sizeof(OutputStream));
3309     if (!ost) {
3310         fprintf(stderr, "Could not alloc output stream\n");
3311         exit_program(1);
3312     }
3313     ost->file_index = nb_output_files;
3314     ost->index = idx;
3315     ost->st    = st;
3316     st->codec->codec_type = type;
3317     ost->enc = choose_codec(oc, st, type, codec_names);
3318     if (ost->enc) {
3319         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3320     }
3321
3322     avcodec_get_context_defaults3(st->codec, ost->enc);
3323     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3324
3325     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3326     return ost;
3327 }
3328
3329 static OutputStream *new_video_stream(AVFormatContext *oc)
3330 {
3331     AVStream *st;
3332     OutputStream *ost;
3333     AVCodecContext *video_enc;
3334
3335     ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3336     st  = ost->st;
3337     if (!st->stream_copy) {
3338         ost->frame_aspect_ratio = frame_aspect_ratio;
3339         frame_aspect_ratio = 0;
3340 #if CONFIG_AVFILTER
3341         ost->avfilter = vfilters;
3342         vfilters = NULL;
3343 #endif
3344     }
3345
3346     ost->bitstream_filters = video_bitstream_filters;
3347     video_bitstream_filters= NULL;
3348
3349     st->codec->thread_count= thread_count;
3350
3351     video_enc = st->codec;
3352
3353     if(video_codec_tag)
3354         video_enc->codec_tag= video_codec_tag;
3355
3356     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3357         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3358     }
3359
3360     if (st->stream_copy) {
3361         video_enc->sample_aspect_ratio =
3362         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3363     } else {
3364         const char *p;
3365         int i;
3366
3367         if (frame_rate.num)
3368             ost->frame_rate = frame_rate;
3369
3370         video_enc->width = frame_width;
3371         video_enc->height = frame_height;
3372         video_enc->pix_fmt = frame_pix_fmt;
3373         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3374         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3375
3376         if (intra_only)
3377             video_enc->gop_size = 0;
3378         if (video_qscale || same_quant) {
3379             video_enc->flags |= CODEC_FLAG_QSCALE;
3380             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3381         }
3382
3383         if(intra_matrix)
3384             video_enc->intra_matrix = intra_matrix;
3385         if(inter_matrix)
3386             video_enc->inter_matrix = inter_matrix;
3387
3388         p= video_rc_override_string;
3389         for(i=0; p; i++){
3390             int start, end, q;
3391             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3392             if(e!=3){
3393                 fprintf(stderr, "error parsing rc_override\n");
3394                 exit_program(1);
3395             }
3396             video_enc->rc_override=
3397                 av_realloc(video_enc->rc_override,
3398                            sizeof(RcOverride)*(i+1));
3399             video_enc->rc_override[i].start_frame= start;
3400             video_enc->rc_override[i].end_frame  = end;
3401             if(q>0){
3402                 video_enc->rc_override[i].qscale= q;
3403                 video_enc->rc_override[i].quality_factor= 1.0;
3404             }
3405             else{
3406                 video_enc->rc_override[i].qscale= 0;
3407                 video_enc->rc_override[i].quality_factor= -q/100.0;
3408             }
3409             p= strchr(p, '/');
3410             if(p) p++;
3411         }
3412         video_enc->rc_override_count=i;
3413         if (!video_enc->rc_initial_buffer_occupancy)
3414             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3415         video_enc->me_threshold= me_threshold;
3416         video_enc->intra_dc_precision= intra_dc_precision - 8;
3417
3418         if (do_psnr)
3419             video_enc->flags|= CODEC_FLAG_PSNR;
3420
3421         /* two pass mode */
3422         if (do_pass) {
3423             if (do_pass == 1) {
3424                 video_enc->flags |= CODEC_FLAG_PASS1;
3425             } else {
3426                 video_enc->flags |= CODEC_FLAG_PASS2;
3427             }
3428         }
3429
3430         if (forced_key_frames)
3431             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3432     }
3433     if (video_language) {
3434         av_dict_set(&st->metadata, "language", video_language, 0);
3435         av_freep(&video_language);
3436     }
3437
3438     /* reset some key parameters */
3439     video_disable = 0;
3440     av_freep(&forced_key_frames);
3441     frame_pix_fmt = PIX_FMT_NONE;
3442     return ost;
3443 }
3444
3445 static OutputStream *new_audio_stream(AVFormatContext *oc)
3446 {
3447     AVStream *st;
3448     OutputStream *ost;
3449     AVCodecContext *audio_enc;
3450
3451     ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3452     st  = ost->st;
3453
3454     ost->bitstream_filters = audio_bitstream_filters;
3455     audio_bitstream_filters= NULL;
3456
3457     st->codec->thread_count= thread_count;
3458
3459     audio_enc = st->codec;
3460     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3461
3462     if(audio_codec_tag)
3463         audio_enc->codec_tag= audio_codec_tag;
3464
3465     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3466         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3467     }
3468     if (!st->stream_copy) {
3469         if (audio_qscale > QSCALE_NONE) {
3470             audio_enc->flags |= CODEC_FLAG_QSCALE;
3471             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3472         }
3473         if (audio_channels)
3474             audio_enc->channels = audio_channels;
3475         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3476             audio_enc->sample_fmt = audio_sample_fmt;
3477         if (audio_sample_rate)
3478             audio_enc->sample_rate = audio_sample_rate;
3479     }
3480     if (audio_language) {
3481         av_dict_set(&st->metadata, "language", audio_language, 0);
3482         av_freep(&audio_language);
3483     }
3484
3485     /* reset some key parameters */
3486     audio_disable = 0;
3487
3488     return ost;
3489 }
3490
3491 static OutputStream *new_data_stream(AVFormatContext *oc)
3492 {
3493     AVStream *st;
3494     OutputStream *ost;
3495     AVCodecContext *data_enc;
3496
3497     ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3498     st  = ost->st;
3499     data_enc = st->codec;
3500     if (!st->stream_copy) {
3501         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3502         exit_program(1);
3503     }
3504
3505     if (data_codec_tag)
3506         data_enc->codec_tag= data_codec_tag;
3507
3508     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3509         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3510     }
3511
3512     data_disable = 0;
3513     return ost;
3514 }
3515
3516 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3517 {
3518     AVStream *st;
3519     OutputStream *ost;
3520     AVCodecContext *subtitle_enc;
3521
3522     ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3523     st  = ost->st;
3524     subtitle_enc = st->codec;
3525
3526     ost->bitstream_filters = subtitle_bitstream_filters;
3527     subtitle_bitstream_filters= NULL;
3528
3529     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3530
3531     if(subtitle_codec_tag)
3532         subtitle_enc->codec_tag= subtitle_codec_tag;
3533
3534     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3535         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3536     }
3537
3538     if (subtitle_language) {
3539         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3540         av_freep(&subtitle_language);
3541     }
3542
3543     subtitle_disable = 0;
3544     return ost;
3545 }
3546
3547 /* arg format is "output-stream-index:streamid-value". */
3548 static int opt_streamid(const char *opt, const char *arg)
3549 {
3550     int idx;
3551     char *p;
3552     char idx_str[16];
3553
3554     av_strlcpy(idx_str, arg, sizeof(idx_str));
3555     p = strchr(idx_str, ':');
3556     if (!p) {
3557         fprintf(stderr,
3558                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3559                 arg, opt);
3560         exit_program(1);
3561     }
3562     *p++ = '\0';
3563     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3564     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3565     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3566     return 0;
3567 }
3568 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
3569 {
3570     int i, err;
3571     AVFormatContext *ic = NULL;
3572
3573     err = avformat_open_input(&ic, filename, NULL, NULL);
3574     if (err < 0)
3575         return err;
3576     /* copy stream format */
3577     for(i=0;i<ic->nb_streams;i++) {
3578         AVStream *st;
3579         OutputStream *ost;
3580         AVCodec *codec;
3581
3582         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3583         ost   = new_output_stream(s, codec->type);
3584         st    = ost->st;
3585
3586         // FIXME: a more elegant solution is needed
3587         memcpy(st, ic->streams[i], sizeof(AVStream));
3588         st->info = av_malloc(sizeof(*st->info));
3589         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3590         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3591
3592         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3593             choose_sample_fmt(st, codec);
3594         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3595             choose_pixel_fmt(st, codec);
3596     }
3597
3598     av_close_input_file(ic);
3599     return 0;
3600 }
3601
3602
3603 static int copy_chapters(int infile, int outfile)
3604 {
3605     AVFormatContext *is = input_files[infile].ctx;
3606     AVFormatContext *os = output_files[outfile];
3607     int i;
3608
3609     for (i = 0; i < is->nb_chapters; i++) {
3610         AVChapter *in_ch = is->chapters[i], *out_ch;
3611         int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,
3612                                       AV_TIME_BASE_Q, in_ch->time_base);
3613         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
3614                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3615
3616
3617         if (in_ch->end < ts_off)
3618             continue;
3619         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3620             break;
3621
3622         out_ch = av_mallocz(sizeof(AVChapter));
3623         if (!out_ch)
3624             return AVERROR(ENOMEM);
3625
3626         out_ch->id        = in_ch->id;
3627         out_ch->time_base = in_ch->time_base;
3628         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3629         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3630
3631         if (metadata_chapters_autocopy)
3632             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3633
3634         os->nb_chapters++;
3635         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3636         if (!os->chapters)
3637             return AVERROR(ENOMEM);
3638         os->chapters[os->nb_chapters - 1] = out_ch;
3639     }
3640     return 0;
3641 }
3642
3643 static int opt_output_file(const char *opt, const char *filename)
3644 {
3645     AVFormatContext *oc;
3646     int i, err;
3647     AVOutputFormat *file_oformat;
3648     OutputStream *ost;
3649     InputStream  *ist;
3650
3651     if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3652         fprintf(stderr, "Too many output files\n");
3653         exit_program(1);
3654     }
3655
3656     if (!strcmp(filename, "-"))
3657         filename = "pipe:";
3658
3659     err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3660     last_asked_format = NULL;
3661     if (!oc) {
3662         print_error(filename, err);
3663         exit_program(1);
3664     }
3665     file_oformat= oc->oformat;
3666
3667     if (!strcmp(file_oformat->name, "ffm") &&
3668         av_strstart(filename, "http:", NULL)) {
3669         /* special case for files sent to ffserver: we get the stream
3670            parameters from ffserver */
3671         int err = read_ffserver_streams(oc, filename);
3672         if (err < 0) {
3673             print_error(filename, err);
3674             exit_program(1);
3675         }
3676     } else if (!nb_stream_maps) {
3677         /* pick the "best" stream of each type */
3678 #define NEW_STREAM(type, index)\
3679         if (index >= 0) {\
3680             ost = new_ ## type ## _stream(oc);\
3681             ost->source_index = index;\
3682             ost->sync_ist     = &input_streams[index];\
3683             input_streams[index].discard = 0;\
3684         }
3685
3686         /* video: highest resolution */
3687         if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3688             int area = 0, idx = -1;
3689             for (i = 0; i < nb_input_streams; i++) {
3690                 ist = &input_streams[i];
3691                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3692                     ist->st->codec->width * ist->st->codec->height > area) {
3693                     area = ist->st->codec->width * ist->st->codec->height;
3694                     idx = i;
3695                 }
3696             }
3697             NEW_STREAM(video, idx);
3698         }
3699
3700         /* audio: most channels */
3701         if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3702             int channels = 0, idx = -1;
3703             for (i = 0; i < nb_input_streams; i++) {
3704                 ist = &input_streams[i];
3705                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3706                     ist->st->codec->channels > channels) {
3707                     channels = ist->st->codec->channels;
3708                     idx = i;
3709                 }
3710             }
3711             NEW_STREAM(audio, idx);
3712         }
3713
3714         /* subtitles: pick first */
3715         if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3716             for (i = 0; i < nb_input_streams; i++)
3717                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3718                     NEW_STREAM(subtitle, i);
3719                     break;
3720                 }
3721         }
3722         /* do something with data? */
3723     } else {
3724         for (i = 0; i < nb_stream_maps; i++) {
3725             StreamMap *map = &stream_maps[i];
3726
3727             if (map->disabled)
3728                 continue;
3729
3730             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3731             switch (ist->st->codec->codec_type) {
3732             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(oc);    break;
3733             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(oc);    break;
3734             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3735             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(oc);     break;
3736             default:
3737                 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3738                        map->file_index, map->stream_index);
3739                 exit_program(1);
3740             }
3741
3742             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3743             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3744                                            map->sync_stream_index];
3745             ist->discard = 0;
3746         }
3747     }
3748
3749     av_dict_copy(&oc->metadata, metadata, 0);
3750     av_dict_free(&metadata);
3751
3752     av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3753     output_files[nb_output_files++] = oc;
3754
3755     /* check filename in case of an image number is expected */
3756     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3757         if (!av_filename_number_test(oc->filename)) {
3758             print_error(oc->filename, AVERROR(EINVAL));
3759             exit_program(1);
3760         }
3761     }
3762
3763     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3764         /* test if it already exists to avoid loosing precious files */
3765         if (!file_overwrite &&
3766             (strchr(filename, ':') == NULL ||
3767              filename[1] == ':' ||
3768              av_strstart(filename, "file:", NULL))) {
3769             if (avio_check(filename, 0) == 0) {
3770                 if (!using_stdin) {
3771                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3772                     fflush(stderr);
3773                     if (!read_yesno()) {
3774                         fprintf(stderr, "Not overwriting - exiting\n");
3775                         exit_program(1);
3776                     }
3777                 }
3778                 else {
3779                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3780                     exit_program(1);
3781                 }
3782             }
3783         }
3784
3785         /* open the file */
3786         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3787             print_error(filename, err);
3788             exit_program(1);
3789         }
3790     }
3791
3792     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3793     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3794
3795     if (loop_output >= 0) {
3796         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3797         oc->loop_output = loop_output;
3798     }
3799
3800     /* copy chapters */
3801     if (chapters_input_file >= nb_input_files) {
3802         if (chapters_input_file == INT_MAX) {
3803             /* copy chapters from the first input file that has them*/
3804             chapters_input_file = -1;
3805             for (i = 0; i < nb_input_files; i++)
3806                 if (input_files[i].ctx->nb_chapters) {
3807                     chapters_input_file = i;
3808                     break;
3809                 }
3810         } else {
3811             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3812                    chapters_input_file);
3813             exit_program(1);
3814         }
3815     }
3816     if (chapters_input_file >= 0)
3817         copy_chapters(chapters_input_file, nb_output_files - 1);
3818
3819     /* copy metadata */
3820     for (i = 0; i < nb_meta_data_maps; i++) {
3821         AVFormatContext *files[2];
3822         AVDictionary    **meta[2];
3823         int j;
3824
3825 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3826         if ((index) < 0 || (index) >= (nb_elems)) {\
3827             av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3828                      (desc), (index));\
3829             exit_program(1);\
3830         }
3831
3832         int in_file_index = meta_data_maps[i][1].file;
3833         if (in_file_index < 0)
3834             continue;
3835         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3836
3837         files[0] = oc;
3838         files[1] = input_files[in_file_index].ctx;
3839
3840         for (j = 0; j < 2; j++) {
3841             MetadataMap *map = &meta_data_maps[i][j];
3842
3843             switch (map->type) {
3844             case 'g':
3845                 meta[j] = &files[j]->metadata;
3846                 break;
3847             case 's':
3848                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3849                 meta[j] = &files[j]->streams[map->index]->metadata;
3850                 break;
3851             case 'c':
3852                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3853                 meta[j] = &files[j]->chapters[map->index]->metadata;
3854                 break;
3855             case 'p':
3856                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3857                 meta[j] = &files[j]->programs[map->index]->metadata;
3858                 break;
3859             }
3860         }
3861
3862         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3863     }
3864
3865     /* copy global metadata by default */
3866     if (metadata_global_autocopy)
3867         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3868                      AV_DICT_DONT_OVERWRITE);
3869     if (metadata_streams_autocopy)
3870         for (i = 0; i < oc->nb_streams; i++) {
3871             InputStream *ist = &input_streams[output_streams_for_file[nb_output_files-1][i]->source_index];
3872             av_dict_copy(&oc->streams[i]->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3873         }
3874
3875     frame_rate    = (AVRational){0, 0};
3876     frame_width   = 0;
3877     frame_height  = 0;
3878     audio_sample_rate = 0;
3879     audio_channels    = 0;
3880     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3881     chapters_input_file = INT_MAX;
3882
3883     av_freep(&meta_data_maps);
3884     nb_meta_data_maps = 0;
3885     metadata_global_autocopy   = 1;
3886     metadata_streams_autocopy  = 1;
3887     metadata_chapters_autocopy = 1;
3888     av_freep(&stream_maps);
3889     nb_stream_maps = 0;
3890
3891     av_dict_free(&codec_names);
3892
3893     av_freep(&forced_key_frames);
3894     uninit_opts();
3895     init_opts();
3896     return 0;
3897 }
3898
3899 /* same option as mencoder */
3900 static int opt_pass(const char *opt, const char *arg)
3901 {
3902     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3903     return 0;
3904 }
3905
3906 static int64_t getutime(void)
3907 {
3908 #if HAVE_GETRUSAGE
3909     struct rusage rusage;
3910
3911     getrusage(RUSAGE_SELF, &rusage);
3912     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3913 #elif HAVE_GETPROCESSTIMES
3914     HANDLE proc;
3915     FILETIME c, e, k, u;
3916     proc = GetCurrentProcess();
3917     GetProcessTimes(proc, &c, &e, &k, &u);
3918     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3919 #else
3920     return av_gettime();
3921 #endif
3922 }
3923
3924 static int64_t getmaxrss(void)
3925 {
3926 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3927     struct rusage rusage;
3928     getrusage(RUSAGE_SELF, &rusage);
3929     return (int64_t)rusage.ru_maxrss * 1024;
3930 #elif HAVE_GETPROCESSMEMORYINFO
3931     HANDLE proc;
3932     PROCESS_MEMORY_COUNTERS memcounters;
3933     proc = GetCurrentProcess();
3934     memcounters.cb = sizeof(memcounters);
3935     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3936     return memcounters.PeakPagefileUsage;
3937 #else
3938     return 0;
3939 #endif
3940 }
3941
3942 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3943 {
3944     int i;
3945     const char *p = str;
3946     for(i = 0;; i++) {
3947         dest[i] = atoi(p);
3948         if(i == 63)
3949             break;
3950         p = strchr(p, ',');
3951         if(!p) {
3952             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3953             exit_program(1);
3954         }
3955         p++;
3956     }
3957 }
3958
3959 static int opt_inter_matrix(const char *opt, const char *arg)
3960 {
3961     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3962     parse_matrix_coeffs(inter_matrix, arg);
3963     return 0;
3964 }
3965
3966 static int opt_intra_matrix(const char *opt, const char *arg)
3967 {
3968     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3969     parse_matrix_coeffs(intra_matrix, arg);
3970     return 0;
3971 }
3972
3973 static void show_usage(void)
3974 {
3975     printf("Hyper fast Audio and Video encoder\n");
3976     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3977     printf("\n");
3978 }
3979
3980 static int opt_help(const char *opt, const char *arg)
3981 {
3982     AVCodec *c;
3983     AVOutputFormat *oformat = NULL;
3984     AVInputFormat  *iformat = NULL;
3985
3986     av_log_set_callback(log_callback_help);
3987     show_usage();
3988     show_help_options(options, "Main options:\n",
3989                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3990     show_help_options(options, "\nAdvanced options:\n",
3991                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3992                       OPT_EXPERT);
3993     show_help_options(options, "\nVideo options:\n",
3994                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3995                       OPT_VIDEO);
3996     show_help_options(options, "\nAdvanced Video options:\n",
3997                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3998                       OPT_VIDEO | OPT_EXPERT);
3999     show_help_options(options, "\nAudio options:\n",
4000                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4001                       OPT_AUDIO);
4002     show_help_options(options, "\nAdvanced Audio options:\n",
4003                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4004                       OPT_AUDIO | OPT_EXPERT);
4005     show_help_options(options, "\nSubtitle options:\n",
4006                       OPT_SUBTITLE | OPT_GRAB,
4007                       OPT_SUBTITLE);
4008     show_help_options(options, "\nAudio/Video grab options:\n",
4009                       OPT_GRAB,
4010                       OPT_GRAB);
4011     printf("\n");
4012     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4013     printf("\n");
4014
4015     /* individual codec options */
4016     c = NULL;
4017     while ((c = av_codec_next(c))) {
4018         if (c->priv_class) {
4019             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4020             printf("\n");
4021         }
4022     }
4023
4024     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4025     printf("\n");
4026
4027     /* individual muxer options */
4028     while ((oformat = av_oformat_next(oformat))) {
4029         if (oformat->priv_class) {
4030             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4031             printf("\n");
4032         }
4033     }
4034
4035     /* individual demuxer options */
4036     while ((iformat = av_iformat_next(iformat))) {
4037         if (iformat->priv_class) {
4038             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4039             printf("\n");
4040         }
4041     }
4042
4043     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4044     return 0;
4045 }
4046
4047 static int opt_target(const char *opt, const char *arg)
4048 {
4049     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4050     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4051
4052     if(!strncmp(arg, "pal-", 4)) {
4053         norm = PAL;
4054         arg += 4;
4055     } else if(!strncmp(arg, "ntsc-", 5)) {
4056         norm = NTSC;
4057         arg += 5;
4058     } else if(!strncmp(arg, "film-", 5)) {
4059         norm = FILM;
4060         arg += 5;
4061     } else {
4062         int fr;
4063         /* Calculate FR via float to avoid int overflow */
4064         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4065         if(fr == 25000) {
4066             norm = PAL;
4067         } else if((fr == 29970) || (fr == 23976)) {
4068             norm = NTSC;
4069         } else {
4070             /* Try to determine PAL/NTSC by peeking in the input files */
4071             if(nb_input_files) {
4072                 int i, j;
4073                 for (j = 0; j < nb_input_files; j++) {
4074                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4075                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4076                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4077                             continue;
4078                         fr = c->time_base.den * 1000 / c->time_base.num;
4079                         if(fr == 25000) {
4080                             norm = PAL;
4081                             break;
4082                         } else if((fr == 29970) || (fr == 23976)) {
4083                             norm = NTSC;
4084                             break;
4085                         }
4086                     }
4087                     if(norm != UNKNOWN)
4088                         break;
4089                 }
4090             }
4091         }
4092         if(verbose > 0 && norm != UNKNOWN)
4093             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4094     }
4095
4096     if(norm == UNKNOWN) {
4097         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4098         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4099         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4100         exit_program(1);
4101     }
4102
4103     if(!strcmp(arg, "vcd")) {
4104         opt_codec("c:v", "mpeg1video");
4105         opt_codec("c:a", "mp2");
4106         opt_format("f", "vcd");
4107
4108         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4109         opt_frame_rate("r", frame_rates[norm]);
4110         opt_default("g", norm == PAL ? "15" : "18");
4111
4112         opt_default("b", "1150000");
4113         opt_default("maxrate", "1150000");
4114         opt_default("minrate", "1150000");
4115         opt_default("bufsize", "327680"); // 40*1024*8;
4116
4117         opt_default("b:a", "224000");
4118         audio_sample_rate = 44100;
4119         audio_channels = 2;
4120
4121         opt_default("packetsize", "2324");
4122         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4123
4124         /* We have to offset the PTS, so that it is consistent with the SCR.
4125            SCR starts at 36000, but the first two packs contain only padding
4126            and the first pack from the other stream, respectively, may also have
4127            been written before.
4128            So the real data starts at SCR 36000+3*1200. */
4129         mux_preload= (36000+3*1200) / 90000.0; //0.44
4130     } else if(!strcmp(arg, "svcd")) {
4131
4132         opt_codec("c:v", "mpeg2video");
4133         opt_codec("c:a", "mp2");
4134         opt_format("f", "svcd");
4135
4136         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4137         opt_frame_rate("r", frame_rates[norm]);
4138         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4139         opt_default("g", norm == PAL ? "15" : "18");
4140
4141         opt_default("b", "2040000");
4142         opt_default("maxrate", "2516000");
4143         opt_default("minrate", "0"); //1145000;
4144         opt_default("bufsize", "1835008"); //224*1024*8;
4145         opt_default("flags", "+scan_offset");
4146
4147
4148         opt_default("b:a", "224000");
4149         audio_sample_rate = 44100;
4150
4151         opt_default("packetsize", "2324");
4152
4153     } else if(!strcmp(arg, "dvd")) {
4154
4155         opt_codec("c:v", "mpeg2video");
4156         opt_codec("c:a", "ac3");
4157         opt_format("f", "dvd");
4158
4159         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4160         opt_frame_rate("r", frame_rates[norm]);
4161         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4162         opt_default("g", norm == PAL ? "15" : "18");
4163
4164         opt_default("b", "6000000");
4165         opt_default("maxrate", "9000000");
4166         opt_default("minrate", "0"); //1500000;
4167         opt_default("bufsize", "1835008"); //224*1024*8;
4168
4169         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4170         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4171
4172         opt_default("b:a", "448000");
4173         audio_sample_rate = 48000;
4174
4175     } else if(!strncmp(arg, "dv", 2)) {
4176
4177         opt_format("f", "dv");
4178
4179         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4180         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4181                           norm == PAL ? "yuv420p" : "yuv411p");
4182         opt_frame_rate("r", frame_rates[norm]);
4183
4184         audio_sample_rate = 48000;
4185         audio_channels = 2;
4186
4187     } else {
4188         fprintf(stderr, "Unknown target: %s\n", arg);
4189         return AVERROR(EINVAL);
4190     }
4191     return 0;
4192 }
4193
4194 static int opt_vstats_file(const char *opt, const char *arg)
4195 {
4196     av_free (vstats_filename);
4197     vstats_filename=av_strdup (arg);
4198     return 0;
4199 }
4200
4201 static int opt_vstats(const char *opt, const char *arg)
4202 {
4203     char filename[40];
4204     time_t today2 = time(NULL);
4205     struct tm *today = localtime(&today2);
4206
4207     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4208              today->tm_sec);
4209     return opt_vstats_file(opt, filename);
4210 }
4211
4212 static int opt_bsf(const char *opt, const char *arg)
4213 {
4214     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4215     AVBitStreamFilterContext **bsfp;
4216
4217     if(!bsfc){
4218         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4219         exit_program(1);
4220     }
4221
4222     bsfp= *opt == 'v' ? &video_bitstream_filters :
4223           *opt == 'a' ? &audio_bitstream_filters :
4224                         &subtitle_bitstream_filters;
4225     while(*bsfp)
4226         bsfp= &(*bsfp)->next;
4227
4228     *bsfp= bsfc;
4229
4230     return 0;
4231 }
4232
4233 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4234 {
4235 }
4236
4237 static int opt_passlogfile(const char *opt, const char *arg)
4238 {
4239     pass_logfilename_prefix = arg;
4240 #if CONFIG_LIBX264_ENCODER
4241     return opt_default("passlogfile", arg);
4242 #else
4243     return 0;
4244 #endif
4245 }
4246
4247 static const OptionDef options[] = {
4248     /* main options */
4249 #include "cmdutils_common_opts.h"
4250     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4251     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4252     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4253     { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4254     { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4255     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4256     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4257       "outfile[,metadata]:infile[,metadata]" },
4258     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4259       "outfile[,metadata]:infile[,metadata]" },
4260     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file},  "set chapters mapping", "input_file_index" },
4261     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4262     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4263     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4264     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4265     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4266     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4267     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4268     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4269     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4270       "add timings for benchmarking" },
4271     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4272     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4273       "dump each input packet" },
4274     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4275       "when dumping packets, also dump the payload" },
4276     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4277     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4278     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4279     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4280     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4281     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4282     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4283     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4284     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4285     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4286     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4287     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4288     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4289     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4290     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4291     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4292
4293     /* video options */
4294     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4295     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4296     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4297     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4298     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4299     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4300     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4301     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4302     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4303     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4304     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4305     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4306     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4307     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4308     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4309     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4310     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4311     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4312     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4313     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4314     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4315     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4316     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4317     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4318     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4319     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4320     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4321       "deinterlace pictures" },
4322     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4323     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4324     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4325 #if CONFIG_AVFILTER
4326     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4327 #endif
4328     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4329     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4330     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4331     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4332     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4333     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4334     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4335     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4336     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4337     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4338
4339     /* audio options */
4340     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4341     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4342     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4343     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4344     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4345     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4346     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4347     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4348     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4349     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4350
4351     /* subtitle options */
4352     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4353     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4354     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4355     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4356
4357     /* grab options */
4358     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4359     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4360     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4361
4362     /* muxer options */
4363     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4364     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4365
4366     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4367     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4368     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4369
4370     /* data codec support */
4371     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4372
4373     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4374     { NULL, },
4375 };
4376
4377 int main(int argc, char **argv)
4378 {
4379     int64_t ti;
4380
4381     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4382
4383     if(argc>1 && !strcmp(argv[1], "-d")){
4384         run_as_daemon=1;
4385         verbose=-1;
4386         av_log_set_callback(log_callback_null);
4387         argc--;
4388         argv++;
4389     }
4390
4391     avcodec_register_all();
4392 #if CONFIG_AVDEVICE
4393     avdevice_register_all();
4394 #endif
4395 #if CONFIG_AVFILTER
4396     avfilter_register_all();
4397 #endif
4398     av_register_all();
4399
4400 #if HAVE_ISATTY
4401     if(isatty(STDIN_FILENO))
4402         avio_set_interrupt_cb(decode_interrupt_cb);
4403 #endif
4404
4405     init_opts();
4406
4407     if(verbose>=0)
4408         show_banner();
4409
4410     /* parse options */
4411     parse_options(argc, argv, options, opt_output_file);
4412
4413     if(nb_output_files <= 0 && nb_input_files == 0) {
4414         show_usage();
4415         fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4416         exit_program(1);
4417     }
4418
4419     /* file converter / grab */
4420     if (nb_output_files <= 0) {
4421         fprintf(stderr, "At least one output file must be specified\n");
4422         exit_program(1);
4423     }
4424
4425     if (nb_input_files == 0) {
4426         fprintf(stderr, "At least one input file must be specified\n");
4427         exit_program(1);
4428     }
4429
4430     ti = getutime();
4431     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4432         exit_program(1);
4433     ti = getutime() - ti;
4434     if (do_benchmark) {
4435         int maxrss = getmaxrss() / 1024;
4436         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4437     }
4438
4439     return exit_program(0);
4440 }