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