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     static int samples_size= 0;
1089     static short *samples= NULL;
1090
1091     if(!pkt){
1092         ist->pts= ist->next_pts; // needed for last packet if vsync=0
1093     } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1094         ist->next_pts = ist->pts = pkt->dts;
1095     } else {
1096         assert(ist->pts == ist->next_pts);
1097     }
1098
1099     if (pkt == NULL) {
1100         /* EOF handling */
1101         ptr = NULL;
1102         len = 0;
1103         goto handle_eof;
1104     }
1105
1106     len = pkt->size;
1107     ptr = pkt->data;
1108     while (len > 0) {
1109     handle_eof:
1110         /* decode the packet if needed */
1111         data_buf = NULL; /* fail safe */
1112         data_size = 0;
1113         if (ist->decoding_needed) {
1114             switch(ist->st->codec.codec_type) {
1115             case CODEC_TYPE_AUDIO:{
1116                 if(pkt)
1117                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1118                     /* XXX: could avoid copy if PCM 16 bits with same
1119                        endianness as CPU */
1120                 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1121                                            ptr, len);
1122                 if (ret < 0)
1123                     goto fail_decode;
1124                 ptr += ret;
1125                 len -= ret;
1126                 /* Some bug in mpeg audio decoder gives */
1127                 /* data_size < 0, it seems they are overflows */
1128                 if (data_size <= 0) {
1129                     /* no audio frame */
1130                     continue;
1131                 }
1132                 data_buf = (uint8_t *)samples;
1133                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1134                     (ist->st->codec.sample_rate * ist->st->codec.channels);
1135                 break;}
1136             case CODEC_TYPE_VIDEO:
1137                     data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1138                     /* XXX: allocate picture correctly */
1139                     avcodec_get_frame_defaults(&picture);
1140
1141                     ret = avcodec_decode_video(&ist->st->codec,
1142                                                &picture, &got_picture, ptr, len);
1143                     ist->st->quality= picture.quality;
1144                     if (ret < 0)
1145                         goto fail_decode;
1146                     if (!got_picture) {
1147                         /* no picture yet */
1148                         goto discard_packet;
1149                     }
1150                     if (ist->st->codec.frame_rate_base != 0) {
1151                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1152                                           ist->st->codec.frame_rate_base) /
1153                             ist->st->codec.frame_rate;
1154                     }
1155                     len = 0;
1156                     break;
1157                 default:
1158                     goto fail_decode;
1159                 }
1160             } else {
1161                 data_buf = ptr;
1162                 data_size = len;
1163                 ret = len;
1164                 len = 0;
1165             }
1166
1167             buffer_to_free = NULL;
1168             if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1169                 pre_process_video_frame(ist, (AVPicture *)&picture,
1170                                         &buffer_to_free);
1171             }
1172
1173             /* frame rate emulation */
1174             if (ist->st->codec.rate_emu) {
1175                 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1176                 int64_t now = av_gettime() - ist->start;
1177                 if (pts > now)
1178                     usleep(pts - now);
1179
1180                 ist->frame++;
1181             }
1182
1183 #if 0
1184             /* mpeg PTS deordering : if it is a P or I frame, the PTS
1185                is the one of the next displayed one */
1186             /* XXX: add mpeg4 too ? */
1187             if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1188                 if (ist->st->codec.pict_type != B_TYPE) {
1189                     int64_t tmp;
1190                     tmp = ist->last_ip_pts;
1191                     ist->last_ip_pts  = ist->frac_pts.val;
1192                     ist->frac_pts.val = tmp;
1193                 }
1194             }
1195 #endif
1196             /* if output time reached then transcode raw format,
1197                encode packets and output them */
1198             if (start_time == 0 || ist->pts >= start_time)
1199                 for(i=0;i<nb_ostreams;i++) {
1200                     int frame_size;
1201
1202                     ost = ost_table[i];
1203                     if (ost->source_index == ist_index) {
1204                         os = output_files[ost->file_index];
1205
1206 #if 0
1207                         printf("%d: got pts=%0.3f %0.3f\n", i,
1208                                (double)pkt->pts / AV_TIME_BASE,
1209                                ((double)ist->pts / AV_TIME_BASE) -
1210                                ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1211 #endif
1212                         /* set the input output pts pairs */
1213                         ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1214
1215                         if (ost->encoding_needed) {
1216                             switch(ost->st->codec.codec_type) {
1217                             case CODEC_TYPE_AUDIO:
1218                                 do_audio_out(os, ost, ist, data_buf, data_size);
1219                                 break;
1220                             case CODEC_TYPE_VIDEO:
1221                                     do_video_out(os, ost, ist, &picture, &frame_size);
1222                                     video_size += frame_size;
1223                                     if (do_vstats && frame_size)
1224                                         do_video_stats(os, ost, frame_size);
1225                                 break;
1226                             default:
1227                                 av_abort();
1228                             }
1229                         } else {
1230                             AVFrame avframe; //FIXME/XXX remove this
1231                             AVPacket opkt;
1232                             av_init_packet(&opkt);
1233
1234                             /* no reencoding needed : output the packet directly */
1235                             /* force the input stream PTS */
1236
1237                             avcodec_get_frame_defaults(&avframe);
1238                             ost->st->codec.coded_frame= &avframe;
1239                             avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1240
1241                             if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1242                                 audio_size += data_size;
1243                             else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1244                                 video_size += data_size;
1245
1246                             opkt.stream_index= ost->index;
1247                             opkt.data= data_buf;
1248                             opkt.size= data_size;
1249                             opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1250                             opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1251                             opkt.flags= pkt->flags;
1252
1253                             av_interleaved_write_frame(os, &opkt);
1254                             ost->st->codec.frame_number++;
1255                             ost->frame_number++;
1256                         }
1257                     }
1258                 }
1259             av_free(buffer_to_free);
1260         }
1261  discard_packet:
1262     if (pkt == NULL) {
1263         /* EOF handling */
1264
1265         for(i=0;i<nb_ostreams;i++) {
1266             ost = ost_table[i];
1267             if (ost->source_index == ist_index) {
1268                 AVCodecContext *enc= &ost->st->codec;
1269                 os = output_files[ost->file_index];
1270
1271                 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1272                     continue;
1273                 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1274                     continue;
1275
1276                 if (ost->encoding_needed) {
1277                     for(;;) {
1278                         AVPacket pkt;
1279                         av_init_packet(&pkt);
1280                         pkt.stream_index= ost->index;
1281
1282                         switch(ost->st->codec.codec_type) {
1283                         case CODEC_TYPE_AUDIO:
1284                             ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1285                             audio_size += ret;
1286                             pkt.flags |= PKT_FLAG_KEY;
1287                             break;
1288                         case CODEC_TYPE_VIDEO:
1289                             ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1290                             video_size += ret;
1291                             if(enc->coded_frame && enc->coded_frame->key_frame)
1292                                 pkt.flags |= PKT_FLAG_KEY;
1293                             if (ost->logfile && enc->stats_out) {
1294                                 fprintf(ost->logfile, "%s", enc->stats_out);
1295                             }
1296                             break;
1297                         default:
1298                             ret=-1;
1299                         }
1300
1301                         if(ret<=0)
1302                             break;
1303                         pkt.data= bit_buffer;
1304                         pkt.size= ret;
1305                         if(enc->coded_frame)
1306                             pkt.pts= enc->coded_frame->pts;
1307                         av_interleaved_write_frame(os, &pkt);
1308                     }
1309                 }
1310             }
1311         }
1312     }
1313
1314     return 0;
1315  fail_decode:
1316     return -1;
1317 }
1318
1319
1320 /*
1321  * The following code is the main loop of the file converter
1322  */
1323 static int av_encode(AVFormatContext **output_files,
1324                      int nb_output_files,
1325                      AVFormatContext **input_files,
1326                      int nb_input_files,
1327                      AVStreamMap *stream_maps, int nb_stream_maps)
1328 {
1329     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1330     AVFormatContext *is, *os;
1331     AVCodecContext *codec, *icodec;
1332     AVOutputStream *ost, **ost_table = NULL;
1333     AVInputStream *ist, **ist_table = NULL;
1334     AVInputFile *file_table;
1335     AVFormatContext *stream_no_data;
1336     int key;
1337
1338     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1339     if (!file_table)
1340         goto fail;
1341
1342     if (!bit_buffer)
1343         bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1344     if (!bit_buffer)
1345         goto fail;
1346
1347     /* input stream init */
1348     j = 0;
1349     for(i=0;i<nb_input_files;i++) {
1350         is = input_files[i];
1351         file_table[i].ist_index = j;
1352         file_table[i].nb_streams = is->nb_streams;
1353         j += is->nb_streams;
1354     }
1355     nb_istreams = j;
1356
1357     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1358     if (!ist_table)
1359         goto fail;
1360
1361     for(i=0;i<nb_istreams;i++) {
1362         ist = av_mallocz(sizeof(AVInputStream));
1363         if (!ist)
1364             goto fail;
1365         ist_table[i] = ist;
1366     }
1367     j = 0;
1368     for(i=0;i<nb_input_files;i++) {
1369         is = input_files[i];
1370         for(k=0;k<is->nb_streams;k++) {
1371             ist = ist_table[j++];
1372             ist->st = is->streams[k];
1373             ist->file_index = i;
1374             ist->index = k;
1375             ist->discard = 1; /* the stream is discarded by default
1376                                  (changed later) */
1377
1378             if (ist->st->codec.rate_emu) {
1379                 ist->start = av_gettime();
1380                 ist->frame = 0;
1381             }
1382         }
1383     }
1384
1385     /* output stream init */
1386     nb_ostreams = 0;
1387     for(i=0;i<nb_output_files;i++) {
1388         os = output_files[i];
1389         nb_ostreams += os->nb_streams;
1390     }
1391     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1392         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1393         exit(1);
1394     }
1395
1396     /* Sanity check the mapping args -- do the input files & streams exist? */
1397     for(i=0;i<nb_stream_maps;i++) {
1398         int fi = stream_maps[i].file_index;
1399         int si = stream_maps[i].stream_index;
1400
1401         if (fi < 0 || fi > nb_input_files - 1 ||
1402             si < 0 || si > file_table[fi].nb_streams - 1) {
1403             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1404             exit(1);
1405         }
1406     }
1407
1408     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1409     if (!ost_table)
1410         goto fail;
1411     for(i=0;i<nb_ostreams;i++) {
1412         ost = av_mallocz(sizeof(AVOutputStream));
1413         if (!ost)
1414             goto fail;
1415         ost_table[i] = ost;
1416     }
1417
1418     n = 0;
1419     for(k=0;k<nb_output_files;k++) {
1420         os = output_files[k];
1421         for(i=0;i<os->nb_streams;i++) {
1422             int found;
1423             ost = ost_table[n++];
1424             ost->file_index = k;
1425             ost->index = i;
1426             ost->st = os->streams[i];
1427             if (nb_stream_maps > 0) {
1428                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1429                     stream_maps[n-1].stream_index;
1430
1431                 /* Sanity check that the stream types match */
1432                 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1433                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1434                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1435                         ost->file_index, ost->index);
1436                     exit(1);
1437                 }
1438
1439             } else {
1440                 /* get corresponding input stream index : we select the first one with the right type */
1441                 found = 0;
1442                 for(j=0;j<nb_istreams;j++) {
1443                     ist = ist_table[j];
1444                     if (ist->discard &&
1445                         ist->st->codec.codec_type == ost->st->codec.codec_type) {
1446                         ost->source_index = j;
1447                         found = 1;
1448                         break;
1449                     }
1450                 }
1451
1452                 if (!found) {
1453                     /* try again and reuse existing stream */
1454                     for(j=0;j<nb_istreams;j++) {
1455                         ist = ist_table[j];
1456                         if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1457                             ost->source_index = j;
1458                             found = 1;
1459                         }
1460                     }
1461                     if (!found) {
1462                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1463                                 ost->file_index, ost->index);
1464                         exit(1);
1465                     }
1466                 }
1467             }
1468             ist = ist_table[ost->source_index];
1469             ist->discard = 0;
1470         }
1471     }
1472
1473     /* for each output stream, we compute the right encoding parameters */
1474     for(i=0;i<nb_ostreams;i++) {
1475         ost = ost_table[i];
1476         ist = ist_table[ost->source_index];
1477
1478         codec = &ost->st->codec;
1479         icodec = &ist->st->codec;
1480
1481         if (ost->st->stream_copy) {
1482             /* if stream_copy is selected, no need to decode or encode */
1483             codec->codec_id = icodec->codec_id;
1484             codec->codec_type = icodec->codec_type;
1485             codec->codec_tag = icodec->codec_tag;
1486             codec->bit_rate = icodec->bit_rate;
1487             switch(codec->codec_type) {
1488             case CODEC_TYPE_AUDIO:
1489                 codec->sample_rate = icodec->sample_rate;
1490                 codec->channels = icodec->channels;
1491                 codec->frame_size = icodec->frame_size;
1492                 break;
1493             case CODEC_TYPE_VIDEO:
1494                 codec->frame_rate = icodec->frame_rate;
1495                 codec->frame_rate_base = icodec->frame_rate_base;
1496                 codec->width = icodec->width;
1497                 codec->height = icodec->height;
1498                 break;
1499             default:
1500                 av_abort();
1501             }
1502         } else {
1503             switch(codec->codec_type) {
1504             case CODEC_TYPE_AUDIO:
1505                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1506                     goto fail;
1507
1508                 if (codec->channels == icodec->channels &&
1509                     codec->sample_rate == icodec->sample_rate) {
1510                     ost->audio_resample = 0;
1511                 } else {
1512                     if (codec->channels != icodec->channels &&
1513                         (icodec->codec_id == CODEC_ID_AC3 ||
1514                          icodec->codec_id == CODEC_ID_DTS)) {
1515                         /* Special case for 5:1 AC3 and DTS input */
1516                         /* and mono or stereo output      */
1517                         /* Request specific number of channels */
1518                         icodec->channels = codec->channels;
1519                         if (codec->sample_rate == icodec->sample_rate)
1520                             ost->audio_resample = 0;
1521                         else {
1522                             ost->audio_resample = 1;
1523                         }
1524                     } else {
1525                         ost->audio_resample = 1;
1526                     }
1527                 }
1528                 if(audio_sync_method>1)
1529                     ost->audio_resample = 1;
1530
1531                 if(ost->audio_resample){
1532                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1533                                                     codec->sample_rate, icodec->sample_rate);
1534                     if(!ost->resample){
1535                         printf("Can't resample.  Aborting.\n");
1536                         av_abort();
1537                     }
1538                 }
1539                 ist->decoding_needed = 1;
1540                 ost->encoding_needed = 1;
1541                 break;
1542             case CODEC_TYPE_VIDEO:
1543                 if (codec->width == icodec->width &&
1544                     codec->height == icodec->height &&
1545                     frame_topBand == 0 &&
1546                     frame_bottomBand == 0 &&
1547                     frame_leftBand == 0 &&
1548                     frame_rightBand == 0 &&
1549                     frame_padtop == 0 &&
1550                     frame_padbottom == 0 &&
1551                     frame_padleft == 0 &&
1552                     frame_padright == 0)
1553                 {
1554                     ost->video_resample = 0;
1555                     ost->video_crop = 0;
1556                     ost->video_pad = 0;
1557                 } else if ((codec->width == icodec->width -
1558                                 (frame_leftBand + frame_rightBand)) &&
1559                         (codec->height == icodec->height -
1560                                 (frame_topBand  + frame_bottomBand)))
1561                 {
1562                     ost->video_resample = 0;
1563                     ost->video_crop = 1;
1564                     ost->topBand = frame_topBand;
1565                     ost->leftBand = frame_leftBand;
1566                 } else if ((codec->width == icodec->width +
1567                                 (frame_padleft + frame_padright)) &&
1568                         (codec->height == icodec->height +
1569                                 (frame_padtop + frame_padbottom))) {
1570                     ost->video_resample = 0;
1571                     ost->video_crop = 0;
1572                     ost->video_pad = 1;
1573                     ost->padtop = frame_padtop;
1574                     ost->padleft = frame_padleft;
1575                     ost->padbottom = frame_padbottom;
1576                     ost->padright = frame_padright;
1577                     avcodec_get_frame_defaults(&ost->pict_tmp);
1578                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1579                                 codec->width, codec->height ) )
1580                         goto fail;
1581                 } else {
1582                     ost->video_resample = 1;
1583                     ost->video_crop = 0; // cropping is handled as part of resample
1584                     avcodec_get_frame_defaults(&ost->pict_tmp);
1585                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1586                                          codec->width, codec->height ) )
1587                         goto fail;
1588
1589                     ost->img_resample_ctx = img_resample_full_init(
1590                                       ost->st->codec.width, ost->st->codec.height,
1591                                       ist->st->codec.width, ist->st->codec.height,
1592                                       frame_topBand, frame_bottomBand,
1593                             frame_leftBand, frame_rightBand,
1594                             frame_padtop, frame_padbottom,
1595                             frame_padleft, frame_padright);
1596
1597                     ost->padtop = frame_padtop;
1598                     ost->padleft = frame_padleft;
1599                     ost->padbottom = frame_padbottom;
1600                     ost->padright = frame_padright;
1601
1602                 }
1603                 ost->encoding_needed = 1;
1604                 ist->decoding_needed = 1;
1605                 break;
1606             default:
1607                 av_abort();
1608             }
1609             /* two pass mode */
1610             if (ost->encoding_needed &&
1611                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1612                 char logfilename[1024];
1613                 FILE *f;
1614                 int size;
1615                 char *logbuffer;
1616
1617                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1618                          pass_logfilename ?
1619                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1620                 if (codec->flags & CODEC_FLAG_PASS1) {
1621                     f = fopen(logfilename, "w");
1622                     if (!f) {
1623                         perror(logfilename);
1624                         exit(1);
1625                     }
1626                     ost->logfile = f;
1627                 } else {
1628                     /* read the log file */
1629                     f = fopen(logfilename, "r");
1630                     if (!f) {
1631                         perror(logfilename);
1632                         exit(1);
1633                     }
1634                     fseek(f, 0, SEEK_END);
1635                     size = ftell(f);
1636                     fseek(f, 0, SEEK_SET);
1637                     logbuffer = av_malloc(size + 1);
1638                     if (!logbuffer) {
1639                         fprintf(stderr, "Could not allocate log buffer\n");
1640                         exit(1);
1641                     }
1642                     size = fread(logbuffer, 1, size, f);
1643                     fclose(f);
1644                     logbuffer[size] = '\0';
1645                     codec->stats_in = logbuffer;
1646                 }
1647             }
1648         }
1649     }
1650
1651     /* dump the file output parameters - cannot be done before in case
1652        of stream copy */
1653     for(i=0;i<nb_output_files;i++) {
1654         dump_format(output_files[i], i, output_files[i]->filename, 1);
1655     }
1656
1657     /* dump the stream mapping */
1658     if (verbose >= 0) {
1659         fprintf(stderr, "Stream mapping:\n");
1660         for(i=0;i<nb_ostreams;i++) {
1661             ost = ost_table[i];
1662             fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1663                     ist_table[ost->source_index]->file_index,
1664                     ist_table[ost->source_index]->index,
1665                     ost->file_index,
1666                     ost->index);
1667         }
1668     }
1669
1670     /* open each encoder */
1671     for(i=0;i<nb_ostreams;i++) {
1672         ost = ost_table[i];
1673         if (ost->encoding_needed) {
1674             AVCodec *codec;
1675             codec = avcodec_find_encoder(ost->st->codec.codec_id);
1676             if (!codec) {
1677                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1678                         ost->file_index, ost->index);
1679                 exit(1);
1680             }
1681             if (avcodec_open(&ost->st->codec, codec) < 0) {
1682                 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1683                         ost->file_index, ost->index);
1684                 exit(1);
1685             }
1686             extra_size += ost->st->codec.extradata_size;
1687         }
1688     }
1689
1690     /* open each decoder */
1691     for(i=0;i<nb_istreams;i++) {
1692         ist = ist_table[i];
1693         if (ist->decoding_needed) {
1694             AVCodec *codec;
1695             codec = avcodec_find_decoder(ist->st->codec.codec_id);
1696             if (!codec) {
1697                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1698                         ist->st->codec.codec_id, ist->file_index, ist->index);
1699                 exit(1);
1700             }
1701             if (avcodec_open(&ist->st->codec, codec) < 0) {
1702                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1703                         ist->file_index, ist->index);
1704                 exit(1);
1705             }
1706             //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1707             //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1708         }
1709     }
1710
1711     /* init pts */
1712     for(i=0;i<nb_istreams;i++) {
1713         ist = ist_table[i];
1714         is = input_files[ist->file_index];
1715         ist->pts = 0;
1716         ist->next_pts = ist->st->start_time;
1717         if(ist->next_pts == AV_NOPTS_VALUE)
1718             ist->next_pts=0;
1719         ist->is_start = 1;
1720     }
1721
1722     /* compute buffer size max (should use a complete heuristic) */
1723     for(i=0;i<nb_input_files;i++) {
1724         file_table[i].buffer_size_max = 2048;
1725     }
1726
1727     /* set meta data information from input file if required */
1728     for (i=0;i<nb_meta_data_maps;i++) {
1729         AVFormatContext *out_file;
1730         AVFormatContext *in_file;
1731
1732         int out_file_index = meta_data_maps[i].out_file;
1733         int in_file_index = meta_data_maps[i].in_file;
1734         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1735             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1736             ret = -EINVAL;
1737             goto fail;
1738         }
1739         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1740             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1741             ret = -EINVAL;
1742             goto fail;
1743         }
1744
1745         out_file = output_files[out_file_index];
1746         in_file = input_files[in_file_index];
1747
1748         strcpy(out_file->title, in_file->title);
1749         strcpy(out_file->author, in_file->author);
1750         strcpy(out_file->copyright, in_file->copyright);
1751         strcpy(out_file->comment, in_file->comment);
1752         strcpy(out_file->album, in_file->album);
1753         out_file->year = in_file->year;
1754         out_file->track = in_file->track;
1755         strcpy(out_file->genre, in_file->genre);
1756     }
1757
1758     /* open files and write file headers */
1759     for(i=0;i<nb_output_files;i++) {
1760         os = output_files[i];
1761         if (av_write_header(os) < 0) {
1762             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1763             ret = -EINVAL;
1764             goto fail;
1765         }
1766     }
1767
1768 #ifndef CONFIG_WIN32
1769     if ( !using_stdin && verbose >= 0) {
1770         fprintf(stderr, "Press [q] to stop encoding\n");
1771         url_set_interrupt_cb(decode_interrupt_cb);
1772     }
1773 #endif
1774     term_init();
1775
1776     stream_no_data = 0;
1777     key = -1;
1778
1779     for(; received_sigterm == 0;) {
1780         int file_index, ist_index;
1781         AVPacket pkt;
1782         double ipts_min;
1783         double opts_min;
1784
1785     redo:
1786         ipts_min= 1e100;
1787         opts_min= 1e100;
1788         /* if 'q' pressed, exits */
1789         if (!using_stdin) {
1790             if (q_pressed)
1791                 break;
1792             /* read_key() returns 0 on EOF */
1793             key = read_key();
1794             if (key == 'q')
1795                 break;
1796         }
1797
1798         /* select the stream that we must read now by looking at the
1799            smallest output pts */
1800         file_index = -1;
1801         for(i=0;i<nb_ostreams;i++) {
1802             double ipts, opts;
1803             ost = ost_table[i];
1804             os = output_files[ost->file_index];
1805             ist = ist_table[ost->source_index];
1806             if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1807                 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1808             else
1809                 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1810             ipts = (double)ist->pts;
1811             if (!file_table[ist->file_index].eof_reached){
1812                 if(ipts < ipts_min) {
1813                     ipts_min = ipts;
1814                     if(input_sync ) file_index = ist->file_index;
1815                 }
1816                 if(opts < opts_min) {
1817                     opts_min = opts;
1818                     if(!input_sync) file_index = ist->file_index;
1819                 }
1820             }
1821         }
1822         /* if none, if is finished */
1823         if (file_index < 0) {
1824             break;
1825         }
1826
1827         /* finish if recording time exhausted */
1828         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1829             break;
1830
1831         /* read a frame from it and output it in the fifo */
1832         is = input_files[file_index];
1833         if (av_read_frame(is, &pkt) < 0) {
1834             file_table[file_index].eof_reached = 1;
1835             continue;
1836         }
1837
1838         if (!pkt.size) {
1839             stream_no_data = is;
1840         } else {
1841             stream_no_data = 0;
1842         }
1843         if (do_pkt_dump) {
1844             av_pkt_dump(stdout, &pkt, do_hex_dump);
1845         }
1846         /* the following test is needed in case new streams appear
1847            dynamically in stream : we ignore them */
1848         if (pkt.stream_index >= file_table[file_index].nb_streams)
1849             goto discard_packet;
1850         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1851         ist = ist_table[ist_index];
1852         if (ist->discard)
1853             goto discard_packet;
1854
1855 //        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);
1856         if (pkt.dts != AV_NOPTS_VALUE) {
1857             int64_t delta= pkt.dts - ist->next_pts;
1858             if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1859                 input_files_ts_offset[ist->file_index]-= delta;
1860                 if (verbose > 2)
1861                     fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1862                 for(i=0; i<file_table[file_index].nb_streams; i++){
1863                     int index= file_table[file_index].ist_index + i;
1864                     ist_table[index]->next_pts += delta;
1865                     ist_table[index]->is_start=1;
1866                 }
1867             }
1868         }
1869
1870         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1871         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1872
1873             if (verbose >= 0)
1874                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1875                         ist->file_index, ist->index);
1876
1877             av_free_packet(&pkt);
1878             goto redo;
1879         }
1880
1881     discard_packet:
1882         av_free_packet(&pkt);
1883
1884         /* dump report by using the output first video and audio streams */
1885         print_report(output_files, ost_table, nb_ostreams, 0);
1886     }
1887
1888     /* at the end of stream, we must flush the decoder buffers */
1889     for(i=0;i<nb_istreams;i++) {
1890         ist = ist_table[i];
1891         if (ist->decoding_needed) {
1892             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1893         }
1894     }
1895
1896     term_exit();
1897
1898     /* write the trailer if needed and close file */
1899     for(i=0;i<nb_output_files;i++) {
1900         os = output_files[i];
1901         av_write_trailer(os);
1902     }
1903
1904     /* dump report by using the first video and audio streams */
1905     print_report(output_files, ost_table, nb_ostreams, 1);
1906
1907     /* close each encoder */
1908     for(i=0;i<nb_ostreams;i++) {
1909         ost = ost_table[i];
1910         if (ost->encoding_needed) {
1911             av_freep(&ost->st->codec.stats_in);
1912             avcodec_close(&ost->st->codec);
1913         }
1914     }
1915
1916     /* close each decoder */
1917     for(i=0;i<nb_istreams;i++) {
1918         ist = ist_table[i];
1919         if (ist->decoding_needed) {
1920             avcodec_close(&ist->st->codec);
1921         }
1922     }
1923
1924     /* finished ! */
1925
1926     ret = 0;
1927  fail1:
1928     av_free(file_table);
1929
1930     if (ist_table) {
1931         for(i=0;i<nb_istreams;i++) {
1932             ist = ist_table[i];
1933             av_free(ist);
1934         }
1935         av_free(ist_table);
1936     }
1937     if (ost_table) {
1938         for(i=0;i<nb_ostreams;i++) {
1939             ost = ost_table[i];
1940             if (ost) {
1941                 if (ost->logfile) {
1942                     fclose(ost->logfile);
1943                     ost->logfile = NULL;
1944                 }
1945                 fifo_free(&ost->fifo); /* works even if fifo is not
1946                                           initialized but set to zero */
1947                 av_free(ost->pict_tmp.data[0]);
1948                 if (ost->video_resample)
1949                     img_resample_close(ost->img_resample_ctx);
1950                 if (ost->audio_resample)
1951                     audio_resample_close(ost->resample);
1952                 av_free(ost);
1953             }
1954         }
1955         av_free(ost_table);
1956     }
1957     return ret;
1958  fail:
1959     ret = -ENOMEM;
1960     goto fail1;
1961 }
1962
1963 #if 0
1964 int file_read(const char *filename)
1965 {
1966     URLContext *h;
1967     unsigned char buffer[1024];
1968     int len, i;
1969
1970     if (url_open(&h, filename, O_RDONLY) < 0) {
1971         printf("could not open '%s'\n", filename);
1972         return -1;
1973     }
1974     for(;;) {
1975         len = url_read(h, buffer, sizeof(buffer));
1976         if (len <= 0)
1977             break;
1978         for(i=0;i<len;i++) putchar(buffer[i]);
1979     }
1980     url_close(h);
1981     return 0;
1982 }
1983 #endif
1984
1985 static void opt_image_format(const char *arg)
1986 {
1987     AVImageFormat *f;
1988
1989     for(f = first_image_format; f != NULL; f = f->next) {
1990         if (!strcmp(arg, f->name))
1991             break;
1992     }
1993     if (!f) {
1994         fprintf(stderr, "Unknown image format: '%s'\n", arg);
1995         exit(1);
1996     }
1997     image_format = f;
1998 }
1999
2000 static void opt_format(const char *arg)
2001 {
2002     /* compatibility stuff for pgmyuv */
2003     if (!strcmp(arg, "pgmyuv")) {
2004         opt_image_format(arg);
2005         arg = "image";
2006     }
2007
2008     file_iformat = av_find_input_format(arg);
2009     file_oformat = guess_format(arg, NULL, NULL);
2010     if (!file_iformat && !file_oformat) {
2011         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2012         exit(1);
2013     }
2014 }
2015
2016 static void opt_video_bitrate(const char *arg)
2017 {
2018     video_bit_rate = atoi(arg) * 1000;
2019 }
2020
2021 static void opt_video_bitrate_tolerance(const char *arg)
2022 {
2023     video_bit_rate_tolerance = atoi(arg) * 1000;
2024 }
2025
2026 static void opt_video_bitrate_max(const char *arg)
2027 {
2028     video_rc_max_rate = atoi(arg) * 1000;
2029 }
2030
2031 static void opt_video_bitrate_min(const char *arg)
2032 {
2033     video_rc_min_rate = atoi(arg) * 1000;
2034 }
2035
2036 static void opt_video_buffer_size(const char *arg)
2037 {
2038     video_rc_buffer_size = atoi(arg) * 8*1024;
2039 }
2040
2041 static void opt_video_rc_eq(char *arg)
2042 {
2043     video_rc_eq = arg;
2044 }
2045
2046 static void opt_video_rc_override_string(char *arg)
2047 {
2048     video_rc_override_string = arg;
2049 }
2050
2051
2052 static void opt_workaround_bugs(const char *arg)
2053 {
2054     workaround_bugs = atoi(arg);
2055 }
2056
2057 static void opt_dct_algo(const char *arg)
2058 {
2059     dct_algo = atoi(arg);
2060 }
2061
2062 static void opt_idct_algo(const char *arg)
2063 {
2064     idct_algo = atoi(arg);
2065 }
2066
2067 static void opt_me_threshold(const char *arg)
2068 {
2069     me_threshold = atoi(arg);
2070 }
2071
2072 static void opt_mb_threshold(const char *arg)
2073 {
2074     mb_threshold = atoi(arg);
2075 }
2076
2077 static void opt_error_resilience(const char *arg)
2078 {
2079     error_resilience = atoi(arg);
2080 }
2081
2082 static void opt_error_concealment(const char *arg)
2083 {
2084     error_concealment = atoi(arg);
2085 }
2086
2087 static void opt_debug(const char *arg)
2088 {
2089     debug = atoi(arg);
2090 }
2091
2092 static void opt_vismv(const char *arg)
2093 {
2094     debug_mv = atoi(arg);
2095 }
2096
2097 static void opt_verbose(const char *arg)
2098 {
2099     verbose = atoi(arg);
2100     av_log_set_level(atoi(arg));
2101 }
2102
2103 static void opt_frame_rate(const char *arg)
2104 {
2105     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2106         fprintf(stderr, "Incorrect frame rate\n");
2107         exit(1);
2108     }
2109 }
2110
2111 static void opt_frame_crop_top(const char *arg)
2112 {
2113     frame_topBand = atoi(arg);
2114     if (frame_topBand < 0) {
2115         fprintf(stderr, "Incorrect top crop size\n");
2116         exit(1);
2117     }
2118     if ((frame_topBand % 2) != 0) {
2119         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2120         exit(1);
2121     }
2122     if ((frame_topBand) >= frame_height){
2123         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2124         exit(1);
2125     }
2126     frame_height -= frame_topBand;
2127 }
2128
2129 static void opt_frame_crop_bottom(const char *arg)
2130 {
2131     frame_bottomBand = atoi(arg);
2132     if (frame_bottomBand < 0) {
2133         fprintf(stderr, "Incorrect bottom crop size\n");
2134         exit(1);
2135     }
2136     if ((frame_bottomBand % 2) != 0) {
2137         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2138         exit(1);
2139     }
2140     if ((frame_bottomBand) >= frame_height){
2141         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2142         exit(1);
2143     }
2144     frame_height -= frame_bottomBand;
2145 }
2146
2147 static void opt_frame_crop_left(const char *arg)
2148 {
2149     frame_leftBand = atoi(arg);
2150     if (frame_leftBand < 0) {
2151         fprintf(stderr, "Incorrect left crop size\n");
2152         exit(1);
2153     }
2154     if ((frame_leftBand % 2) != 0) {
2155         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2156         exit(1);
2157     }
2158     if ((frame_leftBand) >= frame_width){
2159         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2160         exit(1);
2161     }
2162     frame_width -= frame_leftBand;
2163 }
2164
2165 static void opt_frame_crop_right(const char *arg)
2166 {
2167     frame_rightBand = atoi(arg);
2168     if (frame_rightBand < 0) {
2169         fprintf(stderr, "Incorrect right crop size\n");
2170         exit(1);
2171     }
2172     if ((frame_rightBand % 2) != 0) {
2173         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2174         exit(1);
2175     }
2176     if ((frame_rightBand) >= frame_width){
2177         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2178         exit(1);
2179     }
2180     frame_width -= frame_rightBand;
2181 }
2182
2183 static void opt_frame_size(const char *arg)
2184 {
2185     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2186         fprintf(stderr, "Incorrect frame size\n");
2187         exit(1);
2188     }
2189     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2190         fprintf(stderr, "Frame size must be a multiple of 2\n");
2191         exit(1);
2192     }
2193 }
2194
2195
2196 #define SCALEBITS 10
2197 #define ONE_HALF  (1 << (SCALEBITS - 1))
2198 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2199
2200 #define RGB_TO_Y(r, g, b) \
2201 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2202   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2203
2204 #define RGB_TO_U(r1, g1, b1, shift)\
2205 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2206      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2207
2208 #define RGB_TO_V(r1, g1, b1, shift)\
2209 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2210    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2211
2212 static void opt_pad_color(const char *arg) {
2213     /* Input is expected to be six hex digits similar to
2214        how colors are expressed in html tags (but without the #) */
2215     int rgb = strtol(arg, NULL, 16);
2216     int r,g,b;
2217
2218     r = (rgb >> 16);
2219     g = ((rgb >> 8) & 255);
2220     b = (rgb & 255);
2221
2222     padcolor[0] = RGB_TO_Y(r,g,b);
2223     padcolor[1] = RGB_TO_U(r,g,b,0);
2224     padcolor[2] = RGB_TO_V(r,g,b,0);
2225 }
2226
2227 static void opt_frame_pad_top(const char *arg)
2228 {
2229     frame_padtop = atoi(arg);
2230     if (frame_padtop < 0) {
2231         fprintf(stderr, "Incorrect top pad size\n");
2232         exit(1);
2233     }
2234     if ((frame_padtop % 2) != 0) {
2235         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2236         exit(1);
2237     }
2238 }
2239
2240 static void opt_frame_pad_bottom(const char *arg)
2241 {
2242     frame_padbottom = atoi(arg);
2243     if (frame_padbottom < 0) {
2244         fprintf(stderr, "Incorrect bottom pad size\n");
2245         exit(1);
2246     }
2247     if ((frame_padbottom % 2) != 0) {
2248         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2249         exit(1);
2250     }
2251 }
2252
2253
2254 static void opt_frame_pad_left(const char *arg)
2255 {
2256     frame_padleft = atoi(arg);
2257     if (frame_padleft < 0) {
2258         fprintf(stderr, "Incorrect left pad size\n");
2259         exit(1);
2260     }
2261     if ((frame_padleft % 2) != 0) {
2262         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2263         exit(1);
2264     }
2265 }
2266
2267
2268 static void opt_frame_pad_right(const char *arg)
2269 {
2270     frame_padright = atoi(arg);
2271     if (frame_padright < 0) {
2272         fprintf(stderr, "Incorrect right pad size\n");
2273         exit(1);
2274     }
2275     if ((frame_padright % 2) != 0) {
2276         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2277         exit(1);
2278     }
2279 }
2280
2281
2282 static void opt_frame_pix_fmt(const char *arg)
2283 {
2284     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2285 }
2286
2287 static void opt_frame_aspect_ratio(const char *arg)
2288 {
2289     int x = 0, y = 0;
2290     double ar = 0;
2291     const char *p;
2292
2293     p = strchr(arg, ':');
2294     if (p) {
2295         x = strtol(arg, (char **)&arg, 10);
2296         if (arg == p)
2297             y = strtol(arg+1, (char **)&arg, 10);
2298         if (x > 0 && y > 0)
2299             ar = (double)x / (double)y;
2300     } else
2301         ar = strtod(arg, (char **)&arg);
2302
2303     if (!ar) {
2304         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2305         exit(1);
2306     }
2307     frame_aspect_ratio = ar;
2308 }
2309
2310 static void opt_gop_size(const char *arg)
2311 {
2312     gop_size = atoi(arg);
2313 }
2314
2315 static void opt_b_frames(const char *arg)
2316 {
2317     b_frames = atoi(arg);
2318     if (b_frames > FF_MAX_B_FRAMES) {
2319         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2320         exit(1);
2321     } else if (b_frames < 1) {
2322         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2323         exit(1);
2324     }
2325 }
2326
2327 static void opt_mb_decision(const char *arg)
2328 {
2329     mb_decision = atoi(arg);
2330 }
2331
2332 static void opt_mb_cmp(const char *arg)
2333 {
2334     mb_cmp = atoi(arg);
2335 }
2336
2337 static void opt_ildct_cmp(const char *arg)
2338 {
2339     ildct_cmp = atoi(arg);
2340 }
2341
2342 static void opt_sub_cmp(const char *arg)
2343 {
2344     sub_cmp = atoi(arg);
2345 }
2346
2347 static void opt_cmp(const char *arg)
2348 {
2349     cmp = atoi(arg);
2350 }
2351
2352 static void opt_pre_cmp(const char *arg)
2353 {
2354     pre_cmp = atoi(arg);
2355 }
2356
2357 static void opt_pre_me(const char *arg)
2358 {
2359     pre_me = atoi(arg);
2360 }
2361
2362 static void opt_lumi_mask(const char *arg)
2363 {
2364     lumi_mask = atof(arg);
2365 }
2366
2367 static void opt_dark_mask(const char *arg)
2368 {
2369     dark_mask = atof(arg);
2370 }
2371
2372 static void opt_scplx_mask(const char *arg)
2373 {
2374     scplx_mask = atof(arg);
2375 }
2376
2377 static void opt_tcplx_mask(const char *arg)
2378 {
2379     tcplx_mask = atof(arg);
2380 }
2381
2382 static void opt_p_mask(const char *arg)
2383 {
2384     p_mask = atof(arg);
2385 }
2386
2387 static void opt_qscale(const char *arg)
2388 {
2389     video_qscale = atof(arg);
2390     if (video_qscale < 0.01 ||
2391         video_qscale > 255) {
2392         fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2393         exit(1);
2394     }
2395 }
2396
2397 static void opt_lmax(const char *arg)
2398 {
2399     video_lmax = atof(arg)*FF_QP2LAMBDA;
2400 }
2401
2402 static void opt_lmin(const char *arg)
2403 {
2404     video_lmin = atof(arg)*FF_QP2LAMBDA;
2405 }
2406
2407 static void opt_qmin(const char *arg)
2408 {
2409     video_qmin = atoi(arg);
2410     if (video_qmin < 0 ||
2411         video_qmin > 31) {
2412         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2413         exit(1);
2414     }
2415 }
2416
2417 static void opt_qmax(const char *arg)
2418 {
2419     video_qmax = atoi(arg);
2420     if (video_qmax < 0 ||
2421         video_qmax > 31) {
2422         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2423         exit(1);
2424     }
2425 }
2426
2427 static void opt_mb_qmin(const char *arg)
2428 {
2429     video_mb_qmin = atoi(arg);
2430     if (video_mb_qmin < 0 ||
2431         video_mb_qmin > 31) {
2432         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2433         exit(1);
2434     }
2435 }
2436
2437 static void opt_mb_qmax(const char *arg)
2438 {
2439     video_mb_qmax = atoi(arg);
2440     if (video_mb_qmax < 0 ||
2441         video_mb_qmax > 31) {
2442         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2443         exit(1);
2444     }
2445 }
2446
2447 static void opt_qdiff(const char *arg)
2448 {
2449     video_qdiff = atoi(arg);
2450     if (video_qdiff < 0 ||
2451         video_qdiff > 31) {
2452         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2453         exit(1);
2454     }
2455 }
2456
2457 static void opt_qblur(const char *arg)
2458 {
2459     video_qblur = atof(arg);
2460 }
2461
2462 static void opt_qcomp(const char *arg)
2463 {
2464     video_qcomp = atof(arg);
2465 }
2466
2467 static void opt_rc_initial_cplx(const char *arg)
2468 {
2469     video_rc_initial_cplx = atof(arg);
2470 }
2471 static void opt_b_qfactor(const char *arg)
2472 {
2473     video_b_qfactor = atof(arg);
2474 }
2475 static void opt_i_qfactor(const char *arg)
2476 {
2477     video_i_qfactor = atof(arg);
2478 }
2479 static void opt_b_qoffset(const char *arg)
2480 {
2481     video_b_qoffset = atof(arg);
2482 }
2483 static void opt_i_qoffset(const char *arg)
2484 {
2485     video_i_qoffset = atof(arg);
2486 }
2487
2488 static void opt_ibias(const char *arg)
2489 {
2490     video_intra_quant_bias = atoi(arg);
2491 }
2492 static void opt_pbias(const char *arg)
2493 {
2494     video_inter_quant_bias = atoi(arg);
2495 }
2496
2497 static void opt_packet_size(const char *arg)
2498 {
2499     packet_size= atoi(arg);
2500 }
2501
2502 static void opt_error_rate(const char *arg)
2503 {
2504     error_rate= atoi(arg);
2505 }
2506
2507 static void opt_strict(const char *arg)
2508 {
2509     strict= atoi(arg);
2510 }
2511
2512 static void opt_top_field_first(const char *arg)
2513 {
2514     top_field_first= atoi(arg);
2515 }
2516
2517 static void opt_noise_reduction(const char *arg)
2518 {
2519     noise_reduction= atoi(arg);
2520 }
2521
2522 static void opt_qns(const char *arg)
2523 {
2524     qns= atoi(arg);
2525 }
2526
2527 static void opt_sc_threshold(const char *arg)
2528 {
2529     sc_threshold= atoi(arg);
2530 }
2531
2532 static void opt_me_range(const char *arg)
2533 {
2534     me_range = atoi(arg);
2535 }
2536
2537 static void opt_thread_count(const char *arg)
2538 {
2539     thread_count= atoi(arg);
2540 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2541     if (verbose >= 0)
2542         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2543 #endif
2544 }
2545
2546 static void opt_audio_bitrate(const char *arg)
2547 {
2548     audio_bit_rate = atoi(arg) * 1000;
2549 }
2550
2551 static void opt_audio_rate(const char *arg)
2552 {
2553     audio_sample_rate = atoi(arg);
2554 }
2555
2556 static void opt_audio_channels(const char *arg)
2557 {
2558     audio_channels = atoi(arg);
2559 }
2560
2561 static void opt_video_device(const char *arg)
2562 {
2563     video_device = av_strdup(arg);
2564 }
2565
2566 static void opt_video_channel(const char *arg)
2567 {
2568     video_channel = strtol(arg, NULL, 0);
2569 }
2570
2571 static void opt_video_standard(const char *arg)
2572 {
2573     video_standard = av_strdup(arg);
2574 }
2575
2576 static void opt_audio_device(const char *arg)
2577 {
2578     audio_device = av_strdup(arg);
2579 }
2580
2581 static void opt_dv1394(const char *arg)
2582 {
2583     video_grab_format = "dv1394";
2584     audio_grab_format = NULL;
2585 }
2586
2587 static void opt_audio_codec(const char *arg)
2588 {
2589     AVCodec *p;
2590
2591     if (!strcmp(arg, "copy")) {
2592         audio_stream_copy = 1;
2593     } else {
2594         p = first_avcodec;
2595         while (p) {
2596             if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2597                 break;
2598             p = p->next;
2599         }
2600         if (p == NULL) {
2601             fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2602             exit(1);
2603         } else {
2604             audio_codec_id = p->id;
2605         }
2606     }
2607 }
2608
2609 static void add_frame_hooker(const char *arg)
2610 {
2611     int argc = 0;
2612     char *argv[64];
2613     int i;
2614     char *args = av_strdup(arg);
2615
2616     using_vhook = 1;
2617
2618     argv[0] = strtok(args, " ");
2619     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2620     }
2621
2622     i = frame_hook_add(argc, argv);
2623
2624     if (i != 0) {
2625         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2626         exit(1);
2627     }
2628 }
2629
2630 const char *motion_str[] = {
2631     "zero",
2632     "full",
2633     "log",
2634     "phods",
2635     "epzs",
2636     "x1",
2637     NULL,
2638 };
2639
2640 static void opt_motion_estimation(const char *arg)
2641 {
2642     const char **p;
2643     p = motion_str;
2644     for(;;) {
2645         if (!*p) {
2646             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2647             exit(1);
2648         }
2649         if (!strcmp(*p, arg))
2650             break;
2651         p++;
2652     }
2653     me_method = (p - motion_str) + 1;
2654 }
2655
2656 static void opt_video_codec(const char *arg)
2657 {
2658     AVCodec *p;
2659
2660     if (!strcmp(arg, "copy")) {
2661         video_stream_copy = 1;
2662     } else {
2663         p = first_avcodec;
2664         while (p) {
2665             if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2666                 break;
2667             p = p->next;
2668         }
2669         if (p == NULL) {
2670             fprintf(stderr, "Unknown video codec '%s'\n", arg);
2671             exit(1);
2672         } else {
2673             video_codec_id = p->id;
2674         }
2675     }
2676 }
2677
2678 static void opt_map(const char *arg)
2679 {
2680     AVStreamMap *m;
2681     const char *p;
2682
2683     p = arg;
2684     m = &stream_maps[nb_stream_maps++];
2685
2686     m->file_index = strtol(arg, (char **)&p, 0);
2687     if (*p)
2688         p++;
2689
2690     m->stream_index = strtol(p, (char **)&p, 0);
2691 }
2692
2693 static void opt_map_meta_data(const char *arg)
2694 {
2695     AVMetaDataMap *m;
2696     const char *p;
2697
2698     p = arg;
2699     m = &meta_data_maps[nb_meta_data_maps++];
2700
2701     m->out_file = strtol(arg, (char **)&p, 0);
2702     if (*p)
2703         p++;
2704
2705     m->in_file = strtol(p, (char **)&p, 0);
2706 }
2707
2708 static void opt_recording_time(const char *arg)
2709 {
2710     recording_time = parse_date(arg, 1);
2711 }
2712
2713 static void opt_start_time(const char *arg)
2714 {
2715     start_time = parse_date(arg, 1);
2716 }
2717
2718 static void opt_rec_timestamp(const char *arg)
2719 {
2720     rec_timestamp = parse_date(arg, 0) / 1000000;
2721 }
2722
2723 static void opt_input_ts_offset(const char *arg)
2724 {
2725     input_ts_offset = parse_date(arg, 1);
2726 }
2727
2728 static void opt_input_file(const char *filename)
2729 {
2730     AVFormatContext *ic;
2731     AVFormatParameters params, *ap = &params;
2732     int err, i, ret, rfps, rfps_base;
2733     int64_t timestamp;
2734
2735     if (!strcmp(filename, "-"))
2736         filename = "pipe:";
2737
2738     using_stdin |= !strcmp(filename, "pipe:" ) ||
2739                    !strcmp( filename, "/dev/stdin" );
2740
2741     /* get default parameters from command line */
2742     memset(ap, 0, sizeof(*ap));
2743     ap->sample_rate = audio_sample_rate;
2744     ap->channels = audio_channels;
2745     ap->frame_rate = frame_rate;
2746     ap->frame_rate_base = frame_rate_base;
2747     ap->width = frame_width + frame_padleft + frame_padright;
2748     ap->height = frame_height + frame_padtop + frame_padbottom;
2749     ap->image_format = image_format;
2750     ap->pix_fmt = frame_pix_fmt;
2751
2752     /* open the input file with generic libav function */
2753     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2754     if (err < 0) {
2755         print_error(filename, err);
2756         exit(1);
2757     }
2758
2759     /* If not enough info to get the stream parameters, we decode the
2760        first frames to get it. (used in mpeg case for example) */
2761     ret = av_find_stream_info(ic);
2762     if (ret < 0 && verbose >= 0) {
2763         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2764         exit(1);
2765     }
2766
2767     timestamp = start_time;
2768     /* add the stream start time */
2769     if (ic->start_time != AV_NOPTS_VALUE)
2770         timestamp += ic->start_time;
2771
2772     /* if seeking requested, we execute it */
2773     if (start_time != 0) {
2774         ret = av_seek_frame(ic, -1, timestamp);
2775         if (ret < 0) {
2776             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2777                     filename, (double)timestamp / AV_TIME_BASE);
2778         }
2779         /* reset seek info */
2780         start_time = 0;
2781     }
2782
2783     /* update the current parameters so that they match the one of the input stream */
2784     for(i=0;i<ic->nb_streams;i++) {
2785         AVCodecContext *enc = &ic->streams[i]->codec;
2786 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2787         if(thread_count>1)
2788             avcodec_thread_init(enc, thread_count);
2789 #endif
2790         enc->thread_count= thread_count;
2791         switch(enc->codec_type) {
2792         case CODEC_TYPE_AUDIO:
2793             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2794             audio_channels = enc->channels;
2795             audio_sample_rate = enc->sample_rate;
2796             break;
2797         case CODEC_TYPE_VIDEO:
2798             frame_height = enc->height;
2799             frame_width = enc->width;
2800             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2801             frame_pix_fmt = enc->pix_fmt;
2802             rfps      = ic->streams[i]->r_frame_rate;
2803             rfps_base = ic->streams[i]->r_frame_rate_base;
2804             enc->workaround_bugs = workaround_bugs;
2805             enc->error_resilience = error_resilience;
2806             enc->error_concealment = error_concealment;
2807             enc->idct_algo = idct_algo;
2808             enc->debug = debug;
2809             enc->debug_mv = debug_mv;
2810             enc->lowres= lowres;
2811             if(bitexact)
2812                 enc->flags|= CODEC_FLAG_BITEXACT;
2813             if(me_threshold)
2814                 enc->debug |= FF_DEBUG_MV;
2815
2816             assert(enc->frame_rate_base == rfps_base); // should be true for now
2817             if (enc->frame_rate != rfps) {
2818
2819                 if (verbose >= 0)
2820                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2821                             i, (float)enc->frame_rate / enc->frame_rate_base,
2822
2823                     (float)rfps / rfps_base);
2824             }
2825             /* update the current frame rate to match the stream frame rate */
2826             frame_rate      = rfps;
2827             frame_rate_base = rfps_base;
2828
2829             enc->rate_emu = rate_emu;
2830             break;
2831         case CODEC_TYPE_DATA:
2832             break;
2833         default:
2834             av_abort();
2835         }
2836     }
2837
2838     input_files[nb_input_files] = ic;
2839     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2840     /* dump the file content */
2841     if (verbose >= 0)
2842         dump_format(ic, nb_input_files, filename, 0);
2843
2844     nb_input_files++;
2845     file_iformat = NULL;
2846     file_oformat = NULL;
2847     image_format = NULL;
2848
2849     rate_emu = 0;
2850 }
2851
2852 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2853 {
2854     int has_video, has_audio, i, j;
2855     AVFormatContext *ic;
2856
2857     has_video = 0;
2858     has_audio = 0;
2859     for(j=0;j<nb_input_files;j++) {
2860         ic = input_files[j];
2861         for(i=0;i<ic->nb_streams;i++) {
2862             AVCodecContext *enc = &ic->streams[i]->codec;
2863             switch(enc->codec_type) {
2864             case CODEC_TYPE_AUDIO:
2865                 has_audio = 1;
2866                 break;
2867             case CODEC_TYPE_VIDEO:
2868                 has_video = 1;
2869                 break;
2870             case CODEC_TYPE_DATA:
2871                 break;
2872             default:
2873                 av_abort();
2874             }
2875         }
2876     }
2877     *has_video_ptr = has_video;
2878     *has_audio_ptr = has_audio;
2879 }
2880
2881 static void opt_output_file(const char *filename)
2882 {
2883     AVStream *st;
2884     AVFormatContext *oc;
2885     int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2886     int codec_id;
2887     AVFormatParameters params, *ap = &params;
2888
2889     if (!strcmp(filename, "-"))
2890         filename = "pipe:";
2891
2892     oc = av_alloc_format_context();
2893
2894     if (!file_oformat) {
2895         file_oformat = guess_format(NULL, filename, NULL);
2896         if (!file_oformat) {
2897             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2898                     filename);
2899             exit(1);
2900         }
2901     }
2902
2903     oc->oformat = file_oformat;
2904
2905     if (!strcmp(file_oformat->name, "ffm") &&
2906         strstart(filename, "http:", NULL)) {
2907         /* special case for files sent to ffserver: we get the stream
2908            parameters from ffserver */
2909         if (read_ffserver_streams(oc, filename) < 0) {
2910             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2911             exit(1);
2912         }
2913     } else {
2914         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2915         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2916
2917         /* disable if no corresponding type found and at least one
2918            input file */
2919         if (nb_input_files > 0) {
2920             check_audio_video_inputs(&input_has_video, &input_has_audio);
2921             if (!input_has_video)
2922                 use_video = 0;
2923             if (!input_has_audio)
2924                 use_audio = 0;
2925         }
2926
2927         /* manual disable */
2928         if (audio_disable) {
2929             use_audio = 0;
2930         }
2931         if (video_disable) {
2932             use_video = 0;
2933         }
2934
2935         nb_streams = 0;
2936         if (use_video) {
2937             AVCodecContext *video_enc;
2938
2939             st = av_new_stream(oc, nb_streams++);
2940             if (!st) {
2941                 fprintf(stderr, "Could not alloc stream\n");
2942                 exit(1);
2943             }
2944 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2945             if(thread_count>1)
2946                 avcodec_thread_init(&st->codec, thread_count);
2947 #endif
2948
2949             video_enc = &st->codec;
2950
2951             if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2952                 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2953             if (video_stream_copy) {
2954                 st->stream_copy = 1;
2955                 video_enc->codec_type = CODEC_TYPE_VIDEO;
2956             } else {
2957                 char *p;
2958                 int i;
2959                 AVCodec *codec;
2960
2961                 codec_id = file_oformat->video_codec;
2962                 if (video_codec_id != CODEC_ID_NONE)
2963                     codec_id = video_codec_id;
2964
2965                 video_enc->codec_id = codec_id;
2966                 codec = avcodec_find_encoder(codec_id);
2967
2968                 video_enc->bit_rate = video_bit_rate;
2969                 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2970                 video_enc->frame_rate = frame_rate;
2971                 video_enc->frame_rate_base = frame_rate_base;
2972                 if(codec && codec->supported_framerates){
2973                     const AVRational *p= codec->supported_framerates;
2974                     AVRational req= (AVRational){frame_rate, frame_rate_base};
2975                     const AVRational *best=NULL;
2976                     AVRational best_error= (AVRational){INT_MAX, 1};
2977                     for(; p->den!=0; p++){
2978                         AVRational error= av_sub_q(req, *p);
2979                         if(error.num <0) error.num *= -1;
2980                         if(av_cmp_q(error, best_error) < 0){
2981                             best_error= error;
2982                             best= p;
2983                         }
2984                     }
2985                     video_enc->frame_rate     = best->num;
2986                     video_enc->frame_rate_base= best->den;
2987                 }
2988
2989                 video_enc->width = frame_width + frame_padright + frame_padleft;
2990                 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2991                 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2992                 video_enc->pix_fmt = frame_pix_fmt;
2993
2994                 if(codec && codec->pix_fmts){
2995                     const enum PixelFormat *p= codec->pix_fmts;
2996                     for(; *p!=-1; p++){
2997                         if(*p == video_enc->pix_fmt)
2998                             break;
2999                     }
3000                     if(*p == -1)
3001                         video_enc->pix_fmt = codec->pix_fmts[0];
3002                 }
3003
3004                 if (!intra_only)
3005                     video_enc->gop_size = gop_size;
3006                 else
3007                     video_enc->gop_size = 0;
3008                 if (video_qscale || same_quality) {
3009                     video_enc->flags |= CODEC_FLAG_QSCALE;
3010                     st->quality = FF_QP2LAMBDA * video_qscale;
3011                 }
3012
3013                 if(intra_matrix)
3014                     video_enc->intra_matrix = intra_matrix;
3015                 if(inter_matrix)
3016                     video_enc->inter_matrix = inter_matrix;
3017
3018                 if(bitexact)
3019                     video_enc->flags |= CODEC_FLAG_BITEXACT;
3020
3021                 video_enc->mb_decision = mb_decision;
3022                 video_enc->mb_cmp = mb_cmp;
3023                 video_enc->ildct_cmp = ildct_cmp;
3024                 video_enc->me_sub_cmp = sub_cmp;
3025                 video_enc->me_cmp = cmp;
3026                 video_enc->me_pre_cmp = pre_cmp;
3027                 video_enc->pre_me = pre_me;
3028                 video_enc->lumi_masking = lumi_mask;
3029                 video_enc->dark_masking = dark_mask;
3030                 video_enc->spatial_cplx_masking = scplx_mask;
3031                 video_enc->temporal_cplx_masking = tcplx_mask;
3032                 video_enc->p_masking = p_mask;
3033                 video_enc->quantizer_noise_shaping= qns;
3034
3035                 if (use_umv) {
3036                     video_enc->flags |= CODEC_FLAG_H263P_UMV;
3037                 }
3038                 if (use_ss) {
3039                     video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3040                 }
3041                 if (use_aic) {
3042                     video_enc->flags |= CODEC_FLAG_H263P_AIC;
3043                 }
3044                 if (use_aiv) {
3045                     video_enc->flags |= CODEC_FLAG_H263P_AIV;
3046                 }
3047                 if (use_4mv) {
3048                     video_enc->flags |= CODEC_FLAG_4MV;
3049                 }
3050                 if (use_obmc) {
3051                     video_enc->flags |= CODEC_FLAG_OBMC;
3052                 }
3053                 if (use_loop) {
3054                     video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3055                 }
3056
3057                 if(use_part) {
3058                     video_enc->flags |= CODEC_FLAG_PART;
3059                 }
3060                 if (use_alt_scan) {
3061                     video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3062                 }
3063                 if (use_trell) {
3064                     video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3065                 }
3066                 if (use_scan_offset) {
3067                     video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3068                 }
3069                 if (closed_gop) {
3070                     video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3071                 }
3072                 if (use_qpel) {
3073                     video_enc->flags |= CODEC_FLAG_QPEL;
3074                 }
3075                 if (use_qprd) {
3076                     video_enc->flags |= CODEC_FLAG_QP_RD;
3077                 }
3078                 if (use_cbprd) {
3079                     video_enc->flags |= CODEC_FLAG_CBP_RD;
3080                 }
3081                 if (b_frames) {
3082                     video_enc->max_b_frames = b_frames;
3083                     video_enc->b_frame_strategy = 0;
3084                     video_enc->b_quant_factor = 2.0;
3085                 }
3086                 if (do_interlace_dct) {
3087                     video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3088                 }
3089                 if (do_interlace_me) {
3090                     video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3091                 }
3092                 video_enc->qmin = video_qmin;
3093                 video_enc->qmax = video_qmax;
3094                 video_enc->lmin = video_lmin;
3095                 video_enc->lmax = video_lmax;
3096                 video_enc->mb_qmin = video_mb_qmin;
3097                 video_enc->mb_qmax = video_mb_qmax;
3098                 video_enc->max_qdiff = video_qdiff;
3099                 video_enc->qblur = video_qblur;
3100                 video_enc->qcompress = video_qcomp;
3101                 video_enc->rc_eq = video_rc_eq;
3102                 video_enc->debug = debug;
3103                 video_enc->debug_mv = debug_mv;
3104                 video_enc->thread_count = thread_count;
3105                 p= video_rc_override_string;
3106                 for(i=0; p; i++){
3107                     int start, end, q;
3108                     int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3109                     if(e!=3){
3110                         fprintf(stderr, "error parsing rc_override\n");
3111                         exit(1);
3112                     }
3113                     video_enc->rc_override=
3114                         av_realloc(video_enc->rc_override,
3115                                    sizeof(RcOverride)*(i+1));
3116                     video_enc->rc_override[i].start_frame= start;
3117                     video_enc->rc_override[i].end_frame  = end;
3118                     if(q>0){
3119                         video_enc->rc_override[i].qscale= q;
3120                         video_enc->rc_override[i].quality_factor= 1.0;
3121                     }
3122                     else{
3123                         video_enc->rc_override[i].qscale= 0;
3124                         video_enc->rc_override[i].quality_factor= -q/100.0;
3125                     }
3126                     p= strchr(p, '/');
3127                     if(p) p++;
3128                 }
3129                 video_enc->rc_override_count=i;
3130
3131                 video_enc->rc_max_rate = video_rc_max_rate;
3132                 video_enc->rc_min_rate = video_rc_min_rate;
3133                 video_enc->rc_buffer_size = video_rc_buffer_size;
3134                 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3135                 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3136                 video_enc->i_quant_factor = video_i_qfactor;
3137                 video_enc->b_quant_factor = video_b_qfactor;
3138                 video_enc->i_quant_offset = video_i_qoffset;
3139                 video_enc->b_quant_offset = video_b_qoffset;
3140                 video_enc->intra_quant_bias = video_intra_quant_bias;
3141                 video_enc->inter_quant_bias = video_inter_quant_bias;
3142                 video_enc->dct_algo = dct_algo;
3143                 video_enc->idct_algo = idct_algo;
3144                 video_enc->me_threshold= me_threshold;
3145                 video_enc->mb_threshold= mb_threshold;
3146                 video_enc->intra_dc_precision= intra_dc_precision - 8;
3147                 video_enc->strict_std_compliance = strict;
3148                 video_enc->error_rate = error_rate;
3149                 video_enc->noise_reduction= noise_reduction;
3150                 video_enc->scenechange_threshold= sc_threshold;
3151                 video_enc->me_range = me_range;
3152                 video_enc->coder_type= coder;
3153                 video_enc->context_model= context;
3154                 video_enc->prediction_method= predictor;
3155                 video_enc->profile= video_profile;
3156                 video_enc->level= video_level;
3157                 video_enc->nsse_weight= nsse_weight;
3158                 video_enc->me_subpel_quality= subpel_quality;
3159
3160                 if(packet_size){
3161                     video_enc->rtp_mode= 1;
3162                     video_enc->rtp_payload_size= packet_size;
3163                 }
3164
3165                 if (do_psnr)
3166                     video_enc->flags|= CODEC_FLAG_PSNR;
3167
3168                 video_enc->me_method = me_method;
3169
3170                 /* two pass mode */
3171                 if (do_pass) {
3172                     if (do_pass == 1) {
3173                         video_enc->flags |= CODEC_FLAG_PASS1;
3174                     } else {
3175                         video_enc->flags |= CODEC_FLAG_PASS2;
3176                     }
3177                 }
3178             }
3179         }
3180
3181         if (use_audio) {
3182             AVCodecContext *audio_enc;
3183
3184             st = av_new_stream(oc, nb_streams++);
3185             if (!st) {
3186                 fprintf(stderr, "Could not alloc stream\n");
3187                 exit(1);
3188             }
3189 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3190             if(thread_count>1)
3191                 avcodec_thread_init(&st->codec, thread_count);
3192 #endif
3193
3194             audio_enc = &st->codec;
3195             audio_enc->codec_type = CODEC_TYPE_AUDIO;
3196
3197             if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3198                 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3199             if (audio_stream_copy) {
3200                 st->stream_copy = 1;
3201                 audio_enc->channels = audio_channels;
3202             } else {
3203                 codec_id = file_oformat->audio_codec;
3204                 if (audio_codec_id != CODEC_ID_NONE)
3205                     codec_id = audio_codec_id;
3206                 audio_enc->codec_id = codec_id;
3207
3208                 audio_enc->bit_rate = audio_bit_rate;
3209                 audio_enc->strict_std_compliance = strict;
3210                 audio_enc->thread_count = thread_count;
3211                 /* For audio codecs other than AC3 or DTS we limit */
3212                 /* the number of coded channels to stereo   */
3213                 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3214                     && codec_id != CODEC_ID_DTS) {
3215                     audio_enc->channels = 2;
3216                 } else
3217                     audio_enc->channels = audio_channels;
3218             }
3219             audio_enc->sample_rate = audio_sample_rate;
3220         }
3221
3222         oc->nb_streams = nb_streams;
3223
3224         if (!nb_streams) {
3225             fprintf(stderr, "No audio or video streams available\n");
3226             exit(1);
3227         }
3228
3229         oc->timestamp = rec_timestamp;
3230
3231         if (str_title)
3232             pstrcpy(oc->title, sizeof(oc->title), str_title);
3233         if (str_author)
3234             pstrcpy(oc->author, sizeof(oc->author), str_author);
3235         if (str_copyright)
3236             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3237         if (str_comment)
3238             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3239     }
3240
3241     output_files[nb_output_files++] = oc;
3242
3243     strcpy(oc->filename, filename);
3244
3245     /* check filename in case of an image number is expected */
3246     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3247         if (filename_number_test(oc->filename) < 0) {
3248             print_error(oc->filename, AVERROR_NUMEXPECTED);
3249             exit(1);
3250         }
3251     }
3252
3253     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3254         /* test if it already exists to avoid loosing precious files */
3255         if (!file_overwrite &&
3256             (strchr(filename, ':') == NULL ||
3257              strstart(filename, "file:", NULL))) {
3258             if (url_exist(filename)) {
3259                 int c;
3260
3261                 if ( !using_stdin ) {
3262                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3263                     fflush(stderr);
3264                     c = getchar();
3265                     if (toupper(c) != 'Y') {
3266                         fprintf(stderr, "Not overwriting - exiting\n");
3267                         exit(1);
3268                     }
3269                                 }
3270                                 else {
3271                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3272                     exit(1);
3273                                 }
3274             }
3275         }
3276
3277         /* open the file */
3278         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3279             fprintf(stderr, "Could not open '%s'\n", filename);
3280             exit(1);
3281         }
3282     }
3283
3284     memset(ap, 0, sizeof(*ap));
3285     ap->image_format = image_format;
3286     if (av_set_parameters(oc, ap) < 0) {
3287         fprintf(stderr, "%s: Invalid encoding parameters\n",
3288                 oc->filename);
3289         exit(1);
3290     }
3291
3292     /* reset some options */
3293     file_oformat = NULL;
3294     file_iformat = NULL;
3295     image_format = NULL;
3296     audio_disable = 0;
3297     video_disable = 0;
3298     audio_codec_id = CODEC_ID_NONE;
3299     video_codec_id = CODEC_ID_NONE;
3300     audio_stream_copy = 0;
3301     video_stream_copy = 0;
3302 }
3303
3304 /* prepare dummy protocols for grab */
3305 static void prepare_grab(void)
3306 {
3307     int has_video, has_audio, i, j;
3308     AVFormatContext *oc;
3309     AVFormatContext *ic;
3310     AVFormatParameters vp1, *vp = &vp1;
3311     AVFormatParameters ap1, *ap = &ap1;
3312
3313     /* see if audio/video inputs are needed */
3314     has_video = 0;
3315     has_audio = 0;
3316     memset(ap, 0, sizeof(*ap));
3317     memset(vp, 0, sizeof(*vp));
3318     vp->frame_rate_base= 1;
3319     for(j=0;j<nb_output_files;j++) {
3320         oc = output_files[j];
3321         for(i=0;i<oc->nb_streams;i++) {
3322             AVCodecContext *enc = &oc->streams[i]->codec;
3323             switch(enc->codec_type) {
3324             case CODEC_TYPE_AUDIO:
3325                 if (enc->sample_rate > ap->sample_rate)
3326                     ap->sample_rate = enc->sample_rate;
3327                 if (enc->channels > ap->channels)
3328                     ap->channels = enc->channels;
3329                 has_audio = 1;
3330                 break;
3331             case CODEC_TYPE_VIDEO:
3332                 if (enc->width > vp->width)
3333                     vp->width = enc->width;
3334                 if (enc->height > vp->height)
3335                     vp->height = enc->height;
3336
3337                 if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3338                     vp->frame_rate      = enc->frame_rate;
3339                     vp->frame_rate_base = enc->frame_rate_base;
3340                 }
3341                 has_video = 1;
3342                 break;
3343             default:
3344                 av_abort();
3345             }
3346         }
3347     }
3348
3349     if (has_video == 0 && has_audio == 0) {
3350         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3351         exit(1);
3352     }
3353
3354     if (has_video) {
3355         AVInputFormat *fmt1;
3356         fmt1 = av_find_input_format(video_grab_format);
3357         vp->device  = video_device;
3358         vp->channel = video_channel;
3359         vp->standard = video_standard;
3360         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3361             fprintf(stderr, "Could not find video grab device\n");
3362             exit(1);
3363         }
3364         /* If not enough info to get the stream parameters, we decode the
3365            first frames to get it. */
3366         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3367             fprintf(stderr, "Could not find video grab parameters\n");
3368             exit(1);
3369         }
3370         /* by now video grab has one stream */
3371         ic->streams[0]->r_frame_rate      = vp->frame_rate;
3372         ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3373         input_files[nb_input_files] = ic;
3374
3375         if (verbose >= 0)
3376             dump_format(ic, nb_input_files, "", 0);
3377
3378         nb_input_files++;
3379     }
3380     if (has_audio && audio_grab_format) {
3381         AVInputFormat *fmt1;
3382         fmt1 = av_find_input_format(audio_grab_format);
3383         ap->device = audio_device;
3384         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3385             fprintf(stderr, "Could not find audio grab device\n");
3386             exit(1);
3387         }
3388         input_files[nb_input_files] = ic;
3389
3390         if (verbose >= 0)
3391             dump_format(ic, nb_input_files, "", 0);
3392
3393         nb_input_files++;
3394     }
3395 }
3396
3397 /* same option as mencoder */
3398 static void opt_pass(const char *pass_str)
3399 {
3400     int pass;
3401     pass = atoi(pass_str);
3402     if (pass != 1 && pass != 2) {
3403         fprintf(stderr, "pass number can be only 1 or 2\n");
3404         exit(1);
3405     }
3406     do_pass = pass;
3407 }
3408
3409 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3410 static int64_t getutime(void)
3411 {
3412   return av_gettime();
3413 }
3414 #else
3415 static int64_t getutime(void)
3416 {
3417     struct rusage rusage;
3418
3419     getrusage(RUSAGE_SELF, &rusage);
3420     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3421 }
3422 #endif
3423
3424 extern int ffm_nopts;
3425
3426 static void opt_bitexact(void)
3427 {
3428     bitexact=1;
3429     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3430     ffm_nopts = 1;
3431 }
3432
3433 static void show_formats(void)
3434 {
3435     AVInputFormat *ifmt;
3436     AVOutputFormat *ofmt;
3437     AVImageFormat *image_fmt;
3438     URLProtocol *up;
3439     AVCodec *p, *p2;
3440     const char **pp, *last_name;
3441
3442     printf("File formats:\n");
3443     last_name= "000";
3444     for(;;){
3445         int decode=0;
3446         int encode=0;
3447         const char *name=NULL;
3448
3449         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3450             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3451                 strcmp(ofmt->name, last_name)>0){
3452                 name= ofmt->name;
3453                 encode=1;
3454             }
3455         }
3456         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3457             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3458                 strcmp(ifmt->name, last_name)>0){
3459                 name= ifmt->name;
3460                 encode=0;
3461             }
3462             if(name && strcmp(ifmt->name, name)==0)
3463                 decode=1;
3464         }
3465         if(name==NULL)
3466             break;
3467         last_name= name;
3468
3469         printf(
3470             " %s%s %s\n",
3471             decode ? "D":" ",
3472             encode ? "E":" ",
3473             name);
3474     }
3475     printf("\n");
3476
3477     printf("Image formats:\n");
3478     for(image_fmt = first_image_format; image_fmt != NULL;
3479         image_fmt = image_fmt->next) {
3480         printf(
3481             " %s%s %s\n",
3482             image_fmt->img_read  ? "D":" ",
3483             image_fmt->img_write ? "E":" ",
3484             image_fmt->name);
3485     }
3486     printf("\n");
3487
3488     printf("Codecs:\n");
3489     last_name= "000";
3490     for(;;){
3491         int decode=0;
3492         int encode=0;
3493         int cap=0;
3494
3495         p2=NULL;
3496         for(p = first_avcodec; p != NULL; p = p->next) {
3497             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3498                 strcmp(p->name, last_name)>0){
3499                 p2= p;
3500                 decode= encode= cap=0;
3501             }
3502             if(p2 && strcmp(p->name, p2->name)==0){
3503                 if(p->decode) decode=1;
3504                 if(p->encode) encode=1;
3505                 cap |= p->capabilities;
3506             }
3507         }
3508         if(p2==NULL)
3509             break;
3510         last_name= p2->name;
3511
3512         printf(
3513             " %s%s%s%s%s%s %s",
3514             decode ? "D": (/*p2->decoder ? "d":*/" "),
3515             encode ? "E":" ",
3516             p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3517             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3518             cap & CODEC_CAP_DR1 ? "D":" ",
3519             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3520             p2->name);
3521        /* if(p2->decoder && decode==0)
3522             printf(" use %s for decoding", p2->decoder->name);*/
3523         printf("\n");
3524     }
3525     printf("\n");
3526
3527     printf("Supported file protocols:\n");
3528     for(up = first_protocol; up != NULL; up = up->next)
3529         printf(" %s:", up->name);
3530     printf("\n");
3531
3532     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3533     printf("Motion estimation methods:\n");
3534     pp = motion_str;
3535     while (*pp) {
3536         printf(" %s", *pp);
3537         if ((pp - motion_str + 1) == ME_ZERO)
3538             printf("(fastest)");
3539         else if ((pp - motion_str + 1) == ME_FULL)
3540             printf("(slowest)");
3541         else if ((pp - motion_str + 1) == ME_EPZS)
3542             printf("(default)");
3543         pp++;
3544     }
3545     printf("\n\n");
3546     printf(
3547 "Note, the names of encoders and decoders dont always match, so there are\n"
3548 "several cases where the above table shows encoder only or decoder only entries\n"
3549 "even though both encoding and decoding are supported for example, the h263\n"
3550 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3551 "worse\n");
3552     exit(1);
3553 }
3554
3555 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3556 {
3557     int i;
3558     const char *p = str;
3559     for(i = 0;; i++) {
3560         dest[i] = atoi(p);
3561         if(i == 63)
3562             break;
3563         p = strchr(p, ',');
3564         if(!p) {
3565             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3566             exit(1);
3567         }
3568         p++;
3569     }
3570 }
3571
3572 void opt_inter_matrix(const char *arg)
3573 {
3574     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3575     parse_matrix_coeffs(inter_matrix, arg);
3576 }
3577
3578 void opt_intra_matrix(const char *arg)
3579 {
3580     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3581     parse_matrix_coeffs(intra_matrix, arg);
3582 }
3583
3584 static void opt_target(const char *arg)
3585 {
3586     int norm = -1;
3587
3588     if(!strncmp(arg, "pal-", 4)) {
3589         norm = 0;
3590         arg += 4;
3591     } else if(!strncmp(arg, "ntsc-", 5)) {
3592         norm = 1;
3593         arg += 5;
3594     } else {
3595         int fr;
3596         /* Calculate FR via float to avoid int overflow */
3597         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3598         if(fr == 25000) {
3599             norm = 0;
3600         } else if((fr == 29970) || (fr == 23976)) {
3601             norm = 1;
3602         } else {
3603             /* Try to determine PAL/NTSC by peeking in the input files */
3604             if(nb_input_files) {
3605                 int i, j;
3606                 for(j = 0; j < nb_input_files; j++) {
3607                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3608                         AVCodecContext *c = &input_files[j]->streams[i]->codec;
3609                         if(c->codec_type != CODEC_TYPE_VIDEO)
3610                             continue;
3611                         fr = c->frame_rate * 1000 / c->frame_rate_base;
3612                         if(fr == 25000) {
3613                             norm = 0;
3614                             break;
3615                         } else if((fr == 29970) || (fr == 23976)) {
3616                             norm = 1;
3617                             break;
3618                         }
3619                     }
3620                     if(norm >= 0)
3621                         break;
3622                 }
3623             }
3624         }
3625         if(verbose && norm >= 0)
3626             printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3627     }
3628
3629     if(norm < 0) {
3630         fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3631         fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3632         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3633         exit(1);
3634     }
3635
3636     if(!strcmp(arg, "vcd")) {
3637
3638         opt_video_codec("mpeg1video");
3639         opt_audio_codec("mp2");
3640         opt_format("vcd");
3641
3642         opt_frame_size(norm ? "352x240" : "352x288");
3643
3644         video_bit_rate = 1150000;
3645         video_rc_max_rate = 1150000;
3646         video_rc_min_rate = 1150000;
3647         video_rc_buffer_size = 40*1024*8;
3648
3649         audio_bit_rate = 224000;
3650         audio_sample_rate = 44100;
3651
3652     } else if(!strcmp(arg, "svcd")) {
3653
3654         opt_video_codec("mpeg2video");
3655         opt_audio_codec("mp2");
3656         opt_format("svcd");
3657
3658         opt_frame_size(norm ? "480x480" : "480x576");
3659         opt_gop_size(norm ? "18" : "15");
3660
3661         video_bit_rate = 2040000;
3662         video_rc_max_rate = 2516000;
3663         video_rc_min_rate = 0; //1145000;
3664         video_rc_buffer_size = 224*1024*8;
3665         use_scan_offset = 1;
3666
3667         audio_bit_rate = 224000;
3668         audio_sample_rate = 44100;
3669
3670     } else if(!strcmp(arg, "dvd")) {
3671
3672         opt_video_codec("mpeg2video");
3673         opt_audio_codec("ac3");
3674         opt_format("vob");
3675
3676         opt_frame_size(norm ? "720x480" : "720x576");
3677         opt_gop_size(norm ? "18" : "15");
3678
3679         video_bit_rate = 6000000;
3680         video_rc_max_rate = 9000000;
3681         video_rc_min_rate = 0; //1500000;
3682         video_rc_buffer_size = 224*1024*8;
3683
3684         audio_bit_rate = 448000;
3685         audio_sample_rate = 48000;
3686
3687     } else {
3688         fprintf(stderr, "Unknown target: %s\n", arg);
3689         exit(1);
3690     }
3691 }
3692
3693 static void show_version(void)
3694 {
3695     printf("ffmpeg      " FFMPEG_VERSION "\n"
3696            "libavcodec  %d\n"
3697            "libavformat %d\n",
3698            avcodec_build(), LIBAVFORMAT_BUILD);
3699     exit(1);
3700 }
3701
3702 const OptionDef options[] = {
3703     /* main options */
3704     { "L", 0, {(void*)show_license}, "show license" },
3705     { "h", 0, {(void*)show_help}, "show help" },
3706     { "version", 0, {(void*)show_version}, "show version" },
3707     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3708     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3709     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3710     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3711     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3712     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3713     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3714     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3715     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3716     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3717     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3718     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3719     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3720     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3721     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3722     { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3723     { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3724     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3725       "add timings for benchmarking" },
3726     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3727       "dump each input packet" },
3728     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3729       "when dumping packets, also dump the payload" },
3730     { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3731     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3732     { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3733     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3734     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3735     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3736     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3737     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3738     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3739
3740     /* video options */
3741     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3742     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3743     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3744     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3745     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3746     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3747     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3748     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3749     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3750     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3751     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3752     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3753     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3754     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3755     { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3756     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3757     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3758     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3759     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3760     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3761     { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3762     { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3763     { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3764     { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3765     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3766     { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3767     { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3768     { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3769     { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3770     { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3771     { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3772     { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3773     { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3774     { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3775 //    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3776     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3777     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3778     { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3779     { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3780     { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3781     { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3782     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3783     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3784       "method" },
3785     { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3786     { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3787     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3788     { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3789     { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3790     { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3791     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3792     { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3793     { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3794     { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3795     { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3796     { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3797     { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3798     { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3799     { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3800     { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3801     { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3802     { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3803     { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3804     { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3805     { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3806     { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3807     { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3808     { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3809     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3810     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3811     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3812     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3813     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3814       "use same video quality as source (implies VBR)" },
3815     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3816     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3817     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3818       "deinterlace pictures" },
3819     { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3820       "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3821     { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3822       "force interlaced me support in encoder (MPEG2/MPEG4)" },
3823     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3824     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3825     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3826     { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3827     { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3828     { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3829     { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3830     { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3831     { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3832     { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3833     { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3834     { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3835     { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3836     { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3837     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3838     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3839     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3840     { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3841     { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3842     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3843     { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3844     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3845     { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3846     { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3847     { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3848     { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3849     { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3850     { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3851     { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3852     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3853
3854     /* audio options */
3855     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3856     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3857     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3858     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3859     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3860
3861     /* grab options */
3862     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3863     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3864     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3865     { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3866     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3867     { NULL, },
3868 };
3869
3870 static void show_banner(void)
3871 {
3872     printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3873         LIBAVCODEC_BUILD);
3874     printf("  built on " __DATE__ " " __TIME__);
3875 #ifdef __GNUC__
3876     printf(", gcc: %s\n", __VERSION__);
3877 #else
3878     printf(", using a non-gcc compiler\n");
3879 #endif
3880 }
3881
3882 static void show_license(void)
3883 {
3884     show_banner();
3885 #ifdef CONFIG_GPL
3886     printf(
3887     "This program is free software; you can redistribute it and/or modify\n"
3888     "it under the terms of the GNU General Public License as published by\n"
3889     "the Free Software Foundation; either version 2 of the License, or\n"
3890     "(at your option) any later version.\n"
3891     "\n"
3892     "This program is distributed in the hope that it will be useful,\n"
3893     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3894     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3895     "GNU General Public License for more details.\n"
3896     "\n"
3897     "You should have received a copy of the GNU General Public License\n"
3898     "along with this program; if not, write to the Free Software\n"
3899     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3900     );
3901 #else
3902     printf(
3903     "This library is free software; you can redistribute it and/or\n"
3904     "modify it under the terms of the GNU Lesser General Public\n"
3905     "License as published by the Free Software Foundation; either\n"
3906     "version 2 of the License, or (at your option) any later version.\n"
3907     "\n"
3908     "This library is distributed in the hope that it will be useful,\n"
3909     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3910     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3911     "Lesser General Public License for more details.\n"
3912     "\n"
3913     "You should have received a copy of the GNU Lesser General Public\n"
3914     "License along with this library; if not, write to the Free Software\n"
3915     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3916     );
3917 #endif
3918     exit(1);
3919 }
3920
3921 static void show_help(void)
3922 {
3923     show_banner();
3924     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3925            "Hyper fast Audio and Video encoder\n");
3926     printf("\n");
3927     show_help_options(options, "Main options:\n",
3928                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3929     show_help_options(options, "\nVideo options:\n",
3930                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3931                       OPT_VIDEO);
3932     show_help_options(options, "\nAdvanced Video options:\n",
3933                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3934                       OPT_VIDEO | OPT_EXPERT);
3935     show_help_options(options, "\nAudio options:\n",
3936                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3937                       OPT_AUDIO);
3938     show_help_options(options, "\nAdvanced Audio options:\n",
3939                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3940                       OPT_AUDIO | OPT_EXPERT);
3941     show_help_options(options, "\nAudio/Video grab options:\n",
3942                       OPT_GRAB,
3943                       OPT_GRAB);
3944     show_help_options(options, "\nAdvanced options:\n",
3945                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3946                       OPT_EXPERT);
3947     exit(1);
3948 }
3949
3950 void parse_arg_file(const char *filename)
3951 {
3952     opt_output_file(filename);
3953 }
3954
3955 int main(int argc, char **argv)
3956 {
3957     int i;
3958     int64_t ti;
3959
3960     av_register_all();
3961
3962     if (argc <= 1)
3963         show_help();
3964     else
3965         show_banner();
3966
3967     /* parse options */
3968     parse_options(argc, argv, options);
3969
3970     /* file converter / grab */
3971     if (nb_output_files <= 0) {
3972         fprintf(stderr, "Must supply at least one output file\n");
3973         exit(1);
3974     }
3975
3976     if (nb_input_files == 0) {
3977         input_sync = 1;
3978         prepare_grab();
3979     }
3980
3981     ti = getutime();
3982     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3983               stream_maps, nb_stream_maps);
3984     ti = getutime() - ti;
3985     if (do_benchmark) {
3986         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3987     }
3988
3989     /* close files */
3990     for(i=0;i<nb_output_files;i++) {
3991         /* maybe av_close_output_file ??? */
3992         AVFormatContext *s = output_files[i];
3993         int j;
3994         if (!(s->oformat->flags & AVFMT_NOFILE))
3995             url_fclose(&s->pb);
3996         for(j=0;j<s->nb_streams;j++)
3997             av_free(s->streams[j]);
3998         av_free(s);
3999     }
4000     for(i=0;i<nb_input_files;i++)
4001         av_close_input_file(input_files[i]);
4002
4003     av_free_static();
4004
4005     if(intra_matrix)
4006         av_free(intra_matrix);
4007     if(inter_matrix)
4008         av_free(inter_matrix);
4009
4010 #ifdef POWERPC_PERFORMANCE_REPORT
4011     extern void powerpc_display_perf_report(void);
4012     powerpc_display_perf_report();
4013 #endif /* POWERPC_PERFORMANCE_REPORT */
4014
4015 #ifndef CONFIG_WIN32
4016     if (received_sigterm) {
4017         fprintf(stderr,
4018             "Received signal %d: terminating.\n",
4019             (int) received_sigterm);
4020         exit (255);
4021     }
4022 #endif
4023     exit(0); /* not all OS-es handle main() return value */
4024     return 0;
4025 }