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