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

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