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