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

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