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

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