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