git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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