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