avconv.c

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