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