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