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

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