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

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