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