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