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

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