avconv.c

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