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