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

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