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