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