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