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