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

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