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 = avformat_new_stream(oc, NULL);
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     if (oc->nb_streams - 1 < o->nb_streamid_map)
3270         st->id = o->streamid_map[oc->nb_streams - 1];
3271
3272     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3273                                 nb_output_streams + 1);
3274     ost = &output_streams[nb_output_streams - 1];
3275     ost->file_index = nb_output_files;
3276     ost->index = idx;
3277     ost->st    = st;
3278     st->codec->codec_type = type;
3279     ost->enc = choose_codec(o, oc, st, type);
3280     if (ost->enc) {
3281         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3282     }
3283
3284     avcodec_get_context_defaults3(st->codec, ost->enc);
3285     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3286
3287     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3288     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3289         do  {
3290             buf = get_line(s);
3291             if (!buf[0] || buf[0] == '#') {
3292                 av_free(buf);
3293                 continue;
3294             }
3295             if (!(arg = strchr(buf, '='))) {
3296                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3297                 exit_program(1);
3298             }
3299             *arg++ = 0;
3300             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3301             av_free(buf);
3302         } while (!s->eof_reached);
3303         avio_close(s);
3304     }
3305     if (ret) {
3306         av_log(NULL, AV_LOG_FATAL,
3307                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3308                preset, ost->file_index, ost->index);
3309         exit_program(1);
3310     }
3311
3312     MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3313     ost->max_frames = max_frames;
3314
3315     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3316     while (bsf) {
3317         if (next = strchr(bsf, ','))
3318             *next++ = 0;
3319         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3320             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3321             exit_program(1);
3322         }
3323         if (bsfc_prev)
3324             bsfc_prev->next = bsfc;
3325         else
3326             ost->bitstream_filters = bsfc;
3327
3328         bsfc_prev = bsfc;
3329         bsf       = next;
3330     }
3331
3332     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3333     if (codec_tag) {
3334         uint32_t tag = strtol(codec_tag, &next, 0);
3335         if (*next)
3336             tag = AV_RL32(codec_tag);
3337         st->codec->codec_tag = tag;
3338     }
3339
3340     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3341     if (qscale >= 0 || same_quant) {
3342         st->codec->flags |= CODEC_FLAG_QSCALE;
3343         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3344     }
3345
3346     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3347         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3348
3349     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3350     return ost;
3351 }
3352
3353 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3354 {
3355     int i;
3356     const char *p = str;
3357     for(i = 0;; i++) {
3358         dest[i] = atoi(p);
3359         if(i == 63)
3360             break;
3361         p = strchr(p, ',');
3362         if(!p) {
3363             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3364             exit_program(1);
3365         }
3366         p++;
3367     }
3368 }
3369
3370 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3371 {
3372     AVStream *st;
3373     OutputStream *ost;
3374     AVCodecContext *video_enc;
3375
3376     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3377     st  = ost->st;
3378     video_enc = st->codec;
3379
3380     if (!st->stream_copy) {
3381         const char *p = NULL;
3382         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3383         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3384         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3385         int i, force_fps = 0, top_field_first = -1;
3386
3387         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3388         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3389             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3390             exit_program(1);
3391         }
3392
3393         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3394         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3395             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3396             exit_program(1);
3397         }
3398
3399         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3400         if (frame_aspect_ratio)
3401             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3402
3403         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3404         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3405         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3406             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3407             exit_program(1);
3408         }
3409         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3410
3411         if (intra_only)
3412             video_enc->gop_size = 0;
3413         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3414         if (intra_matrix) {
3415             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3416                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3417                 exit_program(1);
3418             }
3419             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3420         }
3421         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3422         if (inter_matrix) {
3423             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3424                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3425                 exit_program(1);
3426             }
3427             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3428         }
3429
3430         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3431         for(i=0; p; i++){
3432             int start, end, q;
3433             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3434             if(e!=3){
3435                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3436                 exit_program(1);
3437             }
3438             /* FIXME realloc failure */
3439             video_enc->rc_override=
3440                 av_realloc(video_enc->rc_override,
3441                            sizeof(RcOverride)*(i+1));
3442             video_enc->rc_override[i].start_frame= start;
3443             video_enc->rc_override[i].end_frame  = end;
3444             if(q>0){
3445                 video_enc->rc_override[i].qscale= q;
3446                 video_enc->rc_override[i].quality_factor= 1.0;
3447             }
3448             else{
3449                 video_enc->rc_override[i].qscale= 0;
3450                 video_enc->rc_override[i].quality_factor= -q/100.0;
3451             }
3452             p= strchr(p, '/');
3453             if(p) p++;
3454         }
3455         video_enc->rc_override_count=i;
3456         if (!video_enc->rc_initial_buffer_occupancy)
3457             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3458         video_enc->intra_dc_precision= intra_dc_precision - 8;
3459
3460         /* two pass mode */
3461         if (do_pass) {
3462             if (do_pass == 1) {
3463                 video_enc->flags |= CODEC_FLAG_PASS1;
3464             } else {
3465                 video_enc->flags |= CODEC_FLAG_PASS2;
3466             }
3467         }
3468
3469         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3470         if (forced_key_frames)
3471             parse_forced_key_frames(forced_key_frames, ost);
3472
3473         MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3474         ost->force_fps = force_fps;
3475
3476         MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3477         ost->top_field_first = top_field_first;
3478
3479 #if CONFIG_AVFILTER
3480         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3481         if (filters)
3482             ost->avfilter = av_strdup(filters);
3483 #endif
3484     }
3485
3486     return ost;
3487 }
3488
3489 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3490 {
3491     AVStream *st;
3492     OutputStream *ost;
3493     AVCodecContext *audio_enc;
3494
3495     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3496     st  = ost->st;
3497
3498     audio_enc = st->codec;
3499     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3500
3501     if (!st->stream_copy) {
3502         char *sample_fmt = NULL;
3503
3504         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3505
3506         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3507         if (sample_fmt &&
3508             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3509             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3510             exit_program(1);
3511         }
3512
3513         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3514     }
3515
3516     return ost;
3517 }
3518
3519 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3520 {
3521     AVStream *st;
3522     OutputStream *ost;
3523
3524     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3525     st  = ost->st;
3526     if (!st->stream_copy) {
3527         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3528         exit_program(1);
3529     }
3530
3531     return ost;
3532 }
3533
3534 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3535 {
3536     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3537     ost->st->stream_copy = 1;
3538     return ost;
3539 }
3540
3541 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3542 {
3543     AVStream *st;
3544     OutputStream *ost;
3545     AVCodecContext *subtitle_enc;
3546
3547     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3548     st  = ost->st;
3549     subtitle_enc = st->codec;
3550
3551     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3552
3553     return ost;
3554 }
3555
3556 /* arg format is "output-stream-index:streamid-value". */
3557 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3558 {
3559     int idx;
3560     char *p;
3561     char idx_str[16];
3562
3563     av_strlcpy(idx_str, arg, sizeof(idx_str));
3564     p = strchr(idx_str, ':');
3565     if (!p) {
3566         av_log(NULL, AV_LOG_FATAL,
3567                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3568                arg, opt);
3569         exit_program(1);
3570     }
3571     *p++ = '\0';
3572     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3573     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3574     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3575     return 0;
3576 }
3577
3578 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3579 {
3580     AVFormatContext *is = ifile->ctx;
3581     AVFormatContext *os = ofile->ctx;
3582     int i;
3583
3584     for (i = 0; i < is->nb_chapters; i++) {
3585         AVChapter *in_ch = is->chapters[i], *out_ch;
3586         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3587                                       AV_TIME_BASE_Q, in_ch->time_base);
3588         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3589                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3590
3591
3592         if (in_ch->end < ts_off)
3593             continue;
3594         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3595             break;
3596
3597         out_ch = av_mallocz(sizeof(AVChapter));
3598         if (!out_ch)
3599             return AVERROR(ENOMEM);
3600
3601         out_ch->id        = in_ch->id;
3602         out_ch->time_base = in_ch->time_base;
3603         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3604         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3605
3606         if (copy_metadata)
3607             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3608
3609         os->nb_chapters++;
3610         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3611         if (!os->chapters)
3612             return AVERROR(ENOMEM);
3613         os->chapters[os->nb_chapters - 1] = out_ch;
3614     }
3615     return 0;
3616 }
3617
3618 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3619 {
3620     int i, err;
3621     AVFormatContext *ic = NULL;
3622
3623     err = avformat_open_input(&ic, filename, NULL, NULL);
3624     if (err < 0)
3625         return err;
3626     /* copy stream format */
3627     for(i=0;i<ic->nb_streams;i++) {
3628         AVStream *st;
3629         OutputStream *ost;
3630         AVCodec *codec;
3631
3632         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3633         ost   = new_output_stream(o, s, codec->type);
3634         st    = ost->st;
3635
3636         // FIXME: a more elegant solution is needed
3637         memcpy(st, ic->streams[i], sizeof(AVStream));
3638         st->info = av_malloc(sizeof(*st->info));
3639         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3640         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3641
3642         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3643             choose_sample_fmt(st, codec);
3644         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3645             choose_pixel_fmt(st, codec);
3646     }
3647
3648     av_close_input_file(ic);
3649     return 0;
3650 }
3651
3652 static void opt_output_file(void *optctx, const char *filename)
3653 {
3654     OptionsContext *o = optctx;
3655     AVFormatContext *oc;
3656     int i, err;
3657     AVOutputFormat *file_oformat;
3658     OutputStream *ost;
3659     InputStream  *ist;
3660
3661     if (!strcmp(filename, "-"))
3662         filename = "pipe:";
3663
3664     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3665     if (!oc) {
3666         print_error(filename, err);
3667         exit_program(1);
3668     }
3669     file_oformat= oc->oformat;
3670
3671     if (!strcmp(file_oformat->name, "ffm") &&
3672         av_strstart(filename, "http:", NULL)) {
3673         /* special case for files sent to ffserver: we get the stream
3674            parameters from ffserver */
3675         int err = read_ffserver_streams(o, oc, filename);
3676         if (err < 0) {
3677             print_error(filename, err);
3678             exit_program(1);
3679         }
3680     } else if (!o->nb_stream_maps) {
3681         /* pick the "best" stream of each type */
3682 #define NEW_STREAM(type, index)\
3683         if (index >= 0) {\
3684             ost = new_ ## type ## _stream(o, oc);\
3685             ost->source_index = index;\
3686             ost->sync_ist     = &input_streams[index];\
3687             input_streams[index].discard = 0;\
3688         }
3689
3690         /* video: highest resolution */
3691         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3692             int area = 0, idx = -1;
3693             for (i = 0; i < nb_input_streams; i++) {
3694                 ist = &input_streams[i];
3695                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3696                     ist->st->codec->width * ist->st->codec->height > area) {
3697                     area = ist->st->codec->width * ist->st->codec->height;
3698                     idx = i;
3699                 }
3700             }
3701             NEW_STREAM(video, idx);
3702         }
3703
3704         /* audio: most channels */
3705         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3706             int channels = 0, idx = -1;
3707             for (i = 0; i < nb_input_streams; i++) {
3708                 ist = &input_streams[i];
3709                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3710                     ist->st->codec->channels > channels) {
3711                     channels = ist->st->codec->channels;
3712                     idx = i;
3713                 }
3714             }
3715             NEW_STREAM(audio, idx);
3716         }
3717
3718         /* subtitles: pick first */
3719         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3720             for (i = 0; i < nb_input_streams; i++)
3721                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3722                     NEW_STREAM(subtitle, i);
3723                     break;
3724                 }
3725         }
3726         /* do something with data? */
3727     } else {
3728         for (i = 0; i < o->nb_stream_maps; i++) {
3729             StreamMap *map = &o->stream_maps[i];
3730
3731             if (map->disabled)
3732                 continue;
3733
3734             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3735             if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
3736                 continue;
3737             if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3738                 continue;
3739             if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3740                 continue;
3741
3742             switch (ist->st->codec->codec_type) {
3743             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3744             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3745             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3746             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3747             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3748             default:
3749                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3750                        map->file_index, map->stream_index);
3751                 exit_program(1);
3752             }
3753
3754             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3755             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3756                                            map->sync_stream_index];
3757             ist->discard = 0;
3758         }
3759     }
3760
3761     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3762     output_files[nb_output_files - 1].ctx       = oc;
3763     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3764     output_files[nb_output_files - 1].recording_time = o->recording_time;
3765     output_files[nb_output_files - 1].start_time     = o->start_time;
3766     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3767     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3768
3769     /* check filename in case of an image number is expected */
3770     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3771         if (!av_filename_number_test(oc->filename)) {
3772             print_error(oc->filename, AVERROR(EINVAL));
3773             exit_program(1);
3774         }
3775     }
3776
3777     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3778         /* test if it already exists to avoid loosing precious files */
3779         if (!file_overwrite &&
3780             (strchr(filename, ':') == NULL ||
3781              filename[1] == ':' ||
3782              av_strstart(filename, "file:", NULL))) {
3783             if (avio_check(filename, 0) == 0) {
3784                 if (!using_stdin) {
3785                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3786                     fflush(stderr);
3787                     term_exit();
3788                     if (!read_yesno()) {
3789                         av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3790                         exit_program(1);
3791                     }
3792                     term_init();
3793                 }
3794                 else {
3795                     av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3796                     exit_program(1);
3797                 }
3798             }
3799         }
3800
3801         /* open the file */
3802         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3803             print_error(filename, err);
3804             exit_program(1);
3805         }
3806     }
3807
3808     oc->preload   = (int)(o->mux_preload   * AV_TIME_BASE);
3809     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3810
3811     if (loop_output >= 0) {
3812         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3813         oc->loop_output = loop_output;
3814     }
3815
3816     /* copy chapters */
3817     if (o->chapters_input_file >= nb_input_files) {
3818         if (o->chapters_input_file == INT_MAX) {
3819             /* copy chapters from the first input file that has them*/
3820             o->chapters_input_file = -1;
3821             for (i = 0; i < nb_input_files; i++)
3822                 if (input_files[i].ctx->nb_chapters) {
3823                     o->chapters_input_file = i;
3824                     break;
3825                 }
3826         } else {
3827             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3828                    o->chapters_input_file);
3829             exit_program(1);
3830         }
3831     }
3832     if (o->chapters_input_file >= 0)
3833         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3834                       !o->metadata_chapters_manual);
3835
3836     /* copy metadata */
3837     for (i = 0; i < o->nb_meta_data_maps; i++) {
3838         AVFormatContext *files[2];
3839         AVDictionary    **meta[2];
3840         int j;
3841
3842 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3843         if ((index) < 0 || (index) >= (nb_elems)) {\
3844             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3845                      (desc), (index));\
3846             exit_program(1);\
3847         }
3848
3849         int in_file_index = o->meta_data_maps[i][1].file;
3850         if (in_file_index < 0)
3851             continue;
3852         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3853
3854         files[0] = oc;
3855         files[1] = input_files[in_file_index].ctx;
3856
3857         for (j = 0; j < 2; j++) {
3858             MetadataMap *map = &o->meta_data_maps[i][j];
3859
3860             switch (map->type) {
3861             case 'g':
3862                 meta[j] = &files[j]->metadata;
3863                 break;
3864             case 's':
3865                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3866                 meta[j] = &files[j]->streams[map->index]->metadata;
3867                 break;
3868             case 'c':
3869                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3870                 meta[j] = &files[j]->chapters[map->index]->metadata;
3871                 break;
3872             case 'p':
3873                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3874                 meta[j] = &files[j]->programs[map->index]->metadata;
3875                 break;
3876             }
3877         }
3878
3879         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3880     }
3881
3882     /* copy global metadata by default */
3883     if (!o->metadata_global_manual && nb_input_files){
3884         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3885                      AV_DICT_DONT_OVERWRITE);
3886         if(o->recording_time != INT64_MAX)
3887             av_dict_set(&oc->metadata, "duration", NULL, 0);
3888     }
3889     if (!o->metadata_streams_manual)
3890         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3891             InputStream *ist = &input_streams[output_streams[i].source_index];
3892             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3893         }
3894
3895     /* process manually set metadata */
3896     for (i = 0; i < o->nb_metadata; i++) {
3897         AVDictionary **m;
3898         char type, *val;
3899         int index = 0;
3900
3901         val = strchr(o->metadata[i].u.str, '=');
3902         if (!val) {
3903             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3904                    o->metadata[i].u.str);
3905             exit_program(1);
3906         }
3907         *val++ = 0;
3908
3909         parse_meta_type(o->metadata[i].specifier, &type, &index);
3910         switch (type) {
3911         case 'g':
3912             m = &oc->metadata;
3913             break;
3914         case 's':
3915             if (index < 0 || index >= oc->nb_streams) {
3916                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3917                 exit_program(1);
3918             }
3919             m = &oc->streams[index]->metadata;
3920             break;
3921         case 'c':
3922             if (index < 0 || index >= oc->nb_chapters) {
3923                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3924                 exit_program(1);
3925             }
3926             m = &oc->chapters[index]->metadata;
3927             break;
3928         default:
3929             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3930             exit_program(1);
3931         }
3932
3933         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3934     }
3935
3936     reset_options(o, 0);
3937 }
3938
3939 /* same option as mencoder */
3940 static int opt_pass(const char *opt, const char *arg)
3941 {
3942     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3943     return 0;
3944 }
3945
3946 static int64_t getutime(void)
3947 {
3948 #if HAVE_GETRUSAGE
3949     struct rusage rusage;
3950
3951     getrusage(RUSAGE_SELF, &rusage);
3952     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3953 #elif HAVE_GETPROCESSTIMES
3954     HANDLE proc;
3955     FILETIME c, e, k, u;
3956     proc = GetCurrentProcess();
3957     GetProcessTimes(proc, &c, &e, &k, &u);
3958     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3959 #else
3960     return av_gettime();
3961 #endif
3962 }
3963
3964 static int64_t getmaxrss(void)
3965 {
3966 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3967     struct rusage rusage;
3968     getrusage(RUSAGE_SELF, &rusage);
3969     return (int64_t)rusage.ru_maxrss * 1024;
3970 #elif HAVE_GETPROCESSMEMORYINFO
3971     HANDLE proc;
3972     PROCESS_MEMORY_COUNTERS memcounters;
3973     proc = GetCurrentProcess();
3974     memcounters.cb = sizeof(memcounters);
3975     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3976     return memcounters.PeakPagefileUsage;
3977 #else
3978     return 0;
3979 #endif
3980 }
3981
3982 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3983 {
3984     return parse_option(o, "q:a", arg, options);
3985 }
3986
3987 static void show_usage(void)
3988 {
3989     printf("Hyper fast Audio and Video encoder\n");
3990     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3991     printf("\n");
3992 }
3993
3994 static int opt_help(const char *opt, const char *arg)
3995 {
3996     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3997     av_log_set_callback(log_callback_help);
3998     show_usage();
3999     show_help_options(options, "Main options:\n",
4000                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4001     show_help_options(options, "\nAdvanced options:\n",
4002                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4003                       OPT_EXPERT);
4004     show_help_options(options, "\nVideo options:\n",
4005                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4006                       OPT_VIDEO);
4007     show_help_options(options, "\nAdvanced Video options:\n",
4008                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4009                       OPT_VIDEO | OPT_EXPERT);
4010     show_help_options(options, "\nAudio options:\n",
4011                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4012                       OPT_AUDIO);
4013     show_help_options(options, "\nAdvanced Audio options:\n",
4014                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4015                       OPT_AUDIO | OPT_EXPERT);
4016     show_help_options(options, "\nSubtitle options:\n",
4017                       OPT_SUBTITLE | OPT_GRAB,
4018                       OPT_SUBTITLE);
4019     show_help_options(options, "\nAudio/Video grab options:\n",
4020                       OPT_GRAB,
4021                       OPT_GRAB);
4022     printf("\n");
4023     show_help_children(avcodec_get_class(), flags);
4024     show_help_children(avformat_get_class(), flags);
4025     show_help_children(sws_get_class(), flags);
4026
4027     return 0;
4028 }
4029
4030 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4031 {
4032     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4033     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4034
4035     if(!strncmp(arg, "pal-", 4)) {
4036         norm = PAL;
4037         arg += 4;
4038     } else if(!strncmp(arg, "ntsc-", 5)) {
4039         norm = NTSC;
4040         arg += 5;
4041     } else if(!strncmp(arg, "film-", 5)) {
4042         norm = FILM;
4043         arg += 5;
4044     } else {
4045         /* Try to determine PAL/NTSC by peeking in the input files */
4046         if(nb_input_files) {
4047             int i, j, fr;
4048             for (j = 0; j < nb_input_files; j++) {
4049                 for (i = 0; i < input_files[j].nb_streams; i++) {
4050                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4051                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4052                         continue;
4053                     fr = c->time_base.den * 1000 / c->time_base.num;
4054                     if(fr == 25000) {
4055                         norm = PAL;
4056                         break;
4057                     } else if((fr == 29970) || (fr == 23976)) {
4058                         norm = NTSC;
4059                         break;
4060                     }
4061                 }
4062                 if(norm != UNKNOWN)
4063                     break;
4064             }
4065         }
4066         if (norm != UNKNOWN)
4067             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4068     }
4069
4070     if(norm == UNKNOWN) {
4071         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4072         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4073         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4074         exit_program(1);
4075     }
4076
4077     if(!strcmp(arg, "vcd")) {
4078         opt_video_codec(o, "c:v", "mpeg1video");
4079         opt_audio_codec(o, "c:a", "mp2");
4080         parse_option(o, "f", "vcd", options);
4081
4082         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4083         parse_option(o, "r", frame_rates[norm], options);
4084         opt_default("g", norm == PAL ? "15" : "18");
4085
4086         opt_default("b", "1150000");
4087         opt_default("maxrate", "1150000");
4088         opt_default("minrate", "1150000");
4089         opt_default("bufsize", "327680"); // 40*1024*8;
4090
4091         opt_default("b:a", "224000");
4092         parse_option(o, "ar", "44100", options);
4093         parse_option(o, "ac", "2", options);
4094
4095         opt_default("packetsize", "2324");
4096         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4097
4098         /* We have to offset the PTS, so that it is consistent with the SCR.
4099            SCR starts at 36000, but the first two packs contain only padding
4100            and the first pack from the other stream, respectively, may also have
4101            been written before.
4102            So the real data starts at SCR 36000+3*1200. */
4103         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4104     } else if(!strcmp(arg, "svcd")) {
4105
4106         opt_video_codec(o, "c:v", "mpeg2video");
4107         opt_audio_codec(o, "c:a", "mp2");
4108         parse_option(o, "f", "svcd", options);
4109
4110         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4111         parse_option(o, "r", frame_rates[norm], options);
4112         parse_option(o, "pix_fmt", "yuv420p", options);
4113         opt_default("g", norm == PAL ? "15" : "18");
4114
4115         opt_default("b", "2040000");
4116         opt_default("maxrate", "2516000");
4117         opt_default("minrate", "0"); //1145000;
4118         opt_default("bufsize", "1835008"); //224*1024*8;
4119         opt_default("flags", "+scan_offset");
4120
4121
4122         opt_default("b:a", "224000");
4123         parse_option(o, "ar", "44100", options);
4124
4125         opt_default("packetsize", "2324");
4126
4127     } else if(!strcmp(arg, "dvd")) {
4128
4129         opt_video_codec(o, "c:v", "mpeg2video");
4130         opt_audio_codec(o, "c:a", "ac3");
4131         parse_option(o, "f", "dvd", options);
4132
4133         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4134         parse_option(o, "r", frame_rates[norm], options);
4135         parse_option(o, "pix_fmt", "yuv420p", options);
4136         opt_default("g", norm == PAL ? "15" : "18");
4137
4138         opt_default("b", "6000000");
4139         opt_default("maxrate", "9000000");
4140         opt_default("minrate", "0"); //1500000;
4141         opt_default("bufsize", "1835008"); //224*1024*8;
4142
4143         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4144         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4145
4146         opt_default("b:a", "448000");
4147         parse_option(o, "ar", "48000", options);
4148
4149     } else if(!strncmp(arg, "dv", 2)) {
4150
4151         parse_option(o, "f", "dv", options);
4152
4153         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4154         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4155                           norm == PAL ? "yuv420p" : "yuv411p", options);
4156         parse_option(o, "r", frame_rates[norm], options);
4157
4158         parse_option(o, "ar", "48000", options);
4159         parse_option(o, "ac", "2", options);
4160
4161     } else {
4162         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4163         return AVERROR(EINVAL);
4164     }
4165     return 0;
4166 }
4167
4168 static int opt_vstats_file(const char *opt, const char *arg)
4169 {
4170     av_free (vstats_filename);
4171     vstats_filename=av_strdup (arg);
4172     return 0;
4173 }
4174
4175 static int opt_vstats(const char *opt, const char *arg)
4176 {
4177     char filename[40];
4178     time_t today2 = time(NULL);
4179     struct tm *today = localtime(&today2);
4180
4181     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4182              today->tm_sec);
4183     return opt_vstats_file(opt, filename);
4184 }
4185
4186 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4187 {
4188     return parse_option(o, "frames:v", arg, options);
4189 }
4190
4191 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4192 {
4193     return parse_option(o, "frames:a", arg, options);
4194 }
4195
4196 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4197 {
4198     return parse_option(o, "frames:d", arg, options);
4199 }
4200
4201 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4202 {
4203     FILE *f=NULL;
4204     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4205     const char *codec_name = *opt == 'v' ? video_codec_name :
4206                              *opt == 'a' ? audio_codec_name :
4207                                            subtitle_codec_name;
4208
4209     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4210         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4211             av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4212         }else
4213             av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4214         exit_program(1);
4215     }
4216
4217     while(!feof(f)){
4218         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4219         if(line[0] == '#' && !e)
4220             continue;
4221         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4222         if(e){
4223             av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4224             exit_program(1);
4225         }
4226         if(!strcmp(tmp, "acodec")){
4227             opt_audio_codec(o, tmp, tmp2);
4228         }else if(!strcmp(tmp, "vcodec")){
4229             opt_video_codec(o, tmp, tmp2);
4230         }else if(!strcmp(tmp, "scodec")){
4231             opt_subtitle_codec(o, tmp, tmp2);
4232         }else if(!strcmp(tmp, "dcodec")){
4233             opt_data_codec(o, tmp, tmp2);
4234         }else if(opt_default(tmp, tmp2) < 0){
4235             av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4236             exit_program(1);
4237         }
4238     }
4239
4240     fclose(f);
4241
4242     return 0;
4243 }
4244
4245 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4246 {
4247 }
4248
4249 static int opt_passlogfile(const char *opt, const char *arg)
4250 {
4251     pass_logfilename_prefix = arg;
4252 #if CONFIG_LIBX264_ENCODER
4253     return opt_default("passlogfile", arg);
4254 #else
4255     return 0;
4256 #endif
4257 }
4258
4259 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4260 {
4261     char *s= av_malloc(strlen(opt)+2);
4262     snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4263     return parse_option(o, s, arg, options);
4264 }
4265
4266 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4267 {
4268     if(!strcmp(opt, "b")){
4269         av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4270         return parse_option(o, av_strdup("b:v"), arg, options);
4271     }
4272     return opt_default(opt, arg);
4273 }
4274
4275 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4276 {
4277     return parse_option(o, "filter:v", arg, options);
4278 }
4279
4280 #define OFFSET(x) offsetof(OptionsContext, x)
4281 static const OptionDef options[] = {
4282     /* main options */
4283 #include "cmdutils_common_opts.h"
4284     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4285     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4286     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4287     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4288     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4289     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4290     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4291     { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4292       "outfile[,metadata]:infile[,metadata]" },
4293     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4294       "outfile[,metadata]:infile[,metadata]" },
4295     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4296     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4297     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4298     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4299     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4300     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4301     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4302     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4303     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4304     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4305       "add timings for benchmarking" },
4306     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4307     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4308       "dump each input packet" },
4309     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4310       "when dumping packets, also dump the payload" },
4311     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4312     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4313     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4314     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4315     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4316     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4317     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4318     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4319     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4320     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4321     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4322     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4323     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4324     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4325     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4326     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4327     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4328 #if CONFIG_AVFILTER
4329     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4330 #endif
4331     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4332
4333     /* video options */
4334     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4335     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4336     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4337     { "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" },
4338     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4339     { "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" },
4340     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4341     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4342     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4343     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4344     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4345     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4346     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4347     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4348     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4349     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4350     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4351     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4352     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4353     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4354     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4355     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4356       "use same quantizer as source (implies VBR)" },
4357     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4358     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4359     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4360       "deinterlace pictures" },
4361     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4362     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4363 #if CONFIG_AVFILTER
4364     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4365 #endif
4366     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4367     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4368     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4369     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4370     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4371     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4372     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4373     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4374     { "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" },
4375     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4376
4377     /* audio options */
4378     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4379     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4380     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4381     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4382     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4383     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4384     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4385     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4386     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4387
4388     /* subtitle options */
4389     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4390     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4391     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4392
4393     /* grab options */
4394     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4395     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4396     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4397
4398     /* muxer options */
4399     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4400     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4401
4402     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4403     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4404     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4405
4406     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4407     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4408     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4409     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4410     /* data codec support */
4411     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4412
4413     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4414     { NULL, },
4415 };
4416
4417 int main(int argc, char **argv)
4418 {
4419     OptionsContext o = { 0 };
4420     int64_t ti;
4421
4422     reset_options(&o, 0);
4423
4424     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4425     parse_loglevel(argc, argv, options);
4426
4427     if(argc>1 && !strcmp(argv[1], "-d")){
4428         run_as_daemon=1;
4429         av_log_set_callback(log_callback_null);
4430         argc--;
4431         argv++;
4432     }
4433
4434     avcodec_register_all();
4435 #if CONFIG_AVDEVICE
4436     avdevice_register_all();
4437 #endif
4438 #if CONFIG_AVFILTER
4439     avfilter_register_all();
4440 #endif
4441     av_register_all();
4442
4443 #if HAVE_ISATTY
4444     if(isatty(STDIN_FILENO))
4445         avio_set_interrupt_cb(decode_interrupt_cb);
4446 #endif
4447
4448     show_banner();
4449
4450     term_init();
4451
4452     /* parse options */
4453     parse_options(&o, argc, argv, options, opt_output_file);
4454
4455     if(nb_output_files <= 0 && nb_input_files == 0) {
4456         show_usage();
4457         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4458         exit_program(1);
4459     }
4460
4461     /* file converter / grab */
4462     if (nb_output_files <= 0) {
4463         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4464         exit_program(1);
4465     }
4466
4467     if (nb_input_files == 0) {
4468         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4469         exit_program(1);
4470     }
4471
4472     ti = getutime();
4473     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4474         exit_program(1);
4475     ti = getutime() - ti;
4476     if (do_benchmark) {
4477         int maxrss = getmaxrss() / 1024;
4478         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4479     }
4480
4481     exit_program(0);
4482     return 0;
4483 }