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