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
3640         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3641         ost   = new_output_stream(o, s, codec->type);
3642         st    = ost->st;
3643
3644         // FIXME: a more elegant solution is needed
3645         memcpy(st, ic->streams[i], sizeof(AVStream));
3646         st->info = av_malloc(sizeof(*st->info));
3647         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3648         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3649
3650         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3651             choose_sample_fmt(st, codec);
3652         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3653             choose_pixel_fmt(st, codec);
3654     }
3655
3656     av_close_input_file(ic);
3657     return 0;
3658 }
3659
3660 static void opt_output_file(void *optctx, const char *filename)
3661 {
3662     OptionsContext *o = optctx;
3663     AVFormatContext *oc;
3664     int i, err;
3665     AVOutputFormat *file_oformat;
3666     OutputStream *ost;
3667     InputStream  *ist;
3668
3669     if (!strcmp(filename, "-"))
3670         filename = "pipe:";
3671
3672     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3673     if (!oc) {
3674         print_error(filename, err);
3675         exit_program(1);
3676     }
3677     file_oformat= oc->oformat;
3678
3679     if (!strcmp(file_oformat->name, "ffm") &&
3680         av_strstart(filename, "http:", NULL)) {
3681         /* special case for files sent to ffserver: we get the stream
3682            parameters from ffserver */
3683         int err = read_ffserver_streams(o, oc, filename);
3684         if (err < 0) {
3685             print_error(filename, err);
3686             exit_program(1);
3687         }
3688     } else if (!o->nb_stream_maps) {
3689         /* pick the "best" stream of each type */
3690 #define NEW_STREAM(type, index)\
3691         if (index >= 0) {\
3692             ost = new_ ## type ## _stream(o, oc);\
3693             ost->source_index = index;\
3694             ost->sync_ist     = &input_streams[index];\
3695             input_streams[index].discard = 0;\
3696         }
3697
3698         /* video: highest resolution */
3699         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3700             int area = 0, idx = -1;
3701             for (i = 0; i < nb_input_streams; i++) {
3702                 ist = &input_streams[i];
3703                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3704                     ist->st->codec->width * ist->st->codec->height > area) {
3705                     area = ist->st->codec->width * ist->st->codec->height;
3706                     idx = i;
3707                 }
3708             }
3709             NEW_STREAM(video, idx);
3710         }
3711
3712         /* audio: most channels */
3713         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3714             int channels = 0, idx = -1;
3715             for (i = 0; i < nb_input_streams; i++) {
3716                 ist = &input_streams[i];
3717                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3718                     ist->st->codec->channels > channels) {
3719                     channels = ist->st->codec->channels;
3720                     idx = i;
3721                 }
3722             }
3723             NEW_STREAM(audio, idx);
3724         }
3725
3726         /* subtitles: pick first */
3727         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3728             for (i = 0; i < nb_input_streams; i++)
3729                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3730                     NEW_STREAM(subtitle, i);
3731                     break;
3732                 }
3733         }
3734         /* do something with data? */
3735     } else {
3736         for (i = 0; i < o->nb_stream_maps; i++) {
3737             StreamMap *map = &o->stream_maps[i];
3738
3739             if (map->disabled)
3740                 continue;
3741
3742             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3743             if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
3744                 continue;
3745             if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3746                 continue;
3747             if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3748                 continue;
3749
3750             switch (ist->st->codec->codec_type) {
3751             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3752             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3753             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3754             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3755             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3756             default:
3757                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3758                        map->file_index, map->stream_index);
3759                 exit_program(1);
3760             }
3761
3762             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3763             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3764                                            map->sync_stream_index];
3765             ist->discard = 0;
3766         }
3767     }
3768
3769     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3770     output_files[nb_output_files - 1].ctx       = oc;
3771     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3772     output_files[nb_output_files - 1].recording_time = o->recording_time;
3773     output_files[nb_output_files - 1].start_time     = o->start_time;
3774     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3775     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3776
3777     /* check filename in case of an image number is expected */
3778     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3779         if (!av_filename_number_test(oc->filename)) {
3780             print_error(oc->filename, AVERROR(EINVAL));
3781             exit_program(1);
3782         }
3783     }
3784
3785     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3786         /* test if it already exists to avoid loosing precious files */
3787         if (!file_overwrite &&
3788             (strchr(filename, ':') == NULL ||
3789              filename[1] == ':' ||
3790              av_strstart(filename, "file:", NULL))) {
3791             if (avio_check(filename, 0) == 0) {
3792                 if (!using_stdin) {
3793                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3794                     fflush(stderr);
3795                     term_exit();
3796                     if (!read_yesno()) {
3797                         av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3798                         exit_program(1);
3799                     }
3800                     term_init();
3801                 }
3802                 else {
3803                     av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3804                     exit_program(1);
3805                 }
3806             }
3807         }
3808
3809         /* open the file */
3810         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3811             print_error(filename, err);
3812             exit_program(1);
3813         }
3814     }
3815
3816     if (o->mux_preload) {
3817         uint8_t buf[64];
3818         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3819         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3820     }
3821     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3822
3823     if (loop_output >= 0) {
3824         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3825         oc->loop_output = loop_output;
3826     }
3827
3828     /* copy chapters */
3829     if (o->chapters_input_file >= nb_input_files) {
3830         if (o->chapters_input_file == INT_MAX) {
3831             /* copy chapters from the first input file that has them*/
3832             o->chapters_input_file = -1;
3833             for (i = 0; i < nb_input_files; i++)
3834                 if (input_files[i].ctx->nb_chapters) {
3835                     o->chapters_input_file = i;
3836                     break;
3837                 }
3838         } else {
3839             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3840                    o->chapters_input_file);
3841             exit_program(1);
3842         }
3843     }
3844     if (o->chapters_input_file >= 0)
3845         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3846                       !o->metadata_chapters_manual);
3847
3848     /* copy metadata */
3849     for (i = 0; i < o->nb_meta_data_maps; i++) {
3850         AVFormatContext *files[2];
3851         AVDictionary    **meta[2];
3852         int j;
3853
3854 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3855         if ((index) < 0 || (index) >= (nb_elems)) {\
3856             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3857                      (desc), (index));\
3858             exit_program(1);\
3859         }
3860
3861         int in_file_index = o->meta_data_maps[i][1].file;
3862         if (in_file_index < 0)
3863             continue;
3864         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3865
3866         files[0] = oc;
3867         files[1] = input_files[in_file_index].ctx;
3868
3869         for (j = 0; j < 2; j++) {
3870             MetadataMap *map = &o->meta_data_maps[i][j];
3871
3872             switch (map->type) {
3873             case 'g':
3874                 meta[j] = &files[j]->metadata;
3875                 break;
3876             case 's':
3877                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3878                 meta[j] = &files[j]->streams[map->index]->metadata;
3879                 break;
3880             case 'c':
3881                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3882                 meta[j] = &files[j]->chapters[map->index]->metadata;
3883                 break;
3884             case 'p':
3885                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3886                 meta[j] = &files[j]->programs[map->index]->metadata;
3887                 break;
3888             }
3889         }
3890
3891         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3892     }
3893
3894     /* copy global metadata by default */
3895     if (!o->metadata_global_manual && nb_input_files){
3896         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3897                      AV_DICT_DONT_OVERWRITE);
3898         if(o->recording_time != INT64_MAX)
3899             av_dict_set(&oc->metadata, "duration", NULL, 0);
3900     }
3901     if (!o->metadata_streams_manual)
3902         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3903             InputStream *ist = &input_streams[output_streams[i].source_index];
3904             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3905         }
3906
3907     /* process manually set metadata */
3908     for (i = 0; i < o->nb_metadata; i++) {
3909         AVDictionary **m;
3910         char type, *val;
3911         int index = 0;
3912
3913         val = strchr(o->metadata[i].u.str, '=');
3914         if (!val) {
3915             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3916                    o->metadata[i].u.str);
3917             exit_program(1);
3918         }
3919         *val++ = 0;
3920
3921         parse_meta_type(o->metadata[i].specifier, &type, &index);
3922         switch (type) {
3923         case 'g':
3924             m = &oc->metadata;
3925             break;
3926         case 's':
3927             if (index < 0 || index >= oc->nb_streams) {
3928                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3929                 exit_program(1);
3930             }
3931             m = &oc->streams[index]->metadata;
3932             break;
3933         case 'c':
3934             if (index < 0 || index >= oc->nb_chapters) {
3935                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3936                 exit_program(1);
3937             }
3938             m = &oc->chapters[index]->metadata;
3939             break;
3940         default:
3941             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3942             exit_program(1);
3943         }
3944
3945         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3946     }
3947
3948     reset_options(o, 0);
3949 }
3950
3951 /* same option as mencoder */
3952 static int opt_pass(const char *opt, const char *arg)
3953 {
3954     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3955     return 0;
3956 }
3957
3958 static int64_t getutime(void)
3959 {
3960 #if HAVE_GETRUSAGE
3961     struct rusage rusage;
3962
3963     getrusage(RUSAGE_SELF, &rusage);
3964     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3965 #elif HAVE_GETPROCESSTIMES
3966     HANDLE proc;
3967     FILETIME c, e, k, u;
3968     proc = GetCurrentProcess();
3969     GetProcessTimes(proc, &c, &e, &k, &u);
3970     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3971 #else
3972     return av_gettime();
3973 #endif
3974 }
3975
3976 static int64_t getmaxrss(void)
3977 {
3978 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3979     struct rusage rusage;
3980     getrusage(RUSAGE_SELF, &rusage);
3981     return (int64_t)rusage.ru_maxrss * 1024;
3982 #elif HAVE_GETPROCESSMEMORYINFO
3983     HANDLE proc;
3984     PROCESS_MEMORY_COUNTERS memcounters;
3985     proc = GetCurrentProcess();
3986     memcounters.cb = sizeof(memcounters);
3987     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3988     return memcounters.PeakPagefileUsage;
3989 #else
3990     return 0;
3991 #endif
3992 }
3993
3994 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3995 {
3996     return parse_option(o, "q:a", arg, options);
3997 }
3998
3999 static void show_usage(void)
4000 {
4001     printf("Hyper fast Audio and Video encoder\n");
4002     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4003     printf("\n");
4004 }
4005
4006 static int opt_help(const char *opt, const char *arg)
4007 {
4008     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4009     av_log_set_callback(log_callback_help);
4010     show_usage();
4011     show_help_options(options, "Main options:\n",
4012                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4013     show_help_options(options, "\nAdvanced options:\n",
4014                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4015                       OPT_EXPERT);
4016     show_help_options(options, "\nVideo options:\n",
4017                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4018                       OPT_VIDEO);
4019     show_help_options(options, "\nAdvanced Video options:\n",
4020                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4021                       OPT_VIDEO | OPT_EXPERT);
4022     show_help_options(options, "\nAudio options:\n",
4023                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4024                       OPT_AUDIO);
4025     show_help_options(options, "\nAdvanced Audio options:\n",
4026                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4027                       OPT_AUDIO | OPT_EXPERT);
4028     show_help_options(options, "\nSubtitle options:\n",
4029                       OPT_SUBTITLE | OPT_GRAB,
4030                       OPT_SUBTITLE);
4031     show_help_options(options, "\nAudio/Video grab options:\n",
4032                       OPT_GRAB,
4033                       OPT_GRAB);
4034     printf("\n");
4035     show_help_children(avcodec_get_class(), flags);
4036     show_help_children(avformat_get_class(), flags);
4037     show_help_children(sws_get_class(), flags);
4038
4039     return 0;
4040 }
4041
4042 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4043 {
4044     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4045     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4046
4047     if(!strncmp(arg, "pal-", 4)) {
4048         norm = PAL;
4049         arg += 4;
4050     } else if(!strncmp(arg, "ntsc-", 5)) {
4051         norm = NTSC;
4052         arg += 5;
4053     } else if(!strncmp(arg, "film-", 5)) {
4054         norm = FILM;
4055         arg += 5;
4056     } else {
4057         /* Try to determine PAL/NTSC by peeking in the input files */
4058         if(nb_input_files) {
4059             int i, j, fr;
4060             for (j = 0; j < nb_input_files; j++) {
4061                 for (i = 0; i < input_files[j].nb_streams; i++) {
4062                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4063                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4064                         continue;
4065                     fr = c->time_base.den * 1000 / c->time_base.num;
4066                     if(fr == 25000) {
4067                         norm = PAL;
4068                         break;
4069                     } else if((fr == 29970) || (fr == 23976)) {
4070                         norm = NTSC;
4071                         break;
4072                     }
4073                 }
4074                 if(norm != UNKNOWN)
4075                     break;
4076             }
4077         }
4078         if (norm != UNKNOWN)
4079             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4080     }
4081
4082     if(norm == UNKNOWN) {
4083         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4084         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4085         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4086         exit_program(1);
4087     }
4088
4089     if(!strcmp(arg, "vcd")) {
4090         opt_video_codec(o, "c:v", "mpeg1video");
4091         opt_audio_codec(o, "c:a", "mp2");
4092         parse_option(o, "f", "vcd", options);
4093
4094         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4095         parse_option(o, "r", frame_rates[norm], options);
4096         opt_default("g", norm == PAL ? "15" : "18");
4097
4098         opt_default("b", "1150000");
4099         opt_default("maxrate", "1150000");
4100         opt_default("minrate", "1150000");
4101         opt_default("bufsize", "327680"); // 40*1024*8;
4102
4103         opt_default("b:a", "224000");
4104         parse_option(o, "ar", "44100", options);
4105         parse_option(o, "ac", "2", options);
4106
4107         opt_default("packetsize", "2324");
4108         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4109
4110         /* We have to offset the PTS, so that it is consistent with the SCR.
4111            SCR starts at 36000, but the first two packs contain only padding
4112            and the first pack from the other stream, respectively, may also have
4113            been written before.
4114            So the real data starts at SCR 36000+3*1200. */
4115         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4116     } else if(!strcmp(arg, "svcd")) {
4117
4118         opt_video_codec(o, "c:v", "mpeg2video");
4119         opt_audio_codec(o, "c:a", "mp2");
4120         parse_option(o, "f", "svcd", options);
4121
4122         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4123         parse_option(o, "r", frame_rates[norm], options);
4124         parse_option(o, "pix_fmt", "yuv420p", options);
4125         opt_default("g", norm == PAL ? "15" : "18");
4126
4127         opt_default("b", "2040000");
4128         opt_default("maxrate", "2516000");
4129         opt_default("minrate", "0"); //1145000;
4130         opt_default("bufsize", "1835008"); //224*1024*8;
4131         opt_default("flags", "+scan_offset");
4132
4133
4134         opt_default("b:a", "224000");
4135         parse_option(o, "ar", "44100", options);
4136
4137         opt_default("packetsize", "2324");
4138
4139     } else if(!strcmp(arg, "dvd")) {
4140
4141         opt_video_codec(o, "c:v", "mpeg2video");
4142         opt_audio_codec(o, "c:a", "ac3");
4143         parse_option(o, "f", "dvd", options);
4144
4145         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4146         parse_option(o, "r", frame_rates[norm], options);
4147         parse_option(o, "pix_fmt", "yuv420p", options);
4148         opt_default("g", norm == PAL ? "15" : "18");
4149
4150         opt_default("b", "6000000");
4151         opt_default("maxrate", "9000000");
4152         opt_default("minrate", "0"); //1500000;
4153         opt_default("bufsize", "1835008"); //224*1024*8;
4154
4155         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4156         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4157
4158         opt_default("b:a", "448000");
4159         parse_option(o, "ar", "48000", options);
4160
4161     } else if(!strncmp(arg, "dv", 2)) {
4162
4163         parse_option(o, "f", "dv", options);
4164
4165         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4166         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4167                           norm == PAL ? "yuv420p" : "yuv411p", options);
4168         parse_option(o, "r", frame_rates[norm], options);
4169
4170         parse_option(o, "ar", "48000", options);
4171         parse_option(o, "ac", "2", options);
4172
4173     } else {
4174         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4175         return AVERROR(EINVAL);
4176     }
4177     return 0;
4178 }
4179
4180 static int opt_vstats_file(const char *opt, const char *arg)
4181 {
4182     av_free (vstats_filename);
4183     vstats_filename=av_strdup (arg);
4184     return 0;
4185 }
4186
4187 static int opt_vstats(const char *opt, const char *arg)
4188 {
4189     char filename[40];
4190     time_t today2 = time(NULL);
4191     struct tm *today = localtime(&today2);
4192
4193     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4194              today->tm_sec);
4195     return opt_vstats_file(opt, filename);
4196 }
4197
4198 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4199 {
4200     return parse_option(o, "frames:v", arg, options);
4201 }
4202
4203 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4204 {
4205     return parse_option(o, "frames:a", arg, options);
4206 }
4207
4208 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4209 {
4210     return parse_option(o, "frames:d", arg, options);
4211 }
4212
4213 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4214 {
4215     FILE *f=NULL;
4216     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4217     const char *codec_name = *opt == 'v' ? video_codec_name :
4218                              *opt == 'a' ? audio_codec_name :
4219                                            subtitle_codec_name;
4220
4221     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4222         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4223             av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4224         }else
4225             av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4226         exit_program(1);
4227     }
4228
4229     while(!feof(f)){
4230         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4231         if(line[0] == '#' && !e)
4232             continue;
4233         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4234         if(e){
4235             av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4236             exit_program(1);
4237         }
4238         if(!strcmp(tmp, "acodec")){
4239             opt_audio_codec(o, tmp, tmp2);
4240         }else if(!strcmp(tmp, "vcodec")){
4241             opt_video_codec(o, tmp, tmp2);
4242         }else if(!strcmp(tmp, "scodec")){
4243             opt_subtitle_codec(o, tmp, tmp2);
4244         }else if(!strcmp(tmp, "dcodec")){
4245             opt_data_codec(o, tmp, tmp2);
4246         }else if(opt_default(tmp, tmp2) < 0){
4247             av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4248             exit_program(1);
4249         }
4250     }
4251
4252     fclose(f);
4253
4254     return 0;
4255 }
4256
4257 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4258 {
4259 }
4260
4261 static int opt_passlogfile(const char *opt, const char *arg)
4262 {
4263     pass_logfilename_prefix = arg;
4264 #if CONFIG_LIBX264_ENCODER
4265     return opt_default("passlogfile", arg);
4266 #else
4267     return 0;
4268 #endif
4269 }
4270
4271 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4272 {
4273     char *s= av_malloc(strlen(opt)+2);
4274     snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4275     return parse_option(o, s, arg, options);
4276 }
4277
4278 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4279 {
4280     if(!strcmp(opt, "b")){
4281         av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4282         return parse_option(o, av_strdup("b:v"), arg, options);
4283     }
4284     return opt_default(opt, arg);
4285 }
4286
4287 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4288 {
4289     return parse_option(o, "filter:v", arg, options);
4290 }
4291
4292 #define OFFSET(x) offsetof(OptionsContext, x)
4293 static const OptionDef options[] = {
4294     /* main options */
4295 #include "cmdutils_common_opts.h"
4296     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4297     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4298     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4299     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4300     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4301     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4302     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4303     { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4304       "outfile[,metadata]:infile[,metadata]" },
4305     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4306       "outfile[,metadata]:infile[,metadata]" },
4307     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4308     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4309     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4310     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4311     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4312     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4313     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4314     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4315     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4316     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4317       "add timings for benchmarking" },
4318     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4319     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4320       "dump each input packet" },
4321     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4322       "when dumping packets, also dump the payload" },
4323     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4324     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4325     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4326     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4327     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4328     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4329     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4330     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4331     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4332     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4333     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4334     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4335     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4336     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4337     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4338     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4339     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4340 #if CONFIG_AVFILTER
4341     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4342 #endif
4343     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4344
4345     /* video options */
4346     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4347     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4348     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4349     { "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" },
4350     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4351     { "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" },
4352     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4353     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4354     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4355     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4356     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4357     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4358     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4359     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4360     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4361     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4362     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4363     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4364     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4365     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4366     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4367     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4368       "use same quantizer as source (implies VBR)" },
4369     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4370     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4371     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4372       "deinterlace pictures" },
4373     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4374     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4375 #if CONFIG_AVFILTER
4376     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4377 #endif
4378     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4379     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4380     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4381     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4382     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4383     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4384     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4385     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4386     { "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" },
4387     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4388
4389     /* audio options */
4390     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4391     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4392     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4393     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4394     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4395     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4396     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4397     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4398     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4399     { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4400
4401     /* subtitle options */
4402     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4403     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4404     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4405
4406     /* grab options */
4407     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4408     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4409     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4410
4411     /* muxer options */
4412     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4413     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4414
4415     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4416     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4417     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4418
4419     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4420     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4421     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4422     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4423     /* data codec support */
4424     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4425
4426     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4427     { NULL, },
4428 };
4429
4430 int main(int argc, char **argv)
4431 {
4432     OptionsContext o = { 0 };
4433     int64_t ti;
4434
4435     reset_options(&o, 0);
4436
4437     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4438     parse_loglevel(argc, argv, options);
4439
4440     if(argc>1 && !strcmp(argv[1], "-d")){
4441         run_as_daemon=1;
4442         av_log_set_callback(log_callback_null);
4443         argc--;
4444         argv++;
4445     }
4446
4447     avcodec_register_all();
4448 #if CONFIG_AVDEVICE
4449     avdevice_register_all();
4450 #endif
4451 #if CONFIG_AVFILTER
4452     avfilter_register_all();
4453 #endif
4454     av_register_all();
4455
4456 #if HAVE_ISATTY
4457     if(isatty(STDIN_FILENO))
4458         avio_set_interrupt_cb(decode_interrupt_cb);
4459 #endif
4460
4461     show_banner();
4462
4463     term_init();
4464
4465     /* parse options */
4466     parse_options(&o, argc, argv, options, opt_output_file);
4467
4468     if(nb_output_files <= 0 && nb_input_files == 0) {
4469         show_usage();
4470         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4471         exit_program(1);
4472     }
4473
4474     /* file converter / grab */
4475     if (nb_output_files <= 0) {
4476         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4477         exit_program(1);
4478     }
4479
4480     if (nb_input_files == 0) {
4481         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4482         exit_program(1);
4483     }
4484
4485     ti = getutime();
4486     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4487         exit_program(1);
4488     ti = getutime() - ti;
4489     if (do_benchmark) {
4490         int maxrss = getmaxrss() / 1024;
4491         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4492     }
4493
4494     exit_program(0);
4495     return 0;
4496 }