avconv.c

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