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

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