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_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 : 2) : 1;
1250
1251     if (format_video_sync) {
1252         double vdelta = sync_ipts - ost->sync_opts + duration;
1253         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1254         if (vdelta < -1.1)
1255             nb_frames = 0;
1256         else if (format_video_sync == 2) {
1257             if(vdelta<=-0.6){
1258                 nb_frames=0;
1259             }else if(vdelta>0.6)
1260                 ost->sync_opts= lrintf(sync_ipts);
1261         }else if (vdelta > 1.1)
1262             nb_frames = lrintf(vdelta);
1263 //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);
1264         if (nb_frames == 0){
1265             ++nb_frames_drop;
1266             av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1267         }else if (nb_frames > 1) {
1268             nb_frames_dup += nb_frames - 1;
1269             av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1270         }
1271     }else
1272         ost->sync_opts= lrintf(sync_ipts);
1273
1274     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1275     if (nb_frames <= 0)
1276         return;
1277
1278     do_video_resample(ost, ist, in_picture, &final_picture);
1279
1280     /* duplicates frame if needed */
1281     for(i=0;i<nb_frames;i++) {
1282         AVPacket pkt;
1283         av_init_packet(&pkt);
1284         pkt.stream_index= ost->index;
1285
1286         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1287             /* raw pictures are written as AVPicture structure to
1288                avoid any copies. We support temporarily the older
1289                method. */
1290             enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1291             enc->coded_frame->top_field_first  = in_picture->top_field_first;
1292             pkt.data= (uint8_t *)final_picture;
1293             pkt.size=  sizeof(AVPicture);
1294             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1295             pkt.flags |= AV_PKT_FLAG_KEY;
1296
1297             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1298         } else {
1299             AVFrame big_picture;
1300
1301             big_picture= *final_picture;
1302             /* better than nothing: use input picture interlaced
1303                settings */
1304             big_picture.interlaced_frame = in_picture->interlaced_frame;
1305             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1306                 if (ost->top_field_first == -1)
1307                     big_picture.top_field_first = in_picture->top_field_first;
1308                 else
1309                     big_picture.top_field_first = !!ost->top_field_first;
1310             }
1311
1312             /* handles same_quant here. This is not correct because it may
1313                not be a global option */
1314             big_picture.quality = quality;
1315             if (!enc->me_threshold)
1316                 big_picture.pict_type = 0;
1317 //            big_picture.pts = AV_NOPTS_VALUE;
1318             big_picture.pts= ost->sync_opts;
1319 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1320 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1321             if (ost->forced_kf_index < ost->forced_kf_count &&
1322                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1323                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1324                 ost->forced_kf_index++;
1325             }
1326             ret = avcodec_encode_video(enc,
1327                                        bit_buffer, bit_buffer_size,
1328                                        &big_picture);
1329             if (ret < 0) {
1330                 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1331                 exit_program(1);
1332             }
1333
1334             if(ret>0){
1335                 pkt.data= bit_buffer;
1336                 pkt.size= ret;
1337                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1338                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1339 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1340    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1341    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1342
1343                 if(enc->coded_frame->key_frame)
1344                     pkt.flags |= AV_PKT_FLAG_KEY;
1345                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1346                 *frame_size = ret;
1347                 video_size += ret;
1348                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1349                 //        enc->frame_number-1, ret, enc->pict_type);
1350                 /* if two pass, output log */
1351                 if (ost->logfile && enc->stats_out) {
1352                     fprintf(ost->logfile, "%s", enc->stats_out);
1353                 }
1354             }
1355         }
1356         ost->sync_opts++;
1357         ost->frame_number++;
1358     }
1359 }
1360
1361 static double psnr(double d)
1362 {
1363     return -10.0*log(d)/log(10.0);
1364 }
1365
1366 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1367                            int frame_size)
1368 {
1369     AVCodecContext *enc;
1370     int frame_number;
1371     double ti1, bitrate, avg_bitrate;
1372
1373     /* this is executed just the first time do_video_stats is called */
1374     if (!vstats_file) {
1375         vstats_file = fopen(vstats_filename, "w");
1376         if (!vstats_file) {
1377             perror("fopen");
1378             exit_program(1);
1379         }
1380     }
1381
1382     enc = ost->st->codec;
1383     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1384         frame_number = ost->frame_number;
1385         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1386         if (enc->flags&CODEC_FLAG_PSNR)
1387             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1388
1389         fprintf(vstats_file,"f_size= %6d ", frame_size);
1390         /* compute pts value */
1391         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1392         if (ti1 < 0.01)
1393             ti1 = 0.01;
1394
1395         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1396         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1397         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1398             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1399         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1400     }
1401 }
1402
1403 static void print_report(OutputFile *output_files,
1404                          OutputStream *ost_table, int nb_ostreams,
1405                          int is_last_report, int64_t timer_start, int64_t cur_time)
1406 {
1407     char buf[1024];
1408     OutputStream *ost;
1409     AVFormatContext *oc;
1410     int64_t total_size;
1411     AVCodecContext *enc;
1412     int frame_number, vid, i;
1413     double bitrate;
1414     int64_t pts = INT64_MAX;
1415     static int64_t last_time = -1;
1416     static int qp_histogram[52];
1417     int hours, mins, secs, us;
1418
1419     if (!print_stats && !is_last_report)
1420         return;
1421
1422     if (!is_last_report) {
1423         if (last_time == -1) {
1424             last_time = cur_time;
1425             return;
1426         }
1427         if ((cur_time - last_time) < 500000)
1428             return;
1429         last_time = cur_time;
1430     }
1431
1432
1433     oc = output_files[0].ctx;
1434
1435     total_size = avio_size(oc->pb);
1436     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1437         total_size= avio_tell(oc->pb);
1438
1439     buf[0] = '\0';
1440     vid = 0;
1441     for(i=0;i<nb_ostreams;i++) {
1442         float q = -1;
1443         ost = &ost_table[i];
1444         enc = ost->st->codec;
1445         if (!ost->stream_copy && enc->coded_frame)
1446             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1447         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1448             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1449         }
1450         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1451             float t = (cur_time-timer_start) / 1000000.0;
1452
1453             frame_number = ost->frame_number;
1454             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1455                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1456             if(is_last_report)
1457                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1458             if(qp_hist){
1459                 int j;
1460                 int qp = lrintf(q);
1461                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1462                     qp_histogram[qp]++;
1463                 for(j=0; j<32; j++)
1464                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1465             }
1466             if (enc->flags&CODEC_FLAG_PSNR){
1467                 int j;
1468                 double error, error_sum=0;
1469                 double scale, scale_sum=0;
1470                 char type[3]= {'Y','U','V'};
1471                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1472                 for(j=0; j<3; j++){
1473                     if(is_last_report){
1474                         error= enc->error[j];
1475                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1476                     }else{
1477                         error= enc->coded_frame->error[j];
1478                         scale= enc->width*enc->height*255.0*255.0;
1479                     }
1480                     if(j) scale/=4;
1481                     error_sum += error;
1482                     scale_sum += scale;
1483                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1484                 }
1485                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1486             }
1487             vid = 1;
1488         }
1489         /* compute min output value */
1490         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1491                                       ost->st->time_base, AV_TIME_BASE_Q));
1492     }
1493
1494     secs = pts / AV_TIME_BASE;
1495     us = pts % AV_TIME_BASE;
1496     mins = secs / 60;
1497     secs %= 60;
1498     hours = mins / 60;
1499     mins %= 60;
1500
1501     bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1502
1503     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1504              "size=%8.0fkB time=", total_size / 1024.0);
1505     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1506              "%02d:%02d:%02d.%02d ", hours, mins, secs,
1507              (100 * us) / AV_TIME_BASE);
1508     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1509              "bitrate=%6.1fkbits/s", bitrate);
1510
1511     if (nb_frames_dup || nb_frames_drop)
1512         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1513                 nb_frames_dup, nb_frames_drop);
1514
1515     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
1516
1517     fflush(stderr);
1518
1519     if (is_last_report) {
1520         int64_t raw= audio_size + video_size + extra_size;
1521         av_log(NULL, AV_LOG_INFO, "\n");
1522         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1523                video_size/1024.0,
1524                audio_size/1024.0,
1525                extra_size/1024.0,
1526                100.0*(total_size - raw)/raw
1527         );
1528     }
1529 }
1530
1531 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1532 {
1533     int fill_char = 0x00;
1534     if (sample_fmt == AV_SAMPLE_FMT_U8)
1535         fill_char = 0x80;
1536     memset(buf, fill_char, size);
1537 }
1538
1539 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1540 {
1541     int i, ret;
1542
1543     for (i = 0; i < nb_ostreams; i++) {
1544         OutputStream   *ost = &ost_table[i];
1545         AVCodecContext *enc = ost->st->codec;
1546         AVFormatContext *os = output_files[ost->file_index].ctx;
1547
1548         if (!ost->encoding_needed)
1549             continue;
1550
1551         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1552             continue;
1553         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1554             continue;
1555
1556         for(;;) {
1557             AVPacket pkt;
1558             int fifo_bytes;
1559             av_init_packet(&pkt);
1560             pkt.stream_index= ost->index;
1561
1562             switch (ost->st->codec->codec_type) {
1563             case AVMEDIA_TYPE_AUDIO:
1564                 fifo_bytes = av_fifo_size(ost->fifo);
1565                 ret = 0;
1566                 /* encode any samples remaining in fifo */
1567                 if (fifo_bytes > 0) {
1568                     int osize = av_get_bytes_per_sample(enc->sample_fmt);
1569                     int fs_tmp = enc->frame_size;
1570
1571                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1572                     if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1573                         enc->frame_size = fifo_bytes / (osize * enc->channels);
1574                     } else { /* pad */
1575                         int frame_bytes = enc->frame_size*osize*enc->channels;
1576                         if (allocated_audio_buf_size < frame_bytes)
1577                             exit_program(1);
1578                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1579                     }
1580
1581                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1582                     pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1583                                               ost->st->time_base.num, enc->sample_rate);
1584                     enc->frame_size = fs_tmp;
1585                 }
1586                 if (ret <= 0) {
1587                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1588                 }
1589                 if (ret < 0) {
1590                     av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1591                     exit_program(1);
1592                 }
1593                 audio_size += ret;
1594                 pkt.flags |= AV_PKT_FLAG_KEY;
1595                 break;
1596             case AVMEDIA_TYPE_VIDEO:
1597                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1598                 if (ret < 0) {
1599                     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1600                     exit_program(1);
1601                 }
1602                 video_size += ret;
1603                 if(enc->coded_frame && enc->coded_frame->key_frame)
1604                     pkt.flags |= AV_PKT_FLAG_KEY;
1605                 if (ost->logfile && enc->stats_out) {
1606                     fprintf(ost->logfile, "%s", enc->stats_out);
1607                 }
1608                 break;
1609             default:
1610                 ret=-1;
1611             }
1612
1613             if (ret <= 0)
1614                 break;
1615             pkt.data = bit_buffer;
1616             pkt.size = ret;
1617             if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1618                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1619             write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1620         }
1621     }
1622 }
1623
1624 /*
1625  * Check whether a packet from ist should be written into ost at this time
1626  */
1627 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1628 {
1629     OutputFile *of = &output_files[ost->file_index];
1630     int ist_index  = ist - input_streams;
1631
1632     if (ost->source_index != ist_index)
1633         return 0;
1634
1635     if (of->start_time && ist->pts < of->start_time)
1636         return 0;
1637
1638     if (of->recording_time != INT64_MAX &&
1639         av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1640                       (AVRational){1, 1000000}) >= 0) {
1641         ost->is_past_recording_time = 1;
1642         return 0;
1643     }
1644
1645     return 1;
1646 }
1647
1648 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1649 {
1650     OutputFile *of = &output_files[ost->file_index];
1651     int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1652     AVPicture pict;
1653     AVPacket opkt;
1654
1655     av_init_packet(&opkt);
1656
1657     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1658         !ost->copy_initial_nonkeyframes)
1659         return;
1660
1661     /* force the input stream PTS */
1662     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1663         audio_size += pkt->size;
1664     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1665         video_size += pkt->size;
1666         ost->sync_opts++;
1667     }
1668
1669     opkt.stream_index = ost->index;
1670     if (pkt->pts != AV_NOPTS_VALUE)
1671         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1672     else
1673         opkt.pts = AV_NOPTS_VALUE;
1674
1675     if (pkt->dts == AV_NOPTS_VALUE)
1676         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1677     else
1678         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1679     opkt.dts -= ost_tb_start_time;
1680
1681     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1682     opkt.flags    = pkt->flags;
1683
1684     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1685     if(   ost->st->codec->codec_id != CODEC_ID_H264
1686        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1687        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1688        ) {
1689         if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1690             opkt.destruct = av_destruct_packet;
1691     } else {
1692         opkt.data = pkt->data;
1693         opkt.size = pkt->size;
1694     }
1695     if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1696         /* store AVPicture in AVPacket, as expected by the output format */
1697         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1698         opkt.data = (uint8_t *)&pict;
1699         opkt.size = sizeof(AVPicture);
1700         opkt.flags |= AV_PKT_FLAG_KEY;
1701     }
1702
1703     write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1704     ost->st->codec->frame_number++;
1705     ost->frame_number++;
1706     av_free_packet(&opkt);
1707 }
1708
1709 static void rate_emu_sleep(InputStream *ist)
1710 {
1711     if (input_files[ist->file_index].rate_emu) {
1712         int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1713         int64_t now = av_gettime() - ist->start;
1714         if (pts > now)
1715             usleep(pts - now);
1716     }
1717 }
1718
1719 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1720 {
1721     static unsigned int samples_size = 0;
1722     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1723     uint8_t *decoded_data_buf  = NULL;
1724     int      decoded_data_size = 0;
1725     int i, ret;
1726
1727     if (pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1728         av_free(samples);
1729         samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1730         samples      = av_malloc(samples_size);
1731     }
1732     decoded_data_size = samples_size;
1733
1734     ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1735                                 pkt);
1736     if (ret < 0)
1737         return ret;
1738     *got_output  = decoded_data_size > 0;
1739
1740     /* Some bug in mpeg audio decoder gives */
1741     /* decoded_data_size < 0, it seems they are overflows */
1742     if (!*got_output) {
1743         /* no audio frame */
1744         return ret;
1745     }
1746
1747     decoded_data_buf = (uint8_t *)samples;
1748     ist->next_pts   += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1749                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1750
1751     // preprocess audio (volume)
1752     if (audio_volume != 256) {
1753         switch (ist->st->codec->sample_fmt) {
1754         case AV_SAMPLE_FMT_U8:
1755         {
1756             uint8_t *volp = samples;
1757             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1758                 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1759                 *volp++ = av_clip_uint8(v);
1760             }
1761             break;
1762         }
1763         case AV_SAMPLE_FMT_S16:
1764         {
1765             int16_t *volp = samples;
1766             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1767                 int v = ((*volp) * audio_volume + 128) >> 8;
1768                 *volp++ = av_clip_int16(v);
1769             }
1770             break;
1771         }
1772         case AV_SAMPLE_FMT_S32:
1773         {
1774             int32_t *volp = samples;
1775             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1776                 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1777                 *volp++ = av_clipl_int32(v);
1778             }
1779             break;
1780         }
1781         case AV_SAMPLE_FMT_FLT:
1782         {
1783             float *volp = samples;
1784             float scale = audio_volume / 256.f;
1785             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1786                 *volp++ *= scale;
1787             }
1788             break;
1789         }
1790         case AV_SAMPLE_FMT_DBL:
1791         {
1792             double *volp = samples;
1793             double scale = audio_volume / 256.;
1794             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1795                 *volp++ *= scale;
1796             }
1797             break;
1798         }
1799         default:
1800             av_log(NULL, AV_LOG_FATAL,
1801                    "Audio volume adjustment on sample format %s is not supported.\n",
1802                    av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1803             exit_program(1);
1804         }
1805     }
1806
1807     rate_emu_sleep(ist);
1808
1809     for (i = 0; i < nb_output_streams; i++) {
1810         OutputStream *ost = &output_streams[i];
1811
1812         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1813             continue;
1814         do_audio_out(output_files[ost->file_index].ctx, ost, ist,
1815                      decoded_data_buf, decoded_data_size);
1816     }
1817     return ret;
1818 }
1819
1820 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
1821 {
1822     AVFrame *decoded_frame, *filtered_frame = NULL;
1823     void *buffer_to_free = NULL;
1824     int i, ret = 0;
1825     float quality = 0;
1826 #if CONFIG_AVFILTER
1827     int frame_available = 1;
1828 #endif
1829
1830     if (!(decoded_frame = avcodec_alloc_frame()))
1831         return AVERROR(ENOMEM);
1832     pkt->pts  = *pkt_pts;
1833     pkt->dts  = *pkt_dts;
1834     *pkt_pts  = AV_NOPTS_VALUE;
1835
1836     if(*pkt_dts != AV_NOPTS_VALUE && ist->st->codec->time_base.num != 0) {
1837         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1838         *pkt_dts += ((int64_t)AV_TIME_BASE *
1839                           ist->st->codec->time_base.num * ticks) /
1840             ist->st->codec->time_base.den;
1841     }else
1842         *pkt_dts = AV_NOPTS_VALUE;
1843
1844     ret = avcodec_decode_video2(ist->st->codec,
1845                                 decoded_frame, got_output, pkt);
1846     if (ret < 0)
1847         goto fail;
1848
1849     quality = same_quant ? decoded_frame->quality : 0;
1850     if (!*got_output) {
1851         /* no picture yet */
1852         av_freep(&decoded_frame);
1853         return ret;
1854     }
1855
1856     if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)
1857         ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1858
1859     if (ist->st->codec->time_base.num != 0) {
1860         int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1861                                            ist->st->codec->ticks_per_frame;
1862         ist->next_pts += ((int64_t)AV_TIME_BASE *
1863                           ist->st->codec->time_base.num * ticks) /
1864                           ist->st->codec->time_base.den;
1865     }
1866     pkt->size = 0;
1867
1868     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1869
1870 #if CONFIG_AVFILTER
1871     for(i=0;i<nb_output_streams;i++) {
1872         OutputStream *ost = ost = &output_streams[i];
1873         if(check_output_constraints(ist, ost)){
1874             if (!decoded_frame->sample_aspect_ratio.num)
1875                 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1876             decoded_frame->pts = ist->pts;
1877
1878             av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1879         }
1880     }
1881 #endif
1882
1883     rate_emu_sleep(ist);
1884
1885     for (i = 0; i < nb_output_streams; i++) {
1886         OutputStream *ost = &output_streams[i];
1887         int frame_size;
1888
1889         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1890             continue;
1891
1892 #if CONFIG_AVFILTER
1893         if (ost->input_video_filter) {
1894             frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1895         }
1896         while (frame_available) {
1897             if (ost->output_video_filter) {
1898                 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1899                 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1900                     goto cont;
1901                 if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
1902                     ret = AVERROR(ENOMEM);
1903                     goto fail;
1904                 }
1905                 *filtered_frame= *decoded_frame; //for me_threshold
1906                 if (ost->picref) {
1907                     avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1908                     ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1909                 }
1910             }
1911             if (ost->picref->video && !ost->frame_aspect_ratio)
1912                 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1913 #else
1914             filtered_frame = decoded_frame;
1915 #endif
1916
1917             do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
1918                          same_quant ? quality : ost->st->codec->global_quality);
1919             if (vstats_filename && frame_size)
1920                 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1921 #if CONFIG_AVFILTER
1922             cont:
1923             frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1924             avfilter_unref_buffer(ost->picref);
1925         }
1926         av_freep(&filtered_frame);
1927 #endif
1928     }
1929
1930 fail:
1931     av_free(buffer_to_free);
1932     av_freep(&decoded_frame);
1933     return ret;
1934 }
1935
1936 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1937 {
1938     AVSubtitle subtitle;
1939     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1940                                           &subtitle, got_output, pkt);
1941     if (ret < 0)
1942         return ret;
1943     if (!*got_output)
1944         return ret;
1945
1946     rate_emu_sleep(ist);
1947
1948     for (i = 0; i < nb_output_streams; i++) {
1949         OutputStream *ost = &output_streams[i];
1950
1951         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1952             continue;
1953
1954         do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1955     }
1956
1957     avsubtitle_free(&subtitle);
1958     return ret;
1959 }
1960
1961 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1962 static int output_packet(InputStream *ist,
1963                          OutputStream *ost_table, int nb_ostreams,
1964                          const AVPacket *pkt)
1965 {
1966     int ret = 0, i;
1967     int got_output;
1968     int64_t pkt_dts = AV_NOPTS_VALUE;
1969     int64_t pkt_pts = AV_NOPTS_VALUE;
1970
1971     AVPacket avpkt;
1972
1973     if (ist->next_pts == AV_NOPTS_VALUE)
1974         ist->next_pts = ist->pts;
1975
1976     if (pkt == NULL) {
1977         /* EOF handling */
1978         av_init_packet(&avpkt);
1979         avpkt.data = NULL;
1980         avpkt.size = 0;
1981         goto handle_eof;
1982     } else {
1983         avpkt = *pkt;
1984     }
1985
1986     if(pkt->dts != AV_NOPTS_VALUE){
1987         if(ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
1988             ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1989         pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1990     }
1991     if(pkt->pts != AV_NOPTS_VALUE)
1992         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1993
1994     //while we have more to decode or while the decoder did output something on EOF
1995     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1996     handle_eof:
1997
1998         ist->pts = ist->next_pts;
1999
2000         if (avpkt.size && avpkt.size != pkt->size) {
2001             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2002                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2003             ist->showed_multi_packet_warning = 1;
2004         }
2005
2006         switch(ist->st->codec->codec_type) {
2007         case AVMEDIA_TYPE_AUDIO:
2008             ret = transcode_audio    (ist, &avpkt, &got_output);
2009             break;
2010         case AVMEDIA_TYPE_VIDEO:
2011             ret = transcode_video    (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2012             break;
2013         case AVMEDIA_TYPE_SUBTITLE:
2014             ret = transcode_subtitles(ist, &avpkt, &got_output);
2015             break;
2016         default:
2017             return -1;
2018         }
2019
2020         if (ret < 0)
2021             return ret;
2022         // touch data and size only if not EOF
2023         if (pkt) {
2024             if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2025                 ret = avpkt.size;
2026             avpkt.data += ret;
2027             avpkt.size -= ret;
2028         }
2029         if (!got_output) {
2030             continue;
2031         }
2032     }
2033
2034     /* handle stream copy */
2035     if (!ist->decoding_needed) {
2036         rate_emu_sleep(ist);
2037         switch (ist->st->codec->codec_type) {
2038         case AVMEDIA_TYPE_AUDIO:
2039             ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2040                              ist->st->codec->sample_rate;
2041             break;
2042         case AVMEDIA_TYPE_VIDEO:
2043             if (ist->st->codec->time_base.num != 0) {
2044                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2045                 ist->next_pts += ((int64_t)AV_TIME_BASE *
2046                                   ist->st->codec->time_base.num * ticks) /
2047                                   ist->st->codec->time_base.den;
2048             }
2049             break;
2050         }
2051     }
2052     for (i = 0; pkt && i < nb_ostreams; i++) {
2053         OutputStream *ost = &ost_table[i];
2054
2055         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2056             continue;
2057
2058         do_streamcopy(ist, ost, pkt);
2059     }
2060
2061     return 0;
2062 }
2063
2064 static void print_sdp(OutputFile *output_files, int n)
2065 {
2066     char sdp[2048];
2067     int i;
2068     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
2069
2070     if (!avc)
2071         exit_program(1);
2072     for (i = 0; i < n; i++)
2073         avc[i] = output_files[i].ctx;
2074
2075     av_sdp_create(avc, n, sdp, sizeof(sdp));
2076     printf("SDP:\n%s\n", sdp);
2077     fflush(stdout);
2078     av_freep(&avc);
2079 }
2080
2081 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2082                              char *error, int error_len)
2083 {
2084     InputStream *ist = &input_streams[ist_index];
2085     if (ist->decoding_needed) {
2086         AVCodec *codec = ist->dec;
2087         if (!codec) {
2088             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2089                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2090             return AVERROR(EINVAL);
2091         }
2092         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2093             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2094                     ist->file_index, ist->st->index);
2095             return AVERROR(EINVAL);
2096         }
2097         assert_codec_experimental(ist->st->codec, 0);
2098         assert_avoptions(ist->opts);
2099     }
2100
2101     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;
2102     ist->next_pts = AV_NOPTS_VALUE;
2103     ist->is_start = 1;
2104
2105     return 0;
2106 }
2107
2108 static int transcode_init(OutputFile *output_files, int nb_output_files,
2109                           InputFile  *input_files,  int nb_input_files)
2110 {
2111     int ret = 0, i, j, k;
2112     AVFormatContext *oc;
2113     AVCodecContext *codec, *icodec;
2114     OutputStream *ost;
2115     InputStream *ist;
2116     char error[1024];
2117     int want_sdp = 1;
2118
2119     /* init framerate emulation */
2120     for (i = 0; i < nb_input_files; i++) {
2121         InputFile *ifile = &input_files[i];
2122         if (ifile->rate_emu)
2123             for (j = 0; j < ifile->nb_streams; j++)
2124                 input_streams[j + ifile->ist_index].start = av_gettime();
2125     }
2126
2127     /* output stream init */
2128     for (i = 0; i < nb_output_files; i++) {
2129         oc = output_files[i].ctx;
2130         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2131             av_dump_format(oc, i, oc->filename, 1);
2132             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2133             return AVERROR(EINVAL);
2134         }
2135     }
2136
2137     /* for each output stream, we compute the right encoding parameters */
2138     for (i = 0; i < nb_output_streams; i++) {
2139         ost = &output_streams[i];
2140         oc  = output_files[ost->file_index].ctx;
2141         ist = &input_streams[ost->source_index];
2142
2143         if (ost->attachment_filename)
2144             continue;
2145
2146         codec  = ost->st->codec;
2147         icodec = ist->st->codec;
2148
2149         ost->st->disposition          = ist->st->disposition;
2150         codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2151         codec->chroma_sample_location = icodec->chroma_sample_location;
2152
2153         if (ost->stream_copy) {
2154             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2155
2156             if (extra_size > INT_MAX) {
2157                 return AVERROR(EINVAL);
2158             }
2159
2160             /* if stream_copy is selected, no need to decode or encode */
2161             codec->codec_id   = icodec->codec_id;
2162             codec->codec_type = icodec->codec_type;
2163
2164             if (!codec->codec_tag) {
2165                 if (!oc->oformat->codec_tag ||
2166                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2167                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2168                     codec->codec_tag = icodec->codec_tag;
2169             }
2170
2171             codec->bit_rate       = icodec->bit_rate;
2172             codec->rc_max_rate    = icodec->rc_max_rate;
2173             codec->rc_buffer_size = icodec->rc_buffer_size;
2174             codec->extradata      = av_mallocz(extra_size);
2175             if (!codec->extradata) {
2176                 return AVERROR(ENOMEM);
2177             }
2178             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2179             codec->extradata_size= icodec->extradata_size;
2180
2181             codec->time_base = ist->st->time_base;
2182             if(!strcmp(oc->oformat->name, "avi")) {
2183                 if (!copy_tb &&
2184                     av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) &&
2185                     av_q2d(ist->st->time_base) < 1.0/500){
2186                     codec->time_base = icodec->time_base;
2187                     codec->time_base.num *= icodec->ticks_per_frame;
2188                     codec->time_base.den *= 2;
2189                 }
2190             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)) {
2191                 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){
2192                     codec->time_base = icodec->time_base;
2193                     codec->time_base.num *= icodec->ticks_per_frame;
2194                 }
2195             }
2196             av_reduce(&codec->time_base.num, &codec->time_base.den,
2197                         codec->time_base.num, codec->time_base.den, INT_MAX);
2198
2199             switch(codec->codec_type) {
2200             case AVMEDIA_TYPE_AUDIO:
2201                 if(audio_volume != 256) {
2202                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2203                     exit_program(1);
2204                 }
2205                 codec->channel_layout     = icodec->channel_layout;
2206                 codec->sample_rate        = icodec->sample_rate;
2207                 codec->channels           = icodec->channels;
2208                 codec->frame_size         = icodec->frame_size;
2209                 codec->audio_service_type = icodec->audio_service_type;
2210                 codec->block_align        = icodec->block_align;
2211                 break;
2212             case AVMEDIA_TYPE_VIDEO:
2213                 codec->pix_fmt            = icodec->pix_fmt;
2214                 codec->width              = icodec->width;
2215                 codec->height             = icodec->height;
2216                 codec->has_b_frames       = icodec->has_b_frames;
2217                 if (!codec->sample_aspect_ratio.num) {
2218                     codec->sample_aspect_ratio   =
2219                     ost->st->sample_aspect_ratio =
2220                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2221                         ist->st->codec->sample_aspect_ratio.num ?
2222                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2223                 }
2224                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2225                 break;
2226             case AVMEDIA_TYPE_SUBTITLE:
2227                 codec->width  = icodec->width;
2228                 codec->height = icodec->height;
2229                 break;
2230             case AVMEDIA_TYPE_DATA:
2231             case AVMEDIA_TYPE_ATTACHMENT:
2232                 break;
2233             default:
2234                 abort();
2235             }
2236         } else {
2237             if (!ost->enc)
2238                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2239
2240             ist->decoding_needed = 1;
2241             ost->encoding_needed = 1;
2242
2243             switch(codec->codec_type) {
2244             case AVMEDIA_TYPE_AUDIO:
2245                 ost->fifo = av_fifo_alloc(1024);
2246                 if (!ost->fifo) {
2247                     return AVERROR(ENOMEM);
2248                 }
2249                 if (!codec->sample_rate)
2250                     codec->sample_rate = icodec->sample_rate;
2251                 choose_sample_rate(ost->st, ost->enc);
2252                 codec->time_base = (AVRational){1, codec->sample_rate};
2253
2254                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2255                     codec->sample_fmt = icodec->sample_fmt;
2256                 choose_sample_fmt(ost->st, ost->enc);
2257
2258                 if (ost->audio_channels_mapped) {
2259                     /* the requested output channel is set to the number of
2260                      * -map_channel only if no -ac are specified */
2261                     if (!codec->channels) {
2262                         codec->channels       = ost->audio_channels_mapped;
2263                         codec->channel_layout = av_get_default_channel_layout(codec->channels);
2264                         if (!codec->channel_layout) {
2265                             av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2266                             exit_program(1);
2267                         }
2268                     }
2269                     /* fill unused channel mapping with -1 (which means a muted
2270                      * channel in case the number of output channels is bigger
2271                      * than the number of mapped channel) */
2272                     for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2273                         ost->audio_channels_map[j] = -1;
2274                 } else if (!codec->channels) {
2275                     codec->channels = icodec->channels;
2276                     codec->channel_layout = icodec->channel_layout;
2277                 }
2278                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2279                     codec->channel_layout = 0;
2280
2281                 ost->audio_resample       = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2282                 ost->audio_resample      |=    codec->sample_fmt     != icodec->sample_fmt
2283                                             || codec->channel_layout != icodec->channel_layout;
2284                 icodec->request_channels  = codec->channels;
2285                 ost->resample_sample_fmt  = icodec->sample_fmt;
2286                 ost->resample_sample_rate = icodec->sample_rate;
2287                 ost->resample_channels    = icodec->channels;
2288                 break;
2289             case AVMEDIA_TYPE_VIDEO:
2290                 if (codec->pix_fmt == PIX_FMT_NONE)
2291                     codec->pix_fmt = icodec->pix_fmt;
2292                 choose_pixel_fmt(ost->st, ost->enc);
2293
2294                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2295                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2296                     exit_program(1);
2297                 }
2298
2299                 if (!codec->width || !codec->height) {
2300                     codec->width  = icodec->width;
2301                     codec->height = icodec->height;
2302                 }
2303
2304                 ost->video_resample = codec->width   != icodec->width  ||
2305                                       codec->height  != icodec->height ||
2306                                       codec->pix_fmt != icodec->pix_fmt;
2307                 if (ost->video_resample) {
2308                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2309                 }
2310
2311                 ost->resample_height  = icodec->height;
2312                 ost->resample_width   = icodec->width;
2313                 ost->resample_pix_fmt = icodec->pix_fmt;
2314
2315                 if (!ost->frame_rate.num)
2316                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2317                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2318                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2319                     ost->frame_rate = ost->enc->supported_framerates[idx];
2320                 }
2321                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2322                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2323                    && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2324                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2325                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2326                 }
2327                 for (j = 0; j < ost->forced_kf_count; j++)
2328                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2329                                                          AV_TIME_BASE_Q,
2330                                                          codec->time_base);
2331
2332 #if CONFIG_AVFILTER
2333                 if (configure_video_filters(ist, ost)) {
2334                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2335                     exit(1);
2336                 }
2337 #endif
2338                 break;
2339             case AVMEDIA_TYPE_SUBTITLE:
2340                 break;
2341             default:
2342                 abort();
2343                 break;
2344             }
2345             /* two pass mode */
2346             if (codec->codec_id != CODEC_ID_H264 &&
2347                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2348                 char logfilename[1024];
2349                 FILE *f;
2350
2351                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2352                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2353                          i);
2354                 if (codec->flags & CODEC_FLAG_PASS2) {
2355                     char  *logbuffer;
2356                     size_t logbuffer_size;
2357                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2358                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2359                                logfilename);
2360                         exit_program(1);
2361                     }
2362                     codec->stats_in = logbuffer;
2363                 }
2364                 if (codec->flags & CODEC_FLAG_PASS1) {
2365                     f = fopen(logfilename, "wb");
2366                     if (!f) {
2367                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2368                                logfilename, strerror(errno));
2369                         exit_program(1);
2370                     }
2371                     ost->logfile = f;
2372                 }
2373             }
2374         }
2375         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2376             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2377             int size        = codec->width * codec->height;
2378             bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2379         }
2380     }
2381
2382     if (!bit_buffer)
2383         bit_buffer = av_malloc(bit_buffer_size);
2384     if (!bit_buffer) {
2385         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2386                bit_buffer_size);
2387         return AVERROR(ENOMEM);
2388     }
2389
2390     /* open each encoder */
2391     for (i = 0; i < nb_output_streams; i++) {
2392         ost = &output_streams[i];
2393         if (ost->encoding_needed) {
2394             AVCodec      *codec = ost->enc;
2395             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2396             if (!codec) {
2397                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2398                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2399                 ret = AVERROR(EINVAL);
2400                 goto dump_format;
2401             }
2402             if (dec->subtitle_header) {
2403                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2404                 if (!ost->st->codec->subtitle_header) {
2405                     ret = AVERROR(ENOMEM);
2406                     goto dump_format;
2407                 }
2408                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2409                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2410             }
2411             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2412                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2413                         ost->file_index, ost->index);
2414                 ret = AVERROR(EINVAL);
2415                 goto dump_format;
2416             }
2417             assert_codec_experimental(ost->st->codec, 1);
2418             assert_avoptions(ost->opts);
2419             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2420                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2421                                              " It takes bits/s as argument, not kbits/s\n");
2422             extra_size += ost->st->codec->extradata_size;
2423
2424             if (ost->st->codec->me_threshold)
2425                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2426         }
2427     }
2428
2429     /* init input streams */
2430     for (i = 0; i < nb_input_streams; i++)
2431         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2432             goto dump_format;
2433
2434     /* discard unused programs */
2435     for (i = 0; i < nb_input_files; i++) {
2436         InputFile *ifile = &input_files[i];
2437         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2438             AVProgram *p = ifile->ctx->programs[j];
2439             int discard  = AVDISCARD_ALL;
2440
2441             for (k = 0; k < p->nb_stream_indexes; k++)
2442                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2443                     discard = AVDISCARD_DEFAULT;
2444                     break;
2445                 }
2446             p->discard = discard;
2447         }
2448     }
2449
2450     /* open files and write file headers */
2451     for (i = 0; i < nb_output_files; i++) {
2452         oc = output_files[i].ctx;
2453         oc->interrupt_callback = int_cb;
2454         if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2455             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2456             ret = AVERROR(EINVAL);
2457             goto dump_format;
2458         }
2459 //        assert_avoptions(output_files[i].opts);
2460         if (strcmp(oc->oformat->name, "rtp")) {
2461             want_sdp = 0;
2462         }
2463     }
2464
2465  dump_format:
2466     /* dump the file output parameters - cannot be done before in case
2467        of stream copy */
2468     for (i = 0; i < nb_output_files; i++) {
2469         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2470     }
2471
2472     /* dump the stream mapping */
2473     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2474     for (i = 0; i < nb_output_streams; i++) {
2475         ost = &output_streams[i];
2476
2477         if (ost->attachment_filename) {
2478             /* an attached file */
2479             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2480                    ost->attachment_filename, ost->file_index, ost->index);
2481             continue;
2482         }
2483         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2484                input_streams[ost->source_index].file_index,
2485                input_streams[ost->source_index].st->index,
2486                ost->file_index,
2487                ost->index);
2488         if (ost->audio_channels_mapped) {
2489             av_log(NULL, AV_LOG_INFO, " [ch:");
2490             for (j = 0; j < ost->audio_channels_mapped; j++)
2491                 if (ost->audio_channels_map[j] == -1)
2492                     av_log(NULL, AV_LOG_INFO, " M");
2493                 else
2494                     av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2495             av_log(NULL, AV_LOG_INFO, "]");
2496         }
2497         if (ost->sync_ist != &input_streams[ost->source_index])
2498             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2499                    ost->sync_ist->file_index,
2500                    ost->sync_ist->st->index);
2501         if (ost->stream_copy)
2502             av_log(NULL, AV_LOG_INFO, " (copy)");
2503         else
2504             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2505                    input_streams[ost->source_index].dec->name : "?",
2506                    ost->enc ? ost->enc->name : "?");
2507         av_log(NULL, AV_LOG_INFO, "\n");
2508     }
2509
2510     if (ret) {
2511         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2512         return ret;
2513     }
2514
2515     if (want_sdp) {
2516         print_sdp(output_files, nb_output_files);
2517     }
2518
2519     return 0;
2520 }
2521
2522 /*
2523  * The following code is the main loop of the file converter
2524  */
2525 static int transcode(OutputFile *output_files, int nb_output_files,
2526                      InputFile  *input_files,  int nb_input_files)
2527 {
2528     int ret, i;
2529     AVFormatContext *is, *os;
2530     OutputStream *ost;
2531     InputStream *ist;
2532     uint8_t *no_packet;
2533     int no_packet_count=0;
2534     int64_t timer_start;
2535     int key;
2536
2537     if (!(no_packet = av_mallocz(nb_input_files)))
2538         exit_program(1);
2539
2540     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2541     if (ret < 0)
2542         goto fail;
2543
2544     if (!using_stdin) {
2545         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2546     }
2547
2548     timer_start = av_gettime();
2549
2550     for(; received_sigterm == 0;) {
2551         int file_index, ist_index;
2552         AVPacket pkt;
2553         int64_t ipts_min;
2554         double opts_min;
2555         int64_t cur_time= av_gettime();
2556
2557         ipts_min= INT64_MAX;
2558         opts_min= 1e100;
2559         /* if 'q' pressed, exits */
2560         if (!using_stdin) {
2561             static int64_t last_time;
2562             if (received_nb_signals)
2563                 break;
2564             /* read_key() returns 0 on EOF */
2565             if(cur_time - last_time >= 100000 && !run_as_daemon){
2566                 key =  read_key();
2567                 last_time = cur_time;
2568             }else
2569                 key = -1;
2570             if (key == 'q')
2571                 break;
2572             if (key == '+') av_log_set_level(av_log_get_level()+10);
2573             if (key == '-') av_log_set_level(av_log_get_level()-10);
2574             if (key == 's') qp_hist     ^= 1;
2575             if (key == 'h'){
2576                 if (do_hex_dump){
2577                     do_hex_dump = do_pkt_dump = 0;
2578                 } else if(do_pkt_dump){
2579                     do_hex_dump = 1;
2580                 } else
2581                     do_pkt_dump = 1;
2582                 av_log_set_level(AV_LOG_DEBUG);
2583             }
2584 #if CONFIG_AVFILTER
2585             if (key == 'c' || key == 'C'){
2586                 char buf[4096], target[64], command[256], arg[256] = {0};
2587                 double time;
2588                 int k, n = 0;
2589                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2590                 i = 0;
2591                 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2592                     if (k > 0)
2593                         buf[i++] = k;
2594                 buf[i] = 0;
2595                 if (k > 0 &&
2596                     (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2597                     av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2598                            target, time, command, arg);
2599                     for (i = 0; i < nb_output_streams; i++) {
2600                         ost = &output_streams[i];
2601                         if (ost->graph) {
2602                             if (time < 0) {
2603                                 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2604                                                                   key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2605                                 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2606                             } else {
2607                                 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2608                             }
2609                         }
2610                     }
2611                 } else {
2612                     av_log(NULL, AV_LOG_ERROR,
2613                            "Parse error, at least 3 arguments were expected, "
2614                            "only %d given in string '%s'\n", n, buf);
2615                 }
2616             }
2617 #endif
2618             if (key == 'd' || key == 'D'){
2619                 int debug=0;
2620                 if(key == 'D') {
2621                     debug = input_streams[0].st->codec->debug<<1;
2622                     if(!debug) debug = 1;
2623                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2624                         debug += debug;
2625                 }else
2626                     if(scanf("%d", &debug)!=1)
2627                         fprintf(stderr,"error parsing debug value\n");
2628                 for(i=0;i<nb_input_streams;i++) {
2629                     input_streams[i].st->codec->debug = debug;
2630                 }
2631                 for(i=0;i<nb_output_streams;i++) {
2632                     ost = &output_streams[i];
2633                     ost->st->codec->debug = debug;
2634                 }
2635                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2636                 fprintf(stderr,"debug=%d\n", debug);
2637             }
2638             if (key == '?'){
2639                 fprintf(stderr, "key    function\n"
2640                                 "?      show this help\n"
2641                                 "+      increase verbosity\n"
2642                                 "-      decrease verbosity\n"
2643                                 "c      Send command to filtergraph\n"
2644                                 "D      cycle through available debug modes\n"
2645                                 "h      dump packets/hex press to cycle through the 3 states\n"
2646                                 "q      quit\n"
2647                                 "s      Show QP histogram\n"
2648                 );
2649             }
2650         }
2651
2652         /* select the stream that we must read now by looking at the
2653            smallest output pts */
2654         file_index = -1;
2655         for (i = 0; i < nb_output_streams; i++) {
2656             OutputFile *of;
2657             int64_t ipts;
2658             double  opts;
2659             ost = &output_streams[i];
2660             of = &output_files[ost->file_index];
2661             os = output_files[ost->file_index].ctx;
2662             ist = &input_streams[ost->source_index];
2663             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2664                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2665                 continue;
2666             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2667             ipts = ist->pts;
2668             if (!input_files[ist->file_index].eof_reached){
2669                 if(ipts < ipts_min) {
2670                     ipts_min = ipts;
2671                     if(input_sync ) file_index = ist->file_index;
2672                 }
2673                 if(opts < opts_min) {
2674                     opts_min = opts;
2675                     if(!input_sync) file_index = ist->file_index;
2676                 }
2677             }
2678             if (ost->frame_number >= ost->max_frames) {
2679                 int j;
2680                 for (j = 0; j < of->ctx->nb_streams; j++)
2681                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2682                 continue;
2683             }
2684         }
2685         /* if none, if is finished */
2686         if (file_index < 0) {
2687             if(no_packet_count){
2688                 no_packet_count=0;
2689                 memset(no_packet, 0, nb_input_files);
2690                 usleep(10000);
2691                 continue;
2692             }
2693             break;
2694         }
2695
2696         /* read a frame from it and output it in the fifo */
2697         is = input_files[file_index].ctx;
2698         ret= av_read_frame(is, &pkt);
2699         if(ret == AVERROR(EAGAIN)){
2700             no_packet[file_index]=1;
2701             no_packet_count++;
2702             continue;
2703         }
2704         if (ret < 0) {
2705             input_files[file_index].eof_reached = 1;
2706             if (opt_shortest)
2707                 break;
2708             else
2709                 continue;
2710         }
2711
2712         no_packet_count=0;
2713         memset(no_packet, 0, nb_input_files);
2714
2715         if (do_pkt_dump) {
2716             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2717                              is->streams[pkt.stream_index]);
2718         }
2719         /* the following test is needed in case new streams appear
2720            dynamically in stream : we ignore them */
2721         if (pkt.stream_index >= input_files[file_index].nb_streams)
2722             goto discard_packet;
2723         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2724         ist = &input_streams[ist_index];
2725         if (ist->discard)
2726             goto discard_packet;
2727
2728         if (pkt.dts != AV_NOPTS_VALUE)
2729             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2730         if (pkt.pts != AV_NOPTS_VALUE)
2731             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2732
2733         if(pkt.pts != AV_NOPTS_VALUE)
2734             pkt.pts *= ist->ts_scale;
2735         if(pkt.dts != AV_NOPTS_VALUE)
2736             pkt.dts *= ist->ts_scale;
2737
2738 //        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);
2739         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2740             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2741             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2742             int64_t delta= pkt_dts - ist->next_pts;
2743             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2744                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2745                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2746                 pkt_dts+1<ist->pts)&& !copy_ts){
2747                 input_files[ist->file_index].ts_offset -= delta;
2748                 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2749                        delta, input_files[ist->file_index].ts_offset);
2750                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2751                 if(pkt.pts != AV_NOPTS_VALUE)
2752                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2753             }
2754         }
2755
2756         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2757         if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2758
2759             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2760                    ist->file_index, ist->st->index);
2761             if (exit_on_error)
2762                 exit_program(1);
2763             av_free_packet(&pkt);
2764             continue;
2765         }
2766
2767     discard_packet:
2768         av_free_packet(&pkt);
2769
2770         /* dump report by using the output first video and audio streams */
2771         print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2772     }
2773
2774     /* at the end of stream, we must flush the decoder buffers */
2775     for (i = 0; i < nb_input_streams; i++) {
2776         ist = &input_streams[i];
2777         if (ist->decoding_needed) {
2778             output_packet(ist, output_streams, nb_output_streams, NULL);
2779         }
2780     }
2781     flush_encoders(output_streams, nb_output_streams);
2782
2783     term_exit();
2784
2785     /* write the trailer if needed and close file */
2786     for(i=0;i<nb_output_files;i++) {
2787         os = output_files[i].ctx;
2788         av_write_trailer(os);
2789     }
2790
2791     /* dump report by using the first video and audio streams */
2792     print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2793
2794     /* close each encoder */
2795     for (i = 0; i < nb_output_streams; i++) {
2796         ost = &output_streams[i];
2797         if (ost->encoding_needed) {
2798             av_freep(&ost->st->codec->stats_in);
2799             avcodec_close(ost->st->codec);
2800         }
2801 #if CONFIG_AVFILTER
2802         avfilter_graph_free(&ost->graph);
2803 #endif
2804     }
2805
2806     /* close each decoder */
2807     for (i = 0; i < nb_input_streams; i++) {
2808         ist = &input_streams[i];
2809         if (ist->decoding_needed) {
2810             avcodec_close(ist->st->codec);
2811         }
2812     }
2813
2814     /* finished ! */
2815     ret = 0;
2816
2817  fail:
2818     av_freep(&bit_buffer);
2819     av_freep(&no_packet);
2820
2821     if (output_streams) {
2822         for (i = 0; i < nb_output_streams; i++) {
2823             ost = &output_streams[i];
2824             if (ost) {
2825                 if (ost->stream_copy)
2826                     av_freep(&ost->st->codec->extradata);
2827                 if (ost->logfile) {
2828                     fclose(ost->logfile);
2829                     ost->logfile = NULL;
2830                 }
2831                 av_fifo_free(ost->fifo); /* works even if fifo is not
2832                                              initialized but set to zero */
2833                 av_freep(&ost->st->codec->subtitle_header);
2834                 av_free(ost->resample_frame.data[0]);
2835                 av_free(ost->forced_kf_pts);
2836                 if (ost->video_resample)
2837                     sws_freeContext(ost->img_resample_ctx);
2838                 swr_free(&ost->swr);
2839                 av_dict_free(&ost->opts);
2840             }
2841         }
2842     }
2843     return ret;
2844 }
2845
2846 static int opt_frame_crop(const char *opt, const char *arg)
2847 {
2848     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2849     return AVERROR(EINVAL);
2850 }
2851
2852 static int opt_pad(const char *opt, const char *arg)
2853 {
2854     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2855     return -1;
2856 }
2857
2858 static double parse_frame_aspect_ratio(const char *arg)
2859 {
2860     int x = 0, y = 0;
2861     double ar = 0;
2862     const char *p;
2863     char *end;
2864
2865     p = strchr(arg, ':');
2866     if (p) {
2867         x = strtol(arg, &end, 10);
2868         if (end == p)
2869             y = strtol(end+1, &end, 10);
2870         if (x > 0 && y > 0)
2871             ar = (double)x / (double)y;
2872     } else
2873         ar = strtod(arg, NULL);
2874
2875     if (!ar) {
2876         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2877         exit_program(1);
2878     }
2879     return ar;
2880 }
2881
2882 static int opt_video_channel(const char *opt, const char *arg)
2883 {
2884     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2885     return opt_default("channel", arg);
2886 }
2887
2888 static int opt_video_standard(const char *opt, const char *arg)
2889 {
2890     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2891     return opt_default("standard", arg);
2892 }
2893
2894 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2895 {
2896     audio_codec_name = arg;
2897     return parse_option(o, "codec:a", arg, options);
2898 }
2899
2900 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2901 {
2902     video_codec_name = arg;
2903     return parse_option(o, "codec:v", arg, options);
2904 }
2905
2906 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2907 {
2908     subtitle_codec_name = arg;
2909     return parse_option(o, "codec:s", arg, options);
2910 }
2911
2912 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2913 {
2914     return parse_option(o, "codec:d", arg, options);
2915 }
2916
2917 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2918 {
2919     StreamMap *m = NULL;
2920     int i, negative = 0, file_idx;
2921     int sync_file_idx = -1, sync_stream_idx;
2922     char *p, *sync;
2923     char *map;
2924
2925     if (*arg == '-') {
2926         negative = 1;
2927         arg++;
2928     }
2929     map = av_strdup(arg);
2930
2931     /* parse sync stream first, just pick first matching stream */
2932     if (sync = strchr(map, ',')) {
2933         *sync = 0;
2934         sync_file_idx = strtol(sync + 1, &sync, 0);
2935         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2936             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2937             exit_program(1);
2938         }
2939         if (*sync)
2940             sync++;
2941         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2942             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2943                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2944                 sync_stream_idx = i;
2945                 break;
2946             }
2947         if (i == input_files[sync_file_idx].nb_streams) {
2948             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2949                                        "match any streams.\n", arg);
2950             exit_program(1);
2951         }
2952     }
2953
2954
2955     file_idx = strtol(map, &p, 0);
2956     if (file_idx >= nb_input_files || file_idx < 0) {
2957         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2958         exit_program(1);
2959     }
2960     if (negative)
2961         /* disable some already defined maps */
2962         for (i = 0; i < o->nb_stream_maps; i++) {
2963             m = &o->stream_maps[i];
2964             if (file_idx == m->file_index &&
2965                 check_stream_specifier(input_files[m->file_index].ctx,
2966                                        input_files[m->file_index].ctx->streams[m->stream_index],
2967                                        *p == ':' ? p + 1 : p) > 0)
2968                 m->disabled = 1;
2969         }
2970     else
2971         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2972             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2973                         *p == ':' ? p + 1 : p) <= 0)
2974                 continue;
2975             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2976                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2977             m = &o->stream_maps[o->nb_stream_maps - 1];
2978
2979             m->file_index   = file_idx;
2980             m->stream_index = i;
2981
2982             if (sync_file_idx >= 0) {
2983                 m->sync_file_index   = sync_file_idx;
2984                 m->sync_stream_index = sync_stream_idx;
2985             } else {
2986                 m->sync_file_index   = file_idx;
2987                 m->sync_stream_index = i;
2988             }
2989         }
2990
2991     if (!m) {
2992         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2993         exit_program(1);
2994     }
2995
2996     av_freep(&map);
2997     return 0;
2998 }
2999
3000 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3001 {
3002     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3003                                 &o->nb_attachments, o->nb_attachments + 1);
3004     o->attachments[o->nb_attachments - 1] = arg;
3005     return 0;
3006 }
3007
3008 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3009 {
3010     int n;
3011     AVStream *st;
3012     AudioChannelMap *m;
3013
3014     o->audio_channel_maps =
3015         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3016                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3017     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3018
3019     /* muted channel syntax */
3020     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3021     if ((n == 1 || n == 3) && m->channel_idx == -1) {
3022         m->file_idx = m->stream_idx = -1;
3023         if (n == 1)
3024             m->ofile_idx = m->ostream_idx = -1;
3025         return 0;
3026     }
3027
3028     /* normal syntax */
3029     n = sscanf(arg, "%d.%d.%d:%d.%d",
3030                &m->file_idx,  &m->stream_idx, &m->channel_idx,
3031                &m->ofile_idx, &m->ostream_idx);
3032
3033     if (n != 3 && n != 5) {
3034         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3035                "[file.stream.channel|-1][:syncfile:syncstream]\n");
3036         exit_program(1);
3037     }
3038
3039     if (n != 5) // only file.stream.channel specified
3040         m->ofile_idx = m->ostream_idx = -1;
3041
3042     /* check input */
3043     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3044         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3045                m->file_idx);
3046         exit_program(1);
3047     }
3048     if (m->stream_idx < 0 ||
3049         m->stream_idx >= input_files[m->file_idx].nb_streams) {
3050         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3051                m->file_idx, m->stream_idx);
3052         exit_program(1);
3053     }
3054     st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3055     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3056         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3057                m->file_idx, m->stream_idx);
3058         exit_program(1);
3059     }
3060     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3061         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3062                m->file_idx, m->stream_idx, m->channel_idx);
3063         exit_program(1);
3064     }
3065     return 0;
3066 }
3067
3068 static void parse_meta_type(char *arg, char *type, int *index)
3069 {
3070     if (*arg) {
3071         *type = *arg;
3072         switch (*arg) {
3073         case 'g':
3074             break;
3075         case 's':
3076         case 'c':
3077         case 'p':
3078             if (*(++arg) == ':')
3079                 *index = strtol(++arg, NULL, 0);
3080             break;
3081         default:
3082             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3083             exit_program(1);
3084         }
3085     } else
3086         *type = 'g';
3087 }
3088
3089 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
3090 {
3091     MetadataMap *m, *m1;
3092     char *p;
3093
3094     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
3095                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
3096
3097     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
3098     m->file = strtol(arg, &p, 0);
3099     parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
3100
3101     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
3102     if (p = strchr(opt, ':'))
3103         parse_meta_type(p + 1, &m1->type, &m1->index);
3104     else
3105         m1->type = 'g';
3106
3107     if (m->type == 'g' || m1->type == 'g')
3108         o->metadata_global_manual = 1;
3109     if (m->type == 's' || m1->type == 's')
3110         o->metadata_streams_manual = 1;
3111     if (m->type == 'c' || m1->type == 'c')
3112         o->metadata_chapters_manual = 1;
3113
3114     return 0;
3115 }
3116
3117 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
3118 {
3119     av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
3120                     "Use -map_metadata instead.\n");
3121     return opt_map_metadata(o, opt, arg);
3122 }
3123
3124 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3125 {
3126     char buf[128];
3127     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3128     struct tm time = *gmtime((time_t*)&recording_timestamp);
3129     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3130     parse_option(o, "metadata", buf, options);
3131
3132     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3133                                  "tag instead.\n", opt);
3134     return 0;
3135 }
3136
3137 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3138 {
3139     const char *codec_string = encoder ? "encoder" : "decoder";
3140     AVCodec *codec;
3141
3142     codec = encoder ?
3143         avcodec_find_encoder_by_name(name) :
3144         avcodec_find_decoder_by_name(name);
3145     if(!codec) {
3146         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3147         exit_program(1);
3148     }
3149     if(codec->type != type) {
3150         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3151         exit_program(1);
3152     }
3153     return codec;
3154 }
3155
3156 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3157 {
3158     char *codec_name = NULL;
3159
3160     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3161     if (codec_name) {
3162         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3163         st->codec->codec_id = codec->id;
3164         return codec;
3165     } else
3166         return avcodec_find_decoder(st->codec->codec_id);
3167 }
3168
3169 /**
3170  * Add all the streams from the given input file to the global
3171  * list of input streams.
3172  */
3173 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3174 {
3175     int i, rfps, rfps_base;
3176     char *next, *codec_tag = NULL;
3177
3178     for (i = 0; i < ic->nb_streams; i++) {
3179         AVStream *st = ic->streams[i];
3180         AVCodecContext *dec = st->codec;
3181         InputStream *ist;
3182
3183         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3184         ist = &input_streams[nb_input_streams - 1];
3185         ist->st = st;
3186         ist->file_index = nb_input_files;
3187         ist->discard = 1;
3188         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3189
3190         ist->ts_scale = 1.0;
3191         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3192
3193         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3194         if (codec_tag) {
3195             uint32_t tag = strtol(codec_tag, &next, 0);
3196             if (*next)
3197                 tag = AV_RL32(codec_tag);
3198             st->codec->codec_tag = tag;
3199         }
3200
3201         ist->dec = choose_decoder(o, ic, st);
3202
3203         switch (dec->codec_type) {
3204         case AVMEDIA_TYPE_AUDIO:
3205             if(!ist->dec)
3206                 ist->dec = avcodec_find_decoder(dec->codec_id);
3207             if(o->audio_disable)
3208                 st->discard= AVDISCARD_ALL;
3209             break;
3210         case AVMEDIA_TYPE_VIDEO:
3211             if(!ist->dec)
3212                 ist->dec = avcodec_find_decoder(dec->codec_id);
3213             rfps      = ic->streams[i]->r_frame_rate.num;
3214             rfps_base = ic->streams[i]->r_frame_rate.den;
3215             if (dec->lowres) {
3216                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3217             }
3218
3219             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3220
3221                 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",
3222                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3223                        (float)rfps / rfps_base, rfps, rfps_base);
3224             }
3225
3226             if (o->video_disable)
3227                 st->discard= AVDISCARD_ALL;
3228             else if(video_discard)
3229                 st->discard= video_discard;
3230             break;
3231         case AVMEDIA_TYPE_DATA:
3232             break;
3233         case AVMEDIA_TYPE_SUBTITLE:
3234             if(!ist->dec)
3235                 ist->dec = avcodec_find_decoder(dec->codec_id);
3236             if(o->subtitle_disable)
3237                 st->discard = AVDISCARD_ALL;
3238             break;
3239         case AVMEDIA_TYPE_ATTACHMENT:
3240         case AVMEDIA_TYPE_UNKNOWN:
3241             break;
3242         default:
3243             abort();
3244         }
3245     }
3246 }
3247
3248 static void assert_file_overwrite(const char *filename)
3249 {
3250     if (!file_overwrite &&
3251         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3252          av_strstart(filename, "file:", NULL))) {
3253         if (avio_check(filename, 0) == 0) {
3254             if (!using_stdin) {
3255                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3256                 fflush(stderr);
3257                 term_exit();
3258                 if (!read_yesno()) {
3259                     av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3260                     exit_program(1);
3261                 }
3262                 term_init();
3263             }
3264             else {
3265                 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3266                 exit_program(1);
3267             }
3268         }
3269     }
3270 }
3271
3272 static void dump_attachment(AVStream *st, const char *filename)
3273 {
3274     int ret;
3275     AVIOContext *out = NULL;
3276     AVDictionaryEntry *e;
3277
3278     if (!st->codec->extradata_size) {
3279         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3280                nb_input_files - 1, st->index);
3281         return;
3282     }
3283     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3284         filename = e->value;
3285     if (!*filename) {
3286         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3287                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3288         exit_program(1);
3289     }
3290
3291     assert_file_overwrite(filename);
3292
3293     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3294         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3295                filename);
3296         exit_program(1);
3297     }
3298
3299     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3300     avio_flush(out);
3301     avio_close(out);
3302 }
3303
3304 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3305 {
3306     AVFormatContext *ic;
3307     AVInputFormat *file_iformat = NULL;
3308     int err, i, ret;
3309     int64_t timestamp;
3310     uint8_t buf[128];
3311     AVDictionary **opts;
3312     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3313
3314     if (o->format) {
3315         if (!(file_iformat = av_find_input_format(o->format))) {
3316             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3317             exit_program(1);
3318         }
3319     }
3320
3321     if (!strcmp(filename, "-"))
3322         filename = "pipe:";
3323
3324     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3325                     !strcmp(filename, "/dev/stdin");
3326
3327     /* get default parameters from command line */
3328     ic = avformat_alloc_context();
3329     if (!ic) {
3330         print_error(filename, AVERROR(ENOMEM));
3331         exit_program(1);
3332     }
3333     if (o->nb_audio_sample_rate) {
3334         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3335         av_dict_set(&format_opts, "sample_rate", buf, 0);
3336     }
3337     if (o->nb_audio_channels) {
3338         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3339         av_dict_set(&format_opts, "channels", buf, 0);
3340     }
3341     if (o->nb_frame_rates) {
3342         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3343     }
3344     if (o->nb_frame_sizes) {
3345         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3346     }
3347     if (o->nb_frame_pix_fmts)
3348         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3349
3350     ic->video_codec_id   = video_codec_name ?
3351         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
3352     ic->audio_codec_id   = audio_codec_name ?
3353         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
3354     ic->subtitle_codec_id= subtitle_codec_name ?
3355         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3356     ic->flags |= AVFMT_FLAG_NONBLOCK;
3357     ic->interrupt_callback = int_cb;
3358
3359     if (loop_input) {
3360         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3361         ic->loop_input = loop_input;
3362     }
3363
3364     /* open the input file with generic libav function */
3365     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3366     if (err < 0) {
3367         print_error(filename, err);
3368         exit_program(1);
3369     }
3370     assert_avoptions(format_opts);
3371
3372     /* apply forced codec ids */
3373     for (i = 0; i < ic->nb_streams; i++)
3374         choose_decoder(o, ic, ic->streams[i]);
3375
3376     /* Set AVCodecContext options for avformat_find_stream_info */
3377     opts = setup_find_stream_info_opts(ic, codec_opts);
3378     orig_nb_streams = ic->nb_streams;
3379
3380     /* If not enough info to get the stream parameters, we decode the
3381        first frames to get it. (used in mpeg case for example) */
3382     ret = avformat_find_stream_info(ic, opts);
3383     if (ret < 0) {
3384         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3385         av_close_input_file(ic);
3386         exit_program(1);
3387     }
3388
3389     timestamp = o->start_time;
3390     /* add the stream start time */
3391     if (ic->start_time != AV_NOPTS_VALUE)
3392         timestamp += ic->start_time;
3393
3394     /* if seeking requested, we execute it */
3395     if (o->start_time != 0) {
3396         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3397         if (ret < 0) {
3398             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3399                    filename, (double)timestamp / AV_TIME_BASE);
3400         }
3401     }
3402
3403     /* update the current parameters so that they match the one of the input stream */
3404     add_input_streams(o, ic);
3405
3406     /* dump the file content */
3407     av_dump_format(ic, nb_input_files, filename, 0);
3408
3409     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3410     input_files[nb_input_files - 1].ctx        = ic;
3411     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3412     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3413     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3414     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3415
3416     for (i = 0; i < o->nb_dump_attachment; i++) {
3417         int j;
3418
3419         for (j = 0; j < ic->nb_streams; j++) {
3420             AVStream *st = ic->streams[j];
3421
3422             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3423                 dump_attachment(st, o->dump_attachment[i].u.str);
3424         }
3425     }
3426
3427     for (i = 0; i < orig_nb_streams; i++)
3428         av_dict_free(&opts[i]);
3429     av_freep(&opts);
3430
3431     reset_options(o, 1);
3432     return 0;
3433 }
3434
3435 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3436 {
3437     char *p;
3438     int n = 1, i;
3439
3440     for (p = kf; *p; p++)
3441         if (*p == ',')
3442             n++;
3443     ost->forced_kf_count = n;
3444     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3445     if (!ost->forced_kf_pts) {
3446         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3447         exit_program(1);
3448     }
3449     for (i = 0; i < n; i++) {
3450         p = i ? strchr(p, ',') + 1 : kf;
3451         ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3452     }
3453 }
3454
3455 static uint8_t *get_line(AVIOContext *s)
3456 {
3457     AVIOContext *line;
3458     uint8_t *buf;
3459     char c;
3460
3461     if (avio_open_dyn_buf(&line) < 0) {
3462         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3463         exit_program(1);
3464     }
3465
3466     while ((c = avio_r8(s)) && c != '\n')
3467         avio_w8(line, c);
3468     avio_w8(line, 0);
3469     avio_close_dyn_buf(line, &buf);
3470
3471     return buf;
3472 }
3473
3474 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3475 {
3476     int i, ret = 1;
3477     char filename[1000];
3478     const char *base[3] = { getenv("AVCONV_DATADIR"),
3479                             getenv("HOME"),
3480                             AVCONV_DATADIR,
3481                             };
3482
3483     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3484         if (!base[i])
3485             continue;
3486         if (codec_name) {
3487             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3488                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3489             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3490         }
3491         if (ret) {
3492             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3493                      i != 1 ? "" : "/.avconv", preset_name);
3494             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3495         }
3496     }
3497     return ret;
3498 }
3499
3500 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3501 {
3502     char *codec_name = NULL;
3503
3504     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3505     if (!codec_name) {
3506         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3507                                                   NULL, ost->st->codec->codec_type);
3508         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3509     } else if (!strcmp(codec_name, "copy"))
3510         ost->stream_copy = 1;
3511     else {
3512         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3513         ost->st->codec->codec_id = ost->enc->id;
3514     }
3515 }
3516
3517 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3518 {
3519     OutputStream *ost;
3520     AVStream *st = avformat_new_stream(oc, NULL);
3521     int idx      = oc->nb_streams - 1, ret = 0;
3522     char *bsf = NULL, *next, *codec_tag = NULL;
3523     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3524     double qscale = -1;
3525     char *buf = NULL, *arg = NULL, *preset = NULL;
3526     AVIOContext *s = NULL;
3527
3528     if (!st) {
3529         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3530         exit_program(1);
3531     }
3532
3533     if (oc->nb_streams - 1 < o->nb_streamid_map)
3534         st->id = o->streamid_map[oc->nb_streams - 1];
3535
3536     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3537                                 nb_output_streams + 1);
3538     ost = &output_streams[nb_output_streams - 1];
3539     ost->file_index = nb_output_files;
3540     ost->index = idx;
3541     ost->st    = st;
3542     st->codec->codec_type = type;
3543     choose_encoder(o, oc, ost);
3544     if (ost->enc) {
3545         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3546     }
3547
3548     avcodec_get_context_defaults3(st->codec, ost->enc);
3549     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3550
3551     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3552     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3553         do  {
3554             buf = get_line(s);
3555             if (!buf[0] || buf[0] == '#') {
3556                 av_free(buf);
3557                 continue;
3558             }
3559             if (!(arg = strchr(buf, '='))) {
3560                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3561                 exit_program(1);
3562             }
3563             *arg++ = 0;
3564             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3565             av_free(buf);
3566         } while (!s->eof_reached);
3567         avio_close(s);
3568     }
3569     if (ret) {
3570         av_log(NULL, AV_LOG_FATAL,
3571                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3572                preset, ost->file_index, ost->index);
3573         exit_program(1);
3574     }
3575
3576     ost->max_frames = INT64_MAX;
3577     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3578
3579     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3580     while (bsf) {
3581         if (next = strchr(bsf, ','))
3582             *next++ = 0;
3583         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3584             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3585             exit_program(1);
3586         }
3587         if (bsfc_prev)
3588             bsfc_prev->next = bsfc;
3589         else
3590             ost->bitstream_filters = bsfc;
3591
3592         bsfc_prev = bsfc;
3593         bsf       = next;
3594     }
3595
3596     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3597     if (codec_tag) {
3598         uint32_t tag = strtol(codec_tag, &next, 0);
3599         if (*next)
3600             tag = AV_RL32(codec_tag);
3601         st->codec->codec_tag = tag;
3602     }
3603
3604     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3605     if (qscale >= 0 || same_quant) {
3606         st->codec->flags |= CODEC_FLAG_QSCALE;
3607         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3608     }
3609
3610     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3611         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3612
3613     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3614     return ost;
3615 }
3616
3617 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3618 {
3619     int i;
3620     const char *p = str;
3621     for(i = 0;; i++) {
3622         dest[i] = atoi(p);
3623         if(i == 63)
3624             break;
3625         p = strchr(p, ',');
3626         if(!p) {
3627             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3628             exit_program(1);
3629         }
3630         p++;
3631     }
3632 }
3633
3634 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3635 {
3636     AVStream *st;
3637     OutputStream *ost;
3638     AVCodecContext *video_enc;
3639
3640     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3641     st  = ost->st;
3642     video_enc = st->codec;
3643
3644     if (!ost->stream_copy) {
3645         const char *p = NULL;
3646         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3647         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3648         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3649         int i;
3650
3651         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3652         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3653             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3654             exit_program(1);
3655         }
3656
3657         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3658         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3659             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3660             exit_program(1);
3661         }
3662
3663         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3664         if (frame_aspect_ratio)
3665             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3666
3667         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3668         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3669         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3670             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3671             exit_program(1);
3672         }
3673         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3674
3675         if (intra_only)
3676             video_enc->gop_size = 0;
3677         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3678         if (intra_matrix) {
3679             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3680                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3681                 exit_program(1);
3682             }
3683             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3684         }
3685         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3686         if (inter_matrix) {
3687             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3688                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3689                 exit_program(1);
3690             }
3691             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3692         }
3693
3694         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3695         for(i=0; p; i++){
3696             int start, end, q;
3697             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3698             if(e!=3){
3699                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3700                 exit_program(1);
3701             }
3702             /* FIXME realloc failure */
3703             video_enc->rc_override=
3704                 av_realloc(video_enc->rc_override,
3705                            sizeof(RcOverride)*(i+1));
3706             video_enc->rc_override[i].start_frame= start;
3707             video_enc->rc_override[i].end_frame  = end;
3708             if(q>0){
3709                 video_enc->rc_override[i].qscale= q;
3710                 video_enc->rc_override[i].quality_factor= 1.0;
3711             }
3712             else{
3713                 video_enc->rc_override[i].qscale= 0;
3714                 video_enc->rc_override[i].quality_factor= -q/100.0;
3715             }
3716             p= strchr(p, '/');
3717             if(p) p++;
3718         }
3719         video_enc->rc_override_count=i;
3720         if (!video_enc->rc_initial_buffer_occupancy)
3721             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3722         video_enc->intra_dc_precision= intra_dc_precision - 8;
3723
3724         if (do_psnr)
3725             video_enc->flags|= CODEC_FLAG_PSNR;
3726
3727         /* two pass mode */
3728         if (do_pass) {
3729             if (do_pass & 1) {
3730                 video_enc->flags |= CODEC_FLAG_PASS1;
3731             }
3732             if (do_pass & 2) {
3733                 video_enc->flags |= CODEC_FLAG_PASS2;
3734             }
3735         }
3736
3737         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3738         if (forced_key_frames)
3739             parse_forced_key_frames(forced_key_frames, ost);
3740
3741         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3742
3743         ost->top_field_first = -1;
3744         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3745
3746         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3747
3748 #if CONFIG_AVFILTER
3749         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3750         if (filters)
3751             ost->avfilter = av_strdup(filters);
3752 #endif
3753     }
3754
3755     return ost;
3756 }
3757
3758 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3759 {
3760     int n;
3761     AVStream *st;
3762     OutputStream *ost;
3763     AVCodecContext *audio_enc;
3764
3765     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3766     st  = ost->st;
3767
3768     audio_enc = st->codec;
3769     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3770
3771     if (!ost->stream_copy) {
3772         char *sample_fmt = NULL;
3773
3774         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3775
3776         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3777         if (sample_fmt &&
3778             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3779             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3780             exit_program(1);
3781         }
3782
3783         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3784
3785         ost->rematrix_volume=1.0;
3786         MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3787     }
3788
3789     /* check for channel mapping for this audio stream */
3790     for (n = 0; n < o->nb_audio_channel_maps; n++) {
3791         AudioChannelMap *map = &o->audio_channel_maps[n];
3792         InputStream *ist = &input_streams[ost->source_index];
3793         if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3794             (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
3795             (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
3796             if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3797                 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3798             else
3799                 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3800                        ost->file_index, ost->st->index);
3801         }
3802     }
3803
3804     return ost;
3805 }
3806
3807 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3808 {
3809     OutputStream *ost;
3810
3811     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3812     if (!ost->stream_copy) {
3813         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3814         exit_program(1);
3815     }
3816
3817     return ost;
3818 }
3819
3820 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3821 {
3822     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3823     ost->stream_copy = 1;
3824     return ost;
3825 }
3826
3827 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3828 {
3829     AVStream *st;
3830     OutputStream *ost;
3831     AVCodecContext *subtitle_enc;
3832
3833     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3834     st  = ost->st;
3835     subtitle_enc = st->codec;
3836
3837     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3838
3839     return ost;
3840 }
3841
3842 /* arg format is "output-stream-index:streamid-value". */
3843 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3844 {
3845     int idx;
3846     char *p;
3847     char idx_str[16];
3848
3849     av_strlcpy(idx_str, arg, sizeof(idx_str));
3850     p = strchr(idx_str, ':');
3851     if (!p) {
3852         av_log(NULL, AV_LOG_FATAL,
3853                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3854                arg, opt);
3855         exit_program(1);
3856     }
3857     *p++ = '\0';
3858     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3859     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3860     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3861     return 0;
3862 }
3863
3864 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3865 {
3866     AVFormatContext *is = ifile->ctx;
3867     AVFormatContext *os = ofile->ctx;
3868     int i;
3869
3870     for (i = 0; i < is->nb_chapters; i++) {
3871         AVChapter *in_ch = is->chapters[i], *out_ch;
3872         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3873                                       AV_TIME_BASE_Q, in_ch->time_base);
3874         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3875                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3876
3877
3878         if (in_ch->end < ts_off)
3879             continue;
3880         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3881             break;
3882
3883         out_ch = av_mallocz(sizeof(AVChapter));
3884         if (!out_ch)
3885             return AVERROR(ENOMEM);
3886
3887         out_ch->id        = in_ch->id;
3888         out_ch->time_base = in_ch->time_base;
3889         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3890         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3891
3892         if (copy_metadata)
3893             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3894
3895         os->nb_chapters++;
3896         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3897         if (!os->chapters)
3898             return AVERROR(ENOMEM);
3899         os->chapters[os->nb_chapters - 1] = out_ch;
3900     }
3901     return 0;
3902 }
3903
3904 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3905 {
3906     int i, err;
3907     AVFormatContext *ic = avformat_alloc_context();
3908
3909     ic->interrupt_callback = int_cb;
3910     err = avformat_open_input(&ic, filename, NULL, NULL);
3911     if (err < 0)
3912         return err;
3913     /* copy stream format */
3914     for(i=0;i<ic->nb_streams;i++) {
3915         AVStream *st;
3916         OutputStream *ost;
3917         AVCodec *codec;
3918         AVCodecContext *avctx;
3919
3920         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3921         ost   = new_output_stream(o, s, codec->type);
3922         st    = ost->st;
3923         avctx = st->codec;
3924
3925         // FIXME: a more elegant solution is needed
3926         memcpy(st, ic->streams[i], sizeof(AVStream));
3927         st->info = av_malloc(sizeof(*st->info));
3928         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3929         st->codec= avctx;
3930         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3931
3932         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3933             choose_sample_fmt(st, codec);
3934         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3935             choose_pixel_fmt(st, codec);
3936     }
3937
3938     av_close_input_file(ic);
3939     return 0;
3940 }
3941
3942 static void opt_output_file(void *optctx, const char *filename)
3943 {
3944     OptionsContext *o = optctx;
3945     AVFormatContext *oc;
3946     int i, err;
3947     AVOutputFormat *file_oformat;
3948     OutputStream *ost;
3949     InputStream  *ist;
3950
3951     if (!strcmp(filename, "-"))
3952         filename = "pipe:";
3953
3954     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3955     if (!oc) {
3956         print_error(filename, err);
3957         exit_program(1);
3958     }
3959     file_oformat= oc->oformat;
3960     oc->interrupt_callback = int_cb;
3961
3962     if (!strcmp(file_oformat->name, "ffm") &&
3963         av_strstart(filename, "http:", NULL)) {
3964         int j;
3965         /* special case for files sent to ffserver: we get the stream
3966            parameters from ffserver */
3967         int err = read_ffserver_streams(o, oc, filename);
3968         if (err < 0) {
3969             print_error(filename, err);
3970             exit_program(1);
3971         }
3972         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
3973             ost = &output_streams[j];
3974             for (i = 0; i < nb_input_streams; i++) {
3975                 ist = &input_streams[i];
3976                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
3977                     ost->sync_ist= ist;
3978                     ost->source_index= i;
3979                     ist->discard = 0;
3980                     break;
3981                 }
3982             }
3983             if(!ost->sync_ist){
3984                 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));
3985                 exit_program(1);
3986             }
3987         }
3988     } else if (!o->nb_stream_maps) {
3989         /* pick the "best" stream of each type */
3990 #define NEW_STREAM(type, index)\
3991         if (index >= 0) {\
3992             ost = new_ ## type ## _stream(o, oc);\
3993             ost->source_index = index;\
3994             ost->sync_ist     = &input_streams[index];\
3995             input_streams[index].discard = 0;\
3996         }
3997
3998         /* video: highest resolution */
3999         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4000             int area = 0, idx = -1;
4001             for (i = 0; i < nb_input_streams; i++) {
4002                 ist = &input_streams[i];
4003                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4004                     ist->st->codec->width * ist->st->codec->height > area) {
4005                     area = ist->st->codec->width * ist->st->codec->height;
4006                     idx = i;
4007                 }
4008             }
4009             NEW_STREAM(video, idx);
4010         }
4011
4012         /* audio: most channels */
4013         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4014             int channels = 0, idx = -1;
4015             for (i = 0; i < nb_input_streams; i++) {
4016                 ist = &input_streams[i];
4017                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4018                     ist->st->codec->channels > channels) {
4019                     channels = ist->st->codec->channels;
4020                     idx = i;
4021                 }
4022             }
4023             NEW_STREAM(audio, idx);
4024         }
4025
4026         /* subtitles: pick first */
4027         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4028             for (i = 0; i < nb_input_streams; i++)
4029                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4030                     NEW_STREAM(subtitle, i);
4031                     break;
4032                 }
4033         }
4034         /* do something with data? */
4035     } else {
4036         for (i = 0; i < o->nb_stream_maps; i++) {
4037             StreamMap *map = &o->stream_maps[i];
4038
4039             if (map->disabled)
4040                 continue;
4041
4042             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4043             if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4044                 continue;
4045             if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4046                 continue;
4047             if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4048                 continue;
4049
4050             switch (ist->st->codec->codec_type) {
4051             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
4052             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
4053             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4054             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
4055             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4056             default:
4057                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4058                        map->file_index, map->stream_index);
4059                 exit_program(1);
4060             }
4061
4062             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4063             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4064                                            map->sync_stream_index];
4065             ist->discard = 0;
4066         }
4067     }
4068
4069     /* handle attached files */
4070     for (i = 0; i < o->nb_attachments; i++) {
4071         AVIOContext *pb;
4072         uint8_t *attachment;
4073         const char *p;
4074         int64_t len;
4075
4076         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4077             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4078                    o->attachments[i]);
4079             exit_program(1);
4080         }
4081         if ((len = avio_size(pb)) <= 0) {
4082             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4083                    o->attachments[i]);
4084             exit_program(1);
4085         }
4086         if (!(attachment = av_malloc(len))) {
4087             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4088                    o->attachments[i]);
4089             exit_program(1);
4090         }
4091         avio_read(pb, attachment, len);
4092
4093         ost = new_attachment_stream(o, oc);
4094         ost->stream_copy               = 0;
4095         ost->source_index              = -1;
4096         ost->attachment_filename       = o->attachments[i];
4097         ost->st->codec->extradata      = attachment;
4098         ost->st->codec->extradata_size = len;
4099
4100         p = strrchr(o->attachments[i], '/');
4101         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4102         avio_close(pb);
4103     }
4104
4105     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4106     output_files[nb_output_files - 1].ctx       = oc;
4107     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4108     output_files[nb_output_files - 1].recording_time = o->recording_time;
4109     output_files[nb_output_files - 1].start_time     = o->start_time;
4110     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4111     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4112
4113     /* check filename in case of an image number is expected */
4114     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4115         if (!av_filename_number_test(oc->filename)) {
4116             print_error(oc->filename, AVERROR(EINVAL));
4117             exit_program(1);
4118         }
4119     }
4120
4121     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4122         /* test if it already exists to avoid loosing precious files */
4123         assert_file_overwrite(filename);
4124
4125         /* open the file */
4126         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4127                               &oc->interrupt_callback,
4128                               &output_files[nb_output_files - 1].opts)) < 0) {
4129             print_error(filename, err);
4130             exit_program(1);
4131         }
4132     }
4133
4134     if (o->mux_preload) {
4135         uint8_t buf[64];
4136         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4137         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4138     }
4139     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4140
4141     if (loop_output >= 0) {
4142         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4143         oc->loop_output = loop_output;
4144     }
4145
4146     /* copy chapters */
4147     if (o->chapters_input_file >= nb_input_files) {
4148         if (o->chapters_input_file == INT_MAX) {
4149             /* copy chapters from the first input file that has them*/
4150             o->chapters_input_file = -1;
4151             for (i = 0; i < nb_input_files; i++)
4152                 if (input_files[i].ctx->nb_chapters) {
4153                     o->chapters_input_file = i;
4154                     break;
4155                 }
4156         } else {
4157             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4158                    o->chapters_input_file);
4159             exit_program(1);
4160         }
4161     }
4162     if (o->chapters_input_file >= 0)
4163         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4164                       !o->metadata_chapters_manual);
4165
4166     /* copy metadata */
4167     for (i = 0; i < o->nb_meta_data_maps; i++) {
4168         AVFormatContext *files[2];
4169         AVDictionary    **meta[2];
4170         int j;
4171
4172 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4173         if ((index) < 0 || (index) >= (nb_elems)) {\
4174             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
4175                      (desc), (index));\
4176             exit_program(1);\
4177         }
4178
4179         int in_file_index = o->meta_data_maps[i][1].file;
4180         if (in_file_index < 0)
4181             continue;
4182         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
4183
4184         files[0] = oc;
4185         files[1] = input_files[in_file_index].ctx;
4186
4187         for (j = 0; j < 2; j++) {
4188             MetadataMap *map = &o->meta_data_maps[i][j];
4189
4190             switch (map->type) {
4191             case 'g':
4192                 meta[j] = &files[j]->metadata;
4193                 break;
4194             case 's':
4195                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
4196                 meta[j] = &files[j]->streams[map->index]->metadata;
4197                 break;
4198             case 'c':
4199                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
4200                 meta[j] = &files[j]->chapters[map->index]->metadata;
4201                 break;
4202             case 'p':
4203                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
4204                 meta[j] = &files[j]->programs[map->index]->metadata;
4205                 break;
4206             default:
4207                 abort();
4208             }
4209         }
4210
4211         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
4212     }
4213
4214     /* copy global metadata by default */
4215     if (!o->metadata_global_manual && nb_input_files){
4216         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4217                      AV_DICT_DONT_OVERWRITE);
4218         if(o->recording_time != INT64_MAX)
4219             av_dict_set(&oc->metadata, "duration", NULL, 0);
4220     }
4221     if (!o->metadata_streams_manual)
4222         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4223             InputStream *ist;
4224             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
4225                 continue;
4226             ist = &input_streams[output_streams[i].source_index];
4227             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4228         }
4229
4230     /* process manually set metadata */
4231     for (i = 0; i < o->nb_metadata; i++) {
4232         AVDictionary **m;
4233         char type, *val;
4234         int index = 0;
4235
4236         val = strchr(o->metadata[i].u.str, '=');
4237         if (!val) {
4238             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4239                    o->metadata[i].u.str);
4240             exit_program(1);
4241         }
4242         *val++ = 0;
4243
4244         parse_meta_type(o->metadata[i].specifier, &type, &index);
4245         switch (type) {
4246         case 'g':
4247             m = &oc->metadata;
4248             break;
4249         case 's':
4250             if (index < 0 || index >= oc->nb_streams) {
4251                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
4252                 exit_program(1);
4253             }
4254             m = &oc->streams[index]->metadata;
4255             break;
4256         case 'c':
4257             if (index < 0 || index >= oc->nb_chapters) {
4258                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4259                 exit_program(1);
4260             }
4261             m = &oc->chapters[index]->metadata;
4262             break;
4263         default:
4264             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4265             exit_program(1);
4266         }
4267
4268         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4269     }
4270
4271     reset_options(o, 0);
4272 }
4273
4274 /* same option as mencoder */
4275 static int opt_pass(const char *opt, const char *arg)
4276 {
4277     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4278     return 0;
4279 }
4280
4281 static int64_t getutime(void)
4282 {
4283 #if HAVE_GETRUSAGE
4284     struct rusage rusage;
4285
4286     getrusage(RUSAGE_SELF, &rusage);
4287     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4288 #elif HAVE_GETPROCESSTIMES
4289     HANDLE proc;
4290     FILETIME c, e, k, u;
4291     proc = GetCurrentProcess();
4292     GetProcessTimes(proc, &c, &e, &k, &u);
4293     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4294 #else
4295     return av_gettime();
4296 #endif
4297 }
4298
4299 static int64_t getmaxrss(void)
4300 {
4301 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4302     struct rusage rusage;
4303     getrusage(RUSAGE_SELF, &rusage);
4304     return (int64_t)rusage.ru_maxrss * 1024;
4305 #elif HAVE_GETPROCESSMEMORYINFO
4306     HANDLE proc;
4307     PROCESS_MEMORY_COUNTERS memcounters;
4308     proc = GetCurrentProcess();
4309     memcounters.cb = sizeof(memcounters);
4310     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4311     return memcounters.PeakPagefileUsage;
4312 #else
4313     return 0;
4314 #endif
4315 }
4316
4317 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4318 {
4319     return parse_option(o, "q:a", arg, options);
4320 }
4321
4322 static void show_usage(void)
4323 {
4324     printf("Hyper fast Audio and Video encoder\n");
4325     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4326     printf("\n");
4327 }
4328
4329 static int opt_help(const char *opt, const char *arg)
4330 {
4331     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4332     av_log_set_callback(log_callback_help);
4333     show_usage();
4334     show_help_options(options, "Main options:\n",
4335                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4336     show_help_options(options, "\nAdvanced options:\n",
4337                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4338                       OPT_EXPERT);
4339     show_help_options(options, "\nVideo options:\n",
4340                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4341                       OPT_VIDEO);
4342     show_help_options(options, "\nAdvanced Video options:\n",
4343                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4344                       OPT_VIDEO | OPT_EXPERT);
4345     show_help_options(options, "\nAudio options:\n",
4346                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4347                       OPT_AUDIO);
4348     show_help_options(options, "\nAdvanced Audio options:\n",
4349                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4350                       OPT_AUDIO | OPT_EXPERT);
4351     show_help_options(options, "\nSubtitle options:\n",
4352                       OPT_SUBTITLE | OPT_GRAB,
4353                       OPT_SUBTITLE);
4354     show_help_options(options, "\nAudio/Video grab options:\n",
4355                       OPT_GRAB,
4356                       OPT_GRAB);
4357     printf("\n");
4358     show_help_children(avcodec_get_class(), flags);
4359     show_help_children(avformat_get_class(), flags);
4360     show_help_children(sws_get_class(), flags);
4361
4362     return 0;
4363 }
4364
4365 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4366 {
4367     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4368     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4369
4370     if(!strncmp(arg, "pal-", 4)) {
4371         norm = PAL;
4372         arg += 4;
4373     } else if(!strncmp(arg, "ntsc-", 5)) {
4374         norm = NTSC;
4375         arg += 5;
4376     } else if(!strncmp(arg, "film-", 5)) {
4377         norm = FILM;
4378         arg += 5;
4379     } else {
4380         /* Try to determine PAL/NTSC by peeking in the input files */
4381         if(nb_input_files) {
4382             int i, j, fr;
4383             for (j = 0; j < nb_input_files; j++) {
4384                 for (i = 0; i < input_files[j].nb_streams; i++) {
4385                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4386                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4387                         continue;
4388                     fr = c->time_base.den * 1000 / c->time_base.num;
4389                     if(fr == 25000) {
4390                         norm = PAL;
4391                         break;
4392                     } else if((fr == 29970) || (fr == 23976)) {
4393                         norm = NTSC;
4394                         break;
4395                     }
4396                 }
4397                 if(norm != UNKNOWN)
4398                     break;
4399             }
4400         }
4401         if (norm != UNKNOWN)
4402             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4403     }
4404
4405     if(norm == UNKNOWN) {
4406         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4407         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4408         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4409         exit_program(1);
4410     }
4411
4412     if(!strcmp(arg, "vcd")) {
4413         opt_video_codec(o, "c:v", "mpeg1video");
4414         opt_audio_codec(o, "c:a", "mp2");
4415         parse_option(o, "f", "vcd", options);
4416
4417         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4418         parse_option(o, "r", frame_rates[norm], options);
4419         opt_default("g", norm == PAL ? "15" : "18");
4420
4421         opt_default("b", "1150000");
4422         opt_default("maxrate", "1150000");
4423         opt_default("minrate", "1150000");
4424         opt_default("bufsize", "327680"); // 40*1024*8;
4425
4426         opt_default("b:a", "224000");
4427         parse_option(o, "ar", "44100", options);
4428         parse_option(o, "ac", "2", options);
4429
4430         opt_default("packetsize", "2324");
4431         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4432
4433         /* We have to offset the PTS, so that it is consistent with the SCR.
4434            SCR starts at 36000, but the first two packs contain only padding
4435            and the first pack from the other stream, respectively, may also have
4436            been written before.
4437            So the real data starts at SCR 36000+3*1200. */
4438         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4439     } else if(!strcmp(arg, "svcd")) {
4440
4441         opt_video_codec(o, "c:v", "mpeg2video");
4442         opt_audio_codec(o, "c:a", "mp2");
4443         parse_option(o, "f", "svcd", options);
4444
4445         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4446         parse_option(o, "r", frame_rates[norm], options);
4447         parse_option(o, "pix_fmt", "yuv420p", options);
4448         opt_default("g", norm == PAL ? "15" : "18");
4449
4450         opt_default("b", "2040000");
4451         opt_default("maxrate", "2516000");
4452         opt_default("minrate", "0"); //1145000;
4453         opt_default("bufsize", "1835008"); //224*1024*8;
4454         opt_default("flags", "+scan_offset");
4455
4456
4457         opt_default("b:a", "224000");
4458         parse_option(o, "ar", "44100", options);
4459
4460         opt_default("packetsize", "2324");
4461
4462     } else if(!strcmp(arg, "dvd")) {
4463
4464         opt_video_codec(o, "c:v", "mpeg2video");
4465         opt_audio_codec(o, "c:a", "ac3");
4466         parse_option(o, "f", "dvd", options);
4467
4468         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4469         parse_option(o, "r", frame_rates[norm], options);
4470         parse_option(o, "pix_fmt", "yuv420p", options);
4471         opt_default("g", norm == PAL ? "15" : "18");
4472
4473         opt_default("b", "6000000");
4474         opt_default("maxrate", "9000000");
4475         opt_default("minrate", "0"); //1500000;
4476         opt_default("bufsize", "1835008"); //224*1024*8;
4477
4478         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4479         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4480
4481         opt_default("b:a", "448000");
4482         parse_option(o, "ar", "48000", options);
4483
4484     } else if(!strncmp(arg, "dv", 2)) {
4485
4486         parse_option(o, "f", "dv", options);
4487
4488         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4489         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4490                           norm == PAL ? "yuv420p" : "yuv411p", options);
4491         parse_option(o, "r", frame_rates[norm], options);
4492
4493         parse_option(o, "ar", "48000", options);
4494         parse_option(o, "ac", "2", options);
4495
4496     } else {
4497         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4498         return AVERROR(EINVAL);
4499     }
4500     return 0;
4501 }
4502
4503 static int opt_vstats_file(const char *opt, const char *arg)
4504 {
4505     av_free (vstats_filename);
4506     vstats_filename=av_strdup (arg);
4507     return 0;
4508 }
4509
4510 static int opt_vstats(const char *opt, const char *arg)
4511 {
4512     char filename[40];
4513     time_t today2 = time(NULL);
4514     struct tm *today = localtime(&today2);
4515
4516     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4517              today->tm_sec);
4518     return opt_vstats_file(opt, filename);
4519 }
4520
4521 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4522 {
4523     return parse_option(o, "frames:v", arg, options);
4524 }
4525
4526 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4527 {
4528     return parse_option(o, "frames:a", arg, options);
4529 }
4530
4531 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4532 {
4533     return parse_option(o, "frames:d", arg, options);
4534 }
4535
4536 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4537 {
4538     FILE *f=NULL;
4539     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4540     const char *codec_name = *opt == 'v' ? video_codec_name :
4541                              *opt == 'a' ? audio_codec_name :
4542                                            subtitle_codec_name;
4543
4544     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4545         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4546             av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4547         }else
4548             av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4549         exit_program(1);
4550     }
4551
4552     while(!feof(f)){
4553         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4554         if(line[0] == '#' && !e)
4555             continue;
4556         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4557         if(e){
4558             av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4559             exit_program(1);
4560         }
4561         if(!strcmp(tmp, "acodec")){
4562             opt_audio_codec(o, tmp, tmp2);
4563         }else if(!strcmp(tmp, "vcodec")){
4564             opt_video_codec(o, tmp, tmp2);
4565         }else if(!strcmp(tmp, "scodec")){
4566             opt_subtitle_codec(o, tmp, tmp2);
4567         }else if(!strcmp(tmp, "dcodec")){
4568             opt_data_codec(o, tmp, tmp2);
4569         }else if(opt_default(tmp, tmp2) < 0){
4570             av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4571             exit_program(1);
4572         }
4573     }
4574
4575     fclose(f);
4576
4577     return 0;
4578 }
4579
4580 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4581 {
4582 }
4583
4584 static int opt_passlogfile(const char *opt, const char *arg)
4585 {
4586     pass_logfilename_prefix = arg;
4587 #if CONFIG_LIBX264_ENCODER
4588     return opt_default("passlogfile", arg);
4589 #else
4590     return 0;
4591 #endif
4592 }
4593
4594 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4595 {
4596     char *s= av_malloc(strlen(opt)+2);
4597     snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4598     return parse_option(o, s, arg, options);
4599 }
4600
4601 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4602 {
4603     if(!strcmp(opt, "b")){
4604         av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4605         return parse_option(o, av_strdup("b:v"), arg, options);
4606     }
4607     return opt_default(opt, arg);
4608 }
4609
4610 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4611 {
4612     return parse_option(o, "filter:v", arg, options);
4613 }
4614
4615 #define OFFSET(x) offsetof(OptionsContext, x)
4616 static const OptionDef options[] = {
4617     /* main options */
4618 #include "cmdutils_common_opts.h"
4619     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4620     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4621     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4622     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4623     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4624     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4625     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4626     { "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]" },
4627     { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4628       "outfile[,metadata]:infile[,metadata]" },
4629     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4630       "outfile[,metadata]:infile[,metadata]" },
4631     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4632     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4633     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4634     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4635     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4636     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4637     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4638     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4639     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4640     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4641       "add timings for benchmarking" },
4642     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4643     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4644       "dump each input packet" },
4645     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4646       "when dumping packets, also dump the payload" },
4647     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4648     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4649     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4650     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4651     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4652     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4653     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4654     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4655     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4656     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4657     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4658     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4659     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4660     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4661     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4662     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4663     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4664 #if CONFIG_AVFILTER
4665     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4666 #endif
4667     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4668     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4669     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4670
4671     /* video options */
4672     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4673     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4674     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4675     { "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" },
4676     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4677     { "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" },
4678     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4679     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4680     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4681     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4682     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4683     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4684     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4685     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4686     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4687     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4688     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4689     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4690     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4691     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4692     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4693     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4694       "use same quantizer as source (implies VBR)" },
4695     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4696     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4697     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4698       "deinterlace pictures" },
4699     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4700     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4701     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4702 #if CONFIG_AVFILTER
4703     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4704 #endif
4705     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4706     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4707     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4708     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4709     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4710     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4711     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4712     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4713     { "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" },
4714     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4715
4716     /* audio options */
4717     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4718     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4719     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4720     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4721     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4722     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4723     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4724     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4725     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4726     { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4727
4728     /* subtitle options */
4729     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4730     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4731     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4732
4733     /* grab options */
4734     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4735     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4736     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4737
4738     /* muxer options */
4739     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4740     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4741
4742     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4743     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4744     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4745
4746     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4747     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4748     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4749     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4750     /* data codec support */
4751     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4752
4753     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4754     { NULL, },
4755 };
4756
4757 int main(int argc, char **argv)
4758 {
4759     OptionsContext o = { 0 };
4760     int64_t ti;
4761
4762     reset_options(&o, 0);
4763
4764     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4765     parse_loglevel(argc, argv, options);
4766
4767     if(argc>1 && !strcmp(argv[1], "-d")){
4768         run_as_daemon=1;
4769         av_log_set_callback(log_callback_null);
4770         argc--;
4771         argv++;
4772     }
4773
4774     avcodec_register_all();
4775 #if CONFIG_AVDEVICE
4776     avdevice_register_all();
4777 #endif
4778 #if CONFIG_AVFILTER
4779     avfilter_register_all();
4780 #endif
4781     av_register_all();
4782     avformat_network_init();
4783
4784     show_banner();
4785
4786     term_init();
4787
4788     /* parse options */
4789     parse_options(&o, argc, argv, options, opt_output_file);
4790
4791     if(nb_output_files <= 0 && nb_input_files == 0) {
4792         show_usage();
4793         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4794         exit_program(1);
4795     }
4796
4797     /* file converter / grab */
4798     if (nb_output_files <= 0) {
4799         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4800         exit_program(1);
4801     }
4802
4803     if (nb_input_files == 0) {
4804         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4805         exit_program(1);
4806     }
4807
4808     ti = getutime();
4809     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4810         exit_program(1);
4811     ti = getutime() - ti;
4812     if (do_benchmark) {
4813         int maxrss = getmaxrss() / 1024;
4814         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4815     }
4816
4817     exit_program(0);
4818     return 0;
4819 }