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

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