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

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