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