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