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

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