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