avconv.c

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