avconv.c

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