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