avconv.c

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