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