avconv.c

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