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