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