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 void *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 = 0, 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 * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1655                     samples_size = FFMAX(pkt->size * bps, 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                 switch (ist->st->codec->sample_fmt) {
1762                 case AV_SAMPLE_FMT_U8:
1763                 {
1764                     uint8_t *volp = samples;
1765                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1766                         int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1767                         *volp++ = av_clip_uint8(v);
1768                     }
1769                     break;
1770                 }
1771                 case AV_SAMPLE_FMT_S16:
1772                 {
1773                     int16_t *volp = samples;
1774                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1775                         int v = ((*volp) * audio_volume + 128) >> 8;
1776                         *volp++ = av_clip_int16(v);
1777                     }
1778                     break;
1779                 }
1780                 case AV_SAMPLE_FMT_S32:
1781                 {
1782                     int32_t *volp = samples;
1783                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1784                         int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1785                         *volp++ = av_clipl_int32(v);
1786                     }
1787                     break;
1788                 }
1789                 case AV_SAMPLE_FMT_FLT:
1790                 {
1791                     float *volp = samples;
1792                     float scale = audio_volume / 256.f;
1793                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1794                         *volp++ *= scale;
1795                     }
1796                     break;
1797                 }
1798                 case AV_SAMPLE_FMT_DBL:
1799                 {
1800                     double *volp = samples;
1801                     double scale = audio_volume / 256.;
1802                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1803                         *volp++ *= scale;
1804                     }
1805                     break;
1806                 }
1807                 default:
1808                     av_log(NULL, AV_LOG_FATAL,
1809                            "Audio volume adjustment on sample format %s is not supported.\n",
1810                            av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1811                     exit_program(1);
1812                 }
1813             }
1814         }
1815
1816         /* frame rate emulation */
1817         if (input_files[ist->file_index].rate_emu) {
1818             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1819             int64_t now = av_gettime() - ist->start;
1820             if (pts > now)
1821                 usleep(pts - now);
1822         }
1823         /* if output time reached then transcode raw format,
1824            encode packets and output them */
1825         for (i = 0; i < nb_ostreams; i++) {
1826             OutputFile *of = &output_files[ost_table[i].file_index];
1827             int frame_size;
1828
1829             ost = &ost_table[i];
1830             if (ost->source_index != ist_index)
1831                 continue;
1832
1833             if (of->start_time && ist->pts < of->start_time)
1834                 continue;
1835
1836             if (of->recording_time != INT64_MAX &&
1837                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1838                               (AVRational){1, 1000000}) >= 0) {
1839                 ost->is_past_recording_time = 1;
1840                 continue;
1841             }
1842
1843 #if CONFIG_AVFILTER
1844             frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1845                 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1846             while (frame_available) {
1847                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1848                     AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1849                     if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1850                         goto cont;
1851                     if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
1852                         ret = AVERROR(ENOMEM);
1853                         goto fail;
1854                     }
1855                     *filtered_frame= *decoded_frame; //for me_threshold
1856                     if (ost->picref) {
1857                         avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1858                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1859                     }
1860                 }
1861 #else
1862                 filtered_frame = decoded_frame;
1863 #endif
1864                 os = output_files[ost->file_index].ctx;
1865
1866                 /* set the input output pts pairs */
1867                 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1868
1869                 if (ost->encoding_needed) {
1870                     av_assert0(ist->decoding_needed);
1871                     switch(ost->st->codec->codec_type) {
1872                     case AVMEDIA_TYPE_AUDIO:
1873                         do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1874                         break;
1875                     case AVMEDIA_TYPE_VIDEO:
1876 #if CONFIG_AVFILTER
1877                         if (ost->picref->video && !ost->frame_aspect_ratio)
1878                             ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1879 #endif
1880                         do_video_out(os, ost, ist, filtered_frame, &frame_size,
1881                                      same_quant ? quality : ost->st->codec->global_quality);
1882                         if (vstats_filename && frame_size)
1883                             do_video_stats(os, ost, frame_size);
1884                         break;
1885                     case AVMEDIA_TYPE_SUBTITLE:
1886                         do_subtitle_out(os, ost, ist, &subtitle,
1887                                         pkt->pts);
1888                         break;
1889                     default:
1890                         abort();
1891                     }
1892                 } else {
1893                     AVPicture pict;
1894                     AVPacket opkt;
1895                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1896                     av_init_packet(&opkt);
1897
1898                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1899 #if !CONFIG_AVFILTER
1900                         continue;
1901 #else
1902                         goto cont;
1903 #endif
1904
1905                     /* no reencoding needed : output the packet directly */
1906                     /* force the input stream PTS */
1907
1908                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1909                         audio_size += data_size;
1910                     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1911                         video_size += data_size;
1912                         ost->sync_opts++;
1913                     }
1914
1915                     opkt.stream_index= ost->index;
1916                     if(pkt->pts != AV_NOPTS_VALUE)
1917                         opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1918                     else
1919                         opkt.pts= AV_NOPTS_VALUE;
1920
1921                     if (pkt->dts == AV_NOPTS_VALUE)
1922                         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1923                     else
1924                         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1925                     opkt.dts -= ost_tb_start_time;
1926
1927                     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1928                     opkt.flags= pkt->flags;
1929
1930                     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1931                     if(   ost->st->codec->codec_id != CODEC_ID_H264
1932                        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1933                        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1934                        ) {
1935                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1936                             opkt.destruct= av_destruct_packet;
1937                     } else {
1938                         opkt.data = data_buf;
1939                         opkt.size = data_size;
1940                     }
1941
1942                     if (os->oformat->flags & AVFMT_RAWPICTURE) {
1943                         /* store AVPicture in AVPacket, as expected by the output format */
1944                         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1945                         opkt.data = (uint8_t *)&pict;
1946                         opkt.size = sizeof(AVPicture);
1947                         opkt.flags |= AV_PKT_FLAG_KEY;
1948                     }
1949                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1950                     ost->st->codec->frame_number++;
1951                     ost->frame_number++;
1952                     av_free_packet(&opkt);
1953                 }
1954 #if CONFIG_AVFILTER
1955                 cont:
1956                 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1957                                    ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1958                 avfilter_unref_buffer(ost->picref);
1959             }
1960             av_freep(&filtered_frame);
1961 #endif
1962         }
1963
1964 fail:
1965         av_free(buffer_to_free);
1966         /* XXX: allocate the subtitles in the codec ? */
1967         if (subtitle_to_free) {
1968             avsubtitle_free(subtitle_to_free);
1969             subtitle_to_free = NULL;
1970         }
1971         av_freep(&decoded_frame);
1972         if (ret < 0)
1973             return ret;
1974     }
1975  discard_packet:
1976
1977     return 0;
1978 }
1979
1980 static void print_sdp(OutputFile *output_files, int n)
1981 {
1982     char sdp[2048];
1983     int i;
1984     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1985
1986     if (!avc)
1987         exit_program(1);
1988     for (i = 0; i < n; i++)
1989         avc[i] = output_files[i].ctx;
1990
1991     av_sdp_create(avc, n, sdp, sizeof(sdp));
1992     printf("SDP:\n%s\n", sdp);
1993     fflush(stdout);
1994     av_freep(&avc);
1995 }
1996
1997 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1998                              char *error, int error_len)
1999 {
2000     InputStream *ist = &input_streams[ist_index];
2001     if (ist->decoding_needed) {
2002         AVCodec *codec = ist->dec;
2003         if (!codec) {
2004             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
2005                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2006             return AVERROR(EINVAL);
2007         }
2008         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2009             snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
2010                     ist->file_index, ist->st->index);
2011             return AVERROR(EINVAL);
2012         }
2013         assert_codec_experimental(ist->st->codec, 0);
2014         assert_avoptions(ist->opts);
2015     }
2016
2017     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;
2018     ist->next_pts = AV_NOPTS_VALUE;
2019     ist->is_start = 1;
2020
2021     return 0;
2022 }
2023
2024 static int transcode_init(OutputFile *output_files, int nb_output_files,
2025                           InputFile  *input_files,  int nb_input_files)
2026 {
2027     int ret = 0, i, j, k;
2028     AVFormatContext *os;
2029     AVCodecContext *codec, *icodec;
2030     OutputStream *ost;
2031     InputStream *ist;
2032     char error[1024];
2033     int want_sdp = 1;
2034
2035     /* init framerate emulation */
2036     for (i = 0; i < nb_input_files; i++) {
2037         InputFile *ifile = &input_files[i];
2038         if (ifile->rate_emu)
2039             for (j = 0; j < ifile->nb_streams; j++)
2040                 input_streams[j + ifile->ist_index].start = av_gettime();
2041     }
2042
2043     /* output stream init */
2044     for(i=0;i<nb_output_files;i++) {
2045         os = output_files[i].ctx;
2046         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2047             av_dump_format(os, i, os->filename, 1);
2048             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2049             return AVERROR(EINVAL);
2050         }
2051     }
2052
2053     /* for each output stream, we compute the right encoding parameters */
2054     for (i = 0; i < nb_output_streams; i++) {
2055         ost = &output_streams[i];
2056         os = output_files[ost->file_index].ctx;
2057         ist = &input_streams[ost->source_index];
2058
2059         codec = ost->st->codec;
2060         icodec = ist->st->codec;
2061
2062         ost->st->disposition = ist->st->disposition;
2063         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2064         codec->chroma_sample_location = icodec->chroma_sample_location;
2065
2066         if (ost->st->stream_copy) {
2067             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2068
2069             if (extra_size > INT_MAX) {
2070                 return AVERROR(EINVAL);
2071             }
2072
2073             /* if stream_copy is selected, no need to decode or encode */
2074             codec->codec_id = icodec->codec_id;
2075             codec->codec_type = icodec->codec_type;
2076
2077             if(!codec->codec_tag){
2078                 if(   !os->oformat->codec_tag
2079                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2080                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2081                     codec->codec_tag = icodec->codec_tag;
2082             }
2083
2084             codec->bit_rate = icodec->bit_rate;
2085             codec->rc_max_rate    = icodec->rc_max_rate;
2086             codec->rc_buffer_size = icodec->rc_buffer_size;
2087             codec->extradata= av_mallocz(extra_size);
2088             if (!codec->extradata) {
2089                 return AVERROR(ENOMEM);
2090             }
2091             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2092             codec->extradata_size= icodec->extradata_size;
2093
2094             codec->time_base = ist->st->time_base;
2095             if(!strcmp(os->oformat->name, "avi")) {
2096                 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){
2097                     codec->time_base = icodec->time_base;
2098                     codec->time_base.num *= icodec->ticks_per_frame;
2099                     codec->time_base.den *= 2;
2100                 }
2101             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2102                 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){
2103                     codec->time_base = icodec->time_base;
2104                     codec->time_base.num *= icodec->ticks_per_frame;
2105                 }
2106             }
2107             av_reduce(&codec->time_base.num, &codec->time_base.den,
2108                         codec->time_base.num, codec->time_base.den, INT_MAX);
2109
2110             switch(codec->codec_type) {
2111             case AVMEDIA_TYPE_AUDIO:
2112                 if(audio_volume != 256) {
2113                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2114                     exit_program(1);
2115                 }
2116                 codec->channel_layout = icodec->channel_layout;
2117                 codec->sample_rate = icodec->sample_rate;
2118                 codec->channels = icodec->channels;
2119                 codec->frame_size = icodec->frame_size;
2120                 codec->audio_service_type = icodec->audio_service_type;
2121                 codec->block_align= icodec->block_align;
2122                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2123                     codec->block_align= 0;
2124                 if(codec->codec_id == CODEC_ID_AC3)
2125                     codec->block_align= 0;
2126                 break;
2127             case AVMEDIA_TYPE_VIDEO:
2128                 codec->pix_fmt = icodec->pix_fmt;
2129                 codec->width = icodec->width;
2130                 codec->height = icodec->height;
2131                 codec->has_b_frames = icodec->has_b_frames;
2132                 if (!codec->sample_aspect_ratio.num) {
2133                     codec->sample_aspect_ratio =
2134                     ost->st->sample_aspect_ratio =
2135                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2136                         ist->st->codec->sample_aspect_ratio.num ?
2137                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2138                 }
2139                 break;
2140             case AVMEDIA_TYPE_SUBTITLE:
2141                 codec->width = icodec->width;
2142                 codec->height = icodec->height;
2143                 break;
2144             case AVMEDIA_TYPE_DATA:
2145             case AVMEDIA_TYPE_ATTACHMENT:
2146                 break;
2147             default:
2148                 abort();
2149             }
2150         } else {
2151             if (!ost->enc)
2152                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2153             switch(codec->codec_type) {
2154             case AVMEDIA_TYPE_AUDIO:
2155                 ost->fifo= av_fifo_alloc(1024);
2156                 if (!ost->fifo) {
2157                     return AVERROR(ENOMEM);
2158                 }
2159                 if (!codec->sample_rate) {
2160                     codec->sample_rate = icodec->sample_rate;
2161                 }
2162                 choose_sample_rate(ost->st, ost->enc);
2163                 codec->time_base = (AVRational){1, codec->sample_rate};
2164                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2165                     codec->sample_fmt = icodec->sample_fmt;
2166                 choose_sample_fmt(ost->st, ost->enc);
2167                 if (!codec->channels) {
2168                     codec->channels = icodec->channels;
2169                     codec->channel_layout = icodec->channel_layout;
2170                 }
2171                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2172                     codec->channel_layout = 0;
2173                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2174                 ost->audio_resample |=    codec->sample_fmt     != icodec->sample_fmt
2175                                        || codec->channel_layout != icodec->channel_layout;
2176                 icodec->request_channels = codec->channels;
2177                 ist->decoding_needed = 1;
2178                 ost->encoding_needed = 1;
2179                 ost->resample_sample_fmt  = icodec->sample_fmt;
2180                 ost->resample_sample_rate = icodec->sample_rate;
2181                 ost->resample_channels    = icodec->channels;
2182                 break;
2183             case AVMEDIA_TYPE_VIDEO:
2184                 if (codec->pix_fmt == PIX_FMT_NONE)
2185                     codec->pix_fmt = icodec->pix_fmt;
2186                 choose_pixel_fmt(ost->st, ost->enc);
2187
2188                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2189                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2190                     exit_program(1);
2191                 }
2192
2193                 if (!codec->width || !codec->height) {
2194                     codec->width  = icodec->width;
2195                     codec->height = icodec->height;
2196                 }
2197
2198                 ost->video_resample = codec->width   != icodec->width  ||
2199                                       codec->height  != icodec->height ||
2200                                       codec->pix_fmt != icodec->pix_fmt;
2201                 if (ost->video_resample) {
2202                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2203                 }
2204
2205                 ost->resample_height = icodec->height;
2206                 ost->resample_width  = icodec->width;
2207                 ost->resample_pix_fmt= icodec->pix_fmt;
2208                 ost->encoding_needed = 1;
2209                 ist->decoding_needed = 1;
2210
2211                 if (!ost->frame_rate.num)
2212                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2213                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2214                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2215                     ost->frame_rate = ost->enc->supported_framerates[idx];
2216                 }
2217                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2218                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2219                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2220                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2221                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2222                 }
2223                 for (j = 0; j < ost->forced_kf_count; j++)
2224                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2225                                                          AV_TIME_BASE_Q,
2226                                                          codec->time_base);
2227
2228 #if CONFIG_AVFILTER
2229                 if (configure_video_filters(ist, ost)) {
2230                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2231                     exit(1);
2232                 }
2233 #endif
2234                 break;
2235             case AVMEDIA_TYPE_SUBTITLE:
2236                 ost->encoding_needed = 1;
2237                 ist->decoding_needed = 1;
2238                 break;
2239             default:
2240                 abort();
2241                 break;
2242             }
2243             /* two pass mode */
2244             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2245                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2246                 char logfilename[1024];
2247                 FILE *f;
2248
2249                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2250                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2251                          i);
2252                 if (codec->flags & CODEC_FLAG_PASS1) {
2253                     f = fopen(logfilename, "wb");
2254                     if (!f) {
2255                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2256                                logfilename, strerror(errno));
2257                         exit_program(1);
2258                     }
2259                     ost->logfile = f;
2260                 } else {
2261                     char  *logbuffer;
2262                     size_t logbuffer_size;
2263                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2264                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2265                                logfilename);
2266                         exit_program(1);
2267                     }
2268                     codec->stats_in = logbuffer;
2269                 }
2270             }
2271         }
2272         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2273             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2274             int size= codec->width * codec->height;
2275             bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
2276         }
2277     }
2278
2279     if (!bit_buffer)
2280         bit_buffer = av_malloc(bit_buffer_size);
2281     if (!bit_buffer) {
2282         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2283                bit_buffer_size);
2284         return AVERROR(ENOMEM);
2285     }
2286
2287     /* open each encoder */
2288     for (i = 0; i < nb_output_streams; i++) {
2289         ost = &output_streams[i];
2290         if (ost->encoding_needed) {
2291             AVCodec *codec = ost->enc;
2292             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2293             if (!codec) {
2294                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2295                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2296                 ret = AVERROR(EINVAL);
2297                 goto dump_format;
2298             }
2299             if (dec->subtitle_header) {
2300                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2301                 if (!ost->st->codec->subtitle_header) {
2302                     ret = AVERROR(ENOMEM);
2303                     goto dump_format;
2304                 }
2305                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2306                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2307             }
2308             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2309                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2310                         ost->file_index, ost->index);
2311                 ret = AVERROR(EINVAL);
2312                 goto dump_format;
2313             }
2314             assert_codec_experimental(ost->st->codec, 1);
2315             assert_avoptions(ost->opts);
2316             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2317                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2318                                              "It takes bits/s as argument, not kbits/s\n");
2319             extra_size += ost->st->codec->extradata_size;
2320
2321             if (ost->st->codec->me_threshold)
2322                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2323         }
2324     }
2325
2326     /* init input streams */
2327     for (i = 0; i < nb_input_streams; i++)
2328         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2329             goto dump_format;
2330
2331     /* discard unused programs */
2332     for (i = 0; i < nb_input_files; i++) {
2333         InputFile *ifile = &input_files[i];
2334         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2335             AVProgram *p = ifile->ctx->programs[j];
2336             int discard  = AVDISCARD_ALL;
2337
2338             for (k = 0; k < p->nb_stream_indexes; k++)
2339                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2340                     discard = AVDISCARD_DEFAULT;
2341                     break;
2342                 }
2343             p->discard = discard;
2344         }
2345     }
2346
2347     /* open files and write file headers */
2348     for (i = 0; i < nb_output_files; i++) {
2349         os = output_files[i].ctx;
2350         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2351             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2352             ret = AVERROR(EINVAL);
2353             goto dump_format;
2354         }
2355 //        assert_avoptions(output_files[i].opts);
2356         if (strcmp(os->oformat->name, "rtp")) {
2357             want_sdp = 0;
2358         }
2359     }
2360
2361  dump_format:
2362     /* dump the file output parameters - cannot be done before in case
2363        of stream copy */
2364     for(i=0;i<nb_output_files;i++) {
2365         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2366     }
2367
2368     /* dump the stream mapping */
2369     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2370     for (i = 0; i < nb_output_streams; i++) {
2371         ost = &output_streams[i];
2372         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d -> #%d.%d",
2373                input_streams[ost->source_index].file_index,
2374                input_streams[ost->source_index].st->index,
2375                ost->file_index,
2376                ost->index);
2377         if (ost->sync_ist != &input_streams[ost->source_index])
2378             av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2379                    ost->sync_ist->file_index,
2380                    ost->sync_ist->st->index);
2381         if (ost->st->stream_copy)
2382             av_log(NULL, AV_LOG_INFO, " (copy)");
2383         else
2384             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2385                    input_streams[ost->source_index].dec->name : "?",
2386                    ost->enc ? ost->enc->name : "?");
2387         av_log(NULL, AV_LOG_INFO, "\n");
2388     }
2389
2390     if (ret) {
2391         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2392         return ret;
2393     }
2394
2395     if (want_sdp) {
2396         print_sdp(output_files, nb_output_files);
2397     }
2398
2399     return 0;
2400 }
2401
2402 /*
2403  * The following code is the main loop of the file converter
2404  */
2405 static int transcode(OutputFile *output_files, int nb_output_files,
2406                      InputFile  *input_files,  int nb_input_files)
2407 {
2408     int ret, i;
2409     AVFormatContext *is, *os;
2410     OutputStream *ost;
2411     InputStream *ist;
2412     uint8_t *no_packet;
2413     int no_packet_count=0;
2414     int64_t timer_start;
2415     int key;
2416
2417     if (!(no_packet = av_mallocz(nb_input_files)))
2418         exit_program(1);
2419
2420     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2421     if (ret < 0)
2422         goto fail;
2423
2424     if (!using_stdin) {
2425         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2426         avio_set_interrupt_cb(decode_interrupt_cb);
2427     }
2428     term_init();
2429
2430     timer_start = av_gettime();
2431
2432     for(; received_sigterm == 0;) {
2433         int file_index, ist_index;
2434         AVPacket pkt;
2435         int64_t ipts_min;
2436         double opts_min;
2437
2438         ipts_min= INT64_MAX;
2439         opts_min= 1e100;
2440         /* if 'q' pressed, exits */
2441         if (!using_stdin) {
2442             if (q_pressed)
2443                 break;
2444             /* read_key() returns 0 on EOF */
2445             key = read_key();
2446             if (key == 'q')
2447                 break;
2448             if (key == '+') av_log_set_level(av_log_get_level()+10);
2449             if (key == '-') av_log_set_level(av_log_get_level()-10);
2450             if (key == 's') qp_hist     ^= 1;
2451             if (key == 'h'){
2452                 if (do_hex_dump){
2453                     do_hex_dump = do_pkt_dump = 0;
2454                 } else if(do_pkt_dump){
2455                     do_hex_dump = 1;
2456                 } else
2457                     do_pkt_dump = 1;
2458                 av_log_set_level(AV_LOG_DEBUG);
2459             }
2460 #if CONFIG_AVFILTER
2461             if (key == 'c' || key == 'C'){
2462                 char buf[4096], target[64], command[256], arg[256] = {0};
2463                 double time;
2464                 int k, n = 0;
2465                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2466                 i = 0;
2467                 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2468                     if (k > 0)
2469                         buf[i++] = k;
2470                 buf[i] = 0;
2471                 if (k > 0 &&
2472                     (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2473                     av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2474                            target, time, command, arg);
2475                     for (i = 0; i < nb_output_streams; i++) {
2476                         ost = &output_streams[i];
2477                         if (ost->graph) {
2478                             if (time < 0) {
2479                                 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2480                                                                   key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2481                                 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2482                             } else {
2483                                 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2484                             }
2485                         }
2486                     }
2487                 } else {
2488                     av_log(NULL, AV_LOG_ERROR,
2489                            "Parse error, at least 3 arguments were expected, "
2490                            "only %d given in string '%s'\n", n, buf);
2491                 }
2492             }
2493 #endif
2494             if (key == 'd' || key == 'D'){
2495                 int debug=0;
2496                 if(key == 'D') {
2497                     debug = input_streams[0].st->codec->debug<<1;
2498                     if(!debug) debug = 1;
2499                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2500                         debug += debug;
2501                 }else
2502                     scanf("%d", &debug);
2503                 for(i=0;i<nb_input_streams;i++) {
2504                     input_streams[i].st->codec->debug = debug;
2505                 }
2506                 for(i=0;i<nb_output_streams;i++) {
2507                     ost = &output_streams[i];
2508                     ost->st->codec->debug = debug;
2509                 }
2510                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2511                 fprintf(stderr,"debug=%d\n", debug);
2512             }
2513             if (key == '?'){
2514                 fprintf(stderr, "key    function\n"
2515                                 "?      show this help\n"
2516                                 "+      increase verbosity\n"
2517                                 "-      decrease verbosity\n"
2518                                 "c      Send command to filtergraph\n"
2519                                 "D      cycle through available debug modes\n"
2520                                 "h      dump packets/hex press to cycle through the 3 states\n"
2521                                 "q      quit\n"
2522                                 "s      Show QP histogram\n"
2523                 );
2524             }
2525         }
2526
2527         /* select the stream that we must read now by looking at the
2528            smallest output pts */
2529         file_index = -1;
2530         for (i = 0; i < nb_output_streams; i++) {
2531             OutputFile *of;
2532             int64_t ipts;
2533             double  opts;
2534             ost = &output_streams[i];
2535             of = &output_files[ost->file_index];
2536             os = output_files[ost->file_index].ctx;
2537             ist = &input_streams[ost->source_index];
2538             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2539                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2540                 continue;
2541             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2542             ipts = ist->pts;
2543             if (!input_files[ist->file_index].eof_reached){
2544                 if(ipts < ipts_min) {
2545                     ipts_min = ipts;
2546                     if(input_sync ) file_index = ist->file_index;
2547                 }
2548                 if(opts < opts_min) {
2549                     opts_min = opts;
2550                     if(!input_sync) file_index = ist->file_index;
2551                 }
2552             }
2553             if (ost->frame_number >= ost->max_frames) {
2554                 int j;
2555                 for (j = 0; j < of->ctx->nb_streams; j++)
2556                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2557                 continue;
2558             }
2559         }
2560         /* if none, if is finished */
2561         if (file_index < 0) {
2562             if(no_packet_count){
2563                 no_packet_count=0;
2564                 memset(no_packet, 0, nb_input_files);
2565                 usleep(10000);
2566                 continue;
2567             }
2568             break;
2569         }
2570
2571         /* read a frame from it and output it in the fifo */
2572         is = input_files[file_index].ctx;
2573         ret= av_read_frame(is, &pkt);
2574         if(ret == AVERROR(EAGAIN)){
2575             no_packet[file_index]=1;
2576             no_packet_count++;
2577             continue;
2578         }
2579         if (ret < 0) {
2580             input_files[file_index].eof_reached = 1;
2581             if (opt_shortest)
2582                 break;
2583             else
2584                 continue;
2585         }
2586
2587         no_packet_count=0;
2588         memset(no_packet, 0, nb_input_files);
2589
2590         if (do_pkt_dump) {
2591             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2592                              is->streams[pkt.stream_index]);
2593         }
2594         /* the following test is needed in case new streams appear
2595            dynamically in stream : we ignore them */
2596         if (pkt.stream_index >= input_files[file_index].nb_streams)
2597             goto discard_packet;
2598         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2599         ist = &input_streams[ist_index];
2600         if (ist->discard)
2601             goto discard_packet;
2602
2603         if (pkt.dts != AV_NOPTS_VALUE)
2604             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2605         if (pkt.pts != AV_NOPTS_VALUE)
2606             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2607
2608         if(pkt.pts != AV_NOPTS_VALUE)
2609             pkt.pts *= ist->ts_scale;
2610         if(pkt.dts != AV_NOPTS_VALUE)
2611             pkt.dts *= ist->ts_scale;
2612
2613 //        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);
2614         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2615             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2616             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2617             int64_t delta= pkt_dts - ist->next_pts;
2618             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2619                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2620                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2621                 pkt_dts+1<ist->pts)&& !copy_ts){
2622                 input_files[ist->file_index].ts_offset -= delta;
2623                 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2624                        delta, input_files[ist->file_index].ts_offset);
2625                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2626                 if(pkt.pts != AV_NOPTS_VALUE)
2627                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2628             }
2629         }
2630
2631         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2632         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2633
2634             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2635                    ist->file_index, ist->st->index);
2636             if (exit_on_error)
2637                 exit_program(1);
2638             av_free_packet(&pkt);
2639             continue;
2640         }
2641
2642     discard_packet:
2643         av_free_packet(&pkt);
2644
2645         /* dump report by using the output first video and audio streams */
2646         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2647     }
2648
2649     /* at the end of stream, we must flush the decoder buffers */
2650     for (i = 0; i < nb_input_streams; i++) {
2651         ist = &input_streams[i];
2652         if (ist->decoding_needed) {
2653             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2654         }
2655     }
2656     flush_encoders(output_streams, nb_output_streams);
2657
2658     term_exit();
2659
2660     /* write the trailer if needed and close file */
2661     for(i=0;i<nb_output_files;i++) {
2662         os = output_files[i].ctx;
2663         av_write_trailer(os);
2664     }
2665
2666     /* dump report by using the first video and audio streams */
2667     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2668
2669     /* close each encoder */
2670     for (i = 0; i < nb_output_streams; i++) {
2671         ost = &output_streams[i];
2672         if (ost->encoding_needed) {
2673             av_freep(&ost->st->codec->stats_in);
2674             avcodec_close(ost->st->codec);
2675         }
2676 #if CONFIG_AVFILTER
2677         avfilter_graph_free(&ost->graph);
2678 #endif
2679     }
2680
2681     /* close each decoder */
2682     for (i = 0; i < nb_input_streams; i++) {
2683         ist = &input_streams[i];
2684         if (ist->decoding_needed) {
2685             avcodec_close(ist->st->codec);
2686         }
2687     }
2688
2689     /* finished ! */
2690     ret = 0;
2691
2692  fail:
2693     av_freep(&bit_buffer);
2694     av_freep(&no_packet);
2695
2696     if (output_streams) {
2697         for (i = 0; i < nb_output_streams; i++) {
2698             ost = &output_streams[i];
2699             if (ost) {
2700                 if (ost->st->stream_copy)
2701                     av_freep(&ost->st->codec->extradata);
2702                 if (ost->logfile) {
2703                     fclose(ost->logfile);
2704                     ost->logfile = NULL;
2705                 }
2706                 av_fifo_free(ost->fifo); /* works even if fifo is not
2707                                              initialized but set to zero */
2708                 av_freep(&ost->st->codec->subtitle_header);
2709                 av_free(ost->resample_frame.data[0]);
2710                 av_free(ost->forced_kf_pts);
2711                 if (ost->video_resample)
2712                     sws_freeContext(ost->img_resample_ctx);
2713                 swr_free(&ost->swr);
2714                 av_dict_free(&ost->opts);
2715             }
2716         }
2717     }
2718     return ret;
2719 }
2720
2721 static int opt_verbose(const char *opt, const char *arg)
2722 {
2723     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -loglevel\n", opt);
2724     return 0;
2725 }
2726
2727 static int opt_frame_crop(const char *opt, const char *arg)
2728 {
2729     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2730     return AVERROR(EINVAL);
2731 }
2732
2733 static int opt_pad(const char *opt, const char *arg)
2734 {
2735     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2736     return -1;
2737 }
2738
2739 static double parse_frame_aspect_ratio(const char *arg)
2740 {
2741     int x = 0, y = 0;
2742     double ar = 0;
2743     const char *p;
2744     char *end;
2745
2746     p = strchr(arg, ':');
2747     if (p) {
2748         x = strtol(arg, &end, 10);
2749         if (end == p)
2750             y = strtol(end+1, &end, 10);
2751         if (x > 0 && y > 0)
2752             ar = (double)x / (double)y;
2753     } else
2754         ar = strtod(arg, NULL);
2755
2756     if (!ar) {
2757         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2758         exit_program(1);
2759     }
2760     return ar;
2761 }
2762
2763 static int opt_video_channel(const char *opt, const char *arg)
2764 {
2765     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2766     return opt_default("channel", arg);
2767 }
2768
2769 static int opt_video_standard(const char *opt, const char *arg)
2770 {
2771     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2772     return opt_default("standard", arg);
2773 }
2774
2775 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2776 {
2777     audio_codec_name = arg;
2778     return parse_option(o, "codec:a", arg, options);
2779 }
2780
2781 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2782 {
2783     video_codec_name = arg;
2784     return parse_option(o, "codec:v", arg, options);
2785 }
2786
2787 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2788 {
2789     subtitle_codec_name = arg;
2790     return parse_option(o, "codec:s", arg, options);
2791 }
2792
2793 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2794 {
2795     return parse_option(o, "codec:d", arg, options);
2796 }
2797
2798 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2799 {
2800     StreamMap *m = NULL;
2801     int i, negative = 0, file_idx;
2802     int sync_file_idx = -1, sync_stream_idx;
2803     char *p, *sync;
2804     char *map;
2805
2806     if (*arg == '-') {
2807         negative = 1;
2808         arg++;
2809     }
2810     map = av_strdup(arg);
2811
2812     /* parse sync stream first, just pick first matching stream */
2813     if (sync = strchr(map, ',')) {
2814         *sync = 0;
2815         sync_file_idx = strtol(sync + 1, &sync, 0);
2816         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2817             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2818             exit_program(1);
2819         }
2820         if (*sync)
2821             sync++;
2822         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2823             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2824                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2825                 sync_stream_idx = i;
2826                 break;
2827             }
2828         if (i == input_files[sync_file_idx].nb_streams) {
2829             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2830                                        "match any streams.\n", arg);
2831             exit_program(1);
2832         }
2833     }
2834
2835
2836     file_idx = strtol(map, &p, 0);
2837     if (file_idx >= nb_input_files || file_idx < 0) {
2838         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2839         exit_program(1);
2840     }
2841     if (negative)
2842         /* disable some already defined maps */
2843         for (i = 0; i < o->nb_stream_maps; i++) {
2844             m = &o->stream_maps[i];
2845             if (check_stream_specifier(input_files[m->file_index].ctx,
2846                                        input_files[m->file_index].ctx->streams[m->stream_index],
2847                                        *p == ':' ? p + 1 : p) > 0)
2848                 m->disabled = 1;
2849         }
2850     else
2851         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2852             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2853                         *p == ':' ? p + 1 : p) <= 0)
2854                 continue;
2855             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2856                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2857             m = &o->stream_maps[o->nb_stream_maps - 1];
2858
2859             m->file_index   = file_idx;
2860             m->stream_index = i;
2861
2862             if (sync_file_idx >= 0) {
2863                 m->sync_file_index   = sync_file_idx;
2864                 m->sync_stream_index = sync_stream_idx;
2865             } else {
2866                 m->sync_file_index   = file_idx;
2867                 m->sync_stream_index = i;
2868             }
2869         }
2870
2871     if (!m) {
2872         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2873         exit_program(1);
2874     }
2875
2876     av_freep(&map);
2877     return 0;
2878 }
2879
2880 static void parse_meta_type(char *arg, char *type, int *index)
2881 {
2882     if (*arg) {
2883         *type = *arg;
2884         switch (*arg) {
2885         case 'g':
2886             break;
2887         case 's':
2888         case 'c':
2889         case 'p':
2890             if (*(++arg) == ':')
2891                 *index = strtol(++arg, NULL, 0);
2892             break;
2893         default:
2894             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2895             exit_program(1);
2896         }
2897     } else
2898         *type = 'g';
2899 }
2900
2901 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2902 {
2903     MetadataMap *m, *m1;
2904     char *p;
2905
2906     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2907                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2908
2909     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2910     m->file = strtol(arg, &p, 0);
2911     parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2912
2913     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2914     if (p = strchr(opt, ':'))
2915         parse_meta_type(p + 1, &m1->type, &m1->index);
2916     else
2917         m1->type = 'g';
2918
2919     if (m->type == 'g' || m1->type == 'g')
2920         o->metadata_global_manual = 1;
2921     if (m->type == 's' || m1->type == 's')
2922         o->metadata_streams_manual = 1;
2923     if (m->type == 'c' || m1->type == 'c')
2924         o->metadata_chapters_manual = 1;
2925
2926     return 0;
2927 }
2928
2929 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2930 {
2931     av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
2932                     "Use -map_metadata instead.\n");
2933     return opt_map_metadata(o, opt, arg);
2934 }
2935
2936 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2937 {
2938     char buf[128];
2939     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2940     struct tm time = *gmtime((time_t*)&recording_timestamp);
2941     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2942     parse_option(o, "metadata", buf, options);
2943
2944     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2945                                  "tag instead.\n", opt);
2946     return 0;
2947 }
2948
2949 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2950 {
2951     const char *codec_string = encoder ? "encoder" : "decoder";
2952     AVCodec *codec;
2953
2954     if(!name)
2955         return CODEC_ID_NONE;
2956     codec = encoder ?
2957         avcodec_find_encoder_by_name(name) :
2958         avcodec_find_decoder_by_name(name);
2959     if(!codec) {
2960         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2961         exit_program(1);
2962     }
2963     if(codec->type != type) {
2964         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2965         exit_program(1);
2966     }
2967     return codec->id;
2968 }
2969
2970 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2971 {
2972     char *codec_name = NULL;
2973
2974     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2975
2976     if (!codec_name) {
2977         if (s->oformat) {
2978             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2979             return avcodec_find_encoder(st->codec->codec_id);
2980         }
2981     } else if (!strcmp(codec_name, "copy"))
2982         st->stream_copy = 1;
2983     else {
2984         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2985         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2986                             avcodec_find_decoder_by_name(codec_name);
2987     }
2988
2989     return NULL;
2990 }
2991
2992 /**
2993  * Add all the streams from the given input file to the global
2994  * list of input streams.
2995  */
2996 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2997 {
2998     int i, rfps, rfps_base;
2999
3000     for (i = 0; i < ic->nb_streams; i++) {
3001         AVStream *st = ic->streams[i];
3002         AVCodecContext *dec = st->codec;
3003         InputStream *ist;
3004         double scale = 1.0;
3005
3006         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3007         ist = &input_streams[nb_input_streams - 1];
3008         ist->st = st;
3009         ist->file_index = nb_input_files;
3010         ist->discard = 1;
3011         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3012
3013         MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
3014         ist->ts_scale = scale;
3015
3016         ist->dec = choose_codec(o, ic, st, dec->codec_type);
3017         if (!ist->dec)
3018             ist->dec = avcodec_find_decoder(dec->codec_id);
3019
3020         switch (dec->codec_type) {
3021         case AVMEDIA_TYPE_AUDIO:
3022             if(!ist->dec)
3023                 ist->dec = avcodec_find_decoder(dec->codec_id);
3024             if(o->audio_disable)
3025                 st->discard= AVDISCARD_ALL;
3026             break;
3027         case AVMEDIA_TYPE_VIDEO:
3028             if(!ist->dec)
3029                 ist->dec = avcodec_find_decoder(dec->codec_id);
3030             rfps      = ic->streams[i]->r_frame_rate.num;
3031             rfps_base = ic->streams[i]->r_frame_rate.den;
3032             if (dec->lowres) {
3033                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3034             }
3035
3036             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3037
3038                 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",
3039                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3040                        (float)rfps / rfps_base, rfps, rfps_base);
3041             }
3042
3043             if (o->video_disable)
3044                 st->discard= AVDISCARD_ALL;
3045             else if(video_discard)
3046                 st->discard= video_discard;
3047             break;
3048         case AVMEDIA_TYPE_DATA:
3049             break;
3050         case AVMEDIA_TYPE_SUBTITLE:
3051             if(!ist->dec)
3052                 ist->dec = avcodec_find_decoder(dec->codec_id);
3053             if(o->subtitle_disable)
3054                 st->discard = AVDISCARD_ALL;
3055             break;
3056         case AVMEDIA_TYPE_ATTACHMENT:
3057         case AVMEDIA_TYPE_UNKNOWN:
3058             break;
3059         default:
3060             abort();
3061         }
3062     }
3063 }
3064
3065 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3066 {
3067     AVFormatContext *ic;
3068     AVInputFormat *file_iformat = NULL;
3069     int err, i, ret;
3070     int64_t timestamp;
3071     uint8_t buf[128];
3072     AVDictionary **opts;
3073     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3074
3075     if (o->format) {
3076         if (!(file_iformat = av_find_input_format(o->format))) {
3077             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3078             exit_program(1);
3079         }
3080     }
3081
3082     if (!strcmp(filename, "-"))
3083         filename = "pipe:";
3084
3085     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3086                     !strcmp(filename, "/dev/stdin");
3087
3088     /* get default parameters from command line */
3089     ic = avformat_alloc_context();
3090     if (!ic) {
3091         print_error(filename, AVERROR(ENOMEM));
3092         exit_program(1);
3093     }
3094     if (o->nb_audio_sample_rate) {
3095         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3096         av_dict_set(&format_opts, "sample_rate", buf, 0);
3097     }
3098     if (o->nb_audio_channels) {
3099         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3100         av_dict_set(&format_opts, "channels", buf, 0);
3101     }
3102     if (o->nb_frame_rates) {
3103         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3104     }
3105     if (o->nb_frame_sizes) {
3106         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3107     }
3108     if (o->nb_frame_pix_fmts)
3109         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3110
3111     ic->flags |= AVFMT_FLAG_NONBLOCK;
3112
3113     if (loop_input) {
3114         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3115         ic->loop_input = loop_input;
3116     }
3117
3118     /* open the input file with generic libav function */
3119     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3120     if (err < 0) {
3121         print_error(filename, err);
3122         exit_program(1);
3123     }
3124     assert_avoptions(format_opts);
3125
3126     /* apply forced codec ids */
3127     for (i = 0; i < ic->nb_streams; i++)
3128         choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3129
3130     /* Set AVCodecContext options for avformat_find_stream_info */
3131     opts = setup_find_stream_info_opts(ic, codec_opts);
3132     orig_nb_streams = ic->nb_streams;
3133
3134     /* If not enough info to get the stream parameters, we decode the
3135        first frames to get it. (used in mpeg case for example) */
3136     ret = avformat_find_stream_info(ic, opts);
3137     if (ret < 0) {
3138         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3139         av_close_input_file(ic);
3140         exit_program(1);
3141     }
3142
3143     timestamp = o->start_time;
3144     /* add the stream start time */
3145     if (ic->start_time != AV_NOPTS_VALUE)
3146         timestamp += ic->start_time;
3147
3148     /* if seeking requested, we execute it */
3149     if (o->start_time != 0) {
3150         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3151         if (ret < 0) {
3152             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3153                    filename, (double)timestamp / AV_TIME_BASE);
3154         }
3155     }
3156
3157     /* update the current parameters so that they match the one of the input stream */
3158     add_input_streams(o, ic);
3159
3160     /* dump the file content */
3161     av_dump_format(ic, nb_input_files, filename, 0);
3162
3163     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3164     input_files[nb_input_files - 1].ctx        = ic;
3165     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3166     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3167     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3168     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3169
3170     for (i = 0; i < orig_nb_streams; i++)
3171         av_dict_free(&opts[i]);
3172     av_freep(&opts);
3173
3174     reset_options(o, 1);
3175     return 0;
3176 }
3177
3178 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3179 {
3180     char *p;
3181     int n = 1, i;
3182
3183     for (p = kf; *p; p++)
3184         if (*p == ',')
3185             n++;
3186     ost->forced_kf_count = n;
3187     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3188     if (!ost->forced_kf_pts) {
3189         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3190         exit_program(1);
3191     }
3192     for (i = 0; i < n; i++) {
3193         p = i ? strchr(p, ',') + 1 : kf;
3194         ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3195     }
3196 }
3197
3198 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3199 {
3200     OutputStream *ost;
3201     AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3202     int idx      = oc->nb_streams - 1;
3203     int64_t max_frames = INT64_MAX;
3204     char *bsf = NULL, *next, *codec_tag = NULL;
3205     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3206     double qscale = -1;
3207
3208     if (!st) {
3209         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3210         exit_program(1);
3211     }
3212
3213     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3214                                 nb_output_streams + 1);
3215     ost = &output_streams[nb_output_streams - 1];
3216     ost->file_index = nb_output_files;
3217     ost->index = idx;
3218     ost->st    = st;
3219     st->codec->codec_type = type;
3220     ost->enc = choose_codec(o, oc, st, type);
3221     if (ost->enc) {
3222         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3223     }
3224
3225     avcodec_get_context_defaults3(st->codec, ost->enc);
3226     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3227
3228     MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3229     ost->max_frames = max_frames;
3230
3231     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3232     while (bsf) {
3233         if (next = strchr(bsf, ','))
3234             *next++ = 0;
3235         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3236             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3237             exit_program(1);
3238         }
3239         if (bsfc_prev)
3240             bsfc_prev->next = bsfc;
3241         else
3242             ost->bitstream_filters = bsfc;
3243
3244         bsfc_prev = bsfc;
3245         bsf       = next;
3246     }
3247
3248     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3249     if (codec_tag) {
3250         uint32_t tag = strtol(codec_tag, &next, 0);
3251         if (*next)
3252             tag = AV_RL32(codec_tag);
3253         st->codec->codec_tag = tag;
3254     }
3255
3256     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3257     if (qscale >= 0 || same_quant) {
3258         st->codec->flags |= CODEC_FLAG_QSCALE;
3259         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3260     }
3261
3262     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3263         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3264
3265     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3266     return ost;
3267 }
3268
3269 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3270 {
3271     int i;
3272     const char *p = str;
3273     for(i = 0;; i++) {
3274         dest[i] = atoi(p);
3275         if(i == 63)
3276             break;
3277         p = strchr(p, ',');
3278         if(!p) {
3279             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3280             exit_program(1);
3281         }
3282         p++;
3283     }
3284 }
3285
3286 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3287 {
3288     AVStream *st;
3289     OutputStream *ost;
3290     AVCodecContext *video_enc;
3291
3292     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3293     st  = ost->st;
3294     video_enc = st->codec;
3295
3296     if (!st->stream_copy) {
3297         const char *p = NULL;
3298         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3299         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3300         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3301         int i, force_fps = 0, top_field_first = -1;
3302
3303         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3304         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3305             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3306             exit_program(1);
3307         }
3308
3309         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3310         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3311             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3312             exit_program(1);
3313         }
3314
3315         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3316         if (frame_aspect_ratio)
3317             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3318
3319         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3320         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3321         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3322             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3323             exit_program(1);
3324         }
3325         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3326
3327         if (intra_only)
3328             video_enc->gop_size = 0;
3329         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3330         if (intra_matrix) {
3331             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3332                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3333                 exit_program(1);
3334             }
3335             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3336         }
3337         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3338         if (inter_matrix) {
3339             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3340                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3341                 exit_program(1);
3342             }
3343             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3344         }
3345
3346         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3347         for(i=0; p; i++){
3348             int start, end, q;
3349             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3350             if(e!=3){
3351                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3352                 exit_program(1);
3353             }
3354             /* FIXME realloc failure */
3355             video_enc->rc_override=
3356                 av_realloc(video_enc->rc_override,
3357                            sizeof(RcOverride)*(i+1));
3358             video_enc->rc_override[i].start_frame= start;
3359             video_enc->rc_override[i].end_frame  = end;
3360             if(q>0){
3361                 video_enc->rc_override[i].qscale= q;
3362                 video_enc->rc_override[i].quality_factor= 1.0;
3363             }
3364             else{
3365                 video_enc->rc_override[i].qscale= 0;
3366                 video_enc->rc_override[i].quality_factor= -q/100.0;
3367             }
3368             p= strchr(p, '/');
3369             if(p) p++;
3370         }
3371         video_enc->rc_override_count=i;
3372         if (!video_enc->rc_initial_buffer_occupancy)
3373             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3374         video_enc->intra_dc_precision= intra_dc_precision - 8;
3375
3376         /* two pass mode */
3377         if (do_pass) {
3378             if (do_pass == 1) {
3379                 video_enc->flags |= CODEC_FLAG_PASS1;
3380             } else {
3381                 video_enc->flags |= CODEC_FLAG_PASS2;
3382             }
3383         }
3384
3385         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3386         if (forced_key_frames)
3387             parse_forced_key_frames(forced_key_frames, ost);
3388
3389         MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3390         ost->force_fps = force_fps;
3391
3392         MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3393         ost->top_field_first = top_field_first;
3394
3395 #if CONFIG_AVFILTER
3396         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3397         if (filters)
3398             ost->avfilter = av_strdup(filters);
3399 #endif
3400     }
3401
3402     return ost;
3403 }
3404
3405 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3406 {
3407     AVStream *st;
3408     OutputStream *ost;
3409     AVCodecContext *audio_enc;
3410
3411     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3412     st  = ost->st;
3413
3414     audio_enc = st->codec;
3415     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3416
3417     if (!st->stream_copy) {
3418         char *sample_fmt = NULL;
3419
3420         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3421
3422         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3423         if (sample_fmt &&
3424             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3425             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3426             exit_program(1);
3427         }
3428
3429         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3430     }
3431
3432     return ost;
3433 }
3434
3435 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3436 {
3437     AVStream *st;
3438     OutputStream *ost;
3439
3440     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3441     st  = ost->st;
3442     if (!st->stream_copy) {
3443         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3444         exit_program(1);
3445     }
3446
3447     return ost;
3448 }
3449
3450 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3451 {
3452     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3453     ost->st->stream_copy = 1;
3454     return ost;
3455 }
3456
3457 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3458 {
3459     AVStream *st;
3460     OutputStream *ost;
3461     AVCodecContext *subtitle_enc;
3462
3463     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3464     st  = ost->st;
3465     subtitle_enc = st->codec;
3466
3467     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3468
3469     return ost;
3470 }
3471
3472 /* arg format is "output-stream-index:streamid-value". */
3473 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3474 {
3475     int idx;
3476     char *p;
3477     char idx_str[16];
3478
3479     av_strlcpy(idx_str, arg, sizeof(idx_str));
3480     p = strchr(idx_str, ':');
3481     if (!p) {
3482         av_log(NULL, AV_LOG_FATAL,
3483                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3484                arg, opt);
3485         exit_program(1);
3486     }
3487     *p++ = '\0';
3488     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3489     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3490     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3491     return 0;
3492 }
3493
3494 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3495 {
3496     AVFormatContext *is = ifile->ctx;
3497     AVFormatContext *os = ofile->ctx;
3498     int i;
3499
3500     for (i = 0; i < is->nb_chapters; i++) {
3501         AVChapter *in_ch = is->chapters[i], *out_ch;
3502         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3503                                       AV_TIME_BASE_Q, in_ch->time_base);
3504         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3505                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3506
3507
3508         if (in_ch->end < ts_off)
3509             continue;
3510         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3511             break;
3512
3513         out_ch = av_mallocz(sizeof(AVChapter));
3514         if (!out_ch)
3515             return AVERROR(ENOMEM);
3516
3517         out_ch->id        = in_ch->id;
3518         out_ch->time_base = in_ch->time_base;
3519         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3520         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3521
3522         if (copy_metadata)
3523             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3524
3525         os->nb_chapters++;
3526         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3527         if (!os->chapters)
3528             return AVERROR(ENOMEM);
3529         os->chapters[os->nb_chapters - 1] = out_ch;
3530     }
3531     return 0;
3532 }
3533
3534 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3535 {
3536     int i, err;
3537     AVFormatContext *ic = NULL;
3538
3539     err = avformat_open_input(&ic, filename, NULL, NULL);
3540     if (err < 0)
3541         return err;
3542     /* copy stream format */
3543     for(i=0;i<ic->nb_streams;i++) {
3544         AVStream *st;
3545         OutputStream *ost;
3546         AVCodec *codec;
3547
3548         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3549         ost   = new_output_stream(o, s, codec->type);
3550         st    = ost->st;
3551
3552         // FIXME: a more elegant solution is needed
3553         memcpy(st, ic->streams[i], sizeof(AVStream));
3554         st->info = av_malloc(sizeof(*st->info));
3555         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3556         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3557
3558         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3559             choose_sample_fmt(st, codec);
3560         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3561             choose_pixel_fmt(st, codec);
3562     }
3563
3564     av_close_input_file(ic);
3565     return 0;
3566 }
3567
3568 static void opt_output_file(void *optctx, const char *filename)
3569 {
3570     OptionsContext *o = optctx;
3571     AVFormatContext *oc;
3572     int i, err;
3573     AVOutputFormat *file_oformat;
3574     OutputStream *ost;
3575     InputStream  *ist;
3576
3577     if (!strcmp(filename, "-"))
3578         filename = "pipe:";
3579
3580     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3581     if (!oc) {
3582         print_error(filename, err);
3583         exit_program(1);
3584     }
3585     file_oformat= oc->oformat;
3586
3587     if (!strcmp(file_oformat->name, "ffm") &&
3588         av_strstart(filename, "http:", NULL)) {
3589         /* special case for files sent to ffserver: we get the stream
3590            parameters from ffserver */
3591         int err = read_ffserver_streams(o, oc, filename);
3592         if (err < 0) {
3593             print_error(filename, err);
3594             exit_program(1);
3595         }
3596     } else if (!o->nb_stream_maps) {
3597         /* pick the "best" stream of each type */
3598 #define NEW_STREAM(type, index)\
3599         if (index >= 0) {\
3600             ost = new_ ## type ## _stream(o, oc);\
3601             ost->source_index = index;\
3602             ost->sync_ist     = &input_streams[index];\
3603             input_streams[index].discard = 0;\
3604         }
3605
3606         /* video: highest resolution */
3607         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3608             int area = 0, idx = -1;
3609             for (i = 0; i < nb_input_streams; i++) {
3610                 ist = &input_streams[i];
3611                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3612                     ist->st->codec->width * ist->st->codec->height > area) {
3613                     area = ist->st->codec->width * ist->st->codec->height;
3614                     idx = i;
3615                 }
3616             }
3617             NEW_STREAM(video, idx);
3618         }
3619
3620         /* audio: most channels */
3621         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3622             int channels = 0, idx = -1;
3623             for (i = 0; i < nb_input_streams; i++) {
3624                 ist = &input_streams[i];
3625                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3626                     ist->st->codec->channels > channels) {
3627                     channels = ist->st->codec->channels;
3628                     idx = i;
3629                 }
3630             }
3631             NEW_STREAM(audio, idx);
3632         }
3633
3634         /* subtitles: pick first */
3635         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3636             for (i = 0; i < nb_input_streams; i++)
3637                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3638                     NEW_STREAM(subtitle, i);
3639                     break;
3640                 }
3641         }
3642         /* do something with data? */
3643     } else {
3644         for (i = 0; i < o->nb_stream_maps; i++) {
3645             StreamMap *map = &o->stream_maps[i];
3646
3647             if (map->disabled)
3648                 continue;
3649
3650             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3651             switch (ist->st->codec->codec_type) {
3652             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3653             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3654             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3655             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3656             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3657             default:
3658                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3659                        map->file_index, map->stream_index);
3660                 exit_program(1);
3661             }
3662
3663             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3664             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3665                                            map->sync_stream_index];
3666             ist->discard = 0;
3667         }
3668     }
3669
3670     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3671     output_files[nb_output_files - 1].ctx       = oc;
3672     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3673     output_files[nb_output_files - 1].recording_time = o->recording_time;
3674     output_files[nb_output_files - 1].start_time     = o->start_time;
3675     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3676     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3677
3678     /* check filename in case of an image number is expected */
3679     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3680         if (!av_filename_number_test(oc->filename)) {
3681             print_error(oc->filename, AVERROR(EINVAL));
3682             exit_program(1);
3683         }
3684     }
3685
3686     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3687         /* test if it already exists to avoid loosing precious files */
3688         if (!file_overwrite &&
3689             (strchr(filename, ':') == NULL ||
3690              filename[1] == ':' ||
3691              av_strstart(filename, "file:", NULL))) {
3692             if (avio_check(filename, 0) == 0) {
3693                 if (!using_stdin) {
3694                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3695                     fflush(stderr);
3696                     if (!read_yesno()) {
3697                         av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3698                         exit_program(1);
3699                     }
3700                 }
3701                 else {
3702                     av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3703                     exit_program(1);
3704                 }
3705             }
3706         }
3707
3708         /* open the file */
3709         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3710             print_error(filename, err);
3711             exit_program(1);
3712         }
3713     }
3714
3715     oc->preload   = (int)(o->mux_preload   * AV_TIME_BASE);
3716     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3717
3718     if (loop_output >= 0) {
3719         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3720         oc->loop_output = loop_output;
3721     }
3722
3723     /* copy chapters */
3724     if (o->chapters_input_file >= nb_input_files) {
3725         if (o->chapters_input_file == INT_MAX) {
3726             /* copy chapters from the first input file that has them*/
3727             o->chapters_input_file = -1;
3728             for (i = 0; i < nb_input_files; i++)
3729                 if (input_files[i].ctx->nb_chapters) {
3730                     o->chapters_input_file = i;
3731                     break;
3732                 }
3733         } else {
3734             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3735                    o->chapters_input_file);
3736             exit_program(1);
3737         }
3738     }
3739     if (o->chapters_input_file >= 0)
3740         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3741                       !o->metadata_chapters_manual);
3742
3743     /* copy metadata */
3744     for (i = 0; i < o->nb_meta_data_maps; i++) {
3745         AVFormatContext *files[2];
3746         AVDictionary    **meta[2];
3747         int j;
3748
3749 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3750         if ((index) < 0 || (index) >= (nb_elems)) {\
3751             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3752                      (desc), (index));\
3753             exit_program(1);\
3754         }
3755
3756         int in_file_index = o->meta_data_maps[i][1].file;
3757         if (in_file_index < 0)
3758             continue;
3759         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3760
3761         files[0] = oc;
3762         files[1] = input_files[in_file_index].ctx;
3763
3764         for (j = 0; j < 2; j++) {
3765             MetadataMap *map = &o->meta_data_maps[i][j];
3766
3767             switch (map->type) {
3768             case 'g':
3769                 meta[j] = &files[j]->metadata;
3770                 break;
3771             case 's':
3772                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3773                 meta[j] = &files[j]->streams[map->index]->metadata;
3774                 break;
3775             case 'c':
3776                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3777                 meta[j] = &files[j]->chapters[map->index]->metadata;
3778                 break;
3779             case 'p':
3780                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3781                 meta[j] = &files[j]->programs[map->index]->metadata;
3782                 break;
3783             }
3784         }
3785
3786         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3787     }
3788
3789     /* copy global metadata by default */
3790     if (!o->metadata_global_manual && nb_input_files){
3791         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3792                      AV_DICT_DONT_OVERWRITE);
3793         if(o->recording_time != INT64_MAX)
3794             av_dict_set(&oc->metadata, "duration", NULL, 0);
3795     }
3796     if (!o->metadata_streams_manual)
3797         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3798             InputStream *ist = &input_streams[output_streams[i].source_index];
3799             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3800         }
3801
3802     /* process manually set metadata */
3803     for (i = 0; i < o->nb_metadata; i++) {
3804         AVDictionary **m;
3805         char type, *val;
3806         int index = 0;
3807
3808         val = strchr(o->metadata[i].u.str, '=');
3809         if (!val) {
3810             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3811                    o->metadata[i].u.str);
3812             exit_program(1);
3813         }
3814         *val++ = 0;
3815
3816         parse_meta_type(o->metadata[i].specifier, &type, &index);
3817         switch (type) {
3818         case 'g':
3819             m = &oc->metadata;
3820             break;
3821         case 's':
3822             if (index < 0 || index >= oc->nb_streams) {
3823                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3824                 exit_program(1);
3825             }
3826             m = &oc->streams[index]->metadata;
3827             break;
3828         case 'c':
3829             if (index < 0 || index >= oc->nb_chapters) {
3830                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3831                 exit_program(1);
3832             }
3833             m = &oc->chapters[index]->metadata;
3834             break;
3835         default:
3836             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3837             exit_program(1);
3838         }
3839
3840         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3841     }
3842
3843     reset_options(o, 0);
3844 }
3845
3846 /* same option as mencoder */
3847 static int opt_pass(const char *opt, const char *arg)
3848 {
3849     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3850     return 0;
3851 }
3852
3853 static int64_t getutime(void)
3854 {
3855 #if HAVE_GETRUSAGE
3856     struct rusage rusage;
3857
3858     getrusage(RUSAGE_SELF, &rusage);
3859     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3860 #elif HAVE_GETPROCESSTIMES
3861     HANDLE proc;
3862     FILETIME c, e, k, u;
3863     proc = GetCurrentProcess();
3864     GetProcessTimes(proc, &c, &e, &k, &u);
3865     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3866 #else
3867     return av_gettime();
3868 #endif
3869 }
3870
3871 static int64_t getmaxrss(void)
3872 {
3873 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3874     struct rusage rusage;
3875     getrusage(RUSAGE_SELF, &rusage);
3876     return (int64_t)rusage.ru_maxrss * 1024;
3877 #elif HAVE_GETPROCESSMEMORYINFO
3878     HANDLE proc;
3879     PROCESS_MEMORY_COUNTERS memcounters;
3880     proc = GetCurrentProcess();
3881     memcounters.cb = sizeof(memcounters);
3882     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3883     return memcounters.PeakPagefileUsage;
3884 #else
3885     return 0;
3886 #endif
3887 }
3888
3889 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3890 {
3891     return parse_option(o, "q:a", arg, options);
3892 }
3893
3894 static void show_usage(void)
3895 {
3896     printf("Hyper fast Audio and Video encoder\n");
3897     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3898     printf("\n");
3899 }
3900
3901 static int opt_help(const char *opt, const char *arg)
3902 {
3903     AVCodec *c;
3904     AVOutputFormat *oformat = NULL;
3905     AVInputFormat  *iformat = NULL;
3906     const AVClass *class;
3907
3908     av_log_set_callback(log_callback_help);
3909     show_usage();
3910     show_help_options(options, "Main options:\n",
3911                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3912     show_help_options(options, "\nAdvanced options:\n",
3913                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3914                       OPT_EXPERT);
3915     show_help_options(options, "\nVideo options:\n",
3916                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3917                       OPT_VIDEO);
3918     show_help_options(options, "\nAdvanced Video options:\n",
3919                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3920                       OPT_VIDEO | OPT_EXPERT);
3921     show_help_options(options, "\nAudio options:\n",
3922                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3923                       OPT_AUDIO);
3924     show_help_options(options, "\nAdvanced Audio options:\n",
3925                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3926                       OPT_AUDIO | OPT_EXPERT);
3927     show_help_options(options, "\nSubtitle options:\n",
3928                       OPT_SUBTITLE | OPT_GRAB,
3929                       OPT_SUBTITLE);
3930     show_help_options(options, "\nAudio/Video grab options:\n",
3931                       OPT_GRAB,
3932                       OPT_GRAB);
3933     printf("\n");
3934     class = avcodec_get_class();
3935     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3936     printf("\n");
3937
3938     /* individual codec options */
3939     c = NULL;
3940     while ((c = av_codec_next(c))) {
3941         if (c->priv_class) {
3942             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3943             printf("\n");
3944         }
3945     }
3946
3947     class = avformat_get_class();
3948     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3949     printf("\n");
3950
3951     /* individual muxer options */
3952     while ((oformat = av_oformat_next(oformat))) {
3953         if (oformat->priv_class) {
3954             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3955             printf("\n");
3956         }
3957     }
3958
3959     /* individual demuxer options */
3960     while ((iformat = av_iformat_next(iformat))) {
3961         if (iformat->priv_class) {
3962             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3963             printf("\n");
3964         }
3965     }
3966
3967     class = sws_get_class();
3968     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3969     return 0;
3970 }
3971
3972 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3973 {
3974     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3975     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3976
3977     if(!strncmp(arg, "pal-", 4)) {
3978         norm = PAL;
3979         arg += 4;
3980     } else if(!strncmp(arg, "ntsc-", 5)) {
3981         norm = NTSC;
3982         arg += 5;
3983     } else if(!strncmp(arg, "film-", 5)) {
3984         norm = FILM;
3985         arg += 5;
3986     } else {
3987         /* Try to determine PAL/NTSC by peeking in the input files */
3988         if(nb_input_files) {
3989             int i, j, fr;
3990             for (j = 0; j < nb_input_files; j++) {
3991                 for (i = 0; i < input_files[j].nb_streams; i++) {
3992                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3993                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3994                         continue;
3995                     fr = c->time_base.den * 1000 / c->time_base.num;
3996                     if(fr == 25000) {
3997                         norm = PAL;
3998                         break;
3999                     } else if((fr == 29970) || (fr == 23976)) {
4000                         norm = NTSC;
4001                         break;
4002                     }
4003                 }
4004                 if(norm != UNKNOWN)
4005                     break;
4006             }
4007         }
4008         if (norm != UNKNOWN)
4009             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4010     }
4011
4012     if(norm == UNKNOWN) {
4013         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4014         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4015         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4016         exit_program(1);
4017     }
4018
4019     if(!strcmp(arg, "vcd")) {
4020         opt_video_codec(o, "c:v", "mpeg1video");
4021         opt_audio_codec(o, "c:a", "mp2");
4022         parse_option(o, "f", "vcd", options);
4023
4024         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4025         parse_option(o, "r", frame_rates[norm], options);
4026         opt_default("g", norm == PAL ? "15" : "18");
4027
4028         opt_default("b", "1150000");
4029         opt_default("maxrate", "1150000");
4030         opt_default("minrate", "1150000");
4031         opt_default("bufsize", "327680"); // 40*1024*8;
4032
4033         opt_default("b:a", "224000");
4034         parse_option(o, "ar", "44100", options);
4035         parse_option(o, "ac", "2", options);
4036
4037         opt_default("packetsize", "2324");
4038         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4039
4040         /* We have to offset the PTS, so that it is consistent with the SCR.
4041            SCR starts at 36000, but the first two packs contain only padding
4042            and the first pack from the other stream, respectively, may also have
4043            been written before.
4044            So the real data starts at SCR 36000+3*1200. */
4045         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4046     } else if(!strcmp(arg, "svcd")) {
4047
4048         opt_video_codec(o, "c:v", "mpeg2video");
4049         opt_audio_codec(o, "c:a", "mp2");
4050         parse_option(o, "f", "svcd", options);
4051
4052         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4053         parse_option(o, "r", frame_rates[norm], options);
4054         parse_option(o, "pix_fmt", "yuv420p", options);
4055         opt_default("g", norm == PAL ? "15" : "18");
4056
4057         opt_default("b", "2040000");
4058         opt_default("maxrate", "2516000");
4059         opt_default("minrate", "0"); //1145000;
4060         opt_default("bufsize", "1835008"); //224*1024*8;
4061         opt_default("flags", "+scan_offset");
4062
4063
4064         opt_default("b:a", "224000");
4065         parse_option(o, "ar", "44100", options);
4066
4067         opt_default("packetsize", "2324");
4068
4069     } else if(!strcmp(arg, "dvd")) {
4070
4071         opt_video_codec(o, "c:v", "mpeg2video");
4072         opt_audio_codec(o, "c:a", "ac3");
4073         parse_option(o, "f", "dvd", options);
4074
4075         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4076         parse_option(o, "r", frame_rates[norm], options);
4077         parse_option(o, "pix_fmt", "yuv420p", options);
4078         opt_default("g", norm == PAL ? "15" : "18");
4079
4080         opt_default("b", "6000000");
4081         opt_default("maxrate", "9000000");
4082         opt_default("minrate", "0"); //1500000;
4083         opt_default("bufsize", "1835008"); //224*1024*8;
4084
4085         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4086         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4087
4088         opt_default("b:a", "448000");
4089         parse_option(o, "ar", "48000", options);
4090
4091     } else if(!strncmp(arg, "dv", 2)) {
4092
4093         parse_option(o, "f", "dv", options);
4094
4095         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4096         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4097                           norm == PAL ? "yuv420p" : "yuv411p", options);
4098         parse_option(o, "r", frame_rates[norm], options);
4099
4100         parse_option(o, "ar", "48000", options);
4101         parse_option(o, "ac", "2", options);
4102
4103     } else {
4104         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4105         return AVERROR(EINVAL);
4106     }
4107     return 0;
4108 }
4109
4110 static int opt_vstats_file(const char *opt, const char *arg)
4111 {
4112     av_free (vstats_filename);
4113     vstats_filename=av_strdup (arg);
4114     return 0;
4115 }
4116
4117 static int opt_vstats(const char *opt, const char *arg)
4118 {
4119     char filename[40];
4120     time_t today2 = time(NULL);
4121     struct tm *today = localtime(&today2);
4122
4123     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4124              today->tm_sec);
4125     return opt_vstats_file(opt, filename);
4126 }
4127
4128 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4129 {
4130     return parse_option(o, "frames:v", arg, options);
4131 }
4132
4133 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4134 {
4135     return parse_option(o, "frames:a", arg, options);
4136 }
4137
4138 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4139 {
4140     return parse_option(o, "frames:d", arg, options);
4141 }
4142
4143 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4144 {
4145     FILE *f=NULL;
4146     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4147     const char *codec_name = *opt == 'v' ? video_codec_name :
4148                              *opt == 'a' ? audio_codec_name :
4149                                            subtitle_codec_name;
4150
4151     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4152         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4153             av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4154         }else
4155             av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4156         exit_program(1);
4157     }
4158
4159     while(!feof(f)){
4160         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4161         if(line[0] == '#' && !e)
4162             continue;
4163         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4164         if(e){
4165             av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4166             exit_program(1);
4167         }
4168         if(!strcmp(tmp, "acodec")){
4169             opt_audio_codec(o, tmp, tmp2);
4170         }else if(!strcmp(tmp, "vcodec")){
4171             opt_video_codec(o, tmp, tmp2);
4172         }else if(!strcmp(tmp, "scodec")){
4173             opt_subtitle_codec(o, tmp, tmp2);
4174         }else if(!strcmp(tmp, "dcodec")){
4175             opt_data_codec(o, tmp, tmp2);
4176         }else if(opt_default(tmp, tmp2) < 0){
4177             av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4178             exit_program(1);
4179         }
4180     }
4181
4182     fclose(f);
4183
4184     return 0;
4185 }
4186
4187 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4188 {
4189 }
4190
4191 static int opt_passlogfile(const char *opt, const char *arg)
4192 {
4193     pass_logfilename_prefix = arg;
4194 #if CONFIG_LIBX264_ENCODER
4195     return opt_default("passlogfile", arg);
4196 #else
4197     return 0;
4198 #endif
4199 }
4200
4201 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4202 {
4203     char *s= av_malloc(strlen(opt)+2);
4204     snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4205     return parse_option(o, s, arg, options);
4206 }
4207
4208 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4209 {
4210     if(!strcmp(opt, "b")){
4211         av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4212         return parse_option(o, av_strdup("b:v"), arg, options);
4213     }
4214     return opt_default(opt, arg);
4215 }
4216
4217 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4218 {
4219     return parse_option(o, "filter:v", arg, options);
4220 }
4221
4222 #define OFFSET(x) offsetof(OptionsContext, x)
4223 static const OptionDef options[] = {
4224     /* main options */
4225 #include "cmdutils_common_opts.h"
4226     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4227     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4228     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4229     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4230     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4231     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4232     { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4233       "outfile[,metadata]:infile[,metadata]" },
4234     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4235       "outfile[,metadata]:infile[,metadata]" },
4236     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4237     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4238     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4239     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4240     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4241     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4242     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4243     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4244     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4245     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4246       "add timings for benchmarking" },
4247     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4248     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4249       "dump each input packet" },
4250     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4251       "when dumping packets, also dump the payload" },
4252     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4253     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4254     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4255     { "v", HAS_ARG, {(void*)opt_verbose}, "deprecated, use -loglevel instead", "number" },
4256     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4257     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4258     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4259     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4260     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4261     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4262     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4263     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4264     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4265     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4266     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4267     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4268     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4269     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4270 #if CONFIG_AVFILTER
4271     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4272 #endif
4273
4274     /* video options */
4275     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4276     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4277     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4278     { "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" },
4279     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4280     { "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" },
4281     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4282     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4283     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4284     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4285     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4286     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4287     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4288     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4289     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4290     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4291     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4292     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4293     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4294     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4295     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4296     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4297       "use same quantizer as source (implies VBR)" },
4298     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4299     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4300     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4301       "deinterlace pictures" },
4302     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4303     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4304 #if CONFIG_AVFILTER
4305     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4306 #endif
4307     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4308     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4309     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4310     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4311     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4312     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4313     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4314     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4315     { "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" },
4316     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4317
4318     /* audio options */
4319     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4320     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4321     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4322     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4323     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4324     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4325     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4326     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4327     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4328
4329     /* subtitle options */
4330     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4331     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4332     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4333
4334     /* grab options */
4335     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4336     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4337     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4338
4339     /* muxer options */
4340     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4341     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4342
4343     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4344     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4345     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4346
4347     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4348     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4349     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4350     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4351     /* data codec support */
4352     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4353
4354     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4355     { NULL, },
4356 };
4357
4358 int main(int argc, char **argv)
4359 {
4360     OptionsContext o = { 0 };
4361     int64_t ti;
4362
4363     reset_options(&o, 0);
4364
4365     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4366     parse_loglevel(argc, argv, options);
4367
4368     if(argc>1 && !strcmp(argv[1], "-d")){
4369         run_as_daemon=1;
4370         av_log_set_callback(log_callback_null);
4371         argc--;
4372         argv++;
4373     }
4374
4375     avcodec_register_all();
4376 #if CONFIG_AVDEVICE
4377     avdevice_register_all();
4378 #endif
4379 #if CONFIG_AVFILTER
4380     avfilter_register_all();
4381 #endif
4382     av_register_all();
4383
4384 #if HAVE_ISATTY
4385     if(isatty(STDIN_FILENO))
4386         avio_set_interrupt_cb(decode_interrupt_cb);
4387 #endif
4388
4389     show_banner();
4390
4391     /* parse options */
4392     parse_options(&o, argc, argv, options, opt_output_file);
4393
4394     if(nb_output_files <= 0 && nb_input_files == 0) {
4395         show_usage();
4396         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4397         exit_program(1);
4398     }
4399
4400     /* file converter / grab */
4401     if (nb_output_files <= 0) {
4402         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4403         exit_program(1);
4404     }
4405
4406     if (nb_input_files == 0) {
4407         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4408         exit_program(1);
4409     }
4410
4411     ti = getutime();
4412     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4413         exit_program(1);
4414     ti = getutime() - ti;
4415     if (do_benchmark) {
4416         int maxrss = getmaxrss() / 1024;
4417         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4418     }
4419
4420     exit_program(0);
4421     return 0;
4422 }