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

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