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