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