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