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