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

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19 #define HAVE_AV_CONFIG_H
  20 #include <limits.h>
  21 #include "avformat.h"
  22 #include "swscale.h"
  23 #include "framehook.h"
  24 #include "dsputil.h"
  25 #include "opt.h"
  26
  27 #ifndef __MINGW32__
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <sys/ioctl.h>
  31 #include <sys/time.h>
  32 #include <termios.h>
  33 #include <sys/resource.h>
  34 #include <signal.h>
  35 #endif
  36 #ifdef CONFIG_OS2
  37 #include <sys/types.h>
  38 #include <sys/select.h>
  39 #include <stdlib.h>
  40 #endif
  41 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  42 #include <time.h>
  43
  44 #include "version.h"
  45 #include "cmdutils.h"
  46
  47 #undef NDEBUG
  48 #include <assert.h>
  49
  50 #if !defined(INFINITY) && defined(HUGE_VAL)
  51 #define INFINITY HUGE_VAL
  52 #endif
  53
  54 /* select an input stream for an output stream */
  55 typedef struct AVStreamMap {
  56     int file_index;
  57     int stream_index;
  58     int sync_file_index;
  59     int sync_stream_index;
  60 } AVStreamMap;
  61
  62 /** select an input file for an output file */
  63 typedef struct AVMetaDataMap {
  64     int out_file;
  65     int in_file;
  66 } AVMetaDataMap;
  67
  68 extern const OptionDef options[];
  69
  70 static void show_help(void);
  71 static void show_license(void);
  72 static int opt_default(const char *opt, const char *arg);
  73
  74 #define MAX_FILES 20
  75
  76 static AVFormatContext *input_files[MAX_FILES];
  77 static int64_t input_files_ts_offset[MAX_FILES];
  78 static int nb_input_files = 0;
  79
  80 static AVFormatContext *output_files[MAX_FILES];
  81 static int nb_output_files = 0;
  82
  83 static AVStreamMap stream_maps[MAX_FILES];
  84 static int nb_stream_maps;
  85
  86 static AVMetaDataMap meta_data_maps[MAX_FILES];
  87 static int nb_meta_data_maps;
  88
  89 static AVInputFormat *file_iformat;
  90 static AVOutputFormat *file_oformat;
  91 static AVImageFormat *image_format;
  92 static int frame_width  = 0;
  93 static int frame_height = 0;
  94 static float frame_aspect_ratio = 0;
  95 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
  96 static int frame_padtop  = 0;
  97 static int frame_padbottom = 0;
  98 static int frame_padleft  = 0;
  99 static int frame_padright = 0;
 100 static int padcolor[3] = {16,128,128}; /* default to black */
 101 static int frame_topBand  = 0;
 102 static int frame_bottomBand = 0;
 103 static int frame_leftBand  = 0;
 104 static int frame_rightBand = 0;
 105 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 106 static int frame_rate = 25;
 107 static int frame_rate_base = 1;
 108 static float video_qscale = 0;
 109 static int video_qmin = 2;
 110 static int video_qmax = 31;
 111 static int video_lmin = 2*FF_QP2LAMBDA;
 112 static int video_lmax = 31*FF_QP2LAMBDA;
 113 static int video_mb_lmin = 2*FF_QP2LAMBDA;
 114 static int video_mb_lmax = 31*FF_QP2LAMBDA;
 115 static int video_qdiff = 3;
 116 static float video_qsquish = 0.0;
 117 static uint16_t *intra_matrix = NULL;
 118 static uint16_t *inter_matrix = NULL;
 119 #if 0 //experimental, (can be removed)
 120 static float video_rc_qsquish=1.0;
 121 static float video_rc_qmod_amp=0;
 122 static int video_rc_qmod_freq=0;
 123 #endif
 124 static char *video_rc_override_string=NULL;
 125 static char *video_rc_eq="tex^qComp";
 126 static float video_rc_buffer_aggressivity=1.0;
 127 static int me_method = ME_EPZS;
 128 static int video_disable = 0;
 129 static int video_discard = 0;
 130 static int video_codec_id = CODEC_ID_NONE;
 131 static int video_codec_tag = 0;
 132 static int same_quality = 0;
 133 static int b_frames = 0;
 134 static int do_deinterlace = 0;
 135 static int workaround_bugs = FF_BUG_AUTODETECT;
 136 static int packet_size = 0;
 137 static int error_rate = 0;
 138 static int strict = 0;
 139 static int top_field_first = -1;
 140 static int sc_threshold = 0;
 141 static int me_threshold = 0;
 142 static int mb_threshold = 0;
 143 static int intra_dc_precision = 8;
 144 static int me_penalty_compensation= 256;
 145 static int frame_skip_threshold= 0;
 146 static int frame_skip_factor= 0;
 147 static int frame_skip_exp= 0;
 148 static int loop_input = 0;
 149 static int loop_output = AVFMT_NOOUTPUTLOOP;
 150 static int qp_hist = 0;
 151
 152 static int intra_only = 0;
 153 static int audio_sample_rate = 44100;
 154 static int audio_bit_rate = 64000;
 155 #define QSCALE_NONE -99999
 156 static float audio_qscale = QSCALE_NONE;
 157 static int audio_disable = 0;
 158 static int audio_channels = 1;
 159 static int audio_codec_id = CODEC_ID_NONE;
 160 static int audio_codec_tag = 0;
 161 static char *audio_language = NULL;
 162
 163 static int subtitle_codec_id = CODEC_ID_NONE;
 164 static char *subtitle_language = NULL;
 165
 166 static int mux_packet_size= 0;
 167 static float mux_preload= 0.5;
 168 static float mux_max_delay= 0.7;
 169
 170 static int64_t recording_time = 0;
 171 static int64_t start_time = 0;
 172 static int64_t rec_timestamp = 0;
 173 static int64_t input_ts_offset = 0;
 174 static int file_overwrite = 0;
 175 static char *str_title = NULL;
 176 static char *str_author = NULL;
 177 static char *str_copyright = NULL;
 178 static char *str_comment = NULL;
 179 static char *str_album = NULL;
 180 static int do_benchmark = 0;
 181 static int do_hex_dump = 0;
 182 static int do_pkt_dump = 0;
 183 static int do_psnr = 0;
 184 static int do_vstats = 0;
 185 static int do_pass = 0;
 186 static char *pass_logfilename = NULL;
 187 static int audio_stream_copy = 0;
 188 static int video_stream_copy = 0;
 189 static int subtitle_stream_copy = 0;
 190 static int video_sync_method= 1;
 191 static int audio_sync_method= 0;
 192 static int copy_ts= 0;
 193 static int opt_shortest = 0; //
 194 static int video_global_header = 0;
 195
 196 static int rate_emu = 0;
 197
 198 #ifdef CONFIG_BKTR
 199 static const char *video_grab_format = "bktr";
 200 #else
 201 #ifdef CONFIG_VIDEO4LINUX2
 202 static const char *video_grab_format = "video4linux2";
 203 #else
 204 static const char *video_grab_format = "video4linux";
 205 #endif
 206 #endif
 207 static char *video_device = NULL;
 208 static char *grab_device = NULL;
 209 static int  video_channel = 0;
 210 static char *video_standard = "ntsc";
 211
 212 static const char *audio_grab_format = "audio_device";
 213 static char *audio_device = NULL;
 214 static int audio_volume = 256;
 215
 216 static int using_stdin = 0;
 217 static int using_vhook = 0;
 218 static int verbose = 1;
 219 static int thread_count= 1;
 220 static int q_pressed = 0;
 221 static int64_t video_size = 0;
 222 static int64_t audio_size = 0;
 223 static int64_t extra_size = 0;
 224 static int nb_frames_dup = 0;
 225 static int nb_frames_drop = 0;
 226 static int input_sync;
 227 static int limit_filesize = 0; //
 228
 229 static int pgmyuv_compatibility_hack=0;
 230 static int dts_delta_threshold = 10;
 231
 232 static int sws_flags = SWS_BICUBIC;
 233
 234 const char **opt_names=NULL;
 235 int opt_name_count=0;
 236 AVCodecContext *avctx_opts;
 237 AVFormatContext *avformat_opts;
 238
 239 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 240 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 241 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
 242
 243 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
 244
 245 struct AVInputStream;
 246
 247 typedef struct AVOutputStream {
 248     int file_index;          /* file index */
 249     int index;               /* stream index in the output file */
 250     int source_index;        /* AVInputStream index */
 251     AVStream *st;            /* stream in the output file */
 252     int encoding_needed;     /* true if encoding needed for this stream */
 253     int frame_number;
 254     /* input pts and corresponding output pts
 255        for A/V sync */
 256     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 257     struct AVInputStream *sync_ist; /* input stream to sync against */
 258     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 259     /* video only */
 260     int video_resample;
 261     AVFrame pict_tmp;      /* temporary image for resampling */
 262     struct SwsContext *img_resample_ctx; /* for image resampling */
 263     int resample_height;
 264
 265     int video_crop;
 266     int topBand;             /* cropping area sizes */
 267     int leftBand;
 268
 269     int video_pad;
 270     int padtop;              /* padding area sizes */
 271     int padbottom;
 272     int padleft;
 273     int padright;
 274
 275     /* audio only */
 276     int audio_resample;
 277     ReSampleContext *resample; /* for audio resampling */
 278     FifoBuffer fifo;     /* for compression: one audio fifo per codec */
 279     FILE *logfile;
 280 } AVOutputStream;
 281
 282 typedef struct AVInputStream {
 283     int file_index;
 284     int index;
 285     AVStream *st;
 286     int discard;             /* true if stream data should be discarded */
 287     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 288     int64_t sample_index;      /* current sample */
 289
 290     int64_t       start;     /* time when read started */
 291     unsigned long frame;     /* current frame */
 292     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 293                                 is not defined */
 294     int64_t       pts;       /* current pts */
 295     int is_start;            /* is 1 at the start and after a discontinuity */
 296 } AVInputStream;
 297
 298 typedef struct AVInputFile {
 299     int eof_reached;      /* true if eof reached */
 300     int ist_index;        /* index of first stream in ist_table */
 301     int buffer_size;      /* current total buffer size */
 302     int buffer_size_max;  /* buffer size at which we consider we can stop
 303                              buffering */
 304     int nb_streams;       /* nb streams we are aware of */
 305 } AVInputFile;
 306
 307 #ifndef __MINGW32__
 308
 309 /* init terminal so that we can grab keys */
 310 static struct termios oldtty;
 311
 312 static void term_exit(void)
 313 {
 314     tcsetattr (0, TCSANOW, &oldtty);
 315 }
 316
 317 static volatile sig_atomic_t received_sigterm = 0;
 318
 319 static void
 320 sigterm_handler(int sig)
 321 {
 322     received_sigterm = sig;
 323     term_exit();
 324 }
 325
 326 static void term_init(void)
 327 {
 328     struct termios tty;
 329
 330     tcgetattr (0, &tty);
 331     oldtty = tty;
 332
 333     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 334                           |INLCR|IGNCR|ICRNL|IXON);
 335     tty.c_oflag |= OPOST;
 336     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 337     tty.c_cflag &= ~(CSIZE|PARENB);
 338     tty.c_cflag |= CS8;
 339     tty.c_cc[VMIN] = 1;
 340     tty.c_cc[VTIME] = 0;
 341
 342     tcsetattr (0, TCSANOW, &tty);
 343
 344     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 345     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 346     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 347     /*
 348     register a function to be called at normal program termination
 349     */
 350     atexit(term_exit);
 351 #ifdef CONFIG_BEOS_NETSERVER
 352     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 353 #endif
 354 }
 355
 356 /* read a key without blocking */
 357 static int read_key(void)
 358 {
 359     int n = 1;
 360     unsigned char ch;
 361 #ifndef CONFIG_BEOS_NETSERVER
 362     struct timeval tv;
 363     fd_set rfds;
 364
 365     FD_ZERO(&rfds);
 366     FD_SET(0, &rfds);
 367     tv.tv_sec = 0;
 368     tv.tv_usec = 0;
 369     n = select(1, &rfds, NULL, NULL, &tv);
 370 #endif
 371     if (n > 0) {
 372         n = read(0, &ch, 1);
 373         if (n == 1)
 374             return ch;
 375
 376         return n;
 377     }
 378     return -1;
 379 }
 380
 381 static int decode_interrupt_cb(void)
 382 {
 383     return q_pressed || (q_pressed = read_key() == 'q');
 384 }
 385
 386 #else
 387
 388 static volatile int received_sigterm = 0;
 389
 390 /* no interactive support */
 391 static void term_exit(void)
 392 {
 393 }
 394
 395 static void term_init(void)
 396 {
 397 }
 398
 399 static int read_key(void)
 400 {
 401     return 0;
 402 }
 403
 404 #endif
 405
 406 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 407 {
 408     int i, err;
 409     AVFormatContext *ic;
 410
 411     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 412     if (err < 0)
 413         return err;
 414     /* copy stream format */
 415     s->nb_streams = ic->nb_streams;
 416     for(i=0;i<ic->nb_streams;i++) {
 417         AVStream *st;
 418
 419         // FIXME: a more elegant solution is needed
 420         st = av_mallocz(sizeof(AVStream));
 421         memcpy(st, ic->streams[i], sizeof(AVStream));
 422         st->codec = avcodec_alloc_context();
 423         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
 424         s->streams[i] = st;
 425     }
 426
 427     av_close_input_file(ic);
 428     return 0;
 429 }
 430
 431 static double
 432 get_sync_ipts(const AVOutputStream *ost)
 433 {
 434     const AVInputStream *ist = ost->sync_ist;
 435     return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
 436 }
 437
 438 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 439     while(bsfc){
 440         AVPacket new_pkt= *pkt;
 441         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 442                                           &new_pkt.data, &new_pkt.size,
 443                                           pkt->data, pkt->size,
 444                                           pkt->flags & PKT_FLAG_KEY);
 445         if(a){
 446             av_free_packet(pkt);
 447             new_pkt.destruct= av_destruct_packet;
 448         }
 449         *pkt= new_pkt;
 450
 451         bsfc= bsfc->next;
 452     }
 453
 454     av_interleaved_write_frame(s, pkt);
 455 }
 456
 457 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 458
 459 static void do_audio_out(AVFormatContext *s,
 460                          AVOutputStream *ost,
 461                          AVInputStream *ist,
 462                          unsigned char *buf, int size)
 463 {
 464     uint8_t *buftmp;
 465     static uint8_t *audio_buf = NULL;
 466     static uint8_t *audio_out = NULL;
 467     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
 468
 469     int size_out, frame_bytes, ret;
 470     AVCodecContext *enc= ost->st->codec;
 471
 472     /* SC: dynamic allocation of buffers */
 473     if (!audio_buf)
 474         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
 475     if (!audio_out)
 476         audio_out = av_malloc(audio_out_size);
 477     if (!audio_buf || !audio_out)
 478         return;               /* Should signal an error ! */
 479
 480     if(audio_sync_method){
 481         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 482                 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
 483         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
 484         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
 485
 486         //FIXME resample delay
 487         if(fabs(delta) > 50){
 488             if(ist->is_start){
 489                 if(byte_delta < 0){
 490                     byte_delta= FFMAX(byte_delta, -size);
 491                     size += byte_delta;
 492                     buf  -= byte_delta;
 493                     if(verbose > 2)
 494                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 495                     if(!size)
 496                         return;
 497                     ist->is_start=0;
 498                 }else{
 499                     static uint8_t *input_tmp= NULL;
 500                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 501
 502                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
 503                         ist->is_start=0;
 504                     else
 505                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
 506
 507                     memset(input_tmp, 0, byte_delta);
 508                     memcpy(input_tmp + byte_delta, buf, size);
 509                     buf= input_tmp;
 510                     size += byte_delta;
 511                     if(verbose > 2)
 512                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 513                 }
 514             }else if(audio_sync_method>1){
 515                 int comp= clip(delta, -audio_sync_method, audio_sync_method);
 516                 assert(ost->audio_resample);
 517                 if(verbose > 2)
 518                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 519 //                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
 520                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 521             }
 522         }
 523     }else
 524         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 525                         - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
 526
 527     if (ost->audio_resample) {
 528         buftmp = audio_buf;
 529         size_out = audio_resample(ost->resample,
 530                                   (short *)buftmp, (short *)buf,
 531                                   size / (ist->st->codec->channels * 2));
 532         size_out = size_out * enc->channels * 2;
 533     } else {
 534         buftmp = buf;
 535         size_out = size;
 536     }
 537
 538     /* now encode as many frames as possible */
 539     if (enc->frame_size > 1) {
 540         /* output resampled raw samples */
 541         fifo_write(&ost->fifo, buftmp, size_out,
 542                    &ost->fifo.wptr);
 543
 544         frame_bytes = enc->frame_size * 2 * enc->channels;
 545
 546         while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
 547                      &ost->fifo.rptr) == 0) {
 548             AVPacket pkt;
 549             av_init_packet(&pkt);
 550
 551             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 552                                        (short *)audio_buf);
 553             audio_size += ret;
 554             pkt.stream_index= ost->index;
 555             pkt.data= audio_out;
 556             pkt.size= ret;
 557             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 558                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 559             pkt.flags |= PKT_FLAG_KEY;
 560             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 561
 562             ost->sync_opts += enc->frame_size;
 563         }
 564     } else {
 565         AVPacket pkt;
 566         av_init_packet(&pkt);
 567
 568         ost->sync_opts += size_out / (2 * enc->channels);
 569
 570         /* output a pcm frame */
 571         /* XXX: change encoding codec API to avoid this ? */
 572         switch(enc->codec->id) {
 573         case CODEC_ID_PCM_S32LE:
 574         case CODEC_ID_PCM_S32BE:
 575         case CODEC_ID_PCM_U32LE:
 576         case CODEC_ID_PCM_U32BE:
 577             size_out = size_out << 1;
 578             break;
 579         case CODEC_ID_PCM_S24LE:
 580         case CODEC_ID_PCM_S24BE:
 581         case CODEC_ID_PCM_U24LE:
 582         case CODEC_ID_PCM_U24BE:
 583         case CODEC_ID_PCM_S24DAUD:
 584             size_out = size_out / 2 * 3;
 585             break;
 586         case CODEC_ID_PCM_S16LE:
 587         case CODEC_ID_PCM_S16BE:
 588         case CODEC_ID_PCM_U16LE:
 589         case CODEC_ID_PCM_U16BE:
 590             break;
 591         default:
 592             size_out = size_out >> 1;
 593             break;
 594         }
 595         ret = avcodec_encode_audio(enc, audio_out, size_out,
 596                                    (short *)buftmp);
 597         audio_size += ret;
 598         pkt.stream_index= ost->index;
 599         pkt.data= audio_out;
 600         pkt.size= ret;
 601         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 602             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 603         pkt.flags |= PKT_FLAG_KEY;
 604         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 605     }
 606 }
 607
 608 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
 609 {
 610     AVCodecContext *dec;
 611     AVPicture *picture2;
 612     AVPicture picture_tmp;
 613     uint8_t *buf = 0;
 614
 615     dec = ist->st->codec;
 616
 617     /* deinterlace : must be done before any resize */
 618     if (do_deinterlace || using_vhook) {
 619         int size;
 620
 621         /* create temporary picture */
 622         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 623         buf = av_malloc(size);
 624         if (!buf)
 625             return;
 626
 627         picture2 = &picture_tmp;
 628         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 629
 630         if (do_deinterlace){
 631             if(avpicture_deinterlace(picture2, picture,
 632                                      dec->pix_fmt, dec->width, dec->height) < 0) {
 633                 /* if error, do not deinterlace */
 634                 av_free(buf);
 635                 buf = NULL;
 636                 picture2 = picture;
 637             }
 638         } else {
 639             img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
 640         }
 641     } else {
 642         picture2 = picture;
 643     }
 644
 645     frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
 646
 647     if (picture != picture2)
 648         *picture = *picture2;
 649     *bufp = buf;
 650 }
 651
 652 /* we begin to correct av delay at this threshold */
 653 #define AV_DELAY_MAX 0.100
 654
 655 static void do_subtitle_out(AVFormatContext *s,
 656                             AVOutputStream *ost,
 657                             AVInputStream *ist,
 658                             AVSubtitle *sub,
 659                             int64_t pts)
 660 {
 661     static uint8_t *subtitle_out = NULL;
 662     int subtitle_out_max_size = 65536;
 663     int subtitle_out_size, nb, i;
 664     AVCodecContext *enc;
 665     AVPacket pkt;
 666
 667     if (pts == AV_NOPTS_VALUE) {
 668         fprintf(stderr, "Subtitle packets must have a pts\n");
 669         return;
 670     }
 671
 672     enc = ost->st->codec;
 673
 674     if (!subtitle_out) {
 675         subtitle_out = av_malloc(subtitle_out_max_size);
 676     }
 677
 678     /* Note: DVB subtitle need one packet to draw them and one other
 679        packet to clear them */
 680     /* XXX: signal it in the codec context ? */
 681     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
 682         nb = 2;
 683     else
 684         nb = 1;
 685
 686     for(i = 0; i < nb; i++) {
 687         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
 688                                                     subtitle_out_max_size, sub);
 689
 690         av_init_packet(&pkt);
 691         pkt.stream_index = ost->index;
 692         pkt.data = subtitle_out;
 693         pkt.size = subtitle_out_size;
 694         pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
 695         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
 696             /* XXX: the pts correction is handled here. Maybe handling
 697                it in the codec would be better */
 698             if (i == 0)
 699                 pkt.pts += 90 * sub->start_display_time;
 700             else
 701                 pkt.pts += 90 * sub->end_display_time;
 702         }
 703         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 704     }
 705 }
 706
 707 static int bit_buffer_size= 1024*256;
 708 static uint8_t *bit_buffer= NULL;
 709
 710 static void do_video_out(AVFormatContext *s,
 711                          AVOutputStream *ost,
 712                          AVInputStream *ist,
 713                          AVFrame *in_picture,
 714                          int *frame_size)
 715 {
 716     int nb_frames, i, ret;
 717     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
 718     AVFrame picture_crop_temp, picture_pad_temp;
 719     uint8_t *buf = NULL, *buf1 = NULL;
 720     AVCodecContext *enc, *dec;
 721
 722     avcodec_get_frame_defaults(&picture_crop_temp);
 723     avcodec_get_frame_defaults(&picture_pad_temp);
 724
 725     enc = ost->st->codec;
 726     dec = ist->st->codec;
 727
 728     /* by default, we output a single frame */
 729     nb_frames = 1;
 730
 731     *frame_size = 0;
 732
 733     if(video_sync_method){
 734         double vdelta;
 735         vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
 736         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
 737         if (vdelta < -1.1)
 738             nb_frames = 0;
 739         else if (vdelta > 1.1)
 740             nb_frames = lrintf(vdelta);
 741 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
 742         if (nb_frames == 0){
 743             ++nb_frames_drop;
 744             if (verbose>2)
 745                 fprintf(stderr, "*** drop!\n");
 746         }else if (nb_frames > 1) {
 747             nb_frames_dup += nb_frames;
 748             if (verbose>2)
 749                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
 750         }
 751     }else
 752         ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
 753
 754     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
 755     if (nb_frames <= 0)
 756         return;
 757
 758     if (ost->video_crop) {
 759         if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
 760             av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
 761             goto the_end;
 762         }
 763         formatted_picture = &picture_crop_temp;
 764     } else {
 765         formatted_picture = in_picture;
 766     }
 767
 768     final_picture = formatted_picture;
 769     padding_src = formatted_picture;
 770     resampling_dst = &ost->pict_tmp;
 771     if (ost->video_pad) {
 772         final_picture = &ost->pict_tmp;
 773         if (ost->video_resample) {
 774             if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
 775                 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
 776                 goto the_end;
 777             }
 778             resampling_dst = &picture_pad_temp;
 779         }
 780     }
 781
 782     if (ost->video_resample) {
 783         padding_src = NULL;
 784         final_picture = &ost->pict_tmp;
 785         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
 786               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
 787     }
 788
 789     if (ost->video_pad) {
 790         img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
 791                 enc->height, enc->width, enc->pix_fmt,
 792                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
 793     }
 794
 795     /* duplicates frame if needed */
 796     for(i=0;i<nb_frames;i++) {
 797         AVPacket pkt;
 798         av_init_packet(&pkt);
 799         pkt.stream_index= ost->index;
 800
 801         if (s->oformat->flags & AVFMT_RAWPICTURE) {
 802             /* raw pictures are written as AVPicture structure to
 803                avoid any copies. We support temorarily the older
 804                method. */
 805             AVFrame* old_frame = enc->coded_frame;
 806             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
 807             pkt.data= (uint8_t *)final_picture;
 808             pkt.size=  sizeof(AVPicture);
 809             if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 810                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 811             if(dec->coded_frame && dec->coded_frame->key_frame)
 812                 pkt.flags |= PKT_FLAG_KEY;
 813
 814             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 815             enc->coded_frame = old_frame;
 816         } else {
 817             AVFrame big_picture;
 818
 819             big_picture= *final_picture;
 820             /* better than nothing: use input picture interlaced
 821                settings */
 822             big_picture.interlaced_frame = in_picture->interlaced_frame;
 823             if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
 824                 if(top_field_first == -1)
 825                     big_picture.top_field_first = in_picture->top_field_first;
 826                 else
 827                     big_picture.top_field_first = top_field_first;
 828             }
 829
 830             /* handles sameq here. This is not correct because it may
 831                not be a global option */
 832             if (same_quality) {
 833                 big_picture.quality = ist->st->quality;
 834             }else
 835                 big_picture.quality = ost->st->quality;
 836             if(!me_threshold)
 837                 big_picture.pict_type = 0;
 838 //            big_picture.pts = AV_NOPTS_VALUE;
 839             big_picture.pts= ost->sync_opts;
 840 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
 841 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
 842             ret = avcodec_encode_video(enc,
 843                                        bit_buffer, bit_buffer_size,
 844                                        &big_picture);
 845             //enc->frame_number = enc->real_pict_num;
 846             if(ret>0){
 847                 pkt.data= bit_buffer;
 848                 pkt.size= ret;
 849                 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 850                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 851 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
 852    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
 853    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
 854
 855                 if(enc->coded_frame && enc->coded_frame->key_frame)
 856                     pkt.flags |= PKT_FLAG_KEY;
 857                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 858                 *frame_size = ret;
 859                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
 860                 //        enc->frame_number-1, enc->real_pict_num, ret,
 861                 //        enc->pict_type);
 862                 /* if two pass, output log */
 863                 if (ost->logfile && enc->stats_out) {
 864                     fprintf(ost->logfile, "%s", enc->stats_out);
 865                 }
 866             }
 867         }
 868         ost->sync_opts++;
 869         ost->frame_number++;
 870     }
 871  the_end:
 872     av_free(buf);
 873     av_free(buf1);
 874 }
 875
 876 static double psnr(double d){
 877     if(d==0) return INFINITY;
 878     return -10.0*log(d)/log(10.0);
 879 }
 880
 881 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
 882                            int frame_size)
 883 {
 884     static FILE *fvstats=NULL;
 885     char filename[40];
 886     time_t today2;
 887     struct tm *today;
 888     AVCodecContext *enc;
 889     int frame_number;
 890     int64_t ti;
 891     double ti1, bitrate, avg_bitrate;
 892
 893     if (!fvstats) {
 894         today2 = time(NULL);
 895         today = localtime(&today2);
 896         snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
 897                                                today->tm_min,
 898                                                today->tm_sec);
 899         fvstats = fopen(filename,"w");
 900         if (!fvstats) {
 901             perror("fopen");
 902             exit(1);
 903         }
 904     }
 905
 906     ti = MAXINT64;
 907     enc = ost->st->codec;
 908     if (enc->codec_type == CODEC_TYPE_VIDEO) {
 909         frame_number = ost->frame_number;
 910         fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 911         if (enc->flags&CODEC_FLAG_PSNR)
 912             fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
 913
 914         fprintf(fvstats,"f_size= %6d ", frame_size);
 915         /* compute pts value */
 916         ti1 = ost->sync_opts * av_q2d(enc->time_base);
 917         if (ti1 < 0.01)
 918             ti1 = 0.01;
 919
 920         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
 921         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
 922         fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
 923             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
 924         fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
 925     }
 926 }
 927
 928 static void print_report(AVFormatContext **output_files,
 929                          AVOutputStream **ost_table, int nb_ostreams,
 930                          int is_last_report)
 931 {
 932     char buf[1024];
 933     AVOutputStream *ost;
 934     AVFormatContext *oc, *os;
 935     int64_t total_size;
 936     AVCodecContext *enc;
 937     int frame_number, vid, i;
 938     double bitrate, ti1, pts;
 939     static int64_t last_time = -1;
 940     static int qp_histogram[52];
 941
 942     if (!is_last_report) {
 943         int64_t cur_time;
 944         /* display the report every 0.5 seconds */
 945         cur_time = av_gettime();
 946         if (last_time == -1) {
 947             last_time = cur_time;
 948             return;
 949         }
 950         if ((cur_time - last_time) < 500000)
 951             return;
 952         last_time = cur_time;
 953     }
 954
 955
 956     oc = output_files[0];
 957
 958     total_size = url_ftell(&oc->pb);
 959
 960     buf[0] = '\0';
 961     ti1 = 1e10;
 962     vid = 0;
 963     for(i=0;i<nb_ostreams;i++) {
 964         ost = ost_table[i];
 965         os = output_files[ost->file_index];
 966         enc = ost->st->codec;
 967         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
 968             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
 969                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 970         }
 971         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
 972             frame_number = ost->frame_number;
 973             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
 974                     frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
 975             if(is_last_report)
 976                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
 977             if(qp_hist && enc->coded_frame){
 978                 int j;
 979                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 980                 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
 981                     qp_histogram[qp]++;
 982                 for(j=0; j<32; j++)
 983                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
 984             }
 985             if (enc->flags&CODEC_FLAG_PSNR){
 986                 int j;
 987                 double error, error_sum=0;
 988                 double scale, scale_sum=0;
 989                 char type[3]= {'Y','U','V'};
 990                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
 991                 for(j=0; j<3; j++){
 992                     if(is_last_report){
 993                         error= enc->error[j];
 994                         scale= enc->width*enc->height*255.0*255.0*frame_number;
 995                     }else{
 996                         error= enc->coded_frame->error[j];
 997                         scale= enc->width*enc->height*255.0*255.0;
 998                     }
 999                     if(j) scale/=4;
1000                     error_sum += error;
1001                     scale_sum += scale;
1002                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1003                 }
1004                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1005             }
1006             vid = 1;
1007         }
1008         /* compute min output value */
1009         pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1010         if ((pts < ti1) && (pts > 0))
1011             ti1 = pts;
1012     }
1013     if (ti1 < 0.01)
1014         ti1 = 0.01;
1015
1016     if (verbose || is_last_report) {
1017         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1018
1019         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1020             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1021             (double)total_size / 1024, ti1, bitrate);
1022
1023         if (verbose > 1)
1024           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1025                   nb_frames_dup, nb_frames_drop);
1026
1027         if (verbose >= 0)
1028             fprintf(stderr, "%s    \r", buf);
1029
1030         fflush(stderr);
1031     }
1032
1033     if (is_last_report && verbose >= 0){
1034         int64_t raw= audio_size + video_size + extra_size;
1035         fprintf(stderr, "\n");
1036         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1037                 video_size/1024.0,
1038                 audio_size/1024.0,
1039                 extra_size/1024.0,
1040                 100.0*(total_size - raw)/raw
1041         );
1042     }
1043 }
1044
1045 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1046 static int output_packet(AVInputStream *ist, int ist_index,
1047                          AVOutputStream **ost_table, int nb_ostreams,
1048                          const AVPacket *pkt)
1049 {
1050     AVFormatContext *os;
1051     AVOutputStream *ost;
1052     uint8_t *ptr;
1053     int len, ret, i;
1054     uint8_t *data_buf;
1055     int data_size, got_picture;
1056     AVFrame picture;
1057     void *buffer_to_free;
1058     static unsigned int samples_size= 0;
1059     static short *samples= NULL;
1060     AVSubtitle subtitle, *subtitle_to_free;
1061     int got_subtitle;
1062
1063     if(!pkt){
1064         ist->pts= ist->next_pts; // needed for last packet if vsync=0
1065     } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1066         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1067     } else {
1068 //        assert(ist->pts == ist->next_pts);
1069     }
1070
1071     if (pkt == NULL) {
1072         /* EOF handling */
1073         ptr = NULL;
1074         len = 0;
1075         goto handle_eof;
1076     }
1077
1078     len = pkt->size;
1079     ptr = pkt->data;
1080     while (len > 0) {
1081     handle_eof:
1082         /* decode the packet if needed */
1083         data_buf = NULL; /* fail safe */
1084         data_size = 0;
1085         subtitle_to_free = NULL;
1086         if (ist->decoding_needed) {
1087             switch(ist->st->codec->codec_type) {
1088             case CODEC_TYPE_AUDIO:{
1089                 if(pkt)
1090                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1091                     /* XXX: could avoid copy if PCM 16 bits with same
1092                        endianness as CPU */
1093                 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1094                                            ptr, len);
1095                 if (ret < 0)
1096                     goto fail_decode;
1097                 ptr += ret;
1098                 len -= ret;
1099                 /* Some bug in mpeg audio decoder gives */
1100                 /* data_size < 0, it seems they are overflows */
1101                 if (data_size <= 0) {
1102                     /* no audio frame */
1103                     continue;
1104                 }
1105                 data_buf = (uint8_t *)samples;
1106                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1107                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1108                 break;}
1109             case CODEC_TYPE_VIDEO:
1110                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1111                     /* XXX: allocate picture correctly */
1112                     avcodec_get_frame_defaults(&picture);
1113
1114                     ret = avcodec_decode_video(ist->st->codec,
1115                                                &picture, &got_picture, ptr, len);
1116                     ist->st->quality= picture.quality;
1117                     if (ret < 0)
1118                         goto fail_decode;
1119                     if (!got_picture) {
1120                         /* no picture yet */
1121                         goto discard_packet;
1122                     }
1123                     if (ist->st->codec->time_base.num != 0) {
1124                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1125                                           ist->st->codec->time_base.num) /
1126                             ist->st->codec->time_base.den;
1127                     }
1128                     len = 0;
1129                     break;
1130             case CODEC_TYPE_SUBTITLE:
1131                 ret = avcodec_decode_subtitle(ist->st->codec,
1132                                               &subtitle, &got_subtitle, ptr, len);
1133                 if (ret < 0)
1134                     goto fail_decode;
1135                 if (!got_subtitle) {
1136                     goto discard_packet;
1137                 }
1138                 subtitle_to_free = &subtitle;
1139                 len = 0;
1140                 break;
1141             default:
1142                 goto fail_decode;
1143             }
1144         } else {
1145                 switch(ist->st->codec->codec_type) {
1146                 case CODEC_TYPE_AUDIO:
1147                     ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1148                         (ist->st->codec->sample_rate * ist->st->codec->channels);
1149                     break;
1150                 case CODEC_TYPE_VIDEO:
1151                     if (ist->st->codec->time_base.num != 0) {
1152                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1153                                           ist->st->codec->time_base.num) /
1154                             ist->st->codec->time_base.den;
1155                     }
1156                     break;
1157                 }
1158                 data_buf = ptr;
1159                 data_size = len;
1160                 ret = len;
1161                 len = 0;
1162             }
1163
1164             buffer_to_free = NULL;
1165             if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1166                 pre_process_video_frame(ist, (AVPicture *)&picture,
1167                                         &buffer_to_free);
1168             }
1169
1170             // preprocess audio (volume)
1171             if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1172                 if (audio_volume != 256) {
1173                     short *volp;
1174                     volp = samples;
1175                     for(i=0;i<(data_size / sizeof(short));i++) {
1176                         int v = ((*volp) * audio_volume + 128) >> 8;
1177                         if (v < -32768) v = -32768;
1178                         if (v >  32767) v = 32767;
1179                         *volp++ = v;
1180                     }
1181                 }
1182             }
1183
1184             /* frame rate emulation */
1185             if (ist->st->codec->rate_emu) {
1186                 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1187                 int64_t now = av_gettime() - ist->start;
1188                 if (pts > now)
1189                     usleep(pts - now);
1190
1191                 ist->frame++;
1192             }
1193
1194 #if 0
1195             /* mpeg PTS deordering : if it is a P or I frame, the PTS
1196                is the one of the next displayed one */
1197             /* XXX: add mpeg4 too ? */
1198             if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1199                 if (ist->st->codec->pict_type != B_TYPE) {
1200                     int64_t tmp;
1201                     tmp = ist->last_ip_pts;
1202                     ist->last_ip_pts  = ist->frac_pts.val;
1203                     ist->frac_pts.val = tmp;
1204                 }
1205             }
1206 #endif
1207             /* if output time reached then transcode raw format,
1208                encode packets and output them */
1209             if (start_time == 0 || ist->pts >= start_time)
1210                 for(i=0;i<nb_ostreams;i++) {
1211                     int frame_size;
1212
1213                     ost = ost_table[i];
1214                     if (ost->source_index == ist_index) {
1215                         os = output_files[ost->file_index];
1216
1217 #if 0
1218                         printf("%d: got pts=%0.3f %0.3f\n", i,
1219                                (double)pkt->pts / AV_TIME_BASE,
1220                                ((double)ist->pts / AV_TIME_BASE) -
1221                                ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1222 #endif
1223                         /* set the input output pts pairs */
1224                         //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1225
1226                         if (ost->encoding_needed) {
1227                             switch(ost->st->codec->codec_type) {
1228                             case CODEC_TYPE_AUDIO:
1229                                 do_audio_out(os, ost, ist, data_buf, data_size);
1230                                 break;
1231                             case CODEC_TYPE_VIDEO:
1232                                     do_video_out(os, ost, ist, &picture, &frame_size);
1233                                     video_size += frame_size;
1234                                     if (do_vstats && frame_size)
1235                                         do_video_stats(os, ost, frame_size);
1236                                 break;
1237                             case CODEC_TYPE_SUBTITLE:
1238                                 do_subtitle_out(os, ost, ist, &subtitle,
1239                                                 pkt->pts);
1240                                 break;
1241                             default:
1242                                 av_abort();
1243                             }
1244                         } else {
1245                             AVFrame avframe; //FIXME/XXX remove this
1246                             AVPacket opkt;
1247                             av_init_packet(&opkt);
1248
1249                             /* no reencoding needed : output the packet directly */
1250                             /* force the input stream PTS */
1251
1252                             avcodec_get_frame_defaults(&avframe);
1253                             ost->st->codec->coded_frame= &avframe;
1254                             avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1255
1256                             if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1257                                 audio_size += data_size;
1258                             else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1259                                 video_size += data_size;
1260                                 ost->sync_opts++;
1261                             }
1262
1263                             opkt.stream_index= ost->index;
1264                             if(pkt->pts != AV_NOPTS_VALUE)
1265                                 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1266                             else
1267                                 opkt.pts= AV_NOPTS_VALUE;
1268
1269                             {
1270                                 int64_t dts;
1271                                 if (pkt->dts == AV_NOPTS_VALUE)
1272                                     dts = ist->next_pts;
1273                                 else
1274                                     dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1275                                 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1276                             }
1277                             opkt.flags= pkt->flags;
1278
1279                             //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1280                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1281                                 opkt.destruct= av_destruct_packet;
1282
1283                             write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1284                             ost->st->codec->frame_number++;
1285                             ost->frame_number++;
1286                             av_free_packet(&opkt);
1287                         }
1288                     }
1289                 }
1290             av_free(buffer_to_free);
1291             /* XXX: allocate the subtitles in the codec ? */
1292             if (subtitle_to_free) {
1293                 if (subtitle_to_free->rects != NULL) {
1294                     for (i = 0; i < subtitle_to_free->num_rects; i++) {
1295                         av_free(subtitle_to_free->rects[i].bitmap);
1296                         av_free(subtitle_to_free->rects[i].rgba_palette);
1297                     }
1298                     av_freep(&subtitle_to_free->rects);
1299                 }
1300                 subtitle_to_free->num_rects = 0;
1301                 subtitle_to_free = NULL;
1302             }
1303         }
1304  discard_packet:
1305     if (pkt == NULL) {
1306         /* EOF handling */
1307
1308         for(i=0;i<nb_ostreams;i++) {
1309             ost = ost_table[i];
1310             if (ost->source_index == ist_index) {
1311                 AVCodecContext *enc= ost->st->codec;
1312                 os = output_files[ost->file_index];
1313
1314                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1315                     continue;
1316                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1317                     continue;
1318
1319                 if (ost->encoding_needed) {
1320                     for(;;) {
1321                         AVPacket pkt;
1322                         int fifo_bytes;
1323                         av_init_packet(&pkt);
1324                         pkt.stream_index= ost->index;
1325
1326                         switch(ost->st->codec->codec_type) {
1327                         case CODEC_TYPE_AUDIO:
1328                             fifo_bytes = fifo_size(&ost->fifo, NULL);
1329                             ret = 0;
1330                             /* encode any samples remaining in fifo */
1331                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1332                                 int fs_tmp = enc->frame_size;
1333                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1334                                 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1335                                         &ost->fifo.rptr) == 0) {
1336                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1337                                 }
1338                                 enc->frame_size = fs_tmp;
1339                             }
1340                             if(ret <= 0) {
1341                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1342                             }
1343                             audio_size += ret;
1344                             pkt.flags |= PKT_FLAG_KEY;
1345                             break;
1346                         case CODEC_TYPE_VIDEO:
1347                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1348                             video_size += ret;
1349                             if(enc->coded_frame && enc->coded_frame->key_frame)
1350                                 pkt.flags |= PKT_FLAG_KEY;
1351                             if (ost->logfile && enc->stats_out) {
1352                                 fprintf(ost->logfile, "%s", enc->stats_out);
1353                             }
1354                             break;
1355                         default:
1356                             ret=-1;
1357                         }
1358
1359                         if(ret<=0)
1360                             break;
1361                         pkt.data= bit_buffer;
1362                         pkt.size= ret;
1363                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1364                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1365                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1366                     }
1367                 }
1368             }
1369         }
1370     }
1371
1372     return 0;
1373  fail_decode:
1374     return -1;
1375 }
1376
1377
1378 /*
1379  * The following code is the main loop of the file converter
1380  */
1381 static int av_encode(AVFormatContext **output_files,
1382                      int nb_output_files,
1383                      AVFormatContext **input_files,
1384                      int nb_input_files,
1385                      AVStreamMap *stream_maps, int nb_stream_maps)
1386 {
1387     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1388     AVFormatContext *is, *os;
1389     AVCodecContext *codec, *icodec;
1390     AVOutputStream *ost, **ost_table = NULL;
1391     AVInputStream *ist, **ist_table = NULL;
1392     AVInputFile *file_table;
1393     AVFormatContext *stream_no_data;
1394     int key;
1395
1396     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1397     if (!file_table)
1398         goto fail;
1399
1400     /* input stream init */
1401     j = 0;
1402     for(i=0;i<nb_input_files;i++) {
1403         is = input_files[i];
1404         file_table[i].ist_index = j;
1405         file_table[i].nb_streams = is->nb_streams;
1406         j += is->nb_streams;
1407     }
1408     nb_istreams = j;
1409
1410     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1411     if (!ist_table)
1412         goto fail;
1413
1414     for(i=0;i<nb_istreams;i++) {
1415         ist = av_mallocz(sizeof(AVInputStream));
1416         if (!ist)
1417             goto fail;
1418         ist_table[i] = ist;
1419     }
1420     j = 0;
1421     for(i=0;i<nb_input_files;i++) {
1422         is = input_files[i];
1423         for(k=0;k<is->nb_streams;k++) {
1424             ist = ist_table[j++];
1425             ist->st = is->streams[k];
1426             ist->file_index = i;
1427             ist->index = k;
1428             ist->discard = 1; /* the stream is discarded by default
1429                                  (changed later) */
1430
1431             if (ist->st->codec->rate_emu) {
1432                 ist->start = av_gettime();
1433                 ist->frame = 0;
1434             }
1435         }
1436     }
1437
1438     /* output stream init */
1439     nb_ostreams = 0;
1440     for(i=0;i<nb_output_files;i++) {
1441         os = output_files[i];
1442         nb_ostreams += os->nb_streams;
1443     }
1444     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1445         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1446         exit(1);
1447     }
1448
1449     /* Sanity check the mapping args -- do the input files & streams exist? */
1450     for(i=0;i<nb_stream_maps;i++) {
1451         int fi = stream_maps[i].file_index;
1452         int si = stream_maps[i].stream_index;
1453
1454         if (fi < 0 || fi > nb_input_files - 1 ||
1455             si < 0 || si > file_table[fi].nb_streams - 1) {
1456             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1457             exit(1);
1458         }
1459         fi = stream_maps[i].sync_file_index;
1460         si = stream_maps[i].sync_stream_index;
1461         if (fi < 0 || fi > nb_input_files - 1 ||
1462             si < 0 || si > file_table[fi].nb_streams - 1) {
1463             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1464             exit(1);
1465         }
1466     }
1467
1468     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1469     if (!ost_table)
1470         goto fail;
1471     for(i=0;i<nb_ostreams;i++) {
1472         ost = av_mallocz(sizeof(AVOutputStream));
1473         if (!ost)
1474             goto fail;
1475         ost_table[i] = ost;
1476     }
1477
1478     n = 0;
1479     for(k=0;k<nb_output_files;k++) {
1480         os = output_files[k];
1481         for(i=0;i<os->nb_streams;i++) {
1482             int found;
1483             ost = ost_table[n++];
1484             ost->file_index = k;
1485             ost->index = i;
1486             ost->st = os->streams[i];
1487             if (nb_stream_maps > 0) {
1488                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1489                     stream_maps[n-1].stream_index;
1490
1491                 /* Sanity check that the stream types match */
1492                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1493                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1494                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1495                         ost->file_index, ost->index);
1496                     exit(1);
1497                 }
1498
1499             } else {
1500                 /* get corresponding input stream index : we select the first one with the right type */
1501                 found = 0;
1502                 for(j=0;j<nb_istreams;j++) {
1503                     ist = ist_table[j];
1504                     if (ist->discard &&
1505                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
1506                         ost->source_index = j;
1507                         found = 1;
1508                         break;
1509                     }
1510                 }
1511
1512                 if (!found) {
1513                     /* try again and reuse existing stream */
1514                     for(j=0;j<nb_istreams;j++) {
1515                         ist = ist_table[j];
1516                         if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1517                             ost->source_index = j;
1518                             found = 1;
1519                         }
1520                     }
1521                     if (!found) {
1522                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1523                                 ost->file_index, ost->index);
1524                         exit(1);
1525                     }
1526                 }
1527             }
1528             ist = ist_table[ost->source_index];
1529             ist->discard = 0;
1530             ost->sync_ist = (nb_stream_maps > 0) ?
1531                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1532                          stream_maps[n-1].sync_stream_index] : ist;
1533         }
1534     }
1535
1536     /* for each output stream, we compute the right encoding parameters */
1537     for(i=0;i<nb_ostreams;i++) {
1538         ost = ost_table[i];
1539         ist = ist_table[ost->source_index];
1540
1541         codec = ost->st->codec;
1542         icodec = ist->st->codec;
1543
1544         if (ost->st->stream_copy) {
1545             /* if stream_copy is selected, no need to decode or encode */
1546             codec->codec_id = icodec->codec_id;
1547             codec->codec_type = icodec->codec_type;
1548             if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1549             codec->bit_rate = icodec->bit_rate;
1550             codec->extradata= icodec->extradata;
1551             codec->extradata_size= icodec->extradata_size;
1552             codec->time_base = icodec->time_base;
1553             switch(codec->codec_type) {
1554             case CODEC_TYPE_AUDIO:
1555                 codec->sample_rate = icodec->sample_rate;
1556                 codec->channels = icodec->channels;
1557                 codec->frame_size = icodec->frame_size;
1558                 codec->block_align= icodec->block_align;
1559                 break;
1560             case CODEC_TYPE_VIDEO:
1561                 codec->pix_fmt = icodec->pix_fmt;
1562                 codec->width = icodec->width;
1563                 codec->height = icodec->height;
1564                 codec->has_b_frames = icodec->has_b_frames;
1565                 break;
1566             case CODEC_TYPE_SUBTITLE:
1567                 break;
1568             default:
1569                 av_abort();
1570             }
1571         } else {
1572             switch(codec->codec_type) {
1573             case CODEC_TYPE_AUDIO:
1574                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1575                     goto fail;
1576
1577                 if (codec->channels == icodec->channels &&
1578                     codec->sample_rate == icodec->sample_rate) {
1579                     ost->audio_resample = 0;
1580                 } else {
1581                     if (codec->channels != icodec->channels &&
1582                         (icodec->codec_id == CODEC_ID_AC3 ||
1583                          icodec->codec_id == CODEC_ID_DTS)) {
1584                         /* Special case for 5:1 AC3 and DTS input */
1585                         /* and mono or stereo output      */
1586                         /* Request specific number of channels */
1587                         icodec->channels = codec->channels;
1588                         if (codec->sample_rate == icodec->sample_rate)
1589                             ost->audio_resample = 0;
1590                         else {
1591                             ost->audio_resample = 1;
1592                         }
1593                     } else {
1594                         ost->audio_resample = 1;
1595                     }
1596                 }
1597                 if(audio_sync_method>1)
1598                     ost->audio_resample = 1;
1599
1600                 if(ost->audio_resample){
1601                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1602                                                     codec->sample_rate, icodec->sample_rate);
1603                     if(!ost->resample){
1604                         printf("Can't resample.  Aborting.\n");
1605                         av_abort();
1606                     }
1607                 }
1608                 ist->decoding_needed = 1;
1609                 ost->encoding_needed = 1;
1610                 break;
1611             case CODEC_TYPE_VIDEO:
1612                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1613                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1614                 ost->video_resample = ((codec->width != icodec->width -
1615                                 (frame_leftBand + frame_rightBand) +
1616                                 (frame_padleft + frame_padright)) ||
1617                         (codec->height != icodec->height -
1618                                 (frame_topBand  + frame_bottomBand) +
1619                                 (frame_padtop + frame_padbottom)) ||
1620                         (codec->pix_fmt != icodec->pix_fmt));
1621                 if (ost->video_crop) {
1622                     ost->topBand = frame_topBand;
1623                     ost->leftBand = frame_leftBand;
1624                 }
1625                 if (ost->video_pad) {
1626                     ost->padtop = frame_padtop;
1627                     ost->padleft = frame_padleft;
1628                     ost->padbottom = frame_padbottom;
1629                     ost->padright = frame_padright;
1630                     if (!ost->video_resample) {
1631                         avcodec_get_frame_defaults(&ost->pict_tmp);
1632                         if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1633                                          codec->width, codec->height ) )
1634                             goto fail;
1635                     }
1636                 }
1637                 if (ost->video_resample) {
1638                     avcodec_get_frame_defaults(&ost->pict_tmp);
1639                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1640                                          codec->width, codec->height ) )
1641                         goto fail;
1642
1643                     ost->img_resample_ctx = sws_getContext(
1644                             icodec->width - (frame_leftBand + frame_rightBand),
1645                             icodec->height - (frame_topBand + frame_bottomBand),
1646                             icodec->pix_fmt,
1647                             codec->width - (frame_padleft + frame_padright),
1648                             codec->height - (frame_padtop + frame_padbottom),
1649                             codec->pix_fmt,
1650                             sws_flags, NULL, NULL, NULL);
1651                     if (ost->img_resample_ctx == NULL) {
1652                         fprintf(stderr, "Cannot get resampling context\n");
1653                         exit(1);
1654                     }
1655                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1656                 }
1657                 ost->encoding_needed = 1;
1658                 ist->decoding_needed = 1;
1659                 break;
1660             case CODEC_TYPE_SUBTITLE:
1661                 ost->encoding_needed = 1;
1662                 ist->decoding_needed = 1;
1663                 break;
1664             default:
1665                 av_abort();
1666                 break;
1667             }
1668             /* two pass mode */
1669             if (ost->encoding_needed &&
1670                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1671                 char logfilename[1024];
1672                 FILE *f;
1673                 int size;
1674                 char *logbuffer;
1675
1676                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1677                          pass_logfilename ?
1678                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1679                 if (codec->flags & CODEC_FLAG_PASS1) {
1680                     f = fopen(logfilename, "w");
1681                     if (!f) {
1682                         perror(logfilename);
1683                         exit(1);
1684                     }
1685                     ost->logfile = f;
1686                 } else {
1687                     /* read the log file */
1688                     f = fopen(logfilename, "r");
1689                     if (!f) {
1690                         perror(logfilename);
1691                         exit(1);
1692                     }
1693                     fseek(f, 0, SEEK_END);
1694                     size = ftell(f);
1695                     fseek(f, 0, SEEK_SET);
1696                     logbuffer = av_malloc(size + 1);
1697                     if (!logbuffer) {
1698                         fprintf(stderr, "Could not allocate log buffer\n");
1699                         exit(1);
1700                     }
1701                     size = fread(logbuffer, 1, size, f);
1702                     fclose(f);
1703                     logbuffer[size] = '\0';
1704                     codec->stats_in = logbuffer;
1705                 }
1706             }
1707         }
1708         if(codec->codec_type == CODEC_TYPE_VIDEO){
1709             int size= codec->width * codec->height;
1710             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1711         }
1712     }
1713
1714     if (!bit_buffer)
1715         bit_buffer = av_malloc(bit_buffer_size);
1716     if (!bit_buffer)
1717         goto fail;
1718
1719     /* dump the file output parameters - cannot be done before in case
1720        of stream copy */
1721     for(i=0;i<nb_output_files;i++) {
1722         dump_format(output_files[i], i, output_files[i]->filename, 1);
1723     }
1724
1725     /* dump the stream mapping */
1726     if (verbose >= 0) {
1727         fprintf(stderr, "Stream mapping:\n");
1728         for(i=0;i<nb_ostreams;i++) {
1729             ost = ost_table[i];
1730             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1731                     ist_table[ost->source_index]->file_index,
1732                     ist_table[ost->source_index]->index,
1733                     ost->file_index,
1734                     ost->index);
1735             if (ost->sync_ist != ist_table[ost->source_index])
1736                 fprintf(stderr, " [sync #%d.%d]",
1737                         ost->sync_ist->file_index,
1738                         ost->sync_ist->index);
1739             fprintf(stderr, "\n");
1740         }
1741     }
1742
1743     /* open each encoder */
1744     for(i=0;i<nb_ostreams;i++) {
1745         ost = ost_table[i];
1746         if (ost->encoding_needed) {
1747             AVCodec *codec;
1748             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1749             if (!codec) {
1750                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1751                         ost->file_index, ost->index);
1752                 exit(1);
1753             }
1754             if (avcodec_open(ost->st->codec, codec) < 0) {
1755                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1756                         ost->file_index, ost->index);
1757                 exit(1);
1758             }
1759             extra_size += ost->st->codec->extradata_size;
1760         }
1761     }
1762
1763     /* open each decoder */
1764     for(i=0;i<nb_istreams;i++) {
1765         ist = ist_table[i];
1766         if (ist->decoding_needed) {
1767             AVCodec *codec;
1768             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1769             if (!codec) {
1770                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1771                         ist->st->codec->codec_id, ist->file_index, ist->index);
1772                 exit(1);
1773             }
1774             if (avcodec_open(ist->st->codec, codec) < 0) {
1775                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1776                         ist->file_index, ist->index);
1777                 exit(1);
1778             }
1779             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1780             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1781         }
1782     }
1783
1784     /* init pts */
1785     for(i=0;i<nb_istreams;i++) {
1786         ist = ist_table[i];
1787         is = input_files[ist->file_index];
1788         ist->pts = 0;
1789         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1790         if(ist->st->start_time == AV_NOPTS_VALUE)
1791             ist->next_pts=0;
1792         if(input_files_ts_offset[ist->file_index])
1793             ist->next_pts= AV_NOPTS_VALUE;
1794         ist->is_start = 1;
1795     }
1796
1797     /* compute buffer size max (should use a complete heuristic) */
1798     for(i=0;i<nb_input_files;i++) {
1799         file_table[i].buffer_size_max = 2048;
1800     }
1801
1802     /* set meta data information from input file if required */
1803     for (i=0;i<nb_meta_data_maps;i++) {
1804         AVFormatContext *out_file;
1805         AVFormatContext *in_file;
1806
1807         int out_file_index = meta_data_maps[i].out_file;
1808         int in_file_index = meta_data_maps[i].in_file;
1809         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1810             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1811             ret = -EINVAL;
1812             goto fail;
1813         }
1814         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1815             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1816             ret = -EINVAL;
1817             goto fail;
1818         }
1819
1820         out_file = output_files[out_file_index];
1821         in_file = input_files[in_file_index];
1822
1823         strcpy(out_file->title, in_file->title);
1824         strcpy(out_file->author, in_file->author);
1825         strcpy(out_file->copyright, in_file->copyright);
1826         strcpy(out_file->comment, in_file->comment);
1827         strcpy(out_file->album, in_file->album);
1828         out_file->year = in_file->year;
1829         out_file->track = in_file->track;
1830         strcpy(out_file->genre, in_file->genre);
1831     }
1832
1833     /* open files and write file headers */
1834     for(i=0;i<nb_output_files;i++) {
1835         os = output_files[i];
1836         if (av_write_header(os) < 0) {
1837             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1838             ret = -EINVAL;
1839             goto fail;
1840         }
1841     }
1842
1843 #ifndef __MINGW32__
1844     if ( !using_stdin && verbose >= 0) {
1845         fprintf(stderr, "Press [q] to stop encoding\n");
1846         url_set_interrupt_cb(decode_interrupt_cb);
1847     }
1848 #endif
1849     term_init();
1850
1851     stream_no_data = 0;
1852     key = -1;
1853
1854     for(; received_sigterm == 0;) {
1855         int file_index, ist_index;
1856         AVPacket pkt;
1857         double ipts_min;
1858         double opts_min;
1859
1860     redo:
1861         ipts_min= 1e100;
1862         opts_min= 1e100;
1863         /* if 'q' pressed, exits */
1864         if (!using_stdin) {
1865             if (q_pressed)
1866                 break;
1867             /* read_key() returns 0 on EOF */
1868             key = read_key();
1869             if (key == 'q')
1870                 break;
1871         }
1872
1873         /* select the stream that we must read now by looking at the
1874            smallest output pts */
1875         file_index = -1;
1876         for(i=0;i<nb_ostreams;i++) {
1877             double ipts, opts;
1878             ost = ost_table[i];
1879             os = output_files[ost->file_index];
1880             ist = ist_table[ost->source_index];
1881             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1882                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1883             else
1884                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1885             ipts = (double)ist->pts;
1886             if (!file_table[ist->file_index].eof_reached){
1887                 if(ipts < ipts_min) {
1888                     ipts_min = ipts;
1889                     if(input_sync ) file_index = ist->file_index;
1890                 }
1891                 if(opts < opts_min) {
1892                     opts_min = opts;
1893                     if(!input_sync) file_index = ist->file_index;
1894                 }
1895             }
1896             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1897                 file_index= -1;
1898                 break;
1899             }
1900         }
1901         /* if none, if is finished */
1902         if (file_index < 0) {
1903             break;
1904         }
1905
1906         /* finish if recording time exhausted */
1907         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1908             break;
1909
1910         /* finish if limit size exhausted */
1911         if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1912             break;
1913
1914         /* read a frame from it and output it in the fifo */
1915         is = input_files[file_index];
1916         if (av_read_frame(is, &pkt) < 0) {
1917             file_table[file_index].eof_reached = 1;
1918             if (opt_shortest) break; else continue; //
1919         }
1920
1921         if (!pkt.size) {
1922             stream_no_data = is;
1923         } else {
1924             stream_no_data = 0;
1925         }
1926         if (do_pkt_dump) {
1927             av_pkt_dump(stdout, &pkt, do_hex_dump);
1928         }
1929         /* the following test is needed in case new streams appear
1930            dynamically in stream : we ignore them */
1931         if (pkt.stream_index >= file_table[file_index].nb_streams)
1932             goto discard_packet;
1933         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1934         ist = ist_table[ist_index];
1935         if (ist->discard)
1936             goto discard_packet;
1937
1938 //        fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1939         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1940             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1941             if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1942                 input_files_ts_offset[ist->file_index]-= delta;
1943                 if (verbose > 2)
1944                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1945                 for(i=0; i<file_table[file_index].nb_streams; i++){
1946                     int index= file_table[file_index].ist_index + i;
1947                     ist_table[index]->next_pts += delta;
1948                     ist_table[index]->is_start=1;
1949                 }
1950             }
1951         }
1952
1953         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1954         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1955
1956             if (verbose >= 0)
1957                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1958                         ist->file_index, ist->index);
1959
1960             av_free_packet(&pkt);
1961             goto redo;
1962         }
1963
1964     discard_packet:
1965         av_free_packet(&pkt);
1966
1967         /* dump report by using the output first video and audio streams */
1968         print_report(output_files, ost_table, nb_ostreams, 0);
1969     }
1970
1971     /* at the end of stream, we must flush the decoder buffers */
1972     for(i=0;i<nb_istreams;i++) {
1973         ist = ist_table[i];
1974         if (ist->decoding_needed) {
1975             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1976         }
1977     }
1978
1979     term_exit();
1980
1981     /* write the trailer if needed and close file */
1982     for(i=0;i<nb_output_files;i++) {
1983         os = output_files[i];
1984         av_write_trailer(os);
1985     }
1986
1987     /* dump report by using the first video and audio streams */
1988     print_report(output_files, ost_table, nb_ostreams, 1);
1989
1990     /* close each encoder */
1991     for(i=0;i<nb_ostreams;i++) {
1992         ost = ost_table[i];
1993         if (ost->encoding_needed) {
1994             av_freep(&ost->st->codec->stats_in);
1995             avcodec_close(ost->st->codec);
1996         }
1997     }
1998
1999     /* close each decoder */
2000     for(i=0;i<nb_istreams;i++) {
2001         ist = ist_table[i];
2002         if (ist->decoding_needed) {
2003             avcodec_close(ist->st->codec);
2004         }
2005     }
2006
2007     /* finished ! */
2008
2009     ret = 0;
2010  fail1:
2011     av_freep(&bit_buffer);
2012     av_free(file_table);
2013
2014     if (ist_table) {
2015         for(i=0;i<nb_istreams;i++) {
2016             ist = ist_table[i];
2017             av_free(ist);
2018         }
2019         av_free(ist_table);
2020     }
2021     if (ost_table) {
2022         for(i=0;i<nb_ostreams;i++) {
2023             ost = ost_table[i];
2024             if (ost) {
2025                 if (ost->logfile) {
2026                     fclose(ost->logfile);
2027                     ost->logfile = NULL;
2028                 }
2029                 fifo_free(&ost->fifo); /* works even if fifo is not
2030                                           initialized but set to zero */
2031                 av_free(ost->pict_tmp.data[0]);
2032                 if (ost->video_resample)
2033                     sws_freeContext(ost->img_resample_ctx);
2034                 if (ost->audio_resample)
2035                     audio_resample_close(ost->resample);
2036                 av_free(ost);
2037             }
2038         }
2039         av_free(ost_table);
2040     }
2041     return ret;
2042  fail:
2043     ret = -ENOMEM;
2044     goto fail1;
2045 }
2046
2047 #if 0
2048 int file_read(const char *filename)
2049 {
2050     URLContext *h;
2051     unsigned char buffer[1024];
2052     int len, i;
2053
2054     if (url_open(&h, filename, O_RDONLY) < 0) {
2055         printf("could not open '%s'\n", filename);
2056         return -1;
2057     }
2058     for(;;) {
2059         len = url_read(h, buffer, sizeof(buffer));
2060         if (len <= 0)
2061             break;
2062         for(i=0;i<len;i++) putchar(buffer[i]);
2063     }
2064     url_close(h);
2065     return 0;
2066 }
2067 #endif
2068
2069 static void opt_image_format(const char *arg)
2070 {
2071     AVImageFormat *f;
2072
2073     for(f = first_image_format; f != NULL; f = f->next) {
2074         if (!strcmp(arg, f->name))
2075             break;
2076     }
2077     if (!f) {
2078         fprintf(stderr, "Unknown image format: '%s'\n", arg);
2079         exit(1);
2080     }
2081     image_format = f;
2082 }
2083
2084 static void opt_format(const char *arg)
2085 {
2086     /* compatibility stuff for pgmyuv */
2087     if (!strcmp(arg, "pgmyuv")) {
2088         pgmyuv_compatibility_hack=1;
2089 //        opt_image_format(arg);
2090         arg = "image2";
2091     }
2092
2093     file_iformat = av_find_input_format(arg);
2094     file_oformat = guess_format(arg, NULL, NULL);
2095     if (!file_iformat && !file_oformat) {
2096         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2097         exit(1);
2098     }
2099 }
2100
2101 static void opt_video_rc_eq(char *arg)
2102 {
2103     video_rc_eq = arg;
2104 }
2105
2106 static void opt_video_rc_override_string(char *arg)
2107 {
2108     video_rc_override_string = arg;
2109 }
2110
2111
2112 static void opt_workaround_bugs(const char *arg)
2113 {
2114     workaround_bugs = atoi(arg);
2115 }
2116
2117 static void opt_me_threshold(const char *arg)
2118 {
2119     me_threshold = atoi(arg);
2120 }
2121
2122 static void opt_mb_threshold(const char *arg)
2123 {
2124     mb_threshold = atoi(arg);
2125 }
2126
2127 static void opt_verbose(const char *arg)
2128 {
2129     verbose = atoi(arg);
2130     av_log_set_level(atoi(arg));
2131 }
2132
2133 static void opt_frame_rate(const char *arg)
2134 {
2135     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2136         fprintf(stderr, "Incorrect frame rate\n");
2137         exit(1);
2138     }
2139 }
2140
2141 static void opt_frame_crop_top(const char *arg)
2142 {
2143     frame_topBand = atoi(arg);
2144     if (frame_topBand < 0) {
2145         fprintf(stderr, "Incorrect top crop size\n");
2146         exit(1);
2147     }
2148     if ((frame_topBand % 2) != 0) {
2149         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2150         exit(1);
2151     }
2152     if ((frame_topBand) >= frame_height){
2153         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2154         exit(1);
2155     }
2156     frame_height -= frame_topBand;
2157 }
2158
2159 static void opt_frame_crop_bottom(const char *arg)
2160 {
2161     frame_bottomBand = atoi(arg);
2162     if (frame_bottomBand < 0) {
2163         fprintf(stderr, "Incorrect bottom crop size\n");
2164         exit(1);
2165     }
2166     if ((frame_bottomBand % 2) != 0) {
2167         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2168         exit(1);
2169     }
2170     if ((frame_bottomBand) >= frame_height){
2171         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2172         exit(1);
2173     }
2174     frame_height -= frame_bottomBand;
2175 }
2176
2177 static void opt_frame_crop_left(const char *arg)
2178 {
2179     frame_leftBand = atoi(arg);
2180     if (frame_leftBand < 0) {
2181         fprintf(stderr, "Incorrect left crop size\n");
2182         exit(1);
2183     }
2184     if ((frame_leftBand % 2) != 0) {
2185         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2186         exit(1);
2187     }
2188     if ((frame_leftBand) >= frame_width){
2189         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2190         exit(1);
2191     }
2192     frame_width -= frame_leftBand;
2193 }
2194
2195 static void opt_frame_crop_right(const char *arg)
2196 {
2197     frame_rightBand = atoi(arg);
2198     if (frame_rightBand < 0) {
2199         fprintf(stderr, "Incorrect right crop size\n");
2200         exit(1);
2201     }
2202     if ((frame_rightBand % 2) != 0) {
2203         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2204         exit(1);
2205     }
2206     if ((frame_rightBand) >= frame_width){
2207         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2208         exit(1);
2209     }
2210     frame_width -= frame_rightBand;
2211 }
2212
2213 static void opt_frame_size(const char *arg)
2214 {
2215     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2216         fprintf(stderr, "Incorrect frame size\n");
2217         exit(1);
2218     }
2219     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2220         fprintf(stderr, "Frame size must be a multiple of 2\n");
2221         exit(1);
2222     }
2223 }
2224
2225
2226 #define SCALEBITS 10
2227 #define ONE_HALF  (1 << (SCALEBITS - 1))
2228 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2229
2230 #define RGB_TO_Y(r, g, b) \
2231 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2232   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2233
2234 #define RGB_TO_U(r1, g1, b1, shift)\
2235 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2236      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2237
2238 #define RGB_TO_V(r1, g1, b1, shift)\
2239 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2240    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2241
2242 static void opt_pad_color(const char *arg) {
2243     /* Input is expected to be six hex digits similar to
2244        how colors are expressed in html tags (but without the #) */
2245     int rgb = strtol(arg, NULL, 16);
2246     int r,g,b;
2247
2248     r = (rgb >> 16);
2249     g = ((rgb >> 8) & 255);
2250     b = (rgb & 255);
2251
2252     padcolor[0] = RGB_TO_Y(r,g,b);
2253     padcolor[1] = RGB_TO_U(r,g,b,0);
2254     padcolor[2] = RGB_TO_V(r,g,b,0);
2255 }
2256
2257 static void opt_frame_pad_top(const char *arg)
2258 {
2259     frame_padtop = atoi(arg);
2260     if (frame_padtop < 0) {
2261         fprintf(stderr, "Incorrect top pad size\n");
2262         exit(1);
2263     }
2264     if ((frame_padtop % 2) != 0) {
2265         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2266         exit(1);
2267     }
2268 }
2269
2270 static void opt_frame_pad_bottom(const char *arg)
2271 {
2272     frame_padbottom = atoi(arg);
2273     if (frame_padbottom < 0) {
2274         fprintf(stderr, "Incorrect bottom pad size\n");
2275         exit(1);
2276     }
2277     if ((frame_padbottom % 2) != 0) {
2278         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2279         exit(1);
2280     }
2281 }
2282
2283
2284 static void opt_frame_pad_left(const char *arg)
2285 {
2286     frame_padleft = atoi(arg);
2287     if (frame_padleft < 0) {
2288         fprintf(stderr, "Incorrect left pad size\n");
2289         exit(1);
2290     }
2291     if ((frame_padleft % 2) != 0) {
2292         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2293         exit(1);
2294     }
2295 }
2296
2297
2298 static void opt_frame_pad_right(const char *arg)
2299 {
2300     frame_padright = atoi(arg);
2301     if (frame_padright < 0) {
2302         fprintf(stderr, "Incorrect right pad size\n");
2303         exit(1);
2304     }
2305     if ((frame_padright % 2) != 0) {
2306         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2307         exit(1);
2308     }
2309 }
2310
2311
2312 static void opt_frame_pix_fmt(const char *arg)
2313 {
2314     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2315 }
2316
2317 static void opt_frame_aspect_ratio(const char *arg)
2318 {
2319     int x = 0, y = 0;
2320     double ar = 0;
2321     const char *p;
2322
2323     p = strchr(arg, ':');
2324     if (p) {
2325         x = strtol(arg, (char **)&arg, 10);
2326         if (arg == p)
2327             y = strtol(arg+1, (char **)&arg, 10);
2328         if (x > 0 && y > 0)
2329             ar = (double)x / (double)y;
2330     } else
2331         ar = strtod(arg, (char **)&arg);
2332
2333     if (!ar) {
2334         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2335         exit(1);
2336     }
2337     frame_aspect_ratio = ar;
2338 }
2339
2340 static void opt_b_frames(const char *arg)
2341 {
2342     b_frames = atoi(arg);
2343     if (b_frames > FF_MAX_B_FRAMES) {
2344         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2345         exit(1);
2346     } else if (b_frames < 1) {
2347         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2348         exit(1);
2349     }
2350 }
2351
2352 static void opt_qscale(const char *arg)
2353 {
2354     video_qscale = atof(arg);
2355     if (video_qscale <= 0 ||
2356         video_qscale > 255) {
2357         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2358         exit(1);
2359     }
2360 }
2361
2362 static void opt_qsquish(const char *arg)
2363 {
2364     video_qsquish = atof(arg);
2365     if (video_qsquish < 0.0 ||
2366         video_qsquish > 99.0) {
2367         fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2368         exit(1);
2369     }
2370 }
2371
2372 static void opt_lmax(const char *arg)
2373 {
2374     video_lmax = atof(arg)*FF_QP2LAMBDA;
2375 }
2376
2377 static void opt_lmin(const char *arg)
2378 {
2379     video_lmin = atof(arg)*FF_QP2LAMBDA;
2380 }
2381
2382 static void opt_qmin(const char *arg)
2383 {
2384     video_qmin = atoi(arg);
2385     if (video_qmin < 1 ||
2386         video_qmin > 51) {
2387         fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2388         exit(1);
2389     }
2390 }
2391
2392 static void opt_qmax(const char *arg)
2393 {
2394     video_qmax = atoi(arg);
2395     if (video_qmax < 1 ||
2396         video_qmax > 51) {
2397         fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2398         exit(1);
2399     }
2400 }
2401
2402 static void opt_mb_lmin(const char *arg)
2403 {
2404     video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2405     if (video_mb_lmin < 1 ||
2406         video_mb_lmin > FF_LAMBDA_MAX) {
2407         fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2408         exit(1);
2409     }
2410 }
2411
2412 static void opt_mb_lmax(const char *arg)
2413 {
2414     video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2415     if (video_mb_lmax < 1 ||
2416         video_mb_lmax > FF_LAMBDA_MAX) {
2417         fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2418         exit(1);
2419     }
2420 }
2421
2422 static void opt_qdiff(const char *arg)
2423 {
2424     video_qdiff = atoi(arg);
2425     if (video_qdiff < 0 ||
2426         video_qdiff > 31) {
2427         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2428         exit(1);
2429     }
2430 }
2431
2432 static void opt_packet_size(const char *arg)
2433 {
2434     packet_size= atoi(arg);
2435 }
2436
2437 static void opt_error_rate(const char *arg)
2438 {
2439     error_rate= atoi(arg);
2440 }
2441
2442 static void opt_strict(const char *arg)
2443 {
2444     strict= atoi(arg);
2445 }
2446
2447 static void opt_top_field_first(const char *arg)
2448 {
2449     top_field_first= atoi(arg);
2450 }
2451
2452 static void opt_sc_threshold(const char *arg)
2453 {
2454     sc_threshold= atoi(arg);
2455 }
2456
2457 static void opt_thread_count(const char *arg)
2458 {
2459     thread_count= atoi(arg);
2460 #if !defined(HAVE_THREADS)
2461     if (verbose >= 0)
2462         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2463 #endif
2464 }
2465
2466 static void opt_audio_bitrate(const char *arg)
2467 {
2468     audio_bit_rate = atoi(arg) * 1000;
2469 }
2470
2471 static void opt_audio_rate(const char *arg)
2472 {
2473     audio_sample_rate = atoi(arg);
2474 }
2475
2476 static void opt_audio_channels(const char *arg)
2477 {
2478     audio_channels = atoi(arg);
2479 }
2480
2481 static void opt_video_device(const char *arg)
2482 {
2483     video_device = av_strdup(arg);
2484 }
2485
2486 static void opt_grab_device(const char *arg)
2487 {
2488     grab_device = av_strdup(arg);
2489 }
2490
2491 static void opt_video_channel(const char *arg)
2492 {
2493     video_channel = strtol(arg, NULL, 0);
2494 }
2495
2496 static void opt_video_standard(const char *arg)
2497 {
2498     video_standard = av_strdup(arg);
2499 }
2500
2501 static void opt_audio_device(const char *arg)
2502 {
2503     audio_device = av_strdup(arg);
2504 }
2505
2506 static void opt_codec(int *pstream_copy, int *pcodec_id,
2507                       int codec_type, const char *arg)
2508 {
2509     AVCodec *p;
2510
2511     if (!strcmp(arg, "copy")) {
2512         *pstream_copy = 1;
2513     } else {
2514         p = first_avcodec;
2515         while (p) {
2516             if (!strcmp(p->name, arg) && p->type == codec_type)
2517                 break;
2518             p = p->next;
2519         }
2520         if (p == NULL) {
2521             fprintf(stderr, "Unknown codec '%s'\n", arg);
2522             exit(1);
2523         } else {
2524             *pcodec_id = p->id;
2525         }
2526     }
2527 }
2528
2529 static void opt_audio_codec(const char *arg)
2530 {
2531     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2532 }
2533
2534 static void opt_audio_tag(const char *arg)
2535 {
2536     char *tail;
2537     audio_codec_tag= strtol(arg, &tail, 0);
2538
2539     if(!tail || *tail)
2540         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2541 }
2542
2543 static void opt_video_tag(const char *arg)
2544 {
2545     char *tail;
2546     video_codec_tag= strtol(arg, &tail, 0);
2547
2548     if(!tail || *tail)
2549         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2550 }
2551
2552 static void add_frame_hooker(const char *arg)
2553 {
2554     int argc = 0;
2555     char *argv[64];
2556     int i;
2557     char *args = av_strdup(arg);
2558
2559     using_vhook = 1;
2560
2561     argv[0] = strtok(args, " ");
2562     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2563     }
2564
2565     i = frame_hook_add(argc, argv);
2566
2567     if (i != 0) {
2568         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2569         exit(1);
2570     }
2571 }
2572
2573 const char *motion_str[] = {
2574     "zero",
2575     "full",
2576     "log",
2577     "phods",
2578     "epzs",
2579     "x1",
2580     "hex",
2581     "umh",
2582     "iter",
2583     NULL,
2584 };
2585
2586 static void opt_motion_estimation(const char *arg)
2587 {
2588     const char **p;
2589     p = motion_str;
2590     for(;;) {
2591         if (!*p) {
2592             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2593             exit(1);
2594         }
2595         if (!strcmp(*p, arg))
2596             break;
2597         p++;
2598     }
2599     me_method = (p - motion_str) + 1;
2600 }
2601
2602 static void opt_video_codec(const char *arg)
2603 {
2604     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2605 }
2606
2607 static void opt_subtitle_codec(const char *arg)
2608 {
2609     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2610 }
2611
2612 static void opt_map(const char *arg)
2613 {
2614     AVStreamMap *m;
2615     const char *p;
2616
2617     p = arg;
2618     m = &stream_maps[nb_stream_maps++];
2619
2620     m->file_index = strtol(arg, (char **)&p, 0);
2621     if (*p)
2622         p++;
2623
2624     m->stream_index = strtol(p, (char **)&p, 0);
2625     if (*p) {
2626         p++;
2627         m->sync_file_index = strtol(p, (char **)&p, 0);
2628         if (*p)
2629             p++;
2630         m->sync_stream_index = strtol(p, (char **)&p, 0);
2631     } else {
2632         m->sync_file_index = m->file_index;
2633         m->sync_stream_index = m->stream_index;
2634     }
2635 }
2636
2637 static void opt_map_meta_data(const char *arg)
2638 {
2639     AVMetaDataMap *m;
2640     const char *p;
2641
2642     p = arg;
2643     m = &meta_data_maps[nb_meta_data_maps++];
2644
2645     m->out_file = strtol(arg, (char **)&p, 0);
2646     if (*p)
2647         p++;
2648
2649     m->in_file = strtol(p, (char **)&p, 0);
2650 }
2651
2652 static void opt_recording_time(const char *arg)
2653 {
2654     recording_time = parse_date(arg, 1);
2655 }
2656
2657 static void opt_start_time(const char *arg)
2658 {
2659     start_time = parse_date(arg, 1);
2660 }
2661
2662 static void opt_rec_timestamp(const char *arg)
2663 {
2664     rec_timestamp = parse_date(arg, 0) / 1000000;
2665 }
2666
2667 static void opt_input_ts_offset(const char *arg)
2668 {
2669     input_ts_offset = parse_date(arg, 1);
2670 }
2671
2672 static void opt_input_file(const char *filename)
2673 {
2674     AVFormatContext *ic;
2675     AVFormatParameters params, *ap = &params;
2676     int err, i, ret, rfps, rfps_base;
2677     int64_t timestamp;
2678
2679     if (!strcmp(filename, "-"))
2680         filename = "pipe:";
2681
2682     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2683                    !strcmp( filename, "/dev/stdin" );
2684
2685     /* get default parameters from command line */
2686     ic = av_alloc_format_context();
2687
2688     memset(ap, 0, sizeof(*ap));
2689     ap->prealloced_context = 1;
2690     ap->sample_rate = audio_sample_rate;
2691     ap->channels = audio_channels;
2692     ap->time_base.den = frame_rate;
2693     ap->time_base.num = frame_rate_base;
2694     ap->width = frame_width + frame_padleft + frame_padright;
2695     ap->height = frame_height + frame_padtop + frame_padbottom;
2696     ap->image_format = image_format;
2697     ap->pix_fmt = frame_pix_fmt;
2698     ap->device  = grab_device;
2699     ap->channel = video_channel;
2700     ap->standard = video_standard;
2701     ap->video_codec_id = video_codec_id;
2702     ap->audio_codec_id = audio_codec_id;
2703     if(pgmyuv_compatibility_hack)
2704         ap->video_codec_id= CODEC_ID_PGMYUV;
2705
2706     for(i=0; i<opt_name_count; i++){
2707         AVOption *opt;
2708         double d= av_get_double(avformat_opts, opt_names[i], &opt);
2709         if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2710             av_set_double(ic, opt_names[i], d);
2711     }
2712     /* open the input file with generic libav function */
2713     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2714     if (err < 0) {
2715         print_error(filename, err);
2716         exit(1);
2717     }
2718
2719     ic->loop_input = loop_input;
2720
2721     /* If not enough info to get the stream parameters, we decode the
2722        first frames to get it. (used in mpeg case for example) */
2723     ret = av_find_stream_info(ic);
2724     if (ret < 0 && verbose >= 0) {
2725         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2726         exit(1);
2727     }
2728
2729     timestamp = start_time;
2730     /* add the stream start time */
2731     if (ic->start_time != AV_NOPTS_VALUE)
2732         timestamp += ic->start_time;
2733
2734     /* if seeking requested, we execute it */
2735     if (start_time != 0) {
2736         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2737         if (ret < 0) {
2738             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2739                     filename, (double)timestamp / AV_TIME_BASE);
2740         }
2741         /* reset seek info */
2742         start_time = 0;
2743     }
2744
2745     /* update the current parameters so that they match the one of the input stream */
2746     for(i=0;i<ic->nb_streams;i++) {
2747         int j;
2748         AVCodecContext *enc = ic->streams[i]->codec;
2749 #if defined(HAVE_THREADS)
2750         if(thread_count>1)
2751             avcodec_thread_init(enc, thread_count);
2752 #endif
2753         enc->thread_count= thread_count;
2754         switch(enc->codec_type) {
2755         case CODEC_TYPE_AUDIO:
2756             for(j=0; j<opt_name_count; j++){
2757                 AVOption *opt;
2758                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2759                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2760                     av_set_double(enc, opt_names[j], d);
2761             }
2762             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2763             audio_channels = enc->channels;
2764             audio_sample_rate = enc->sample_rate;
2765             if(audio_disable)
2766                 ic->streams[i]->discard= AVDISCARD_ALL;
2767             break;
2768         case CODEC_TYPE_VIDEO:
2769             for(j=0; j<opt_name_count; j++){
2770                 AVOption *opt;
2771                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2772                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2773                     av_set_double(enc, opt_names[j], d);
2774             }
2775             frame_height = enc->height;
2776             frame_width = enc->width;
2777             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2778             frame_pix_fmt = enc->pix_fmt;
2779             rfps      = ic->streams[i]->r_frame_rate.num;
2780             rfps_base = ic->streams[i]->r_frame_rate.den;
2781             enc->workaround_bugs = workaround_bugs;
2782             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2783             if(me_threshold)
2784                 enc->debug |= FF_DEBUG_MV;
2785
2786             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2787
2788                 if (verbose >= 0)
2789                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2790                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2791
2792                     (float)rfps / rfps_base, rfps, rfps_base);
2793             }
2794             /* update the current frame rate to match the stream frame rate */
2795             frame_rate      = rfps;
2796             frame_rate_base = rfps_base;
2797
2798             enc->rate_emu = rate_emu;
2799             if(video_disable)
2800                 ic->streams[i]->discard= AVDISCARD_ALL;
2801             else if(video_discard)
2802                 ic->streams[i]->discard= video_discard;
2803             break;
2804         case CODEC_TYPE_DATA:
2805             break;
2806         case CODEC_TYPE_SUBTITLE:
2807             break;
2808         case CODEC_TYPE_UNKNOWN:
2809             break;
2810         default:
2811             av_abort();
2812         }
2813     }
2814
2815     input_files[nb_input_files] = ic;
2816     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2817     /* dump the file content */
2818     if (verbose >= 0)
2819         dump_format(ic, nb_input_files, filename, 0);
2820
2821     nb_input_files++;
2822     file_iformat = NULL;
2823     file_oformat = NULL;
2824     image_format = NULL;
2825
2826     grab_device = NULL;
2827     video_channel = 0;
2828
2829     rate_emu = 0;
2830 }
2831
2832 static void opt_grab(const char *arg)
2833 {
2834     file_iformat = av_find_input_format(arg);
2835     opt_input_file("");
2836 }
2837
2838 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2839 {
2840     int has_video, has_audio, i, j;
2841     AVFormatContext *ic;
2842
2843     has_video = 0;
2844     has_audio = 0;
2845     for(j=0;j<nb_input_files;j++) {
2846         ic = input_files[j];
2847         for(i=0;i<ic->nb_streams;i++) {
2848             AVCodecContext *enc = ic->streams[i]->codec;
2849             switch(enc->codec_type) {
2850             case CODEC_TYPE_AUDIO:
2851                 has_audio = 1;
2852                 break;
2853             case CODEC_TYPE_VIDEO:
2854                 has_video = 1;
2855                 break;
2856             case CODEC_TYPE_DATA:
2857             case CODEC_TYPE_UNKNOWN:
2858             case CODEC_TYPE_SUBTITLE:
2859                 break;
2860             default:
2861                 av_abort();
2862             }
2863         }
2864     }
2865     *has_video_ptr = has_video;
2866     *has_audio_ptr = has_audio;
2867 }
2868
2869 static void new_video_stream(AVFormatContext *oc)
2870 {
2871     AVStream *st;
2872     AVCodecContext *video_enc;
2873     int codec_id;
2874
2875     st = av_new_stream(oc, oc->nb_streams);
2876     if (!st) {
2877         fprintf(stderr, "Could not alloc stream\n");
2878         exit(1);
2879     }
2880     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2881     video_bitstream_filters= NULL;
2882
2883 #if defined(HAVE_THREADS)
2884     if(thread_count>1)
2885         avcodec_thread_init(st->codec, thread_count);
2886 #endif
2887
2888     video_enc = st->codec;
2889
2890     if(video_codec_tag)
2891         video_enc->codec_tag= video_codec_tag;
2892
2893     if(   (video_global_header&1)
2894        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2895         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2896         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2897     }
2898     if(video_global_header&2){
2899         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2900         avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2901     }
2902
2903     if (video_stream_copy) {
2904         st->stream_copy = 1;
2905         video_enc->codec_type = CODEC_TYPE_VIDEO;
2906     } else {
2907         char *p;
2908         int i;
2909         AVCodec *codec;
2910
2911         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2912         if (video_codec_id != CODEC_ID_NONE)
2913             codec_id = video_codec_id;
2914
2915         video_enc->codec_id = codec_id;
2916         codec = avcodec_find_encoder(codec_id);
2917
2918         for(i=0; i<opt_name_count; i++){
2919              AVOption *opt;
2920              double d= av_get_double(avctx_opts, opt_names[i], &opt);
2921              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2922                  av_set_double(video_enc, opt_names[i], d);
2923         }
2924
2925         video_enc->time_base.den = frame_rate;
2926         video_enc->time_base.num = frame_rate_base;
2927         if(codec && codec->supported_framerates){
2928             const AVRational *p= codec->supported_framerates;
2929             AVRational req= (AVRational){frame_rate, frame_rate_base};
2930             const AVRational *best=NULL;
2931             AVRational best_error= (AVRational){INT_MAX, 1};
2932             for(; p->den!=0; p++){
2933                 AVRational error= av_sub_q(req, *p);
2934                 if(error.num <0) error.num *= -1;
2935                 if(av_cmp_q(error, best_error) < 0){
2936                     best_error= error;
2937                     best= p;
2938                 }
2939             }
2940             video_enc->time_base.den= best->num;
2941             video_enc->time_base.num= best->den;
2942         }
2943
2944         video_enc->width = frame_width + frame_padright + frame_padleft;
2945         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2946         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2947         video_enc->pix_fmt = frame_pix_fmt;
2948
2949         if(codec && codec->pix_fmts){
2950             const enum PixelFormat *p= codec->pix_fmts;
2951             for(; *p!=-1; p++){
2952                 if(*p == video_enc->pix_fmt)
2953                     break;
2954             }
2955             if(*p == -1)
2956                 video_enc->pix_fmt = codec->pix_fmts[0];
2957         }
2958
2959         if (intra_only)
2960             video_enc->gop_size = 0;
2961         if (video_qscale || same_quality) {
2962             video_enc->flags |= CODEC_FLAG_QSCALE;
2963             video_enc->global_quality=
2964                 st->quality = FF_QP2LAMBDA * video_qscale;
2965         }
2966
2967         if(intra_matrix)
2968             video_enc->intra_matrix = intra_matrix;
2969         if(inter_matrix)
2970             video_enc->inter_matrix = inter_matrix;
2971
2972         video_enc->max_b_frames = b_frames;
2973         video_enc->qmin = video_qmin;
2974         video_enc->qmax = video_qmax;
2975         video_enc->lmin = video_lmin;
2976         video_enc->lmax = video_lmax;
2977         video_enc->rc_qsquish = video_qsquish;
2978         video_enc->mb_lmin = video_mb_lmin;
2979         video_enc->mb_lmax = video_mb_lmax;
2980         video_enc->max_qdiff = video_qdiff;
2981         video_enc->rc_eq = video_rc_eq;
2982         video_enc->workaround_bugs = workaround_bugs;
2983         video_enc->thread_count = thread_count;
2984         p= video_rc_override_string;
2985         for(i=0; p; i++){
2986             int start, end, q;
2987             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2988             if(e!=3){
2989                 fprintf(stderr, "error parsing rc_override\n");
2990                 exit(1);
2991             }
2992             video_enc->rc_override=
2993                 av_realloc(video_enc->rc_override,
2994                            sizeof(RcOverride)*(i+1));
2995             video_enc->rc_override[i].start_frame= start;
2996             video_enc->rc_override[i].end_frame  = end;
2997             if(q>0){
2998                 video_enc->rc_override[i].qscale= q;
2999                 video_enc->rc_override[i].quality_factor= 1.0;
3000             }
3001             else{
3002                 video_enc->rc_override[i].qscale= 0;
3003                 video_enc->rc_override[i].quality_factor= -q/100.0;
3004             }
3005             p= strchr(p, '/');
3006             if(p) p++;
3007         }
3008         video_enc->rc_override_count=i;
3009         video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3010         video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3011         video_enc->me_threshold= me_threshold;
3012         video_enc->mb_threshold= mb_threshold;
3013         video_enc->intra_dc_precision= intra_dc_precision - 8;
3014         video_enc->strict_std_compliance = strict;
3015         video_enc->error_rate = error_rate;
3016         video_enc->scenechange_threshold= sc_threshold;
3017         video_enc->me_penalty_compensation= me_penalty_compensation;
3018         video_enc->frame_skip_threshold= frame_skip_threshold;
3019         video_enc->frame_skip_factor= frame_skip_factor;
3020         video_enc->frame_skip_exp= frame_skip_exp;
3021
3022         if(packet_size){
3023             video_enc->rtp_mode= 1;
3024             video_enc->rtp_payload_size= packet_size;
3025         }
3026
3027         if (do_psnr)
3028             video_enc->flags|= CODEC_FLAG_PSNR;
3029
3030         video_enc->me_method = me_method;
3031
3032         /* two pass mode */
3033         if (do_pass) {
3034             if (do_pass == 1) {
3035                 video_enc->flags |= CODEC_FLAG_PASS1;
3036             } else {
3037                 video_enc->flags |= CODEC_FLAG_PASS2;
3038             }
3039         }
3040     }
3041
3042     /* reset some key parameters */
3043     video_disable = 0;
3044     video_codec_id = CODEC_ID_NONE;
3045     video_stream_copy = 0;
3046 }
3047
3048 static void new_audio_stream(AVFormatContext *oc)
3049 {
3050     AVStream *st;
3051     AVCodecContext *audio_enc;
3052     int codec_id, i;
3053
3054     st = av_new_stream(oc, oc->nb_streams);
3055     if (!st) {
3056         fprintf(stderr, "Could not alloc stream\n");
3057         exit(1);
3058     }
3059
3060     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3061     audio_bitstream_filters= NULL;
3062
3063 #if defined(HAVE_THREADS)
3064     if(thread_count>1)
3065         avcodec_thread_init(st->codec, thread_count);
3066 #endif
3067
3068     audio_enc = st->codec;
3069     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3070
3071     if(audio_codec_tag)
3072         audio_enc->codec_tag= audio_codec_tag;
3073
3074     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3075         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3076         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3077     }
3078     if (audio_stream_copy) {
3079         st->stream_copy = 1;
3080         audio_enc->channels = audio_channels;
3081     } else {
3082         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3083
3084         for(i=0; i<opt_name_count; i++){
3085             AVOption *opt;
3086             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3087             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3088                 av_set_double(audio_enc, opt_names[i], d);
3089         }
3090
3091         if (audio_codec_id != CODEC_ID_NONE)
3092             codec_id = audio_codec_id;
3093         audio_enc->codec_id = codec_id;
3094
3095         audio_enc->bit_rate = audio_bit_rate;
3096         if (audio_qscale > QSCALE_NONE) {
3097             audio_enc->flags |= CODEC_FLAG_QSCALE;
3098             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3099         }
3100         audio_enc->strict_std_compliance = strict;
3101         audio_enc->thread_count = thread_count;
3102         /* For audio codecs other than AC3 or DTS we limit */
3103         /* the number of coded channels to stereo   */
3104         if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3105             && codec_id != CODEC_ID_DTS) {
3106             audio_enc->channels = 2;
3107         } else
3108             audio_enc->channels = audio_channels;
3109     }
3110     audio_enc->sample_rate = audio_sample_rate;
3111     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3112     if (audio_language) {
3113         pstrcpy(st->language, sizeof(st->language), audio_language);
3114         av_free(audio_language);
3115         audio_language = NULL;
3116     }
3117
3118     /* reset some key parameters */
3119     audio_disable = 0;
3120     audio_codec_id = CODEC_ID_NONE;
3121     audio_stream_copy = 0;
3122 }
3123
3124 static void opt_new_subtitle_stream(void)
3125 {
3126     AVFormatContext *oc;
3127     AVStream *st;
3128     AVCodecContext *subtitle_enc;
3129     int i;
3130
3131     if (nb_output_files <= 0) {
3132         fprintf(stderr, "At least one output file must be specified\n");
3133         exit(1);
3134     }
3135     oc = output_files[nb_output_files - 1];
3136
3137     st = av_new_stream(oc, oc->nb_streams);
3138     if (!st) {
3139         fprintf(stderr, "Could not alloc stream\n");
3140         exit(1);
3141     }
3142
3143     subtitle_enc = st->codec;
3144     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3145     if (subtitle_stream_copy) {
3146         st->stream_copy = 1;
3147     } else {
3148         for(i=0; i<opt_name_count; i++){
3149              AVOption *opt;
3150              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3151              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3152                  av_set_double(subtitle_enc, opt_names[i], d);
3153         }
3154         subtitle_enc->codec_id = subtitle_codec_id;
3155     }
3156
3157     if (subtitle_language) {
3158         pstrcpy(st->language, sizeof(st->language), subtitle_language);
3159         av_free(subtitle_language);
3160         subtitle_language = NULL;
3161     }
3162
3163     subtitle_codec_id = CODEC_ID_NONE;
3164     subtitle_stream_copy = 0;
3165 }
3166
3167 static void opt_new_audio_stream(void)
3168 {
3169     AVFormatContext *oc;
3170     if (nb_output_files <= 0) {
3171         fprintf(stderr, "At least one output file must be specified\n");
3172         exit(1);
3173     }
3174     oc = output_files[nb_output_files - 1];
3175     new_audio_stream(oc);
3176 }
3177
3178 static void opt_new_video_stream(void)
3179 {
3180     AVFormatContext *oc;
3181     if (nb_output_files <= 0) {
3182         fprintf(stderr, "At least one output file must be specified\n");
3183         exit(1);
3184     }
3185     oc = output_files[nb_output_files - 1];
3186     new_video_stream(oc);
3187 }
3188
3189 static void opt_output_file(const char *filename)
3190 {
3191     AVFormatContext *oc;
3192     int use_video, use_audio, input_has_video, input_has_audio, i;
3193     AVFormatParameters params, *ap = &params;
3194
3195     if (!strcmp(filename, "-"))
3196         filename = "pipe:";
3197
3198     oc = av_alloc_format_context();
3199
3200     if (!file_oformat) {
3201         file_oformat = guess_format(NULL, filename, NULL);
3202         if (!file_oformat) {
3203             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3204                     filename);
3205             exit(1);
3206         }
3207     }
3208
3209     oc->oformat = file_oformat;
3210     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3211
3212     if (!strcmp(file_oformat->name, "ffm") &&
3213         strstart(filename, "http:", NULL)) {
3214         /* special case for files sent to ffserver: we get the stream
3215            parameters from ffserver */
3216         if (read_ffserver_streams(oc, filename) < 0) {
3217             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3218             exit(1);
3219         }
3220     } else {
3221         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3222         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3223
3224         /* disable if no corresponding type found and at least one
3225            input file */
3226         if (nb_input_files > 0) {
3227             check_audio_video_inputs(&input_has_video, &input_has_audio);
3228             if (!input_has_video)
3229                 use_video = 0;
3230             if (!input_has_audio)
3231                 use_audio = 0;
3232         }
3233
3234         /* manual disable */
3235         if (audio_disable) {
3236             use_audio = 0;
3237         }
3238         if (video_disable) {
3239             use_video = 0;
3240         }
3241
3242         if (use_video) {
3243             new_video_stream(oc);
3244         }
3245
3246         if (use_audio) {
3247             new_audio_stream(oc);
3248         }
3249
3250         if (!oc->nb_streams) {
3251             fprintf(stderr, "No audio or video streams available\n");
3252             exit(1);
3253         }
3254
3255         oc->timestamp = rec_timestamp;
3256
3257         if (str_title)
3258             pstrcpy(oc->title, sizeof(oc->title), str_title);
3259         if (str_author)
3260             pstrcpy(oc->author, sizeof(oc->author), str_author);
3261         if (str_copyright)
3262             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3263         if (str_comment)
3264             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3265         if (str_album)
3266             pstrcpy(oc->album, sizeof(oc->album), str_album);
3267     }
3268
3269     output_files[nb_output_files++] = oc;
3270
3271     /* check filename in case of an image number is expected */
3272     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3273         if (!av_filename_number_test(oc->filename)) {
3274             print_error(oc->filename, AVERROR_NUMEXPECTED);
3275             exit(1);
3276         }
3277     }
3278
3279     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3280         /* test if it already exists to avoid loosing precious files */
3281         if (!file_overwrite &&
3282             (strchr(filename, ':') == NULL ||
3283              strstart(filename, "file:", NULL))) {
3284             if (url_exist(filename)) {
3285                 int c;
3286
3287                 if ( !using_stdin ) {
3288                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3289                     fflush(stderr);
3290                     c = getchar();
3291                     if (toupper(c) != 'Y') {
3292                         fprintf(stderr, "Not overwriting - exiting\n");
3293                         exit(1);
3294                     }
3295                                 }
3296                                 else {
3297                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3298                     exit(1);
3299                                 }
3300             }
3301         }
3302
3303         /* open the file */
3304         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3305             fprintf(stderr, "Could not open '%s'\n", filename);
3306             exit(1);
3307         }
3308     }
3309
3310     memset(ap, 0, sizeof(*ap));
3311     ap->image_format = image_format;
3312     if (av_set_parameters(oc, ap) < 0) {
3313         fprintf(stderr, "%s: Invalid encoding parameters\n",
3314                 oc->filename);
3315         exit(1);
3316     }
3317
3318     oc->packet_size= mux_packet_size;
3319     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3320     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3321     oc->loop_output = loop_output;
3322
3323     for(i=0; i<opt_name_count; i++){
3324         AVOption *opt;
3325         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3326         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3327             av_set_double(oc, opt_names[i], d);
3328     }
3329
3330     /* reset some options */
3331     file_oformat = NULL;
3332     file_iformat = NULL;
3333     image_format = NULL;
3334 }
3335
3336 /* prepare dummy protocols for grab */
3337 static void prepare_grab(void)
3338 {
3339     int has_video, has_audio, i, j;
3340     AVFormatContext *oc;
3341     AVFormatContext *ic;
3342     AVFormatParameters vp1, *vp = &vp1;
3343     AVFormatParameters ap1, *ap = &ap1;
3344
3345     /* see if audio/video inputs are needed */
3346     has_video = 0;
3347     has_audio = 0;
3348     memset(ap, 0, sizeof(*ap));
3349     memset(vp, 0, sizeof(*vp));
3350     vp->time_base.num= 1;
3351     for(j=0;j<nb_output_files;j++) {
3352         oc = output_files[j];
3353         for(i=0;i<oc->nb_streams;i++) {
3354             AVCodecContext *enc = oc->streams[i]->codec;
3355             switch(enc->codec_type) {
3356             case CODEC_TYPE_AUDIO:
3357                 if (enc->sample_rate > ap->sample_rate)
3358                     ap->sample_rate = enc->sample_rate;
3359                 if (enc->channels > ap->channels)
3360                     ap->channels = enc->channels;
3361                 has_audio = 1;
3362                 break;
3363             case CODEC_TYPE_VIDEO:
3364                 if (enc->width > vp->width)
3365                     vp->width = enc->width;
3366                 if (enc->height > vp->height)
3367                     vp->height = enc->height;
3368
3369                 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3370                     vp->time_base = enc->time_base;
3371                     vp->width += frame_leftBand + frame_rightBand;
3372                     vp->width -= (frame_padleft + frame_padright);
3373                     vp->height += frame_topBand + frame_bottomBand;
3374                     vp->height -= (frame_padtop + frame_padbottom);
3375                 }
3376                 has_video = 1;
3377                 break;
3378             default:
3379                 av_abort();
3380             }
3381         }
3382     }
3383
3384     if (has_video == 0 && has_audio == 0) {
3385         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3386         exit(1);
3387     }
3388
3389     if (has_video) {
3390         AVInputFormat *fmt1;
3391         fmt1 = av_find_input_format(video_grab_format);
3392         vp->device  = video_device;
3393         vp->channel = video_channel;
3394         vp->standard = video_standard;
3395         vp->pix_fmt = frame_pix_fmt;
3396         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3397             fprintf(stderr, "Could not find video grab device\n");
3398             exit(1);
3399         }
3400         /* If not enough info to get the stream parameters, we decode the
3401            first frames to get it. */
3402         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3403             fprintf(stderr, "Could not find video grab parameters\n");
3404             exit(1);
3405         }
3406         /* by now video grab has one stream */
3407         ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3408         ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3409         input_files[nb_input_files] = ic;
3410
3411         if (verbose >= 0)
3412             dump_format(ic, nb_input_files, "", 0);
3413
3414         nb_input_files++;
3415     }
3416     if (has_audio && audio_grab_format) {
3417         AVInputFormat *fmt1;
3418         fmt1 = av_find_input_format(audio_grab_format);
3419         ap->device = audio_device;
3420         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3421             fprintf(stderr, "Could not find audio grab device\n");
3422             exit(1);
3423         }
3424         input_files[nb_input_files] = ic;
3425
3426         if (verbose >= 0)
3427             dump_format(ic, nb_input_files, "", 0);
3428
3429         nb_input_files++;
3430     }
3431 }
3432
3433 /* same option as mencoder */
3434 static void opt_pass(const char *pass_str)
3435 {
3436     int pass;
3437     pass = atoi(pass_str);
3438     if (pass != 1 && pass != 2) {
3439         fprintf(stderr, "pass number can be only 1 or 2\n");
3440         exit(1);
3441     }
3442     do_pass = pass;
3443 }
3444
3445 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3446 static int64_t getutime(void)
3447 {
3448   return av_gettime();
3449 }
3450 #else
3451 static int64_t getutime(void)
3452 {
3453     struct rusage rusage;
3454
3455     getrusage(RUSAGE_SELF, &rusage);
3456     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3457 }
3458 #endif
3459
3460 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3461 extern int ffm_nopts;
3462 #endif
3463
3464 static void show_formats(void)
3465 {
3466     AVInputFormat *ifmt;
3467     AVOutputFormat *ofmt;
3468     AVImageFormat *image_fmt;
3469     URLProtocol *up;
3470     AVCodec *p, *p2;
3471     const char **pp, *last_name;
3472
3473     printf("File formats:\n");
3474     last_name= "000";
3475     for(;;){
3476         int decode=0;
3477         int encode=0;
3478         const char *name=NULL;
3479         const char *long_name=NULL;
3480
3481         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3482             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3483                 strcmp(ofmt->name, last_name)>0){
3484                 name= ofmt->name;
3485                 long_name= ofmt->long_name;
3486                 encode=1;
3487             }
3488         }
3489         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3490             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3491                 strcmp(ifmt->name, last_name)>0){
3492                 name= ifmt->name;
3493                 long_name= ifmt->long_name;
3494                 encode=0;
3495             }
3496             if(name && strcmp(ifmt->name, name)==0)
3497                 decode=1;
3498         }
3499         if(name==NULL)
3500             break;
3501         last_name= name;
3502
3503         printf(
3504             " %s%s %-15s %s\n",
3505             decode ? "D":" ",
3506             encode ? "E":" ",
3507             name,
3508             long_name ? long_name:" ");
3509     }
3510     printf("\n");
3511
3512     printf("Image formats (filename extensions, if any, follow):\n");
3513     for(image_fmt = first_image_format; image_fmt != NULL;
3514         image_fmt = image_fmt->next) {
3515         printf(
3516             " %s%s %-6s %s\n",
3517             image_fmt->img_read  ? "D":" ",
3518             image_fmt->img_write ? "E":" ",
3519             image_fmt->name,
3520             image_fmt->extensions ? image_fmt->extensions:" ");
3521     }
3522     printf("\n");
3523
3524     printf("Codecs:\n");
3525     last_name= "000";
3526     for(;;){
3527         int decode=0;
3528         int encode=0;
3529         int cap=0;
3530         const char *type_str;
3531
3532         p2=NULL;
3533         for(p = first_avcodec; p != NULL; p = p->next) {
3534             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3535                 strcmp(p->name, last_name)>0){
3536                 p2= p;
3537                 decode= encode= cap=0;
3538             }
3539             if(p2 && strcmp(p->name, p2->name)==0){
3540                 if(p->decode) decode=1;
3541                 if(p->encode) encode=1;
3542                 cap |= p->capabilities;
3543             }
3544         }
3545         if(p2==NULL)
3546             break;
3547         last_name= p2->name;
3548
3549         switch(p2->type) {
3550         case CODEC_TYPE_VIDEO:
3551             type_str = "V";
3552             break;
3553         case CODEC_TYPE_AUDIO:
3554             type_str = "A";
3555             break;
3556         case CODEC_TYPE_SUBTITLE:
3557             type_str = "S";
3558             break;
3559         default:
3560             type_str = "?";
3561             break;
3562         }
3563         printf(
3564             " %s%s%s%s%s%s %s",
3565             decode ? "D": (/*p2->decoder ? "d":*/" "),
3566             encode ? "E":" ",
3567             type_str,
3568             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3569             cap & CODEC_CAP_DR1 ? "D":" ",
3570             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3571             p2->name);
3572        /* if(p2->decoder && decode==0)
3573             printf(" use %s for decoding", p2->decoder->name);*/
3574         printf("\n");
3575     }
3576     printf("\n");
3577
3578     printf("Supported file protocols:\n");
3579     for(up = first_protocol; up != NULL; up = up->next)
3580         printf(" %s:", up->name);
3581     printf("\n");
3582
3583     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3584     printf("Motion estimation methods:\n");
3585     pp = motion_str;
3586     while (*pp) {
3587         printf(" %s", *pp);
3588         if ((pp - motion_str + 1) == ME_ZERO)
3589             printf("(fastest)");
3590         else if ((pp - motion_str + 1) == ME_FULL)
3591             printf("(slowest)");
3592         else if ((pp - motion_str + 1) == ME_EPZS)
3593             printf("(default)");
3594         pp++;
3595     }
3596     printf("\n\n");
3597     printf(
3598 "Note, the names of encoders and decoders dont always match, so there are\n"
3599 "several cases where the above table shows encoder only or decoder only entries\n"
3600 "even though both encoding and decoding are supported for example, the h263\n"
3601 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3602 "worse\n");
3603     exit(1);
3604 }
3605
3606 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3607 {
3608     int i;
3609     const char *p = str;
3610     for(i = 0;; i++) {
3611         dest[i] = atoi(p);
3612         if(i == 63)
3613             break;
3614         p = strchr(p, ',');
3615         if(!p) {
3616             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3617             exit(1);
3618         }
3619         p++;
3620     }
3621 }
3622
3623 static void opt_inter_matrix(const char *arg)
3624 {
3625     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3626     parse_matrix_coeffs(inter_matrix, arg);
3627 }
3628
3629 static void opt_intra_matrix(const char *arg)
3630 {
3631     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3632     parse_matrix_coeffs(intra_matrix, arg);
3633 }
3634
3635 static void opt_target(const char *arg)
3636 {
3637     int norm = -1;
3638     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3639
3640     if(!strncmp(arg, "pal-", 4)) {
3641         norm = 0;
3642         arg += 4;
3643     } else if(!strncmp(arg, "ntsc-", 5)) {
3644         norm = 1;
3645         arg += 5;
3646     } else if(!strncmp(arg, "film-", 5)) {
3647         norm = 2;
3648         arg += 5;
3649     } else {
3650         int fr;
3651         /* Calculate FR via float to avoid int overflow */
3652         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3653         if(fr == 25000) {
3654             norm = 0;
3655         } else if((fr == 29970) || (fr == 23976)) {
3656             norm = 1;
3657         } else {
3658             /* Try to determine PAL/NTSC by peeking in the input files */
3659             if(nb_input_files) {
3660                 int i, j;
3661                 for(j = 0; j < nb_input_files; j++) {
3662                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3663                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3664                         if(c->codec_type != CODEC_TYPE_VIDEO)
3665                             continue;
3666                         fr = c->time_base.den * 1000 / c->time_base.num;
3667                         if(fr == 25000) {
3668                             norm = 0;
3669                             break;
3670                         } else if((fr == 29970) || (fr == 23976)) {
3671                             norm = 1;
3672                             break;
3673                         }
3674                     }
3675                     if(norm >= 0)
3676                         break;
3677                 }
3678             }
3679         }
3680         if(verbose && norm >= 0)
3681             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3682     }
3683
3684     if(norm < 0) {
3685         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3686         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3687         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3688         exit(1);
3689     }
3690
3691     if(!strcmp(arg, "vcd")) {
3692
3693         opt_video_codec("mpeg1video");
3694         opt_audio_codec("mp2");
3695         opt_format("vcd");
3696
3697         opt_frame_size(norm ? "352x240" : "352x288");
3698         opt_frame_rate(frame_rates[norm]);
3699         opt_default("gop", norm ? "18" : "15");
3700
3701         opt_default("b", "1150000");
3702         opt_default("maxrate", "1150000");
3703         opt_default("minrate", "1150000");
3704         opt_default("bufsize", "327680"); // 40*1024*8;
3705
3706         audio_bit_rate = 224000;
3707         audio_sample_rate = 44100;
3708
3709         mux_packet_size= 2324;
3710         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3711
3712         /* We have to offset the PTS, so that it is consistent with the SCR.
3713            SCR starts at 36000, but the first two packs contain only padding
3714            and the first pack from the other stream, respectively, may also have
3715            been written before.
3716            So the real data starts at SCR 36000+3*1200. */
3717         mux_preload= (36000+3*1200) / 90000.0; //0.44
3718     } else if(!strcmp(arg, "svcd")) {
3719
3720         opt_video_codec("mpeg2video");
3721         opt_audio_codec("mp2");
3722         opt_format("svcd");
3723
3724         opt_frame_size(norm ? "480x480" : "480x576");
3725         opt_frame_rate(frame_rates[norm]);
3726         opt_default("gop", norm ? "18" : "15");
3727
3728         opt_default("b", "2040000");
3729         opt_default("maxrate", "2516000");
3730         opt_default("minrate", "0"); //1145000;
3731         opt_default("bufsize", "1835008"); //224*1024*8;
3732         opt_default("flags", "+SCAN_OFFSET");
3733
3734
3735         audio_bit_rate = 224000;
3736         audio_sample_rate = 44100;
3737
3738         mux_packet_size= 2324;
3739
3740     } else if(!strcmp(arg, "dvd")) {
3741
3742         opt_video_codec("mpeg2video");
3743         opt_audio_codec("ac3");
3744         opt_format("dvd");
3745
3746         opt_frame_size(norm ? "720x480" : "720x576");
3747         opt_frame_rate(frame_rates[norm]);
3748         opt_default("gop", norm ? "18" : "15");
3749
3750         opt_default("b", "6000000");
3751         opt_default("maxrate", "9000000");
3752         opt_default("minrate", "0"); //1500000;
3753         opt_default("bufsize", "1835008"); //224*1024*8;
3754
3755         mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3756         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3757
3758         audio_bit_rate = 448000;
3759         audio_sample_rate = 48000;
3760
3761     } else if(!strncmp(arg, "dv", 2)) {
3762
3763         opt_format("dv");
3764
3765         opt_frame_size(norm ? "720x480" : "720x576");
3766         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3767                                              (norm ? "yuv411p" : "yuv420p"));
3768         opt_frame_rate(frame_rates[norm]);
3769
3770         audio_sample_rate = 48000;
3771         audio_channels = 2;
3772
3773     } else {
3774         fprintf(stderr, "Unknown target: %s\n", arg);
3775         exit(1);
3776     }
3777 }
3778
3779 static void opt_video_bsf(const char *arg)
3780 {
3781     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3782     AVBitStreamFilterContext **bsfp;
3783
3784     if(!bsfc){
3785         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3786         exit(1);
3787     }
3788
3789     bsfp= &video_bitstream_filters;
3790     while(*bsfp)
3791         bsfp= &(*bsfp)->next;
3792
3793     *bsfp= bsfc;
3794 }
3795
3796 //FIXME avoid audio - video code duplication
3797 static void opt_audio_bsf(const char *arg)
3798 {
3799     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3800     AVBitStreamFilterContext **bsfp;
3801
3802     if(!bsfc){
3803         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3804         exit(1);
3805     }
3806
3807     bsfp= &audio_bitstream_filters;
3808     while(*bsfp)
3809         bsfp= &(*bsfp)->next;
3810
3811     *bsfp= bsfc;
3812 }
3813
3814 static void show_version(void)
3815 {
3816     /* TODO: add function interface to avutil and avformat */
3817     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3818            "libavutil   %d\n"
3819            "libavcodec  %d\n"
3820            "libavformat %d\n",
3821            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3822     exit(1);
3823 }
3824
3825 static int opt_default(const char *opt, const char *arg){
3826     AVOption *o= av_set_string(avctx_opts, opt, arg);
3827     if(!o)
3828         o = av_set_string(avformat_opts, opt, arg);
3829     if(!o)
3830         return -1;
3831
3832 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3833
3834     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3835     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3836     opt_names[opt_name_count++]= o->name;
3837
3838 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3839     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3840     if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3841         ffm_nopts = 1;
3842 #endif
3843
3844     if(avctx_opts->debug)
3845         av_log_set_level(AV_LOG_DEBUG);
3846     return 0;
3847 }
3848
3849 const OptionDef options[] = {
3850     /* main options */
3851     { "L", 0, {(void*)show_license}, "show license" },
3852     { "h", 0, {(void*)show_help}, "show help" },
3853     { "version", 0, {(void*)show_version}, "show version" },
3854     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3855     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3856     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3857     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3858     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3859     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3860     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3861     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3862     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3863     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3864     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3865     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3866     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3867     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3868     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3869     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3870     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3871     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3872       "add timings for benchmarking" },
3873     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3874       "dump each input packet" },
3875     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3876       "when dumping packets, also dump the payload" },
3877     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3878     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3879     { "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)", "" },
3880     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3881     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3882     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3883     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3884     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3885     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3886     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3887     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3888     { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3889
3890     /* video options */
3891     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3892     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3893     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3894     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3895     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3896     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3897     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3898     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3899     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3900     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3901     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3902     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3903     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3904     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3905     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3906     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3907     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3908     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3909     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3910     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3911     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3912     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3913     { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3914     { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3915     { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3916     { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3917     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3918     { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
3919     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3920     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3921     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3922     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3923       "method" },
3924     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3925     { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3926     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3927     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3928     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3929     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3930     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3931     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3932       "use same video quality as source (implies VBR)" },
3933     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3934     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3935     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3936       "deinterlace pictures" },
3937     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3938     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3939     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3940     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3941     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3942     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3943     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3944     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3945     { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
3946     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3947     { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3948     { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3949     { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3950     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3951     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3952
3953     /* audio options */
3954     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3955     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3956     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3957     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3958     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3959     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3960     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3961     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3962     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3963     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3964
3965     /* subtitle options */
3966     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3967     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3968     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3969
3970     /* grab options */
3971     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3972     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3973     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3974     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3975
3976     /* G.2 grab options */
3977     { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3978     { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3979
3980     /* muxer options */
3981     { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3982     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3983     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3984
3985     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3986     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3987
3988     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3989     { NULL, },
3990 };
3991
3992 static void show_banner(void)
3993 {
3994     fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3995     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3996     fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3997     fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3998     fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3999     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4000 #ifdef __GNUC__
4001     fprintf(stderr, ", gcc: " __VERSION__ "\n");
4002 #else
4003     fprintf(stderr, ", using a non-gcc compiler\n");
4004 #endif
4005 }
4006
4007 static void show_license(void)
4008 {
4009     show_banner();
4010 #ifdef CONFIG_GPL
4011     printf(
4012     "This program is free software; you can redistribute it and/or modify\n"
4013     "it under the terms of the GNU General Public License as published by\n"
4014     "the Free Software Foundation; either version 2 of the License, or\n"
4015     "(at your option) any later version.\n"
4016     "\n"
4017     "This program is distributed in the hope that it will be useful,\n"
4018     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4019     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4020     "GNU General Public License for more details.\n"
4021     "\n"
4022     "You should have received a copy of the GNU General Public License\n"
4023     "along with this program; if not, write to the Free Software\n"
4024     "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4025     );
4026 #else
4027     printf(
4028     "This library is free software; you can redistribute it and/or\n"
4029     "modify it under the terms of the GNU Lesser General Public\n"
4030     "License as published by the Free Software Foundation; either\n"
4031     "version 2 of the License, or (at your option) any later version.\n"
4032     "\n"
4033     "This library is distributed in the hope that it will be useful,\n"
4034     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4035     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4036     "Lesser General Public License for more details.\n"
4037     "\n"
4038     "You should have received a copy of the GNU Lesser General Public\n"
4039     "License along with this library; if not, write to the Free Software\n"
4040     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4041     );
4042 #endif
4043     exit(1);
4044 }
4045
4046 static void show_help(void)
4047 {
4048     show_banner();
4049     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4050            "Hyper fast Audio and Video encoder\n");
4051     printf("\n");
4052     show_help_options(options, "Main options:\n",
4053                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4054     show_help_options(options, "\nVideo options:\n",
4055                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4056                       OPT_VIDEO);
4057     show_help_options(options, "\nAdvanced Video options:\n",
4058                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4059                       OPT_VIDEO | OPT_EXPERT);
4060     show_help_options(options, "\nAudio options:\n",
4061                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4062                       OPT_AUDIO);
4063     show_help_options(options, "\nAdvanced Audio options:\n",
4064                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4065                       OPT_AUDIO | OPT_EXPERT);
4066     show_help_options(options, "\nSubtitle options:\n",
4067                       OPT_SUBTITLE | OPT_GRAB,
4068                       OPT_SUBTITLE);
4069     show_help_options(options, "\nAudio/Video grab options:\n",
4070                       OPT_GRAB,
4071                       OPT_GRAB);
4072     show_help_options(options, "\nAdvanced options:\n",
4073                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4074                       OPT_EXPERT);
4075     av_opt_show(avctx_opts, NULL);
4076     av_opt_show(avformat_opts, NULL);
4077
4078     exit(1);
4079 }
4080
4081 void parse_arg_file(const char *filename)
4082 {
4083     opt_output_file(filename);
4084 }
4085
4086 int main(int argc, char **argv)
4087 {
4088     int i;
4089     int64_t ti;
4090
4091     av_register_all();
4092
4093     avctx_opts= avcodec_alloc_context();
4094     avformat_opts = av_alloc_format_context();
4095
4096     if (argc <= 1)
4097         show_help();
4098     else
4099         show_banner();
4100
4101     /* parse options */
4102     parse_options(argc, argv, options);
4103
4104     /* file converter / grab */
4105     if (nb_output_files <= 0) {
4106         fprintf(stderr, "Must supply at least one output file\n");
4107         exit(1);
4108     }
4109
4110     if (nb_input_files == 0) {
4111         input_sync = 1;
4112         prepare_grab();
4113     }
4114
4115     ti = getutime();
4116     av_encode(output_files, nb_output_files, input_files, nb_input_files,
4117               stream_maps, nb_stream_maps);
4118     ti = getutime() - ti;
4119     if (do_benchmark) {
4120         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4121     }
4122
4123     /* close files */
4124     for(i=0;i<nb_output_files;i++) {
4125         /* maybe av_close_output_file ??? */
4126         AVFormatContext *s = output_files[i];
4127         int j;
4128         if (!(s->oformat->flags & AVFMT_NOFILE))
4129             url_fclose(&s->pb);
4130         for(j=0;j<s->nb_streams;j++)
4131             av_free(s->streams[j]);
4132         av_free(s);
4133     }
4134     for(i=0;i<nb_input_files;i++)
4135         av_close_input_file(input_files[i]);
4136
4137     av_free_static();
4138
4139     if(intra_matrix)
4140         av_free(intra_matrix);
4141     if(inter_matrix)
4142         av_free(inter_matrix);
4143
4144 #ifdef POWERPC_PERFORMANCE_REPORT
4145     extern void powerpc_display_perf_report(void);
4146     powerpc_display_perf_report();
4147 #endif /* POWERPC_PERFORMANCE_REPORT */
4148
4149 #ifndef __MINGW32__
4150     if (received_sigterm) {
4151         fprintf(stderr,
4152             "Received signal %d: terminating.\n",
4153             (int) received_sigterm);
4154         exit (255);
4155     }
4156 #endif
4157     exit(0); /* not all OS-es handle main() return value */
4158     return 0;
4159 }