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