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