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