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