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

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