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