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