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

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