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 (cmdutils_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 (file_idx == m->file_index &&
2642                 check_stream_specifier(input_files[m->file_index].ctx,
2643                                        input_files[m->file_index].ctx->streams[m->stream_index],
2644                                        *p == ':' ? p + 1 : p) > 0)
2645                 m->disabled = 1;
2646         }
2647     else
2648         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2649             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2650                         *p == ':' ? p + 1 : p) <= 0)
2651                 continue;
2652             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2653                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2654             m = &o->stream_maps[o->nb_stream_maps - 1];
2655
2656             m->file_index   = file_idx;
2657             m->stream_index = i;
2658
2659             if (sync_file_idx >= 0) {
2660                 m->sync_file_index   = sync_file_idx;
2661                 m->sync_stream_index = sync_stream_idx;
2662             } else {
2663                 m->sync_file_index   = file_idx;
2664                 m->sync_stream_index = i;
2665             }
2666         }
2667
2668     if (!m) {
2669         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2670         exit_program(1);
2671     }
2672
2673     av_freep(&map);
2674     return 0;
2675 }
2676
2677 static void parse_meta_type(char *arg, char *type, int *index)
2678 {
2679     if (*arg) {
2680         *type = *arg;
2681         switch (*arg) {
2682         case 'g':
2683             break;
2684         case 's':
2685         case 'c':
2686         case 'p':
2687             if (*(++arg) == ':')
2688                 *index = strtol(++arg, NULL, 0);
2689             break;
2690         default:
2691             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2692             exit_program(1);
2693         }
2694     } else
2695         *type = 'g';
2696 }
2697
2698 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2699 {
2700     MetadataMap *m, *m1;
2701     char *p;
2702
2703     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2704                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2705
2706     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2707     m->file = strtol(arg, &p, 0);
2708     parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2709
2710     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2711     if (p = strchr(opt, ':'))
2712         parse_meta_type(p + 1, &m1->type, &m1->index);
2713     else
2714         m1->type = 'g';
2715
2716     if (m->type == 'g' || m1->type == 'g')
2717         o->metadata_global_manual = 1;
2718     if (m->type == 's' || m1->type == 's')
2719         o->metadata_streams_manual = 1;
2720     if (m->type == 'c' || m1->type == 'c')
2721         o->metadata_chapters_manual = 1;
2722
2723     return 0;
2724 }
2725
2726 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2727 {
2728     const char *codec_string = encoder ? "encoder" : "decoder";
2729     AVCodec *codec;
2730
2731     codec = encoder ?
2732         avcodec_find_encoder_by_name(name) :
2733         avcodec_find_decoder_by_name(name);
2734     if(!codec) {
2735         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2736         exit_program(1);
2737     }
2738     if(codec->type != type) {
2739         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2740         exit_program(1);
2741     }
2742     return codec;
2743 }
2744
2745 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2746 {
2747     char *codec_name = NULL;
2748
2749     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2750     if (codec_name) {
2751         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2752         st->codec->codec_id = codec->id;
2753         return codec;
2754     } else
2755         return avcodec_find_decoder(st->codec->codec_id);
2756 }
2757
2758 /**
2759  * Add all the streams from the given input file to the global
2760  * list of input streams.
2761  */
2762 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2763 {
2764     int i, rfps, rfps_base;
2765
2766     for (i = 0; i < ic->nb_streams; i++) {
2767         AVStream *st = ic->streams[i];
2768         AVCodecContext *dec = st->codec;
2769         InputStream *ist;
2770         double scale = 1.0;
2771
2772         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2773         ist = &input_streams[nb_input_streams - 1];
2774         ist->st = st;
2775         ist->file_index = nb_input_files;
2776         ist->discard = 1;
2777         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2778
2779         MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2780         ist->ts_scale = scale;
2781
2782         ist->dec = choose_decoder(o, ic, st);
2783
2784         switch (dec->codec_type) {
2785         case AVMEDIA_TYPE_AUDIO:
2786             if (o->audio_disable)
2787                 st->discard= AVDISCARD_ALL;
2788             break;
2789         case AVMEDIA_TYPE_VIDEO:
2790             rfps      = ic->streams[i]->r_frame_rate.num;
2791             rfps_base = ic->streams[i]->r_frame_rate.den;
2792             if (dec->lowres) {
2793                 dec->flags |= CODEC_FLAG_EMU_EDGE;
2794                 dec->height >>= dec->lowres;
2795                 dec->width  >>= dec->lowres;
2796             }
2797
2798             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2799
2800                 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",
2801                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2802                        (float)rfps / rfps_base, rfps, rfps_base);
2803             }
2804
2805             if (o->video_disable)
2806                 st->discard= AVDISCARD_ALL;
2807             else if(video_discard)
2808                 st->discard= video_discard;
2809             break;
2810         case AVMEDIA_TYPE_DATA:
2811             break;
2812         case AVMEDIA_TYPE_SUBTITLE:
2813             if (o->subtitle_disable)
2814                 st->discard = AVDISCARD_ALL;
2815             break;
2816         case AVMEDIA_TYPE_ATTACHMENT:
2817         case AVMEDIA_TYPE_UNKNOWN:
2818             break;
2819         default:
2820             abort();
2821         }
2822     }
2823 }
2824
2825 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2826 {
2827     AVFormatContext *ic;
2828     AVInputFormat *file_iformat = NULL;
2829     int err, i, ret;
2830     int64_t timestamp;
2831     uint8_t buf[128];
2832     AVDictionary **opts;
2833     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
2834
2835     if (o->format) {
2836         if (!(file_iformat = av_find_input_format(o->format))) {
2837             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2838             exit_program(1);
2839         }
2840     }
2841
2842     if (!strcmp(filename, "-"))
2843         filename = "pipe:";
2844
2845     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2846                     !strcmp(filename, "/dev/stdin");
2847
2848     /* get default parameters from command line */
2849     ic = avformat_alloc_context();
2850     if (!ic) {
2851         print_error(filename, AVERROR(ENOMEM));
2852         exit_program(1);
2853     }
2854     if (o->nb_audio_sample_rate) {
2855         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2856         av_dict_set(&format_opts, "sample_rate", buf, 0);
2857     }
2858     if (o->nb_audio_channels) {
2859         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2860         av_dict_set(&format_opts, "channels", buf, 0);
2861     }
2862     if (o->nb_frame_rates) {
2863         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2864     }
2865     if (o->nb_frame_sizes) {
2866         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2867     }
2868     if (o->nb_frame_pix_fmts)
2869         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2870
2871     ic->flags |= AVFMT_FLAG_NONBLOCK;
2872
2873     /* open the input file with generic libav function */
2874     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2875     if (err < 0) {
2876         print_error(filename, err);
2877         exit_program(1);
2878     }
2879     assert_avoptions(format_opts);
2880
2881     /* apply forced codec ids */
2882     for (i = 0; i < ic->nb_streams; i++)
2883         choose_decoder(o, ic, ic->streams[i]);
2884
2885     /* Set AVCodecContext options for avformat_find_stream_info */
2886     opts = setup_find_stream_info_opts(ic, codec_opts);
2887     orig_nb_streams = ic->nb_streams;
2888
2889     /* If not enough info to get the stream parameters, we decode the
2890        first frames to get it. (used in mpeg case for example) */
2891     ret = avformat_find_stream_info(ic, opts);
2892     if (ret < 0) {
2893         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
2894         av_close_input_file(ic);
2895         exit_program(1);
2896     }
2897
2898     timestamp = o->start_time;
2899     /* add the stream start time */
2900     if (ic->start_time != AV_NOPTS_VALUE)
2901         timestamp += ic->start_time;
2902
2903     /* if seeking requested, we execute it */
2904     if (o->start_time != 0) {
2905         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2906         if (ret < 0) {
2907             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2908                    filename, (double)timestamp / AV_TIME_BASE);
2909         }
2910     }
2911
2912     /* update the current parameters so that they match the one of the input stream */
2913     add_input_streams(o, ic);
2914
2915     /* dump the file content */
2916     av_dump_format(ic, nb_input_files, filename, 0);
2917
2918     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2919     input_files[nb_input_files - 1].ctx        = ic;
2920     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
2921     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
2922     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
2923     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
2924
2925     for (i = 0; i < orig_nb_streams; i++)
2926         av_dict_free(&opts[i]);
2927     av_freep(&opts);
2928
2929     reset_options(o);
2930     return 0;
2931 }
2932
2933 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2934                                     AVCodecContext *avctx)
2935 {
2936     char *p;
2937     int n = 1, i;
2938     int64_t t;
2939
2940     for (p = kf; *p; p++)
2941         if (*p == ',')
2942             n++;
2943     ost->forced_kf_count = n;
2944     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2945     if (!ost->forced_kf_pts) {
2946         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2947         exit_program(1);
2948     }
2949     for (i = 0; i < n; i++) {
2950         p = i ? strchr(p, ',') + 1 : kf;
2951         t = parse_time_or_die("force_key_frames", p, 1);
2952         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2953     }
2954 }
2955
2956 static uint8_t *get_line(AVIOContext *s)
2957 {
2958     AVIOContext *line;
2959     uint8_t *buf;
2960     char c;
2961
2962     if (avio_open_dyn_buf(&line) < 0) {
2963         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
2964         exit_program(1);
2965     }
2966
2967     while ((c = avio_r8(s)) && c != '\n')
2968         avio_w8(line, c);
2969     avio_w8(line, 0);
2970     avio_close_dyn_buf(line, &buf);
2971
2972     return buf;
2973 }
2974
2975 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
2976 {
2977     int i, ret = 1;
2978     char filename[1000];
2979     const char *base[3] = { getenv("AVCONV_DATADIR"),
2980                             getenv("HOME"),
2981                             AVCONV_DATADIR,
2982                             };
2983
2984     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
2985         if (!base[i])
2986             continue;
2987         if (codec_name) {
2988             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
2989                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
2990             ret = avio_open(s, filename, AVIO_FLAG_READ);
2991         }
2992         if (ret) {
2993             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
2994                      i != 1 ? "" : "/.avconv", preset_name);
2995             ret = avio_open(s, filename, AVIO_FLAG_READ);
2996         }
2997     }
2998     return ret;
2999 }
3000
3001 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3002 {
3003     char *codec_name = NULL;
3004
3005     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3006     if (!codec_name) {
3007         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3008                                                   NULL, ost->st->codec->codec_type);
3009         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3010     } else if (!strcmp(codec_name, "copy"))
3011         ost->stream_copy = 1;
3012     else {
3013         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3014         ost->st->codec->codec_id = ost->enc->id;
3015     }
3016 }
3017
3018 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3019 {
3020     OutputStream *ost;
3021     AVStream *st = avformat_new_stream(oc, NULL);
3022     int idx      = oc->nb_streams - 1, ret = 0;
3023     int64_t max_frames = INT64_MAX;
3024     char *bsf = NULL, *next, *codec_tag = NULL;
3025     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3026     double qscale = -1;
3027     char *buf = NULL, *arg = NULL, *preset = NULL;
3028     AVIOContext *s = NULL;
3029
3030     if (!st) {
3031         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3032         exit_program(1);
3033     }
3034
3035     if (oc->nb_streams - 1 < o->nb_streamid_map)
3036         st->id = o->streamid_map[oc->nb_streams - 1];
3037
3038     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3039                                 nb_output_streams + 1);
3040     ost = &output_streams[nb_output_streams - 1];
3041     ost->file_index = nb_output_files;
3042     ost->index = idx;
3043     ost->st    = st;
3044     st->codec->codec_type = type;
3045     choose_encoder(o, oc, ost);
3046     if (ost->enc) {
3047         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3048     }
3049
3050     avcodec_get_context_defaults3(st->codec, ost->enc);
3051     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3052
3053     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3054     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3055         do  {
3056             buf = get_line(s);
3057             if (!buf[0] || buf[0] == '#') {
3058                 av_free(buf);
3059                 continue;
3060             }
3061             if (!(arg = strchr(buf, '='))) {
3062                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3063                 exit_program(1);
3064             }
3065             *arg++ = 0;
3066             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3067             av_free(buf);
3068         } while (!s->eof_reached);
3069         avio_close(s);
3070     }
3071     if (ret) {
3072         av_log(NULL, AV_LOG_FATAL,
3073                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3074                preset, ost->file_index, ost->index);
3075         exit_program(1);
3076     }
3077
3078     MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3079     ost->max_frames = max_frames;
3080
3081     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3082     while (bsf) {
3083         if (next = strchr(bsf, ','))
3084             *next++ = 0;
3085         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3086             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3087             exit_program(1);
3088         }
3089         if (bsfc_prev)
3090             bsfc_prev->next = bsfc;
3091         else
3092             ost->bitstream_filters = bsfc;
3093
3094         bsfc_prev = bsfc;
3095         bsf       = next;
3096     }
3097
3098     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3099     if (codec_tag) {
3100         uint32_t tag = strtol(codec_tag, &next, 0);
3101         if (*next)
3102             tag = AV_RL32(codec_tag);
3103         st->codec->codec_tag = tag;
3104     }
3105
3106     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3107     if (qscale >= 0 || same_quant) {
3108         st->codec->flags |= CODEC_FLAG_QSCALE;
3109         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3110     }
3111
3112     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3113         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3114
3115     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3116     return ost;
3117 }
3118
3119 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3120 {
3121     int i;
3122     const char *p = str;
3123     for(i = 0;; i++) {
3124         dest[i] = atoi(p);
3125         if(i == 63)
3126             break;
3127         p = strchr(p, ',');
3128         if(!p) {
3129             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3130             exit_program(1);
3131         }
3132         p++;
3133     }
3134 }
3135
3136 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3137 {
3138     AVStream *st;
3139     OutputStream *ost;
3140     AVCodecContext *video_enc;
3141
3142     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3143     st  = ost->st;
3144     video_enc = st->codec;
3145
3146     if (!ost->stream_copy) {
3147         const char *p = NULL;
3148         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3149         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3150         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3151         int i, force_fps = 0, top_field_first = -1;
3152
3153         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3154         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3155             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3156             exit_program(1);
3157         }
3158
3159         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3160         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3161             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3162             exit_program(1);
3163         }
3164
3165         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3166         if (frame_aspect_ratio)
3167             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3168
3169         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3170         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3171             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3172             exit_program(1);
3173         }
3174         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3175
3176         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3177         if (intra_matrix) {
3178             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3179                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3180                 exit_program(1);
3181             }
3182             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3183         }
3184         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3185         if (inter_matrix) {
3186             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3187                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3188                 exit_program(1);
3189             }
3190             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3191         }
3192
3193         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3194         for(i=0; p; i++){
3195             int start, end, q;
3196             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3197             if(e!=3){
3198                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3199                 exit_program(1);
3200             }
3201             video_enc->rc_override=
3202                 av_realloc(video_enc->rc_override,
3203                            sizeof(RcOverride)*(i+1));
3204             video_enc->rc_override[i].start_frame= start;
3205             video_enc->rc_override[i].end_frame  = end;
3206             if(q>0){
3207                 video_enc->rc_override[i].qscale= q;
3208                 video_enc->rc_override[i].quality_factor= 1.0;
3209             }
3210             else{
3211                 video_enc->rc_override[i].qscale= 0;
3212                 video_enc->rc_override[i].quality_factor= -q/100.0;
3213             }
3214             p= strchr(p, '/');
3215             if(p) p++;
3216         }
3217         video_enc->rc_override_count=i;
3218         if (!video_enc->rc_initial_buffer_occupancy)
3219             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3220         video_enc->intra_dc_precision= intra_dc_precision - 8;
3221
3222         /* two pass mode */
3223         if (do_pass) {
3224             if (do_pass == 1) {
3225                 video_enc->flags |= CODEC_FLAG_PASS1;
3226             } else {
3227                 video_enc->flags |= CODEC_FLAG_PASS2;
3228             }
3229         }
3230
3231         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3232         if (forced_key_frames)
3233             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3234
3235         MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3236         ost->force_fps = force_fps;
3237
3238         MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3239         ost->top_field_first = top_field_first;
3240
3241 #if CONFIG_AVFILTER
3242         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3243         if (filters)
3244             ost->avfilter = av_strdup(filters);
3245 #endif
3246     }
3247
3248     return ost;
3249 }
3250
3251 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3252 {
3253     AVStream *st;
3254     OutputStream *ost;
3255     AVCodecContext *audio_enc;
3256
3257     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3258     st  = ost->st;
3259
3260     audio_enc = st->codec;
3261     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3262
3263     if (!ost->stream_copy) {
3264         char *sample_fmt = NULL;
3265
3266         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3267
3268         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3269         if (sample_fmt &&
3270             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3271             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3272             exit_program(1);
3273         }
3274
3275         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3276     }
3277
3278     return ost;
3279 }
3280
3281 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3282 {
3283     OutputStream *ost;
3284
3285     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3286     if (!ost->stream_copy) {
3287         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3288         exit_program(1);
3289     }
3290
3291     return ost;
3292 }
3293
3294 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3295 {
3296     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3297     ost->stream_copy = 1;
3298     return ost;
3299 }
3300
3301 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3302 {
3303     AVStream *st;
3304     OutputStream *ost;
3305     AVCodecContext *subtitle_enc;
3306
3307     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3308     st  = ost->st;
3309     subtitle_enc = st->codec;
3310
3311     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3312
3313     return ost;
3314 }
3315
3316 /* arg format is "output-stream-index:streamid-value". */
3317 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3318 {
3319     int idx;
3320     char *p;
3321     char idx_str[16];
3322
3323     av_strlcpy(idx_str, arg, sizeof(idx_str));
3324     p = strchr(idx_str, ':');
3325     if (!p) {
3326         av_log(NULL, AV_LOG_FATAL,
3327                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3328                arg, opt);
3329         exit_program(1);
3330     }
3331     *p++ = '\0';
3332     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3333     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3334     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3335     return 0;
3336 }
3337
3338 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3339 {
3340     AVFormatContext *is = ifile->ctx;
3341     AVFormatContext *os = ofile->ctx;
3342     int i;
3343
3344     for (i = 0; i < is->nb_chapters; i++) {
3345         AVChapter *in_ch = is->chapters[i], *out_ch;
3346         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3347                                       AV_TIME_BASE_Q, in_ch->time_base);
3348         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3349                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3350
3351
3352         if (in_ch->end < ts_off)
3353             continue;
3354         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3355             break;
3356
3357         out_ch = av_mallocz(sizeof(AVChapter));
3358         if (!out_ch)
3359             return AVERROR(ENOMEM);
3360
3361         out_ch->id        = in_ch->id;
3362         out_ch->time_base = in_ch->time_base;
3363         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3364         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3365
3366         if (copy_metadata)
3367             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3368
3369         os->nb_chapters++;
3370         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3371         if (!os->chapters)
3372             return AVERROR(ENOMEM);
3373         os->chapters[os->nb_chapters - 1] = out_ch;
3374     }
3375     return 0;
3376 }
3377
3378 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3379 {
3380     int i, err;
3381     AVFormatContext *ic = NULL;
3382
3383     err = avformat_open_input(&ic, filename, NULL, NULL);
3384     if (err < 0)
3385         return err;
3386     /* copy stream format */
3387     for(i=0;i<ic->nb_streams;i++) {
3388         AVStream *st;
3389         OutputStream *ost;
3390         AVCodec *codec;
3391
3392         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3393         ost   = new_output_stream(o, s, codec->type);
3394         st    = ost->st;
3395
3396         // FIXME: a more elegant solution is needed
3397         memcpy(st, ic->streams[i], sizeof(AVStream));
3398         st->info = NULL;
3399         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3400
3401         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3402             choose_sample_fmt(st, codec);
3403         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3404             choose_pixel_fmt(st, codec);
3405     }
3406
3407     av_close_input_file(ic);
3408     return 0;
3409 }
3410
3411 static void opt_output_file(void *optctx, const char *filename)
3412 {
3413     OptionsContext *o = optctx;
3414     AVFormatContext *oc;
3415     int i, err;
3416     AVOutputFormat *file_oformat;
3417     OutputStream *ost;
3418     InputStream  *ist;
3419
3420     if (!strcmp(filename, "-"))
3421         filename = "pipe:";
3422
3423     oc = avformat_alloc_context();
3424     if (!oc) {
3425         print_error(filename, AVERROR(ENOMEM));
3426         exit_program(1);
3427     }
3428
3429     if (o->format) {
3430         file_oformat = av_guess_format(o->format, NULL, NULL);
3431         if (!file_oformat) {
3432             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3433             exit_program(1);
3434         }
3435     } else {
3436         file_oformat = av_guess_format(NULL, filename, NULL);
3437         if (!file_oformat) {
3438             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3439                    filename);
3440             exit_program(1);
3441         }
3442     }
3443
3444     oc->oformat = file_oformat;
3445     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3446
3447     if (!strcmp(file_oformat->name, "ffm") &&
3448         av_strstart(filename, "http:", NULL)) {
3449         /* special case for files sent to avserver: we get the stream
3450            parameters from avserver */
3451         int err = read_avserver_streams(o, oc, filename);
3452         if (err < 0) {
3453             print_error(filename, err);
3454             exit_program(1);
3455         }
3456     } else if (!o->nb_stream_maps) {
3457         /* pick the "best" stream of each type */
3458 #define NEW_STREAM(type, index)\
3459         if (index >= 0) {\
3460             ost = new_ ## type ## _stream(o, oc);\
3461             ost->source_index = index;\
3462             ost->sync_ist     = &input_streams[index];\
3463             input_streams[index].discard = 0;\
3464         }
3465
3466         /* video: highest resolution */
3467         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3468             int area = 0, idx = -1;
3469             for (i = 0; i < nb_input_streams; i++) {
3470                 ist = &input_streams[i];
3471                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3472                     ist->st->codec->width * ist->st->codec->height > area) {
3473                     area = ist->st->codec->width * ist->st->codec->height;
3474                     idx = i;
3475                 }
3476             }
3477             NEW_STREAM(video, idx);
3478         }
3479
3480         /* audio: most channels */
3481         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3482             int channels = 0, idx = -1;
3483             for (i = 0; i < nb_input_streams; i++) {
3484                 ist = &input_streams[i];
3485                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3486                     ist->st->codec->channels > channels) {
3487                     channels = ist->st->codec->channels;
3488                     idx = i;
3489                 }
3490             }
3491             NEW_STREAM(audio, idx);
3492         }
3493
3494         /* subtitles: pick first */
3495         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3496             for (i = 0; i < nb_input_streams; i++)
3497                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3498                     NEW_STREAM(subtitle, i);
3499                     break;
3500                 }
3501         }
3502         /* do something with data? */
3503     } else {
3504         for (i = 0; i < o->nb_stream_maps; i++) {
3505             StreamMap *map = &o->stream_maps[i];
3506
3507             if (map->disabled)
3508                 continue;
3509
3510             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3511             switch (ist->st->codec->codec_type) {
3512             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3513             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3514             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3515             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3516             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3517             default:
3518                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3519                        map->file_index, map->stream_index);
3520                 exit_program(1);
3521             }
3522
3523             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3524             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3525                                            map->sync_stream_index];
3526             ist->discard = 0;
3527         }
3528     }
3529
3530     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3531     output_files[nb_output_files - 1].ctx       = oc;
3532     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3533     output_files[nb_output_files - 1].recording_time = o->recording_time;
3534     output_files[nb_output_files - 1].start_time     = o->start_time;
3535     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3536     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3537
3538     /* check filename in case of an image number is expected */
3539     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3540         if (!av_filename_number_test(oc->filename)) {
3541             print_error(oc->filename, AVERROR(EINVAL));
3542             exit_program(1);
3543         }
3544     }
3545
3546     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3547         /* test if it already exists to avoid loosing precious files */
3548         if (!file_overwrite &&
3549             (strchr(filename, ':') == NULL ||
3550              filename[1] == ':' ||
3551              av_strstart(filename, "file:", NULL))) {
3552             if (avio_check(filename, 0) == 0) {
3553                 if (!using_stdin) {
3554                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3555                     fflush(stderr);
3556                     if (!read_yesno()) {
3557                         fprintf(stderr, "Not overwriting - exiting\n");
3558                         exit_program(1);
3559                     }
3560                 }
3561                 else {
3562                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3563                     exit_program(1);
3564                 }
3565             }
3566         }
3567
3568         /* open the file */
3569         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3570             print_error(filename, err);
3571             exit_program(1);
3572         }
3573     }
3574
3575     if (o->mux_preload) {
3576         uint8_t buf[64];
3577         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3578         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3579     }
3580     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3581     oc->flags |= AVFMT_FLAG_NONBLOCK;
3582
3583     /* copy chapters */
3584     if (o->chapters_input_file >= nb_input_files) {
3585         if (o->chapters_input_file == INT_MAX) {
3586             /* copy chapters from the first input file that has them*/
3587             o->chapters_input_file = -1;
3588             for (i = 0; i < nb_input_files; i++)
3589                 if (input_files[i].ctx->nb_chapters) {
3590                     o->chapters_input_file = i;
3591                     break;
3592                 }
3593         } else {
3594             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3595                    o->chapters_input_file);
3596             exit_program(1);
3597         }
3598     }
3599     if (o->chapters_input_file >= 0)
3600         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3601                       !o->metadata_chapters_manual);
3602
3603     /* copy metadata */
3604     for (i = 0; i < o->nb_meta_data_maps; i++) {
3605         AVFormatContext *files[2];
3606         AVDictionary    **meta[2];
3607         int j;
3608
3609 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3610         if ((index) < 0 || (index) >= (nb_elems)) {\
3611             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3612                      (desc), (index));\
3613             exit_program(1);\
3614         }
3615
3616         int in_file_index = o->meta_data_maps[i][1].file;
3617         if (in_file_index < 0)
3618             continue;
3619         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3620
3621         files[0] = oc;
3622         files[1] = input_files[in_file_index].ctx;
3623
3624         for (j = 0; j < 2; j++) {
3625             MetadataMap *map = &o->meta_data_maps[i][j];
3626
3627             switch (map->type) {
3628             case 'g':
3629                 meta[j] = &files[j]->metadata;
3630                 break;
3631             case 's':
3632                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3633                 meta[j] = &files[j]->streams[map->index]->metadata;
3634                 break;
3635             case 'c':
3636                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3637                 meta[j] = &files[j]->chapters[map->index]->metadata;
3638                 break;
3639             case 'p':
3640                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3641                 meta[j] = &files[j]->programs[map->index]->metadata;
3642                 break;
3643             }
3644         }
3645
3646         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3647     }
3648
3649     /* copy global metadata by default */
3650     if (!o->metadata_global_manual && nb_input_files)
3651         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3652                      AV_DICT_DONT_OVERWRITE);
3653     if (!o->metadata_streams_manual)
3654         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3655             InputStream *ist = &input_streams[output_streams[i].source_index];
3656             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3657         }
3658
3659     /* process manually set metadata */
3660     for (i = 0; i < o->nb_metadata; i++) {
3661         AVDictionary **m;
3662         char type, *val;
3663         int index = 0;
3664
3665         val = strchr(o->metadata[i].u.str, '=');
3666         if (!val) {
3667             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3668                    o->metadata[i].u.str);
3669             exit_program(1);
3670         }
3671         *val++ = 0;
3672
3673         parse_meta_type(o->metadata[i].specifier, &type, &index);
3674         switch (type) {
3675         case 'g':
3676             m = &oc->metadata;
3677             break;
3678         case 's':
3679             if (index < 0 || index >= oc->nb_streams) {
3680                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3681                 exit_program(1);
3682             }
3683             m = &oc->streams[index]->metadata;
3684             break;
3685         case 'c':
3686             if (index < 0 || index >= oc->nb_chapters) {
3687                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3688                 exit_program(1);
3689             }
3690             m = &oc->chapters[index]->metadata;
3691             break;
3692         default:
3693             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3694             exit_program(1);
3695         }
3696
3697         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3698     }
3699
3700     reset_options(o);
3701 }
3702
3703 /* same option as mencoder */
3704 static int opt_pass(const char *opt, const char *arg)
3705 {
3706     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3707     return 0;
3708 }
3709
3710 static int64_t getutime(void)
3711 {
3712 #if HAVE_GETRUSAGE
3713     struct rusage rusage;
3714
3715     getrusage(RUSAGE_SELF, &rusage);
3716     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3717 #elif HAVE_GETPROCESSTIMES
3718     HANDLE proc;
3719     FILETIME c, e, k, u;
3720     proc = GetCurrentProcess();
3721     GetProcessTimes(proc, &c, &e, &k, &u);
3722     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3723 #else
3724     return av_gettime();
3725 #endif
3726 }
3727
3728 static int64_t getmaxrss(void)
3729 {
3730 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3731     struct rusage rusage;
3732     getrusage(RUSAGE_SELF, &rusage);
3733     return (int64_t)rusage.ru_maxrss * 1024;
3734 #elif HAVE_GETPROCESSMEMORYINFO
3735     HANDLE proc;
3736     PROCESS_MEMORY_COUNTERS memcounters;
3737     proc = GetCurrentProcess();
3738     memcounters.cb = sizeof(memcounters);
3739     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3740     return memcounters.PeakPagefileUsage;
3741 #else
3742     return 0;
3743 #endif
3744 }
3745
3746 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3747 {
3748     return parse_option(o, "q:a", arg, options);
3749 }
3750
3751 static void show_usage(void)
3752 {
3753     printf("Hyper fast Audio and Video encoder\n");
3754     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3755     printf("\n");
3756 }
3757
3758 static void show_help(void)
3759 {
3760     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3761     av_log_set_callback(log_callback_help);
3762     show_usage();
3763     show_help_options(options, "Main options:\n",
3764                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3765     show_help_options(options, "\nAdvanced options:\n",
3766                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3767                       OPT_EXPERT);
3768     show_help_options(options, "\nVideo options:\n",
3769                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3770                       OPT_VIDEO);
3771     show_help_options(options, "\nAdvanced Video options:\n",
3772                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3773                       OPT_VIDEO | OPT_EXPERT);
3774     show_help_options(options, "\nAudio options:\n",
3775                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3776                       OPT_AUDIO);
3777     show_help_options(options, "\nAdvanced Audio options:\n",
3778                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3779                       OPT_AUDIO | OPT_EXPERT);
3780     show_help_options(options, "\nSubtitle options:\n",
3781                       OPT_SUBTITLE | OPT_GRAB,
3782                       OPT_SUBTITLE);
3783     show_help_options(options, "\nAudio/Video grab options:\n",
3784                       OPT_GRAB,
3785                       OPT_GRAB);
3786     printf("\n");
3787     show_help_children(avcodec_get_class(), flags);
3788     show_help_children(avformat_get_class(), flags);
3789     show_help_children(sws_get_class(), flags);
3790 }
3791
3792 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3793 {
3794     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3795     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3796
3797     if(!strncmp(arg, "pal-", 4)) {
3798         norm = PAL;
3799         arg += 4;
3800     } else if(!strncmp(arg, "ntsc-", 5)) {
3801         norm = NTSC;
3802         arg += 5;
3803     } else if(!strncmp(arg, "film-", 5)) {
3804         norm = FILM;
3805         arg += 5;
3806     } else {
3807         /* Try to determine PAL/NTSC by peeking in the input files */
3808         if(nb_input_files) {
3809             int i, j, fr;
3810             for (j = 0; j < nb_input_files; j++) {
3811                 for (i = 0; i < input_files[j].nb_streams; i++) {
3812                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3813                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3814                         continue;
3815                     fr = c->time_base.den * 1000 / c->time_base.num;
3816                     if(fr == 25000) {
3817                         norm = PAL;
3818                         break;
3819                     } else if((fr == 29970) || (fr == 23976)) {
3820                         norm = NTSC;
3821                         break;
3822                     }
3823                 }
3824                 if(norm != UNKNOWN)
3825                     break;
3826             }
3827         }
3828         if (norm != UNKNOWN)
3829             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3830     }
3831
3832     if(norm == UNKNOWN) {
3833         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3834         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3835         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3836         exit_program(1);
3837     }
3838
3839     if(!strcmp(arg, "vcd")) {
3840         opt_video_codec(o, "c:v", "mpeg1video");
3841         opt_audio_codec(o, "c:a", "mp2");
3842         parse_option(o, "f", "vcd", options);
3843
3844         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3845         parse_option(o, "r", frame_rates[norm], options);
3846         opt_default("g", norm == PAL ? "15" : "18");
3847
3848         opt_default("b", "1150000");
3849         opt_default("maxrate", "1150000");
3850         opt_default("minrate", "1150000");
3851         opt_default("bufsize", "327680"); // 40*1024*8;
3852
3853         opt_default("b:a", "224000");
3854         parse_option(o, "ar", "44100", options);
3855         parse_option(o, "ac", "2", options);
3856
3857         opt_default("packetsize", "2324");
3858         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3859
3860         /* We have to offset the PTS, so that it is consistent with the SCR.
3861            SCR starts at 36000, but the first two packs contain only padding
3862            and the first pack from the other stream, respectively, may also have
3863            been written before.
3864            So the real data starts at SCR 36000+3*1200. */
3865         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3866     } else if(!strcmp(arg, "svcd")) {
3867
3868         opt_video_codec(o, "c:v", "mpeg2video");
3869         opt_audio_codec(o, "c:a", "mp2");
3870         parse_option(o, "f", "svcd", options);
3871
3872         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3873         parse_option(o, "r", frame_rates[norm], options);
3874         opt_default("g", norm == PAL ? "15" : "18");
3875
3876         opt_default("b", "2040000");
3877         opt_default("maxrate", "2516000");
3878         opt_default("minrate", "0"); //1145000;
3879         opt_default("bufsize", "1835008"); //224*1024*8;
3880         opt_default("flags", "+scan_offset");
3881
3882
3883         opt_default("b:a", "224000");
3884         parse_option(o, "ar", "44100", options);
3885
3886         opt_default("packetsize", "2324");
3887
3888     } else if(!strcmp(arg, "dvd")) {
3889
3890         opt_video_codec(o, "c:v", "mpeg2video");
3891         opt_audio_codec(o, "c:a", "ac3");
3892         parse_option(o, "f", "dvd", options);
3893
3894         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3895         parse_option(o, "r", frame_rates[norm], options);
3896         opt_default("g", norm == PAL ? "15" : "18");
3897
3898         opt_default("b", "6000000");
3899         opt_default("maxrate", "9000000");
3900         opt_default("minrate", "0"); //1500000;
3901         opt_default("bufsize", "1835008"); //224*1024*8;
3902
3903         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3904         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3905
3906         opt_default("b:a", "448000");
3907         parse_option(o, "ar", "48000", options);
3908
3909     } else if(!strncmp(arg, "dv", 2)) {
3910
3911         parse_option(o, "f", "dv", options);
3912
3913         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3914         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3915                           norm == PAL ? "yuv420p" : "yuv411p", options);
3916         parse_option(o, "r", frame_rates[norm], options);
3917
3918         parse_option(o, "ar", "48000", options);
3919         parse_option(o, "ac", "2", options);
3920
3921     } else {
3922         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
3923         return AVERROR(EINVAL);
3924     }
3925     return 0;
3926 }
3927
3928 static int opt_vstats_file(const char *opt, const char *arg)
3929 {
3930     av_free (vstats_filename);
3931     vstats_filename=av_strdup (arg);
3932     return 0;
3933 }
3934
3935 static int opt_vstats(const char *opt, const char *arg)
3936 {
3937     char filename[40];
3938     time_t today2 = time(NULL);
3939     struct tm *today = localtime(&today2);
3940
3941     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3942              today->tm_sec);
3943     return opt_vstats_file(opt, filename);
3944 }
3945
3946 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3947 {
3948     return parse_option(o, "frames:v", arg, options);
3949 }
3950
3951 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3952 {
3953     return parse_option(o, "frames:a", arg, options);
3954 }
3955
3956 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3957 {
3958     return parse_option(o, "frames:d", arg, options);
3959 }
3960
3961 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
3962 {
3963     return parse_option(o, "tag:v", arg, options);
3964 }
3965
3966 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
3967 {
3968     return parse_option(o, "tag:a", arg, options);
3969 }
3970
3971 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
3972 {
3973     return parse_option(o, "tag:s", arg, options);
3974 }
3975
3976 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
3977 {
3978     return parse_option(o, "filter:v", arg, options);
3979 }
3980
3981 #define OFFSET(x) offsetof(OptionsContext, x)
3982 static const OptionDef options[] = {
3983     /* main options */
3984 #include "cmdutils_common_opts.h"
3985     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
3986     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
3987     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3988     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3989     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3990     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
3991     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
3992     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
3993       "outfile[,metadata]:infile[,metadata]" },
3994     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
3995     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3996     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
3997     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
3998     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
3999     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4000     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4001     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4002     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4003       "add timings for benchmarking" },
4004     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4005     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4006       "dump each input packet" },
4007     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4008       "when dumping packets, also dump the payload" },
4009     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4010     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4011     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4012     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4013     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4014     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4015     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4016     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4017     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4018     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4019     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4020     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4021     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4022     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4023     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4024 #if CONFIG_AVFILTER
4025     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4026 #endif
4027     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4028
4029     /* video options */
4030     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4031     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4032     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4033     { "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" },
4034     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4035     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4036     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4037     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4038     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4039     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4040       "use same quantizer as source (implies VBR)" },
4041     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4042     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4043     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4044       "deinterlace pictures" },
4045     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4046     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4047 #if CONFIG_AVFILTER
4048     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4049 #endif
4050     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4051     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4052     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4053     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4054     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4055     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4056     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4057     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4058     { "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" },
4059
4060     /* audio options */
4061     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4062     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4063     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4064     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4065     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4066     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4067     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4068     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4069     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4070
4071     /* subtitle options */
4072     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4073     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4074     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4075
4076     /* grab options */
4077     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4078
4079     /* muxer options */
4080     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4081     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4082
4083     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4084
4085     /* data codec support */
4086     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4087
4088     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4089     { NULL, },
4090 };
4091
4092 int main(int argc, char **argv)
4093 {
4094     OptionsContext o = { 0 };
4095     int64_t ti;
4096
4097     reset_options(&o);
4098
4099     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4100     parse_loglevel(argc, argv, options);
4101
4102     avcodec_register_all();
4103 #if CONFIG_AVDEVICE
4104     avdevice_register_all();
4105 #endif
4106 #if CONFIG_AVFILTER
4107     avfilter_register_all();
4108 #endif
4109     av_register_all();
4110
4111     avio_set_interrupt_cb(decode_interrupt_cb);
4112
4113     show_banner();
4114
4115     /* parse options */
4116     parse_options(&o, argc, argv, options, opt_output_file);
4117
4118     if(nb_output_files <= 0 && nb_input_files == 0) {
4119         show_usage();
4120         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4121         exit_program(1);
4122     }
4123
4124     /* file converter / grab */
4125     if (nb_output_files <= 0) {
4126         fprintf(stderr, "At least one output file must be specified\n");
4127         exit_program(1);
4128     }
4129
4130     if (nb_input_files == 0) {
4131         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4132         exit_program(1);
4133     }
4134
4135     ti = getutime();
4136     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4137         exit_program(1);
4138     ti = getutime() - ti;
4139     if (do_benchmark) {
4140         int maxrss = getmaxrss() / 1024;
4141         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4142     }
4143
4144     exit_program(0);
4145     return 0;
4146 }