avconv.c

   1 /*
   2  * avconv main
   3  * Copyright (c) 2000-2011 The libav developers.
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include <unistd.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavdevice/avdevice.h"
  33 #include "libswscale/swscale.h"
  34 #include "libavutil/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/audioconvert.h"
  37 #include "libavutil/parseutils.h"
  38 #include "libavutil/samplefmt.h"
  39 #include "libavutil/colorspace.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/dict.h"
  43 #include "libavutil/mathematics.h"
  44 #include "libavutil/pixdesc.h"
  45 #include "libavutil/avstring.h"
  46 #include "libavutil/libm.h"
  47 #include "libavformat/os_support.h"
  48
  49 #if CONFIG_AVFILTER
  50 # include "libavfilter/avfilter.h"
  51 # include "libavfilter/avfiltergraph.h"
  52 # include "libavfilter/vsrc_buffer.h"
  53 #endif
  54
  55 #if HAVE_SYS_RESOURCE_H
  56 #include <sys/types.h>
  57 #include <sys/time.h>
  58 #include <sys/resource.h>
  59 #elif HAVE_GETPROCESSTIMES
  60 #include <windows.h>
  61 #endif
  62 #if HAVE_GETPROCESSMEMORYINFO
  63 #include <windows.h>
  64 #include <psapi.h>
  65 #endif
  66
  67 #if HAVE_SYS_SELECT_H
  68 #include <sys/select.h>
  69 #endif
  70
  71 #include <time.h>
  72
  73 #include "cmdutils.h"
  74
  75 #include "libavutil/avassert.h"
  76
  77 const char program_name[] = "avconv";
  78 const int program_birth_year = 2000;
  79
  80 /* select an input stream for an output stream */
  81 typedef struct StreamMap {
  82     int disabled;           /** 1 is this mapping is disabled by a negative map */
  83     int file_index;
  84     int stream_index;
  85     int sync_file_index;
  86     int sync_stream_index;
  87 } StreamMap;
  88
  89 /**
  90  * select an input file for an output file
  91  */
  92 typedef struct MetadataMap {
  93     int  file;      ///< file index
  94     char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
  95     int  index;     ///< stream/chapter/program number
  96 } MetadataMap;
  97
  98 static const OptionDef options[];
  99
 100 /* indexed by output file stream index */
 101 static int *streamid_map = NULL;
 102 static int nb_streamid_map = 0;
 103
 104 static int frame_width  = 0;
 105 static int frame_height = 0;
 106 static float frame_aspect_ratio = 0;
 107 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 108 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
 109 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 110 static AVRational frame_rate;
 111 static float video_qscale = 0;
 112 static uint16_t *intra_matrix = NULL;
 113 static uint16_t *inter_matrix = NULL;
 114 static const char *video_rc_override_string=NULL;
 115 static int video_disable = 0;
 116 static int video_discard = 0;
 117 static unsigned int video_codec_tag = 0;
 118 static char *video_language = NULL;
 119 static int same_quant = 0;
 120 static int do_deinterlace = 0;
 121 static int top_field_first = -1;
 122 static int me_threshold = 0;
 123 static int intra_dc_precision = 8;
 124 static int qp_hist = 0;
 125 #if CONFIG_AVFILTER
 126 static char *vfilters = NULL;
 127 #endif
 128
 129 static int audio_sample_rate = 0;
 130 #define QSCALE_NONE -99999
 131 static float audio_qscale = QSCALE_NONE;
 132 static int audio_disable = 0;
 133 static int audio_channels = 0;
 134 static unsigned int audio_codec_tag = 0;
 135 static char *audio_language = NULL;
 136
 137 static int subtitle_disable = 0;
 138 static char *subtitle_language = NULL;
 139 static unsigned int subtitle_codec_tag = 0;
 140
 141 static int data_disable = 0;
 142 static unsigned int data_codec_tag = 0;
 143
 144 static float mux_preload= 0.5;
 145 static float mux_max_delay= 0.7;
 146
 147 static int file_overwrite = 0;
 148 static AVDictionary *metadata;
 149 static int do_benchmark = 0;
 150 static int do_hex_dump = 0;
 151 static int do_pkt_dump = 0;
 152 static int do_psnr = 0;
 153 static int do_pass = 0;
 154 static char *pass_logfilename_prefix = NULL;
 155 static int video_sync_method= -1;
 156 static int audio_sync_method= 0;
 157 static float audio_drift_threshold= 0.1;
 158 static int copy_ts= 0;
 159 static int copy_tb;
 160 static int opt_shortest = 0;
 161 static char *vstats_filename;
 162 static FILE *vstats_file;
 163 static int opt_programid = 0;
 164 static int copy_initial_nonkeyframes = 0;
 165
 166 static int rate_emu = 0;
 167
 168 static int audio_volume = 256;
 169
 170 static int exit_on_error = 0;
 171 static int using_stdin = 0;
 172 static int verbose = 1;
 173 static int64_t video_size = 0;
 174 static int64_t audio_size = 0;
 175 static int64_t extra_size = 0;
 176 static int nb_frames_dup = 0;
 177 static int nb_frames_drop = 0;
 178 static int input_sync;
 179 static int force_fps = 0;
 180 static char *forced_key_frames = NULL;
 181
 182 static float dts_delta_threshold = 10;
 183
 184 static uint8_t *audio_buf;
 185 static uint8_t *audio_out;
 186 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 187
 188 static short *samples;
 189
 190 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 191 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 192 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 193
 194 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
 195
 196 typedef struct InputStream {
 197     int file_index;
 198     AVStream *st;
 199     int discard;             /* true if stream data should be discarded */
 200     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 201     AVCodec *dec;
 202
 203     int64_t       start;     /* time when read started */
 204     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 205                                 is not defined */
 206     int64_t       pts;       /* current pts */
 207     PtsCorrectionContext pts_ctx;
 208     double ts_scale;
 209     int is_start;            /* is 1 at the start and after a discontinuity */
 210     int showed_multi_packet_warning;
 211     AVDictionary *opts;
 212 } InputStream;
 213
 214 typedef struct InputFile {
 215     AVFormatContext *ctx;
 216     int eof_reached;      /* true if eof reached */
 217     int ist_index;        /* index of first stream in ist_table */
 218     int buffer_size;      /* current total buffer size */
 219     int64_t ts_offset;
 220     int nb_streams;       /* number of stream that avconv is aware of; may be different
 221                              from ctx.nb_streams if new streams appear during av_read_frame() */
 222 } InputFile;
 223
 224 typedef struct OutputStream {
 225     int file_index;          /* file index */
 226     int index;               /* stream index in the output file */
 227     int source_index;        /* InputStream index */
 228     AVStream *st;            /* stream in the output file */
 229     int encoding_needed;     /* true if encoding needed for this stream */
 230     int frame_number;
 231     /* input pts and corresponding output pts
 232        for A/V sync */
 233     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 234     struct InputStream *sync_ist; /* input stream to sync against */
 235     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 236     AVBitStreamFilterContext *bitstream_filters;
 237     AVCodec *enc;
 238
 239     /* video only */
 240     int video_resample;
 241     AVFrame pict_tmp;      /* temporary image for resampling */
 242     struct SwsContext *img_resample_ctx; /* for image resampling */
 243     int resample_height;
 244     int resample_width;
 245     int resample_pix_fmt;
 246     AVRational frame_rate;
 247
 248     float frame_aspect_ratio;
 249
 250     /* forced key frames */
 251     int64_t *forced_kf_pts;
 252     int forced_kf_count;
 253     int forced_kf_index;
 254
 255     /* audio only */
 256     int audio_resample;
 257     ReSampleContext *resample; /* for audio resampling */
 258     int resample_sample_fmt;
 259     int resample_channels;
 260     int resample_sample_rate;
 261     int reformat_pair;
 262     AVAudioConvert *reformat_ctx;
 263     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 264     FILE *logfile;
 265
 266 #if CONFIG_AVFILTER
 267     AVFilterContext *output_video_filter;
 268     AVFilterContext *input_video_filter;
 269     AVFilterBufferRef *picref;
 270     char *avfilter;
 271     AVFilterGraph *graph;
 272 #endif
 273
 274    int sws_flags;
 275    AVDictionary *opts;
 276    int is_past_recording_time;
 277 } OutputStream;
 278
 279
 280 typedef struct OutputFile {
 281     AVFormatContext *ctx;
 282     AVDictionary *opts;
 283     int ost_index;       /* index of the first stream in output_streams */
 284     int64_t recording_time; /* desired length of the resulting file in microseconds */
 285     int64_t start_time;     /* start time in microseconds */
 286     uint64_t limit_filesize;
 287 } OutputFile;
 288
 289 static InputStream *input_streams = NULL;
 290 static int         nb_input_streams = 0;
 291 static InputFile   *input_files   = NULL;
 292 static int         nb_input_files   = 0;
 293
 294 static OutputStream *output_streams = NULL;
 295 static int        nb_output_streams = 0;
 296 static OutputFile   *output_files   = NULL;
 297 static int        nb_output_files   = 0;
 298
 299 typedef struct OptionsContext {
 300     /* input/output options */
 301     int64_t start_time;
 302     const char *format;
 303
 304     SpecifierOpt *codec_names;
 305     int        nb_codec_names;
 306
 307     /* input options */
 308     int64_t input_ts_offset;
 309
 310     SpecifierOpt *ts_scale;
 311     int        nb_ts_scale;
 312
 313     /* output options */
 314     StreamMap *stream_maps;
 315     int     nb_stream_maps;
 316     /* first item specifies output metadata, second is input */
 317     MetadataMap (*meta_data_maps)[2];
 318     int nb_meta_data_maps;
 319     int metadata_global_manual;
 320     int metadata_streams_manual;
 321     int metadata_chapters_manual;
 322
 323     int chapters_input_file;
 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     av_freep(&o->meta_data_maps);
 366
 367     memset(o, 0, sizeof(*o));
 368
 369     o->recording_time = INT64_MAX;
 370     o->limit_filesize = UINT64_MAX;
 371     o->chapters_input_file = INT_MAX;
 372
 373     uninit_opts();
 374     init_opts();
 375 }
 376
 377 #if CONFIG_AVFILTER
 378
 379 static int configure_video_filters(InputStream *ist, OutputStream *ost)
 380 {
 381     AVFilterContext *last_filter, *filter;
 382     /** filter graph containing all filters including input & output */
 383     AVCodecContext *codec = ost->st->codec;
 384     AVCodecContext *icodec = ist->st->codec;
 385     FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
 386     AVRational sample_aspect_ratio;
 387     char args[255];
 388     int ret;
 389
 390     ost->graph = avfilter_graph_alloc();
 391
 392     if (ist->st->sample_aspect_ratio.num){
 393         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 394     }else
 395         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 396
 397     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 398              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 399              sample_aspect_ratio.num, sample_aspect_ratio.den);
 400
 401     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
 402                                        "src", args, NULL, ost->graph);
 403     if (ret < 0)
 404         return ret;
 405     ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
 406                                        "out", NULL, &ffsink_ctx, ost->graph);
 407     if (ret < 0)
 408         return ret;
 409     last_filter = ost->input_video_filter;
 410
 411     if (codec->width  != icodec->width || codec->height != icodec->height) {
 412         snprintf(args, 255, "%d:%d:flags=0x%X",
 413                  codec->width,
 414                  codec->height,
 415                  ost->sws_flags);
 416         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 417                                                 NULL, args, NULL, ost->graph)) < 0)
 418             return ret;
 419         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 420             return ret;
 421         last_filter = filter;
 422     }
 423
 424     snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
 425     ost->graph->scale_sws_opts = av_strdup(args);
 426
 427     if (ost->avfilter) {
 428         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
 429         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
 430
 431         outputs->name    = av_strdup("in");
 432         outputs->filter_ctx = last_filter;
 433         outputs->pad_idx = 0;
 434         outputs->next    = NULL;
 435
 436         inputs->name    = av_strdup("out");
 437         inputs->filter_ctx = ost->output_video_filter;
 438         inputs->pad_idx = 0;
 439         inputs->next    = NULL;
 440
 441         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
 442             return ret;
 443         av_freep(&ost->avfilter);
 444     } else {
 445         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
 446             return ret;
 447     }
 448
 449     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
 450         return ret;
 451
 452     codec->width  = ost->output_video_filter->inputs[0]->w;
 453     codec->height = ost->output_video_filter->inputs[0]->h;
 454     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 455         ost->frame_aspect_ratio ? // overridden by the -aspect cli option
 456         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
 457         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
 458
 459     return 0;
 460 }
 461 #endif /* CONFIG_AVFILTER */
 462
 463 static void term_exit(void)
 464 {
 465     av_log(NULL, AV_LOG_QUIET, "");
 466 }
 467
 468 static volatile int received_sigterm = 0;
 469 static volatile int received_nb_signals = 0;
 470
 471 static void
 472 sigterm_handler(int sig)
 473 {
 474     received_sigterm = sig;
 475     received_nb_signals++;
 476     term_exit();
 477 }
 478
 479 static void term_init(void)
 480 {
 481     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 482     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 483 #ifdef SIGXCPU
 484     signal(SIGXCPU, sigterm_handler);
 485 #endif
 486 }
 487
 488 static int decode_interrupt_cb(void)
 489 {
 490     return received_nb_signals > 1;
 491 }
 492
 493 void exit_program(int ret)
 494 {
 495     int i;
 496
 497     /* close files */
 498     for(i=0;i<nb_output_files;i++) {
 499         AVFormatContext *s = output_files[i].ctx;
 500         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 501             avio_close(s->pb);
 502         avformat_free_context(s);
 503         av_dict_free(&output_files[i].opts);
 504     }
 505     for(i=0;i<nb_input_files;i++) {
 506         av_close_input_file(input_files[i].ctx);
 507     }
 508     for (i = 0; i < nb_input_streams; i++)
 509         av_dict_free(&input_streams[i].opts);
 510
 511     av_free(intra_matrix);
 512     av_free(inter_matrix);
 513
 514     if (vstats_file)
 515         fclose(vstats_file);
 516     av_free(vstats_filename);
 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(pkt.pts != AV_NOPTS_VALUE)
2365             pkt.pts *= ist->ts_scale;
2366         if(pkt.dts != AV_NOPTS_VALUE)
2367             pkt.dts *= ist->ts_scale;
2368
2369 //        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);
2370         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2371             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2372             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2373             int64_t delta= pkt_dts - ist->next_pts;
2374             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2375                 input_files[ist->file_index].ts_offset -= delta;
2376                 if (verbose > 2)
2377                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2378                             delta, input_files[ist->file_index].ts_offset);
2379                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2380                 if(pkt.pts != AV_NOPTS_VALUE)
2381                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2382             }
2383         }
2384
2385         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2386         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2387
2388             if (verbose >= 0)
2389                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2390                         ist->file_index, ist->st->index);
2391             if (exit_on_error)
2392                 exit_program(1);
2393             av_free_packet(&pkt);
2394             continue;
2395         }
2396
2397     discard_packet:
2398         av_free_packet(&pkt);
2399
2400         /* dump report by using the output first video and audio streams */
2401         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2402     }
2403
2404     /* at the end of stream, we must flush the decoder buffers */
2405     for (i = 0; i < nb_input_streams; i++) {
2406         ist = &input_streams[i];
2407         if (ist->decoding_needed) {
2408             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2409         }
2410     }
2411     flush_encoders(output_streams, nb_output_streams);
2412
2413     term_exit();
2414
2415     /* write the trailer if needed and close file */
2416     for(i=0;i<nb_output_files;i++) {
2417         os = output_files[i].ctx;
2418         av_write_trailer(os);
2419     }
2420
2421     /* dump report by using the first video and audio streams */
2422     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2423
2424     /* close each encoder */
2425     for (i = 0; i < nb_output_streams; i++) {
2426         ost = &output_streams[i];
2427         if (ost->encoding_needed) {
2428             av_freep(&ost->st->codec->stats_in);
2429             avcodec_close(ost->st->codec);
2430         }
2431 #if CONFIG_AVFILTER
2432         avfilter_graph_free(&ost->graph);
2433 #endif
2434     }
2435
2436     /* close each decoder */
2437     for (i = 0; i < nb_input_streams; i++) {
2438         ist = &input_streams[i];
2439         if (ist->decoding_needed) {
2440             avcodec_close(ist->st->codec);
2441         }
2442     }
2443
2444     /* finished ! */
2445     ret = 0;
2446
2447  fail:
2448     av_freep(&bit_buffer);
2449     av_freep(&no_packet);
2450
2451     if (output_streams) {
2452         for (i = 0; i < nb_output_streams; i++) {
2453             ost = &output_streams[i];
2454             if (ost) {
2455                 if (ost->st->stream_copy)
2456                     av_freep(&ost->st->codec->extradata);
2457                 if (ost->logfile) {
2458                     fclose(ost->logfile);
2459                     ost->logfile = NULL;
2460                 }
2461                 av_fifo_free(ost->fifo); /* works even if fifo is not
2462                                              initialized but set to zero */
2463                 av_freep(&ost->st->codec->subtitle_header);
2464                 av_free(ost->pict_tmp.data[0]);
2465                 av_free(ost->forced_kf_pts);
2466                 if (ost->video_resample)
2467                     sws_freeContext(ost->img_resample_ctx);
2468                 if (ost->resample)
2469                     audio_resample_close(ost->resample);
2470                 if (ost->reformat_ctx)
2471                     av_audio_convert_free(ost->reformat_ctx);
2472                 av_dict_free(&ost->opts);
2473             }
2474         }
2475     }
2476     return ret;
2477 }
2478
2479 static int opt_video_rc_override_string(const char *opt, const char *arg)
2480 {
2481     video_rc_override_string = arg;
2482     return 0;
2483 }
2484
2485 static int opt_me_threshold(const char *opt, const char *arg)
2486 {
2487     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2488     return 0;
2489 }
2490
2491 static int opt_verbose(const char *opt, const char *arg)
2492 {
2493     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2494     return 0;
2495 }
2496
2497 static int opt_frame_rate(const char *opt, const char *arg)
2498 {
2499     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2500         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2501         exit_program(1);
2502     }
2503     return 0;
2504 }
2505
2506 static int opt_frame_size(const char *opt, const char *arg)
2507 {
2508     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2509         fprintf(stderr, "Incorrect frame size\n");
2510         return AVERROR(EINVAL);
2511     }
2512     return 0;
2513 }
2514
2515 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2516 {
2517     if (strcmp(arg, "list")) {
2518         frame_pix_fmt = av_get_pix_fmt(arg);
2519         if (frame_pix_fmt == PIX_FMT_NONE) {
2520             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2521             return AVERROR(EINVAL);
2522         }
2523     } else {
2524         show_pix_fmts();
2525         exit_program(0);
2526     }
2527     return 0;
2528 }
2529
2530 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2531 {
2532     int x = 0, y = 0;
2533     double ar = 0;
2534     const char *p;
2535     char *end;
2536
2537     p = strchr(arg, ':');
2538     if (p) {
2539         x = strtol(arg, &end, 10);
2540         if (end == p)
2541             y = strtol(end+1, &end, 10);
2542         if (x > 0 && y > 0)
2543             ar = (double)x / (double)y;
2544     } else
2545         ar = strtod(arg, NULL);
2546
2547     if (!ar) {
2548         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2549         return AVERROR(EINVAL);
2550     }
2551     frame_aspect_ratio = ar;
2552     return 0;
2553 }
2554
2555 static int opt_metadata(const char *opt, const char *arg)
2556 {
2557     char *mid= strchr(arg, '=');
2558
2559     if(!mid){
2560         fprintf(stderr, "Missing =\n");
2561         exit_program(1);
2562     }
2563     *mid++= 0;
2564
2565     av_dict_set(&metadata, arg, mid, 0);
2566
2567     return 0;
2568 }
2569
2570 static int opt_qscale(const char *opt, const char *arg)
2571 {
2572     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2573     if (video_qscale == 0) {
2574         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2575         return AVERROR(EINVAL);
2576     }
2577     return 0;
2578 }
2579
2580 static int opt_top_field_first(const char *opt, const char *arg)
2581 {
2582     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2583     return 0;
2584 }
2585
2586 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2587 {
2588     if (strcmp(arg, "list")) {
2589         audio_sample_fmt = av_get_sample_fmt(arg);
2590         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2591             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2592             return AVERROR(EINVAL);
2593         }
2594     } else {
2595         int i;
2596         char fmt_str[128];
2597         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2598             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2599         exit_program(0);
2600     }
2601     return 0;
2602 }
2603
2604 static int opt_audio_rate(const char *opt, const char *arg)
2605 {
2606     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2607     return 0;
2608 }
2609
2610 static int opt_audio_channels(const char *opt, const char *arg)
2611 {
2612     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2613     return 0;
2614 }
2615
2616 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2617 {
2618     return parse_option(o, "codec:a", arg, options);
2619 }
2620
2621 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2622 {
2623     return parse_option(o, "codec:v", arg, options);
2624 }
2625
2626 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2627 {
2628     return parse_option(o, "codec:s", arg, options);
2629 }
2630
2631 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2632 {
2633     return parse_option(o, "codec:d", arg, options);
2634 }
2635
2636 static int opt_codec_tag(const char *opt, const char *arg)
2637 {
2638     char *tail;
2639     uint32_t *codec_tag;
2640
2641     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2642                 !strcmp(opt, "vtag") ? &video_codec_tag :
2643                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2644     if (!codec_tag)
2645         return -1;
2646
2647     *codec_tag = strtol(arg, &tail, 0);
2648     if (!tail || *tail)
2649         *codec_tag = AV_RL32(arg);
2650
2651     return 0;
2652 }
2653
2654 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2655 {
2656     StreamMap *m = NULL;
2657     int i, negative = 0, file_idx;
2658     int sync_file_idx = -1, sync_stream_idx;
2659     char *p, *sync;
2660     char *map;
2661
2662     if (*arg == '-') {
2663         negative = 1;
2664         arg++;
2665     }
2666     map = av_strdup(arg);
2667
2668     /* parse sync stream first, just pick first matching stream */
2669     if (sync = strchr(map, ',')) {
2670         *sync = 0;
2671         sync_file_idx = strtol(sync + 1, &sync, 0);
2672         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2673             av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2674             exit_program(1);
2675         }
2676         if (*sync)
2677             sync++;
2678         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2679             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2680                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2681                 sync_stream_idx = i;
2682                 break;
2683             }
2684         if (i == input_files[sync_file_idx].nb_streams) {
2685             av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2686                                        "match any streams.\n", arg);
2687             exit_program(1);
2688         }
2689     }
2690
2691
2692     file_idx = strtol(map, &p, 0);
2693     if (file_idx >= nb_input_files || file_idx < 0) {
2694         av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2695         exit_program(1);
2696     }
2697     if (negative)
2698         /* disable some already defined maps */
2699         for (i = 0; i < o->nb_stream_maps; i++) {
2700             m = &o->stream_maps[i];
2701             if (check_stream_specifier(input_files[m->file_index].ctx,
2702                                        input_files[m->file_index].ctx->streams[m->stream_index],
2703                                        *p == ':' ? p + 1 : p) > 0)
2704                 m->disabled = 1;
2705         }
2706     else
2707         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2708             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2709                         *p == ':' ? p + 1 : p) <= 0)
2710                 continue;
2711             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2712                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2713             m = &o->stream_maps[o->nb_stream_maps - 1];
2714
2715             m->file_index   = file_idx;
2716             m->stream_index = i;
2717
2718             if (sync_file_idx >= 0) {
2719                 m->sync_file_index   = sync_file_idx;
2720                 m->sync_stream_index = sync_stream_idx;
2721             } else {
2722                 m->sync_file_index   = file_idx;
2723                 m->sync_stream_index = i;
2724             }
2725         }
2726
2727     if (!m) {
2728         av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2729         exit_program(1);
2730     }
2731
2732     av_freep(&map);
2733     return 0;
2734 }
2735
2736 static void parse_meta_type(char *arg, char *type, int *index)
2737 {
2738     if (*arg == ':') {
2739         *type = *(++arg);
2740         switch (*arg) {
2741         case 'g':
2742             break;
2743         case 's':
2744         case 'c':
2745         case 'p':
2746             if (*(++arg) == ':')
2747                 *index = strtol(++arg, NULL, 0);
2748             break;
2749         default:
2750             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2751             exit_program(1);
2752         }
2753     } else
2754         *type = 'g';
2755 }
2756
2757 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2758 {
2759     MetadataMap *m, *m1;
2760     char *p;
2761
2762     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2763                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2764
2765     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2766     m->file = strtol(arg, &p, 0);
2767     parse_meta_type(p, &m->type, &m->index);
2768
2769     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2770     if (p = strchr(opt, ':'))
2771         parse_meta_type(p, &m1->type, &m1->index);
2772     else
2773         m1->type = 'g';
2774
2775     if (m->type == 'g' || m1->type == 'g')
2776         o->metadata_global_manual = 1;
2777     if (m->type == 's' || m1->type == 's')
2778         o->metadata_streams_manual = 1;
2779     if (m->type == 'c' || m1->type == 'c')
2780         o->metadata_chapters_manual = 1;
2781
2782     return 0;
2783 }
2784
2785 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2786 {
2787     const char *codec_string = encoder ? "encoder" : "decoder";
2788     AVCodec *codec;
2789
2790     if(!name)
2791         return CODEC_ID_NONE;
2792     codec = encoder ?
2793         avcodec_find_encoder_by_name(name) :
2794         avcodec_find_decoder_by_name(name);
2795     if(!codec) {
2796         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2797         exit_program(1);
2798     }
2799     if(codec->type != type) {
2800         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2801         exit_program(1);
2802     }
2803     return codec->id;
2804 }
2805
2806 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2807 {
2808     char *codec_name = NULL;
2809
2810     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2811
2812     if (!codec_name) {
2813         if (s->oformat) {
2814             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2815             return avcodec_find_encoder(st->codec->codec_id);
2816         }
2817     } else if (!strcmp(codec_name, "copy"))
2818         st->stream_copy = 1;
2819     else {
2820         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2821         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2822                             avcodec_find_decoder_by_name(codec_name);
2823     }
2824
2825     return NULL;
2826 }
2827
2828 /**
2829  * Add all the streams from the given input file to the global
2830  * list of input streams.
2831  */
2832 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2833 {
2834     int i, rfps, rfps_base;
2835
2836     for (i = 0; i < ic->nb_streams; i++) {
2837         AVStream *st = ic->streams[i];
2838         AVCodecContext *dec = st->codec;
2839         InputStream *ist;
2840         double scale = 1.0;
2841
2842         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2843         ist = &input_streams[nb_input_streams - 1];
2844         ist->st = st;
2845         ist->file_index = nb_input_files;
2846         ist->discard = 1;
2847         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2848
2849         MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2850         ist->ts_scale = scale;
2851
2852         ist->dec = choose_codec(o, ic, st, dec->codec_type);
2853         if (!ist->dec)
2854             ist->dec = avcodec_find_decoder(dec->codec_id);
2855
2856         switch (dec->codec_type) {
2857         case AVMEDIA_TYPE_AUDIO:
2858             if(audio_disable)
2859                 st->discard= AVDISCARD_ALL;
2860             break;
2861         case AVMEDIA_TYPE_VIDEO:
2862             rfps      = ic->streams[i]->r_frame_rate.num;
2863             rfps_base = ic->streams[i]->r_frame_rate.den;
2864             if (dec->lowres) {
2865                 dec->flags |= CODEC_FLAG_EMU_EDGE;
2866                 dec->height >>= dec->lowres;
2867                 dec->width  >>= dec->lowres;
2868             }
2869             if(me_threshold)
2870                 dec->debug |= FF_DEBUG_MV;
2871
2872             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2873
2874                 if (verbose >= 0)
2875                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2876                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2877
2878                     (float)rfps / rfps_base, rfps, rfps_base);
2879             }
2880
2881             if(video_disable)
2882                 st->discard= AVDISCARD_ALL;
2883             else if(video_discard)
2884                 st->discard= video_discard;
2885             break;
2886         case AVMEDIA_TYPE_DATA:
2887             break;
2888         case AVMEDIA_TYPE_SUBTITLE:
2889             if(subtitle_disable)
2890                 st->discard = AVDISCARD_ALL;
2891             break;
2892         case AVMEDIA_TYPE_ATTACHMENT:
2893         case AVMEDIA_TYPE_UNKNOWN:
2894             break;
2895         default:
2896             abort();
2897         }
2898     }
2899 }
2900
2901 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2902 {
2903     AVFormatContext *ic;
2904     AVInputFormat *file_iformat = NULL;
2905     int err, i, ret;
2906     int64_t timestamp;
2907     uint8_t buf[128];
2908     AVDictionary **opts;
2909     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
2910
2911     if (o->format) {
2912         if (!(file_iformat = av_find_input_format(o->format))) {
2913             fprintf(stderr, "Unknown input format: '%s'\n", o->format);
2914             exit_program(1);
2915         }
2916     }
2917
2918     if (!strcmp(filename, "-"))
2919         filename = "pipe:";
2920
2921     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2922                     !strcmp(filename, "/dev/stdin");
2923
2924     /* get default parameters from command line */
2925     ic = avformat_alloc_context();
2926     if (!ic) {
2927         print_error(filename, AVERROR(ENOMEM));
2928         exit_program(1);
2929     }
2930     if (audio_sample_rate) {
2931         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2932         av_dict_set(&format_opts, "sample_rate", buf, 0);
2933     }
2934     if (audio_channels) {
2935         snprintf(buf, sizeof(buf), "%d", audio_channels);
2936         av_dict_set(&format_opts, "channels", buf, 0);
2937     }
2938     if (frame_rate.num) {
2939         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2940         av_dict_set(&format_opts, "framerate", buf, 0);
2941     }
2942     if (frame_width && frame_height) {
2943         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2944         av_dict_set(&format_opts, "video_size", buf, 0);
2945     }
2946     if (frame_pix_fmt != PIX_FMT_NONE)
2947         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2948
2949     ic->flags |= AVFMT_FLAG_NONBLOCK;
2950
2951     /* open the input file with generic libav function */
2952     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2953     if (err < 0) {
2954         print_error(filename, err);
2955         exit_program(1);
2956     }
2957     assert_avoptions(format_opts);
2958
2959     if(opt_programid) {
2960         int i, j;
2961         int found=0;
2962         for(i=0; i<ic->nb_streams; i++){
2963             ic->streams[i]->discard= AVDISCARD_ALL;
2964         }
2965         for(i=0; i<ic->nb_programs; i++){
2966             AVProgram *p= ic->programs[i];
2967             if(p->id != opt_programid){
2968                 p->discard = AVDISCARD_ALL;
2969             }else{
2970                 found=1;
2971                 for(j=0; j<p->nb_stream_indexes; j++){
2972                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2973                 }
2974             }
2975         }
2976         if(!found){
2977             fprintf(stderr, "Specified program id not found\n");
2978             exit_program(1);
2979         }
2980         opt_programid=0;
2981     }
2982
2983     /* apply forced codec ids */
2984     for (i = 0; i < ic->nb_streams; i++)
2985         choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2986
2987     /* Set AVCodecContext options for avformat_find_stream_info */
2988     opts = setup_find_stream_info_opts(ic, codec_opts);
2989     orig_nb_streams = ic->nb_streams;
2990
2991     /* If not enough info to get the stream parameters, we decode the
2992        first frames to get it. (used in mpeg case for example) */
2993     ret = avformat_find_stream_info(ic, opts);
2994     if (ret < 0 && verbose >= 0) {
2995         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2996         av_close_input_file(ic);
2997         exit_program(1);
2998     }
2999
3000     timestamp = o->start_time;
3001     /* add the stream start time */
3002     if (ic->start_time != AV_NOPTS_VALUE)
3003         timestamp += ic->start_time;
3004
3005     /* if seeking requested, we execute it */
3006     if (o->start_time != 0) {
3007         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3008         if (ret < 0) {
3009             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3010                     filename, (double)timestamp / AV_TIME_BASE);
3011         }
3012     }
3013
3014     /* update the current parameters so that they match the one of the input stream */
3015     add_input_streams(o, ic);
3016
3017     /* dump the file content */
3018     if (verbose >= 0)
3019         av_dump_format(ic, nb_input_files, filename, 0);
3020
3021     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3022     input_files[nb_input_files - 1].ctx        = ic;
3023     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3024     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3025     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3026
3027     frame_rate    = (AVRational){0, 0};
3028     frame_pix_fmt = PIX_FMT_NONE;
3029     frame_height = 0;
3030     frame_width  = 0;
3031     audio_sample_rate = 0;
3032     audio_channels    = 0;
3033     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3034
3035     for (i = 0; i < orig_nb_streams; i++)
3036         av_dict_free(&opts[i]);
3037     av_freep(&opts);
3038
3039     reset_options(o);
3040     return 0;
3041 }
3042
3043 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3044                                     AVCodecContext *avctx)
3045 {
3046     char *p;
3047     int n = 1, i;
3048     int64_t t;
3049
3050     for (p = kf; *p; p++)
3051         if (*p == ',')
3052             n++;
3053     ost->forced_kf_count = n;
3054     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3055     if (!ost->forced_kf_pts) {
3056         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3057         exit_program(1);
3058     }
3059     for (i = 0; i < n; i++) {
3060         p = i ? strchr(p, ',') + 1 : kf;
3061         t = parse_time_or_die("force_key_frames", p, 1);
3062         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3063     }
3064 }
3065
3066 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3067 {
3068     OutputStream *ost;
3069     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3070     int idx      = oc->nb_streams - 1;
3071
3072     if (!st) {
3073         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3074         exit_program(1);
3075     }
3076
3077     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3078                                 nb_output_streams + 1);
3079     ost = &output_streams[nb_output_streams - 1];
3080     ost->file_index = nb_output_files;
3081     ost->index = idx;
3082     ost->st    = st;
3083     st->codec->codec_type = type;
3084     ost->enc = choose_codec(o, oc, st, type);
3085     if (ost->enc) {
3086         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3087     }
3088
3089     avcodec_get_context_defaults3(st->codec, ost->enc);
3090     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3091
3092     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3093     return ost;
3094 }
3095
3096 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3097 {
3098     AVStream *st;
3099     OutputStream *ost;
3100     AVCodecContext *video_enc;
3101
3102     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3103     st  = ost->st;
3104     if (!st->stream_copy) {
3105         ost->frame_aspect_ratio = frame_aspect_ratio;
3106         frame_aspect_ratio = 0;
3107 #if CONFIG_AVFILTER
3108         ost->avfilter= vfilters;
3109         vfilters = NULL;
3110 #endif
3111     }
3112
3113     ost->bitstream_filters = video_bitstream_filters;
3114     video_bitstream_filters= NULL;
3115
3116     video_enc = st->codec;
3117
3118     if(video_codec_tag)
3119         video_enc->codec_tag= video_codec_tag;
3120
3121     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3122         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3123     }
3124
3125     if (st->stream_copy) {
3126         video_enc->sample_aspect_ratio =
3127         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3128     } else {
3129         const char *p;
3130         int i;
3131
3132         if (frame_rate.num)
3133             ost->frame_rate = frame_rate;
3134
3135         video_enc->width = frame_width;
3136         video_enc->height = frame_height;
3137         video_enc->pix_fmt = frame_pix_fmt;
3138         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3139
3140         if (video_qscale || same_quant) {
3141             video_enc->flags |= CODEC_FLAG_QSCALE;
3142             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3143         }
3144
3145         if(intra_matrix)
3146             video_enc->intra_matrix = intra_matrix;
3147         if(inter_matrix)
3148             video_enc->inter_matrix = inter_matrix;
3149
3150         p= video_rc_override_string;
3151         for(i=0; p; i++){
3152             int start, end, q;
3153             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3154             if(e!=3){
3155                 fprintf(stderr, "error parsing rc_override\n");
3156                 exit_program(1);
3157             }
3158             video_enc->rc_override=
3159                 av_realloc(video_enc->rc_override,
3160                            sizeof(RcOverride)*(i+1));
3161             video_enc->rc_override[i].start_frame= start;
3162             video_enc->rc_override[i].end_frame  = end;
3163             if(q>0){
3164                 video_enc->rc_override[i].qscale= q;
3165                 video_enc->rc_override[i].quality_factor= 1.0;
3166             }
3167             else{
3168                 video_enc->rc_override[i].qscale= 0;
3169                 video_enc->rc_override[i].quality_factor= -q/100.0;
3170             }
3171             p= strchr(p, '/');
3172             if(p) p++;
3173         }
3174         video_enc->rc_override_count=i;
3175         if (!video_enc->rc_initial_buffer_occupancy)
3176             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3177         video_enc->me_threshold= me_threshold;
3178         video_enc->intra_dc_precision= intra_dc_precision - 8;
3179
3180         if (do_psnr)
3181             video_enc->flags|= CODEC_FLAG_PSNR;
3182
3183         /* two pass mode */
3184         if (do_pass) {
3185             if (do_pass == 1) {
3186                 video_enc->flags |= CODEC_FLAG_PASS1;
3187             } else {
3188                 video_enc->flags |= CODEC_FLAG_PASS2;
3189             }
3190         }
3191
3192         if (forced_key_frames)
3193             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3194     }
3195     if (video_language) {
3196         av_dict_set(&st->metadata, "language", video_language, 0);
3197         av_freep(&video_language);
3198     }
3199
3200     /* reset some key parameters */
3201     video_disable = 0;
3202     av_freep(&forced_key_frames);
3203     frame_pix_fmt = PIX_FMT_NONE;
3204     return ost;
3205 }
3206
3207 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3208 {
3209     AVStream *st;
3210     OutputStream *ost;
3211     AVCodecContext *audio_enc;
3212
3213     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3214     st  = ost->st;
3215
3216     ost->bitstream_filters = audio_bitstream_filters;
3217     audio_bitstream_filters= NULL;
3218
3219     audio_enc = st->codec;
3220     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3221
3222     if(audio_codec_tag)
3223         audio_enc->codec_tag= audio_codec_tag;
3224
3225     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3226         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3227     }
3228     if (!st->stream_copy) {
3229         if (audio_qscale > QSCALE_NONE) {
3230             audio_enc->flags |= CODEC_FLAG_QSCALE;
3231             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3232         }
3233         if (audio_channels)
3234             audio_enc->channels = audio_channels;
3235         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3236             audio_enc->sample_fmt = audio_sample_fmt;
3237         if (audio_sample_rate)
3238             audio_enc->sample_rate = audio_sample_rate;
3239     }
3240     if (audio_language) {
3241         av_dict_set(&st->metadata, "language", audio_language, 0);
3242         av_freep(&audio_language);
3243     }
3244
3245     /* reset some key parameters */
3246     audio_disable = 0;
3247
3248     return ost;
3249 }
3250
3251 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3252 {
3253     AVStream *st;
3254     OutputStream *ost;
3255     AVCodecContext *data_enc;
3256
3257     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3258     st  = ost->st;
3259     data_enc = st->codec;
3260     if (!st->stream_copy) {
3261         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3262         exit_program(1);
3263     }
3264
3265     if (data_codec_tag)
3266         data_enc->codec_tag= data_codec_tag;
3267
3268     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3269         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3270     }
3271
3272     data_disable = 0;
3273     return ost;
3274 }
3275
3276 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3277 {
3278     AVStream *st;
3279     OutputStream *ost;
3280     AVCodecContext *subtitle_enc;
3281
3282     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3283     st  = ost->st;
3284     subtitle_enc = st->codec;
3285
3286     ost->bitstream_filters = subtitle_bitstream_filters;
3287     subtitle_bitstream_filters= NULL;
3288
3289     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3290
3291     if(subtitle_codec_tag)
3292         subtitle_enc->codec_tag= subtitle_codec_tag;
3293
3294     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3295         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3296     }
3297
3298     if (subtitle_language) {
3299         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3300         av_freep(&subtitle_language);
3301     }
3302
3303     subtitle_disable = 0;
3304     return ost;
3305 }
3306
3307 /* arg format is "output-stream-index:streamid-value". */
3308 static int opt_streamid(const char *opt, const char *arg)
3309 {
3310     int idx;
3311     char *p;
3312     char idx_str[16];
3313
3314     av_strlcpy(idx_str, arg, sizeof(idx_str));
3315     p = strchr(idx_str, ':');
3316     if (!p) {
3317         fprintf(stderr,
3318                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3319                 arg, opt);
3320         exit_program(1);
3321     }
3322     *p++ = '\0';
3323     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3324     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3325     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3326     return 0;
3327 }
3328
3329 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3330 {
3331     AVFormatContext *is = ifile->ctx;
3332     AVFormatContext *os = ofile->ctx;
3333     int i;
3334
3335     for (i = 0; i < is->nb_chapters; i++) {
3336         AVChapter *in_ch = is->chapters[i], *out_ch;
3337         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3338                                       AV_TIME_BASE_Q, in_ch->time_base);
3339         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3340                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3341
3342
3343         if (in_ch->end < ts_off)
3344             continue;
3345         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3346             break;
3347
3348         out_ch = av_mallocz(sizeof(AVChapter));
3349         if (!out_ch)
3350             return AVERROR(ENOMEM);
3351
3352         out_ch->id        = in_ch->id;
3353         out_ch->time_base = in_ch->time_base;
3354         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3355         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3356
3357         if (copy_metadata)
3358             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3359
3360         os->nb_chapters++;
3361         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3362         if (!os->chapters)
3363             return AVERROR(ENOMEM);
3364         os->chapters[os->nb_chapters - 1] = out_ch;
3365     }
3366     return 0;
3367 }
3368
3369 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3370 {
3371     int i, err;
3372     AVFormatContext *ic = NULL;
3373
3374     err = avformat_open_input(&ic, filename, NULL, NULL);
3375     if (err < 0)
3376         return err;
3377     /* copy stream format */
3378     for(i=0;i<ic->nb_streams;i++) {
3379         AVStream *st;
3380         OutputStream *ost;
3381         AVCodec *codec;
3382
3383         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3384         ost   = new_output_stream(o, s, codec->type);
3385         st    = ost->st;
3386
3387         // FIXME: a more elegant solution is needed
3388         memcpy(st, ic->streams[i], sizeof(AVStream));
3389         st->info = NULL;
3390         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3391
3392         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3393             choose_sample_fmt(st, codec);
3394         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3395             choose_pixel_fmt(st, codec);
3396     }
3397
3398     av_close_input_file(ic);
3399     return 0;
3400 }
3401
3402 static void opt_output_file(void *optctx, const char *filename)
3403 {
3404     OptionsContext *o = optctx;
3405     AVFormatContext *oc;
3406     int i, err;
3407     AVOutputFormat *file_oformat;
3408     OutputStream *ost;
3409     InputStream  *ist;
3410
3411     if (!strcmp(filename, "-"))
3412         filename = "pipe:";
3413
3414     oc = avformat_alloc_context();
3415     if (!oc) {
3416         print_error(filename, AVERROR(ENOMEM));
3417         exit_program(1);
3418     }
3419
3420     if (o->format) {
3421         file_oformat = av_guess_format(o->format, NULL, NULL);
3422         if (!file_oformat) {
3423             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", o->format);
3424             exit_program(1);
3425         }
3426     } else {
3427         file_oformat = av_guess_format(NULL, filename, NULL);
3428         if (!file_oformat) {
3429             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3430                     filename);
3431             exit_program(1);
3432         }
3433     }
3434
3435     oc->oformat = file_oformat;
3436     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3437
3438     if (!strcmp(file_oformat->name, "ffm") &&
3439         av_strstart(filename, "http:", NULL)) {
3440         /* special case for files sent to avserver: we get the stream
3441            parameters from avserver */
3442         int err = read_avserver_streams(o, oc, filename);
3443         if (err < 0) {
3444             print_error(filename, err);
3445             exit_program(1);
3446         }
3447     } else if (!o->nb_stream_maps) {
3448         /* pick the "best" stream of each type */
3449 #define NEW_STREAM(type, index)\
3450         if (index >= 0) {\
3451             ost = new_ ## type ## _stream(o, oc);\
3452             ost->source_index = index;\
3453             ost->sync_ist     = &input_streams[index];\
3454             input_streams[index].discard = 0;\
3455         }
3456
3457         /* video: highest resolution */
3458         if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3459             int area = 0, idx = -1;
3460             for (i = 0; i < nb_input_streams; i++) {
3461                 ist = &input_streams[i];
3462                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3463                     ist->st->codec->width * ist->st->codec->height > area) {
3464                     area = ist->st->codec->width * ist->st->codec->height;
3465                     idx = i;
3466                 }
3467             }
3468             NEW_STREAM(video, idx);
3469         }
3470
3471         /* audio: most channels */
3472         if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3473             int channels = 0, idx = -1;
3474             for (i = 0; i < nb_input_streams; i++) {
3475                 ist = &input_streams[i];
3476                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3477                     ist->st->codec->channels > channels) {
3478                     channels = ist->st->codec->channels;
3479                     idx = i;
3480                 }
3481             }
3482             NEW_STREAM(audio, idx);
3483         }
3484
3485         /* subtitles: pick first */
3486         if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3487             for (i = 0; i < nb_input_streams; i++)
3488                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3489                     NEW_STREAM(subtitle, i);
3490                     break;
3491                 }
3492         }
3493         /* do something with data? */
3494     } else {
3495         for (i = 0; i < o->nb_stream_maps; i++) {
3496             StreamMap *map = &o->stream_maps[i];
3497
3498             if (map->disabled)
3499                 continue;
3500
3501             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3502             switch (ist->st->codec->codec_type) {
3503             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3504             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3505             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3506             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3507             default:
3508                 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3509                        map->file_index, map->stream_index);
3510                 exit_program(1);
3511             }
3512
3513             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3514             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3515                                            map->sync_stream_index];
3516             ist->discard = 0;
3517         }
3518     }
3519
3520     av_dict_copy(&oc->metadata, metadata, 0);
3521     av_dict_free(&metadata);
3522
3523
3524     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3525     output_files[nb_output_files - 1].ctx       = oc;
3526     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3527     output_files[nb_output_files - 1].recording_time = o->recording_time;
3528     output_files[nb_output_files - 1].start_time     = o->start_time;
3529     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3530     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3531
3532     /* check filename in case of an image number is expected */
3533     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3534         if (!av_filename_number_test(oc->filename)) {
3535             print_error(oc->filename, AVERROR(EINVAL));
3536             exit_program(1);
3537         }
3538     }
3539
3540     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3541         /* test if it already exists to avoid loosing precious files */
3542         if (!file_overwrite &&
3543             (strchr(filename, ':') == NULL ||
3544              filename[1] == ':' ||
3545              av_strstart(filename, "file:", NULL))) {
3546             if (avio_check(filename, 0) == 0) {
3547                 if (!using_stdin) {
3548                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3549                     fflush(stderr);
3550                     if (!read_yesno()) {
3551                         fprintf(stderr, "Not overwriting - exiting\n");
3552                         exit_program(1);
3553                     }
3554                 }
3555                 else {
3556                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3557                     exit_program(1);
3558                 }
3559             }
3560         }
3561
3562         /* open the file */
3563         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3564             print_error(filename, err);
3565             exit_program(1);
3566         }
3567     }
3568
3569     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3570     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3571     oc->flags |= AVFMT_FLAG_NONBLOCK;
3572
3573     /* copy chapters */
3574     if (o->chapters_input_file >= nb_input_files) {
3575         if (o->chapters_input_file == INT_MAX) {
3576             /* copy chapters from the first input file that has them*/
3577             o->chapters_input_file = -1;
3578             for (i = 0; i < nb_input_files; i++)
3579                 if (input_files[i].ctx->nb_chapters) {
3580                     o->chapters_input_file = i;
3581                     break;
3582                 }
3583         } else {
3584             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3585                    o->chapters_input_file);
3586             exit_program(1);
3587         }
3588     }
3589     if (o->chapters_input_file >= 0)
3590         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3591                       o->metadata_chapters_manual);
3592
3593     /* copy metadata */
3594     for (i = 0; i < o->nb_meta_data_maps; i++) {
3595         AVFormatContext *files[2];
3596         AVDictionary    **meta[2];
3597         int j;
3598
3599 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3600         if ((index) < 0 || (index) >= (nb_elems)) {\
3601             av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3602                      (desc), (index));\
3603             exit_program(1);\
3604         }
3605
3606         int in_file_index = o->meta_data_maps[i][1].file;
3607         if (in_file_index < 0)
3608             continue;
3609         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3610
3611         files[0] = oc;
3612         files[1] = input_files[in_file_index].ctx;
3613
3614         for (j = 0; j < 2; j++) {
3615             MetadataMap *map = &o->meta_data_maps[i][j];
3616
3617             switch (map->type) {
3618             case 'g':
3619                 meta[j] = &files[j]->metadata;
3620                 break;
3621             case 's':
3622                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3623                 meta[j] = &files[j]->streams[map->index]->metadata;
3624                 break;
3625             case 'c':
3626                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3627                 meta[j] = &files[j]->chapters[map->index]->metadata;
3628                 break;
3629             case 'p':
3630                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3631                 meta[j] = &files[j]->programs[map->index]->metadata;
3632                 break;
3633             }
3634         }
3635
3636         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3637     }
3638
3639     /* copy global metadata by default */
3640     if (!o->metadata_global_manual && nb_input_files)
3641         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3642                      AV_DICT_DONT_OVERWRITE);
3643     if (!o->metadata_streams_manual)
3644         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3645             InputStream *ist = &input_streams[output_streams[i].source_index];
3646             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3647         }
3648
3649     frame_rate    = (AVRational){0, 0};
3650     frame_width   = 0;
3651     frame_height  = 0;
3652     audio_sample_rate = 0;
3653     audio_channels    = 0;
3654     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3655
3656     av_freep(&streamid_map);
3657     nb_streamid_map = 0;
3658
3659     av_freep(&forced_key_frames);
3660     reset_options(o);
3661 }
3662
3663 /* same option as mencoder */
3664 static int opt_pass(const char *opt, const char *arg)
3665 {
3666     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3667     return 0;
3668 }
3669
3670 static int64_t getutime(void)
3671 {
3672 #if HAVE_GETRUSAGE
3673     struct rusage rusage;
3674
3675     getrusage(RUSAGE_SELF, &rusage);
3676     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3677 #elif HAVE_GETPROCESSTIMES
3678     HANDLE proc;
3679     FILETIME c, e, k, u;
3680     proc = GetCurrentProcess();
3681     GetProcessTimes(proc, &c, &e, &k, &u);
3682     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3683 #else
3684     return av_gettime();
3685 #endif
3686 }
3687
3688 static int64_t getmaxrss(void)
3689 {
3690 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3691     struct rusage rusage;
3692     getrusage(RUSAGE_SELF, &rusage);
3693     return (int64_t)rusage.ru_maxrss * 1024;
3694 #elif HAVE_GETPROCESSMEMORYINFO
3695     HANDLE proc;
3696     PROCESS_MEMORY_COUNTERS memcounters;
3697     proc = GetCurrentProcess();
3698     memcounters.cb = sizeof(memcounters);
3699     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3700     return memcounters.PeakPagefileUsage;
3701 #else
3702     return 0;
3703 #endif
3704 }
3705
3706 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3707 {
3708     int i;
3709     const char *p = str;
3710     for(i = 0;; i++) {
3711         dest[i] = atoi(p);
3712         if(i == 63)
3713             break;
3714         p = strchr(p, ',');
3715         if(!p) {
3716             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3717             exit_program(1);
3718         }
3719         p++;
3720     }
3721 }
3722
3723 static void opt_inter_matrix(const char *arg)
3724 {
3725     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3726     parse_matrix_coeffs(inter_matrix, arg);
3727 }
3728
3729 static void opt_intra_matrix(const char *arg)
3730 {
3731     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3732     parse_matrix_coeffs(intra_matrix, arg);
3733 }
3734
3735 static void show_usage(void)
3736 {
3737     printf("Hyper fast Audio and Video encoder\n");
3738     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3739     printf("\n");
3740 }
3741
3742 static void show_help(void)
3743 {
3744     AVCodec *c;
3745     AVOutputFormat *oformat = NULL;
3746     AVInputFormat  *iformat = NULL;
3747     const AVClass *class;
3748
3749     av_log_set_callback(log_callback_help);
3750     show_usage();
3751     show_help_options(options, "Main options:\n",
3752                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3753     show_help_options(options, "\nAdvanced options:\n",
3754                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3755                       OPT_EXPERT);
3756     show_help_options(options, "\nVideo options:\n",
3757                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3758                       OPT_VIDEO);
3759     show_help_options(options, "\nAdvanced Video options:\n",
3760                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3761                       OPT_VIDEO | OPT_EXPERT);
3762     show_help_options(options, "\nAudio options:\n",
3763                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3764                       OPT_AUDIO);
3765     show_help_options(options, "\nAdvanced Audio options:\n",
3766                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3767                       OPT_AUDIO | OPT_EXPERT);
3768     show_help_options(options, "\nSubtitle options:\n",
3769                       OPT_SUBTITLE | OPT_GRAB,
3770                       OPT_SUBTITLE);
3771     show_help_options(options, "\nAudio/Video grab options:\n",
3772                       OPT_GRAB,
3773                       OPT_GRAB);
3774     printf("\n");
3775     class = avcodec_get_class();
3776     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3777     printf("\n");
3778
3779     /* individual codec options */
3780     c = NULL;
3781     while ((c = av_codec_next(c))) {
3782         if (c->priv_class) {
3783             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3784             printf("\n");
3785         }
3786     }
3787
3788     class = avformat_get_class();
3789     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3790     printf("\n");
3791
3792     /* individual muxer options */
3793     while ((oformat = av_oformat_next(oformat))) {
3794         if (oformat->priv_class) {
3795             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3796             printf("\n");
3797         }
3798     }
3799
3800     /* individual demuxer options */
3801     while ((iformat = av_iformat_next(iformat))) {
3802         if (iformat->priv_class) {
3803             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3804             printf("\n");
3805         }
3806     }
3807
3808     class = sws_get_class();
3809     av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3810 }
3811
3812 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3813 {
3814     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3815     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3816
3817     if(!strncmp(arg, "pal-", 4)) {
3818         norm = PAL;
3819         arg += 4;
3820     } else if(!strncmp(arg, "ntsc-", 5)) {
3821         norm = NTSC;
3822         arg += 5;
3823     } else if(!strncmp(arg, "film-", 5)) {
3824         norm = FILM;
3825         arg += 5;
3826     } else {
3827         int fr;
3828         /* Calculate FR via float to avoid int overflow */
3829         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3830         if(fr == 25000) {
3831             norm = PAL;
3832         } else if((fr == 29970) || (fr == 23976)) {
3833             norm = NTSC;
3834         } else {
3835             /* Try to determine PAL/NTSC by peeking in the input files */
3836             if(nb_input_files) {
3837                 int i, j;
3838                 for (j = 0; j < nb_input_files; j++) {
3839                     for (i = 0; i < input_files[j].nb_streams; i++) {
3840                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3841                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3842                             continue;
3843                         fr = c->time_base.den * 1000 / c->time_base.num;
3844                         if(fr == 25000) {
3845                             norm = PAL;
3846                             break;
3847                         } else if((fr == 29970) || (fr == 23976)) {
3848                             norm = NTSC;
3849                             break;
3850                         }
3851                     }
3852                     if(norm != UNKNOWN)
3853                         break;
3854                 }
3855             }
3856         }
3857         if(verbose > 0 && norm != UNKNOWN)
3858             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3859     }
3860
3861     if(norm == UNKNOWN) {
3862         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3863         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3864         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3865         exit_program(1);
3866     }
3867
3868     if(!strcmp(arg, "vcd")) {
3869         opt_video_codec(o, "c:v", "mpeg1video");
3870         opt_audio_codec(o, "c:a", "mp2");
3871         parse_option(o, "f", "vcd", options);
3872
3873         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3874         opt_frame_rate("r", frame_rates[norm]);
3875         opt_default("g", norm == PAL ? "15" : "18");
3876
3877         opt_default("b", "1150000");
3878         opt_default("maxrate", "1150000");
3879         opt_default("minrate", "1150000");
3880         opt_default("bufsize", "327680"); // 40*1024*8;
3881
3882         opt_default("b:a", "224000");
3883         audio_sample_rate = 44100;
3884         audio_channels = 2;
3885
3886         opt_default("packetsize", "2324");
3887         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3888
3889         /* We have to offset the PTS, so that it is consistent with the SCR.
3890            SCR starts at 36000, but the first two packs contain only padding
3891            and the first pack from the other stream, respectively, may also have
3892            been written before.
3893            So the real data starts at SCR 36000+3*1200. */
3894         mux_preload= (36000+3*1200) / 90000.0; //0.44
3895     } else if(!strcmp(arg, "svcd")) {
3896
3897         opt_video_codec(o, "c:v", "mpeg2video");
3898         opt_audio_codec(o, "c:a", "mp2");
3899         parse_option(o, "f", "svcd", options);
3900
3901         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3902         opt_frame_rate("r", frame_rates[norm]);
3903         opt_default("g", norm == PAL ? "15" : "18");
3904
3905         opt_default("b", "2040000");
3906         opt_default("maxrate", "2516000");
3907         opt_default("minrate", "0"); //1145000;
3908         opt_default("bufsize", "1835008"); //224*1024*8;
3909         opt_default("flags", "+scan_offset");
3910
3911
3912         opt_default("b:a", "224000");
3913         audio_sample_rate = 44100;
3914
3915         opt_default("packetsize", "2324");
3916
3917     } else if(!strcmp(arg, "dvd")) {
3918
3919         opt_video_codec(o, "c:v", "mpeg2video");
3920         opt_audio_codec(o, "c:a", "ac3");
3921         parse_option(o, "f", "dvd", options);
3922
3923         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3924         opt_frame_rate("r", frame_rates[norm]);
3925         opt_default("g", norm == PAL ? "15" : "18");
3926
3927         opt_default("b", "6000000");
3928         opt_default("maxrate", "9000000");
3929         opt_default("minrate", "0"); //1500000;
3930         opt_default("bufsize", "1835008"); //224*1024*8;
3931
3932         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3933         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3934
3935         opt_default("b:a", "448000");
3936         audio_sample_rate = 48000;
3937
3938     } else if(!strncmp(arg, "dv", 2)) {
3939
3940         parse_option(o, "f", "dv", options);
3941
3942         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3943         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3944                           norm == PAL ? "yuv420p" : "yuv411p");
3945         opt_frame_rate("r", frame_rates[norm]);
3946
3947         audio_sample_rate = 48000;
3948         audio_channels = 2;
3949
3950     } else {
3951         fprintf(stderr, "Unknown target: %s\n", arg);
3952         return AVERROR(EINVAL);
3953     }
3954     return 0;
3955 }
3956
3957 static int opt_vstats_file(const char *opt, const char *arg)
3958 {
3959     av_free (vstats_filename);
3960     vstats_filename=av_strdup (arg);
3961     return 0;
3962 }
3963
3964 static int opt_vstats(const char *opt, const char *arg)
3965 {
3966     char filename[40];
3967     time_t today2 = time(NULL);
3968     struct tm *today = localtime(&today2);
3969
3970     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3971              today->tm_sec);
3972     return opt_vstats_file(opt, filename);
3973 }
3974
3975 static int opt_bsf(const char *opt, const char *arg)
3976 {
3977     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3978     AVBitStreamFilterContext **bsfp;
3979
3980     if(!bsfc){
3981         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3982         exit_program(1);
3983     }
3984
3985     bsfp= *opt == 'v' ? &video_bitstream_filters :
3986           *opt == 'a' ? &audio_bitstream_filters :
3987                         &subtitle_bitstream_filters;
3988     while(*bsfp)
3989         bsfp= &(*bsfp)->next;
3990
3991     *bsfp= bsfc;
3992
3993     return 0;
3994 }
3995
3996 #define OFFSET(x) offsetof(OptionsContext, x)
3997 static const OptionDef options[] = {
3998     /* main options */
3999 #include "cmdutils_common_opts.h"
4000     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4001     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4002     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4003     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4004     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4005     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4006     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4007       "outfile[,metadata]:infile[,metadata]" },
4008     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4009     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4010     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4011     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4012     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4013     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4014     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4015     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4016     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4017       "add timings for benchmarking" },
4018     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4019     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4020       "dump each input packet" },
4021     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4022       "when dumping packets, also dump the payload" },
4023     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4024     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4025     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4026     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4027     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4028     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4029     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4030     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4031     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4032     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4033     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4034     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4035     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4036
4037     /* video options */
4038     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4039     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4040     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4041     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4042     { "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" },
4043     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4044     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4045     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4046     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4047     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4048     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold",  "threshold" },
4049     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4050       "use same quantizer as source (implies VBR)" },
4051     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4052     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4053     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4054       "deinterlace pictures" },
4055     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4056     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4057     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4058 #if CONFIG_AVFILTER
4059     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4060 #endif
4061     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4062     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4063     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4064     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4065     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4066     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4067     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4068     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4069     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4070     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4071
4072     /* audio options */
4073     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4074     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4075     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4076     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4077     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4078     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4079     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4080     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4081     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4082     { "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" },
4083
4084     /* subtitle options */
4085     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4086     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4087     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4088     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4089
4090     /* grab options */
4091     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4092
4093     /* muxer options */
4094     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4095     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4096
4097     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4098     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4099     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4100
4101     /* data codec support */
4102     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4103
4104     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4105     { NULL, },
4106 };
4107
4108 int main(int argc, char **argv)
4109 {
4110     OptionsContext o = { 0 };
4111     int64_t ti;
4112
4113     reset_options(&o);
4114
4115     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4116
4117     avcodec_register_all();
4118 #if CONFIG_AVDEVICE
4119     avdevice_register_all();
4120 #endif
4121 #if CONFIG_AVFILTER
4122     avfilter_register_all();
4123 #endif
4124     av_register_all();
4125
4126     avio_set_interrupt_cb(decode_interrupt_cb);
4127
4128     show_banner();
4129
4130     /* parse options */
4131     parse_options(&o, argc, argv, options, opt_output_file);
4132
4133     if(nb_output_files <= 0 && nb_input_files == 0) {
4134         show_usage();
4135         fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4136         exit_program(1);
4137     }
4138
4139     /* file converter / grab */
4140     if (nb_output_files <= 0) {
4141         fprintf(stderr, "At least one output file must be specified\n");
4142         exit_program(1);
4143     }
4144
4145     if (nb_input_files == 0) {
4146         fprintf(stderr, "At least one input file must be specified\n");
4147         exit_program(1);
4148     }
4149
4150     ti = getutime();
4151     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4152         exit_program(1);
4153     ti = getutime() - ti;
4154     if (do_benchmark) {
4155         int maxrss = getmaxrss() / 1024;
4156         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4157     }
4158
4159     exit_program(0);
4160     return 0;
4161 }