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