git.sesse.net Git - ffmpeg/blob - avconv.c

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