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

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