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

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