git.sesse.net Git - ffmpeg/blob - avconv.c

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