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