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