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