avconv.c

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