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 "opt.h"
  28 #include "fifo.h"
  29
  30 #ifdef __MINGW32__
  31 #include <conio.h>
  32 #else
  33 #include <unistd.h>
  34 #include <fcntl.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/time.h>
  37 #include <termios.h>
  38 #include <sys/resource.h>
  39 #endif
  40 #ifdef CONFIG_OS2
  41 #include <sys/types.h>
  42 #include <sys/select.h>
  43 #include <stdlib.h>
  44 #endif
  45 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  46 #include <time.h>
  47
  48 #include "version.h"
  49 #include "cmdutils.h"
  50
  51 #undef NDEBUG
  52 #include <assert.h>
  53
  54 #if !defined(INFINITY) && defined(HUGE_VAL)
  55 #define INFINITY HUGE_VAL
  56 #endif
  57
  58 /* select an input stream for an output stream */
  59 typedef struct AVStreamMap {
  60     int file_index;
  61     int stream_index;
  62     int sync_file_index;
  63     int sync_stream_index;
  64 } AVStreamMap;
  65
  66 /** select an input file for an output file */
  67 typedef struct AVMetaDataMap {
  68     int out_file;
  69     int in_file;
  70 } AVMetaDataMap;
  71
  72 extern const OptionDef options[];
  73
  74 static void show_help(void);
  75 static void show_license(void);
  76 static int opt_default(const char *opt, const char *arg);
  77
  78 #define MAX_FILES 20
  79
  80 static AVFormatContext *input_files[MAX_FILES];
  81 static int64_t input_files_ts_offset[MAX_FILES];
  82 static int nb_input_files = 0;
  83
  84 static AVFormatContext *output_files[MAX_FILES];
  85 static int nb_output_files = 0;
  86
  87 static AVStreamMap stream_maps[MAX_FILES];
  88 static int nb_stream_maps;
  89
  90 static AVMetaDataMap meta_data_maps[MAX_FILES];
  91 static int nb_meta_data_maps;
  92
  93 static AVInputFormat *file_iformat;
  94 static AVOutputFormat *file_oformat;
  95 static int frame_width  = 0;
  96 static int frame_height = 0;
  97 static float frame_aspect_ratio = 0;
  98 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
  99 static int frame_padtop  = 0;
 100 static int frame_padbottom = 0;
 101 static int frame_padleft  = 0;
 102 static int frame_padright = 0;
 103 static int padcolor[3] = {16,128,128}; /* default to black */
 104 static int frame_topBand  = 0;
 105 static int frame_bottomBand = 0;
 106 static int frame_leftBand  = 0;
 107 static int frame_rightBand = 0;
 108 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 109 static int frame_rate = 25;
 110 static int frame_rate_base = 1;
 111 static float video_qscale = 0;
 112 static int video_qdiff = 3;
 113 static uint16_t *intra_matrix = NULL;
 114 static uint16_t *inter_matrix = NULL;
 115 #if 0 //experimental, (can be removed)
 116 static float video_rc_qsquish=1.0;
 117 static float video_rc_qmod_amp=0;
 118 static int video_rc_qmod_freq=0;
 119 #endif
 120 static char *video_rc_override_string=NULL;
 121 static char *video_rc_eq="tex^qComp";
 122 static int me_method = ME_EPZS;
 123 static int video_disable = 0;
 124 static int video_discard = 0;
 125 static int video_codec_id = CODEC_ID_NONE;
 126 static int video_codec_tag = 0;
 127 static int same_quality = 0;
 128 static int do_deinterlace = 0;
 129 static int strict = 0;
 130 static int top_field_first = -1;
 131 static int me_threshold = 0;
 132 static int intra_dc_precision = 8;
 133 static int loop_input = 0;
 134 static int loop_output = AVFMT_NOOUTPUTLOOP;
 135 static int qp_hist = 0;
 136
 137 static int intra_only = 0;
 138 static int audio_sample_rate = 44100;
 139 #define QSCALE_NONE -99999
 140 static float audio_qscale = QSCALE_NONE;
 141 static int audio_disable = 0;
 142 static int audio_channels = 1;
 143 static int audio_codec_id = CODEC_ID_NONE;
 144 static int audio_codec_tag = 0;
 145 static char *audio_language = NULL;
 146
 147 static int subtitle_codec_id = CODEC_ID_NONE;
 148 static char *subtitle_language = NULL;
 149
 150 static float mux_preload= 0.5;
 151 static float mux_max_delay= 0.7;
 152
 153 static int64_t recording_time = 0;
 154 static int64_t start_time = 0;
 155 static int64_t rec_timestamp = 0;
 156 static int64_t input_ts_offset = 0;
 157 static int file_overwrite = 0;
 158 static char *str_title = NULL;
 159 static char *str_author = NULL;
 160 static char *str_copyright = NULL;
 161 static char *str_comment = NULL;
 162 static char *str_album = NULL;
 163 static int do_benchmark = 0;
 164 static int do_hex_dump = 0;
 165 static int do_pkt_dump = 0;
 166 static int do_psnr = 0;
 167 static int do_vstats = 0;
 168 static int do_pass = 0;
 169 static char *pass_logfilename = NULL;
 170 static int audio_stream_copy = 0;
 171 static int video_stream_copy = 0;
 172 static int subtitle_stream_copy = 0;
 173 static int video_sync_method= 1;
 174 static int audio_sync_method= 0;
 175 static int copy_ts= 0;
 176 static int opt_shortest = 0; //
 177 static int video_global_header = 0;
 178
 179 static int rate_emu = 0;
 180
 181 static int  video_channel = 0;
 182 static char *video_standard = "ntsc";
 183
 184 static int audio_volume = 256;
 185
 186 static int using_stdin = 0;
 187 static int using_vhook = 0;
 188 static int verbose = 1;
 189 static int thread_count= 1;
 190 static int q_pressed = 0;
 191 static int64_t video_size = 0;
 192 static int64_t audio_size = 0;
 193 static int64_t extra_size = 0;
 194 static int nb_frames_dup = 0;
 195 static int nb_frames_drop = 0;
 196 static int input_sync;
 197 static int limit_filesize = 0; //
 198
 199 static int pgmyuv_compatibility_hack=0;
 200 static int dts_delta_threshold = 10;
 201
 202 static int sws_flags = SWS_BICUBIC;
 203
 204 const char **opt_names=NULL;
 205 int opt_name_count=0;
 206 AVCodecContext *avctx_opts[CODEC_TYPE_NB];
 207 AVFormatContext *avformat_opts;
 208 static int64_t timer_start = 0;
 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             float t = (av_gettime()-timer_start) / 1000000.0;
 930
 931             frame_number = ost->frame_number;
 932             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
 933                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
 934                      enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
 935             if(is_last_report)
 936                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
 937             if(qp_hist && enc->coded_frame){
 938                 int j;
 939                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 940                 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
 941                     qp_histogram[qp]++;
 942                 for(j=0; j<32; j++)
 943                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
 944             }
 945             if (enc->flags&CODEC_FLAG_PSNR){
 946                 int j;
 947                 double error, error_sum=0;
 948                 double scale, scale_sum=0;
 949                 char type[3]= {'Y','U','V'};
 950                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
 951                 for(j=0; j<3; j++){
 952                     if(is_last_report){
 953                         error= enc->error[j];
 954                         scale= enc->width*enc->height*255.0*255.0*frame_number;
 955                     }else{
 956                         error= enc->coded_frame->error[j];
 957                         scale= enc->width*enc->height*255.0*255.0;
 958                     }
 959                     if(j) scale/=4;
 960                     error_sum += error;
 961                     scale_sum += scale;
 962                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
 963                 }
 964                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
 965             }
 966             vid = 1;
 967         }
 968         /* compute min output value */
 969         pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
 970         if ((pts < ti1) && (pts > 0))
 971             ti1 = pts;
 972     }
 973     if (ti1 < 0.01)
 974         ti1 = 0.01;
 975
 976     if (verbose || is_last_report) {
 977         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
 978
 979         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 980             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
 981             (double)total_size / 1024, ti1, bitrate);
 982
 983         if (verbose > 1)
 984           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
 985                   nb_frames_dup, nb_frames_drop);
 986
 987         if (verbose >= 0)
 988             fprintf(stderr, "%s    \r", buf);
 989
 990         fflush(stderr);
 991     }
 992
 993     if (is_last_report && verbose >= 0){
 994         int64_t raw= audio_size + video_size + extra_size;
 995         fprintf(stderr, "\n");
 996         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
 997                 video_size/1024.0,
 998                 audio_size/1024.0,
 999                 extra_size/1024.0,
1000                 100.0*(total_size - raw)/raw
1001         );
1002     }
1003 }
1004
1005 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1006 static int output_packet(AVInputStream *ist, int ist_index,
1007                          AVOutputStream **ost_table, int nb_ostreams,
1008                          const AVPacket *pkt)
1009 {
1010     AVFormatContext *os;
1011     AVOutputStream *ost;
1012     uint8_t *ptr;
1013     int len, ret, i;
1014     uint8_t *data_buf;
1015     int data_size, got_picture;
1016     AVFrame picture;
1017     void *buffer_to_free;
1018     static unsigned int samples_size= 0;
1019     static short *samples= NULL;
1020     AVSubtitle subtitle, *subtitle_to_free;
1021     int got_subtitle;
1022
1023     if(!pkt){
1024         ist->pts= ist->next_pts; // needed for last packet if vsync=0
1025     } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1026         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1027     } else {
1028 //        assert(ist->pts == ist->next_pts);
1029     }
1030
1031     if (pkt == NULL) {
1032         /* EOF handling */
1033         ptr = NULL;
1034         len = 0;
1035         goto handle_eof;
1036     }
1037
1038     len = pkt->size;
1039     ptr = pkt->data;
1040     while (len > 0) {
1041     handle_eof:
1042         /* decode the packet if needed */
1043         data_buf = NULL; /* fail safe */
1044         data_size = 0;
1045         subtitle_to_free = NULL;
1046         if (ist->decoding_needed) {
1047             switch(ist->st->codec->codec_type) {
1048             case CODEC_TYPE_AUDIO:{
1049                 if(pkt)
1050                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1051                 data_size= samples_size;
1052                     /* XXX: could avoid copy if PCM 16 bits with same
1053                        endianness as CPU */
1054                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1055                                            ptr, len);
1056                 if (ret < 0)
1057                     goto fail_decode;
1058                 ptr += ret;
1059                 len -= ret;
1060                 /* Some bug in mpeg audio decoder gives */
1061                 /* data_size < 0, it seems they are overflows */
1062                 if (data_size <= 0) {
1063                     /* no audio frame */
1064                     continue;
1065                 }
1066                 data_buf = (uint8_t *)samples;
1067                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1068                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1069                 break;}
1070             case CODEC_TYPE_VIDEO:
1071                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1072                     /* XXX: allocate picture correctly */
1073                     avcodec_get_frame_defaults(&picture);
1074
1075                     ret = avcodec_decode_video(ist->st->codec,
1076                                                &picture, &got_picture, ptr, len);
1077                     ist->st->quality= picture.quality;
1078                     if (ret < 0)
1079                         goto fail_decode;
1080                     if (!got_picture) {
1081                         /* no picture yet */
1082                         goto discard_packet;
1083                     }
1084                     if (ist->st->codec->time_base.num != 0) {
1085                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1086                                           ist->st->codec->time_base.num) /
1087                             ist->st->codec->time_base.den;
1088                     }
1089                     len = 0;
1090                     break;
1091             case CODEC_TYPE_SUBTITLE:
1092                 ret = avcodec_decode_subtitle(ist->st->codec,
1093                                               &subtitle, &got_subtitle, ptr, len);
1094                 if (ret < 0)
1095                     goto fail_decode;
1096                 if (!got_subtitle) {
1097                     goto discard_packet;
1098                 }
1099                 subtitle_to_free = &subtitle;
1100                 len = 0;
1101                 break;
1102             default:
1103                 goto fail_decode;
1104             }
1105         } else {
1106             switch(ist->st->codec->codec_type) {
1107             case CODEC_TYPE_AUDIO:
1108                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1109                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1110                 break;
1111             case CODEC_TYPE_VIDEO:
1112                 if (ist->st->codec->time_base.num != 0) {
1113                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1114                                       ist->st->codec->time_base.num) /
1115                         ist->st->codec->time_base.den;
1116                 }
1117                 break;
1118             }
1119             data_buf = ptr;
1120             data_size = len;
1121             ret = len;
1122             len = 0;
1123         }
1124
1125         buffer_to_free = NULL;
1126         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1127             pre_process_video_frame(ist, (AVPicture *)&picture,
1128                                     &buffer_to_free);
1129         }
1130
1131         // preprocess audio (volume)
1132         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1133             if (audio_volume != 256) {
1134                 short *volp;
1135                 volp = samples;
1136                 for(i=0;i<(data_size / sizeof(short));i++) {
1137                     int v = ((*volp) * audio_volume + 128) >> 8;
1138                     if (v < -32768) v = -32768;
1139                     if (v >  32767) v = 32767;
1140                     *volp++ = v;
1141                 }
1142             }
1143         }
1144
1145         /* frame rate emulation */
1146         if (ist->st->codec->rate_emu) {
1147             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1148             int64_t now = av_gettime() - ist->start;
1149             if (pts > now)
1150                 usleep(pts - now);
1151
1152             ist->frame++;
1153         }
1154
1155 #if 0
1156         /* mpeg PTS deordering : if it is a P or I frame, the PTS
1157            is the one of the next displayed one */
1158         /* XXX: add mpeg4 too ? */
1159         if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1160             if (ist->st->codec->pict_type != B_TYPE) {
1161                 int64_t tmp;
1162                 tmp = ist->last_ip_pts;
1163                 ist->last_ip_pts  = ist->frac_pts.val;
1164                 ist->frac_pts.val = tmp;
1165             }
1166         }
1167 #endif
1168         /* if output time reached then transcode raw format,
1169            encode packets and output them */
1170         if (start_time == 0 || ist->pts >= start_time)
1171             for(i=0;i<nb_ostreams;i++) {
1172                 int frame_size;
1173
1174                 ost = ost_table[i];
1175                 if (ost->source_index == ist_index) {
1176                     os = output_files[ost->file_index];
1177
1178 #if 0
1179                     printf("%d: got pts=%0.3f %0.3f\n", i,
1180                            (double)pkt->pts / AV_TIME_BASE,
1181                            ((double)ist->pts / AV_TIME_BASE) -
1182                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1183 #endif
1184                     /* set the input output pts pairs */
1185                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1186
1187                     if (ost->encoding_needed) {
1188                         switch(ost->st->codec->codec_type) {
1189                         case CODEC_TYPE_AUDIO:
1190                             do_audio_out(os, ost, ist, data_buf, data_size);
1191                             break;
1192                         case CODEC_TYPE_VIDEO:
1193                             do_video_out(os, ost, ist, &picture, &frame_size);
1194                             video_size += frame_size;
1195                             if (do_vstats && frame_size)
1196                                 do_video_stats(os, ost, frame_size);
1197                             break;
1198                         case CODEC_TYPE_SUBTITLE:
1199                             do_subtitle_out(os, ost, ist, &subtitle,
1200                                             pkt->pts);
1201                             break;
1202                         default:
1203                             av_abort();
1204                         }
1205                     } else {
1206                         AVFrame avframe; //FIXME/XXX remove this
1207                         AVPacket opkt;
1208                         av_init_packet(&opkt);
1209
1210                         /* no reencoding needed : output the packet directly */
1211                         /* force the input stream PTS */
1212
1213                         avcodec_get_frame_defaults(&avframe);
1214                         ost->st->codec->coded_frame= &avframe;
1215                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1216
1217                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1218                             audio_size += data_size;
1219                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1220                             video_size += data_size;
1221                             ost->sync_opts++;
1222                         }
1223
1224                         opkt.stream_index= ost->index;
1225                         if(pkt->pts != AV_NOPTS_VALUE)
1226                             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);
1227                         else
1228                             opkt.pts= AV_NOPTS_VALUE;
1229
1230                         {
1231                             int64_t dts;
1232                             if (pkt->dts == AV_NOPTS_VALUE)
1233                                 dts = ist->next_pts;
1234                             else
1235                                 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1236                             opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1237                         }
1238                         opkt.flags= pkt->flags;
1239
1240                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1241                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1242                             opkt.destruct= av_destruct_packet;
1243
1244                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1245                         ost->st->codec->frame_number++;
1246                         ost->frame_number++;
1247                         av_free_packet(&opkt);
1248                     }
1249                 }
1250             }
1251         av_free(buffer_to_free);
1252         /* XXX: allocate the subtitles in the codec ? */
1253         if (subtitle_to_free) {
1254             if (subtitle_to_free->rects != NULL) {
1255                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1256                     av_free(subtitle_to_free->rects[i].bitmap);
1257                     av_free(subtitle_to_free->rects[i].rgba_palette);
1258                 }
1259                 av_freep(&subtitle_to_free->rects);
1260             }
1261             subtitle_to_free->num_rects = 0;
1262             subtitle_to_free = NULL;
1263         }
1264     }
1265  discard_packet:
1266     if (pkt == NULL) {
1267         /* EOF handling */
1268
1269         for(i=0;i<nb_ostreams;i++) {
1270             ost = ost_table[i];
1271             if (ost->source_index == ist_index) {
1272                 AVCodecContext *enc= ost->st->codec;
1273                 os = output_files[ost->file_index];
1274
1275                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1276                     continue;
1277                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1278                     continue;
1279
1280                 if (ost->encoding_needed) {
1281                     for(;;) {
1282                         AVPacket pkt;
1283                         int fifo_bytes;
1284                         av_init_packet(&pkt);
1285                         pkt.stream_index= ost->index;
1286
1287                         switch(ost->st->codec->codec_type) {
1288                         case CODEC_TYPE_AUDIO:
1289                             fifo_bytes = av_fifo_size(&ost->fifo);
1290                             ret = 0;
1291                             /* encode any samples remaining in fifo */
1292                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1293                                 int fs_tmp = enc->frame_size;
1294                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1295                                 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1296                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1297                                 }
1298                                 enc->frame_size = fs_tmp;
1299                             }
1300                             if(ret <= 0) {
1301                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1302                             }
1303                             audio_size += ret;
1304                             pkt.flags |= PKT_FLAG_KEY;
1305                             break;
1306                         case CODEC_TYPE_VIDEO:
1307                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1308                             video_size += ret;
1309                             if(enc->coded_frame && enc->coded_frame->key_frame)
1310                                 pkt.flags |= PKT_FLAG_KEY;
1311                             if (ost->logfile && enc->stats_out) {
1312                                 fprintf(ost->logfile, "%s", enc->stats_out);
1313                             }
1314                             break;
1315                         default:
1316                             ret=-1;
1317                         }
1318
1319                         if(ret<=0)
1320                             break;
1321                         pkt.data= bit_buffer;
1322                         pkt.size= ret;
1323                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1324                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1325                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1326                     }
1327                 }
1328             }
1329         }
1330     }
1331
1332     return 0;
1333  fail_decode:
1334     return -1;
1335 }
1336
1337
1338 /*
1339  * The following code is the main loop of the file converter
1340  */
1341 static int av_encode(AVFormatContext **output_files,
1342                      int nb_output_files,
1343                      AVFormatContext **input_files,
1344                      int nb_input_files,
1345                      AVStreamMap *stream_maps, int nb_stream_maps)
1346 {
1347     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1348     AVFormatContext *is, *os;
1349     AVCodecContext *codec, *icodec;
1350     AVOutputStream *ost, **ost_table = NULL;
1351     AVInputStream *ist, **ist_table = NULL;
1352     AVInputFile *file_table;
1353     int key;
1354
1355     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1356     if (!file_table)
1357         goto fail;
1358
1359     /* input stream init */
1360     j = 0;
1361     for(i=0;i<nb_input_files;i++) {
1362         is = input_files[i];
1363         file_table[i].ist_index = j;
1364         file_table[i].nb_streams = is->nb_streams;
1365         j += is->nb_streams;
1366     }
1367     nb_istreams = j;
1368
1369     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1370     if (!ist_table)
1371         goto fail;
1372
1373     for(i=0;i<nb_istreams;i++) {
1374         ist = av_mallocz(sizeof(AVInputStream));
1375         if (!ist)
1376             goto fail;
1377         ist_table[i] = ist;
1378     }
1379     j = 0;
1380     for(i=0;i<nb_input_files;i++) {
1381         is = input_files[i];
1382         for(k=0;k<is->nb_streams;k++) {
1383             ist = ist_table[j++];
1384             ist->st = is->streams[k];
1385             ist->file_index = i;
1386             ist->index = k;
1387             ist->discard = 1; /* the stream is discarded by default
1388                                  (changed later) */
1389
1390             if (ist->st->codec->rate_emu) {
1391                 ist->start = av_gettime();
1392                 ist->frame = 0;
1393             }
1394         }
1395     }
1396
1397     /* output stream init */
1398     nb_ostreams = 0;
1399     for(i=0;i<nb_output_files;i++) {
1400         os = output_files[i];
1401         if (!os->nb_streams) {
1402             fprintf(stderr, "Output file does not contain any stream\n");
1403             exit(1);
1404         }
1405         nb_ostreams += os->nb_streams;
1406     }
1407     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1408         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1409         exit(1);
1410     }
1411
1412     /* Sanity check the mapping args -- do the input files & streams exist? */
1413     for(i=0;i<nb_stream_maps;i++) {
1414         int fi = stream_maps[i].file_index;
1415         int si = stream_maps[i].stream_index;
1416
1417         if (fi < 0 || fi > nb_input_files - 1 ||
1418             si < 0 || si > file_table[fi].nb_streams - 1) {
1419             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1420             exit(1);
1421         }
1422         fi = stream_maps[i].sync_file_index;
1423         si = stream_maps[i].sync_stream_index;
1424         if (fi < 0 || fi > nb_input_files - 1 ||
1425             si < 0 || si > file_table[fi].nb_streams - 1) {
1426             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1427             exit(1);
1428         }
1429     }
1430
1431     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1432     if (!ost_table)
1433         goto fail;
1434     for(i=0;i<nb_ostreams;i++) {
1435         ost = av_mallocz(sizeof(AVOutputStream));
1436         if (!ost)
1437             goto fail;
1438         ost_table[i] = ost;
1439     }
1440
1441     n = 0;
1442     for(k=0;k<nb_output_files;k++) {
1443         os = output_files[k];
1444         for(i=0;i<os->nb_streams;i++) {
1445             int found;
1446             ost = ost_table[n++];
1447             ost->file_index = k;
1448             ost->index = i;
1449             ost->st = os->streams[i];
1450             if (nb_stream_maps > 0) {
1451                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1452                     stream_maps[n-1].stream_index;
1453
1454                 /* Sanity check that the stream types match */
1455                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1456                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1457                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1458                         ost->file_index, ost->index);
1459                     exit(1);
1460                 }
1461
1462             } else {
1463                 /* get corresponding input stream index : we select the first one with the right type */
1464                 found = 0;
1465                 for(j=0;j<nb_istreams;j++) {
1466                     ist = ist_table[j];
1467                     if (ist->discard &&
1468                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
1469                         ost->source_index = j;
1470                         found = 1;
1471                         break;
1472                     }
1473                 }
1474
1475                 if (!found) {
1476                     /* try again and reuse existing stream */
1477                     for(j=0;j<nb_istreams;j++) {
1478                         ist = ist_table[j];
1479                         if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1480                             ost->source_index = j;
1481                             found = 1;
1482                         }
1483                     }
1484                     if (!found) {
1485                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1486                                 ost->file_index, ost->index);
1487                         exit(1);
1488                     }
1489                 }
1490             }
1491             ist = ist_table[ost->source_index];
1492             ist->discard = 0;
1493             ost->sync_ist = (nb_stream_maps > 0) ?
1494                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1495                          stream_maps[n-1].sync_stream_index] : ist;
1496         }
1497     }
1498
1499     /* for each output stream, we compute the right encoding parameters */
1500     for(i=0;i<nb_ostreams;i++) {
1501         ost = ost_table[i];
1502         ist = ist_table[ost->source_index];
1503
1504         codec = ost->st->codec;
1505         icodec = ist->st->codec;
1506
1507         if (ost->st->stream_copy) {
1508             /* if stream_copy is selected, no need to decode or encode */
1509             codec->codec_id = icodec->codec_id;
1510             codec->codec_type = icodec->codec_type;
1511             if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1512             codec->bit_rate = icodec->bit_rate;
1513             codec->extradata= icodec->extradata;
1514             codec->extradata_size= icodec->extradata_size;
1515             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1516                 codec->time_base = icodec->time_base;
1517             else
1518                 codec->time_base = ist->st->time_base;
1519             switch(codec->codec_type) {
1520             case CODEC_TYPE_AUDIO:
1521                 codec->sample_rate = icodec->sample_rate;
1522                 codec->channels = icodec->channels;
1523                 codec->frame_size = icodec->frame_size;
1524                 codec->block_align= icodec->block_align;
1525                 break;
1526             case CODEC_TYPE_VIDEO:
1527                 if(using_vhook) {
1528                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1529                     exit(1);
1530                 }
1531                 codec->pix_fmt = icodec->pix_fmt;
1532                 codec->width = icodec->width;
1533                 codec->height = icodec->height;
1534                 codec->has_b_frames = icodec->has_b_frames;
1535                 break;
1536             case CODEC_TYPE_SUBTITLE:
1537                 break;
1538             default:
1539                 av_abort();
1540             }
1541         } else {
1542             switch(codec->codec_type) {
1543             case CODEC_TYPE_AUDIO:
1544                 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1545                     goto fail;
1546
1547                 if (codec->channels == icodec->channels &&
1548                     codec->sample_rate == icodec->sample_rate) {
1549                     ost->audio_resample = 0;
1550                 } else {
1551                     if (codec->channels != icodec->channels &&
1552                         (icodec->codec_id == CODEC_ID_AC3 ||
1553                          icodec->codec_id == CODEC_ID_DTS)) {
1554                         /* Special case for 5:1 AC3 and DTS input */
1555                         /* and mono or stereo output      */
1556                         /* Request specific number of channels */
1557                         icodec->channels = codec->channels;
1558                         if (codec->sample_rate == icodec->sample_rate)
1559                             ost->audio_resample = 0;
1560                         else {
1561                             ost->audio_resample = 1;
1562                         }
1563                     } else {
1564                         ost->audio_resample = 1;
1565                     }
1566                 }
1567                 if(audio_sync_method>1)
1568                     ost->audio_resample = 1;
1569
1570                 if(ost->audio_resample){
1571                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1572                                                     codec->sample_rate, icodec->sample_rate);
1573                     if(!ost->resample){
1574                         printf("Can't resample.  Aborting.\n");
1575                         av_abort();
1576                     }
1577                 }
1578                 ist->decoding_needed = 1;
1579                 ost->encoding_needed = 1;
1580                 break;
1581             case CODEC_TYPE_VIDEO:
1582                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1583                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1584                 ost->video_resample = ((codec->width != icodec->width -
1585                                 (frame_leftBand + frame_rightBand) +
1586                                 (frame_padleft + frame_padright)) ||
1587                         (codec->height != icodec->height -
1588                                 (frame_topBand  + frame_bottomBand) +
1589                                 (frame_padtop + frame_padbottom)) ||
1590                         (codec->pix_fmt != icodec->pix_fmt));
1591                 if (ost->video_crop) {
1592                     ost->topBand = frame_topBand;
1593                     ost->leftBand = frame_leftBand;
1594                 }
1595                 if (ost->video_pad) {
1596                     ost->padtop = frame_padtop;
1597                     ost->padleft = frame_padleft;
1598                     ost->padbottom = frame_padbottom;
1599                     ost->padright = frame_padright;
1600                     if (!ost->video_resample) {
1601                         avcodec_get_frame_defaults(&ost->pict_tmp);
1602                         if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1603                                          codec->width, codec->height ) )
1604                             goto fail;
1605                     }
1606                 }
1607                 if (ost->video_resample) {
1608                     avcodec_get_frame_defaults(&ost->pict_tmp);
1609                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1610                                          codec->width, codec->height ) )
1611                         exit(1);
1612
1613                     ost->img_resample_ctx = sws_getContext(
1614                             icodec->width - (frame_leftBand + frame_rightBand),
1615                             icodec->height - (frame_topBand + frame_bottomBand),
1616                             icodec->pix_fmt,
1617                             codec->width - (frame_padleft + frame_padright),
1618                             codec->height - (frame_padtop + frame_padbottom),
1619                             codec->pix_fmt,
1620                             sws_flags, NULL, NULL, NULL);
1621                     if (ost->img_resample_ctx == NULL) {
1622                         fprintf(stderr, "Cannot get resampling context\n");
1623                         exit(1);
1624                     }
1625                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1626                 }
1627                 ost->encoding_needed = 1;
1628                 ist->decoding_needed = 1;
1629                 break;
1630             case CODEC_TYPE_SUBTITLE:
1631                 ost->encoding_needed = 1;
1632                 ist->decoding_needed = 1;
1633                 break;
1634             default:
1635                 av_abort();
1636                 break;
1637             }
1638             /* two pass mode */
1639             if (ost->encoding_needed &&
1640                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1641                 char logfilename[1024];
1642                 FILE *f;
1643                 int size;
1644                 char *logbuffer;
1645
1646                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1647                          pass_logfilename ?
1648                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1649                 if (codec->flags & CODEC_FLAG_PASS1) {
1650                     f = fopen(logfilename, "w");
1651                     if (!f) {
1652                         perror(logfilename);
1653                         exit(1);
1654                     }
1655                     ost->logfile = f;
1656                 } else {
1657                     /* read the log file */
1658                     f = fopen(logfilename, "r");
1659                     if (!f) {
1660                         perror(logfilename);
1661                         exit(1);
1662                     }
1663                     fseek(f, 0, SEEK_END);
1664                     size = ftell(f);
1665                     fseek(f, 0, SEEK_SET);
1666                     logbuffer = av_malloc(size + 1);
1667                     if (!logbuffer) {
1668                         fprintf(stderr, "Could not allocate log buffer\n");
1669                         exit(1);
1670                     }
1671                     size = fread(logbuffer, 1, size, f);
1672                     fclose(f);
1673                     logbuffer[size] = '\0';
1674                     codec->stats_in = logbuffer;
1675                 }
1676             }
1677         }
1678         if(codec->codec_type == CODEC_TYPE_VIDEO){
1679             int size= codec->width * codec->height;
1680             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1681         }
1682     }
1683
1684     if (!bit_buffer)
1685         bit_buffer = av_malloc(bit_buffer_size);
1686     if (!bit_buffer)
1687         goto fail;
1688
1689     /* dump the file output parameters - cannot be done before in case
1690        of stream copy */
1691     for(i=0;i<nb_output_files;i++) {
1692         dump_format(output_files[i], i, output_files[i]->filename, 1);
1693     }
1694
1695     /* dump the stream mapping */
1696     if (verbose >= 0) {
1697         fprintf(stderr, "Stream mapping:\n");
1698         for(i=0;i<nb_ostreams;i++) {
1699             ost = ost_table[i];
1700             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1701                     ist_table[ost->source_index]->file_index,
1702                     ist_table[ost->source_index]->index,
1703                     ost->file_index,
1704                     ost->index);
1705             if (ost->sync_ist != ist_table[ost->source_index])
1706                 fprintf(stderr, " [sync #%d.%d]",
1707                         ost->sync_ist->file_index,
1708                         ost->sync_ist->index);
1709             fprintf(stderr, "\n");
1710         }
1711     }
1712
1713     /* open each encoder */
1714     for(i=0;i<nb_ostreams;i++) {
1715         ost = ost_table[i];
1716         if (ost->encoding_needed) {
1717             AVCodec *codec;
1718             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1719             if (!codec) {
1720                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1721                         ost->file_index, ost->index);
1722                 exit(1);
1723             }
1724             if (avcodec_open(ost->st->codec, codec) < 0) {
1725                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1726                         ost->file_index, ost->index);
1727                 exit(1);
1728             }
1729             extra_size += ost->st->codec->extradata_size;
1730         }
1731     }
1732
1733     /* open each decoder */
1734     for(i=0;i<nb_istreams;i++) {
1735         ist = ist_table[i];
1736         if (ist->decoding_needed) {
1737             AVCodec *codec;
1738             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1739             if (!codec) {
1740                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1741                         ist->st->codec->codec_id, ist->file_index, ist->index);
1742                 exit(1);
1743             }
1744             if (avcodec_open(ist->st->codec, codec) < 0) {
1745                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1746                         ist->file_index, ist->index);
1747                 exit(1);
1748             }
1749             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1750             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1751         }
1752     }
1753
1754     /* init pts */
1755     for(i=0;i<nb_istreams;i++) {
1756         ist = ist_table[i];
1757         is = input_files[ist->file_index];
1758         ist->pts = 0;
1759         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1760         if(ist->st->start_time == AV_NOPTS_VALUE)
1761             ist->next_pts=0;
1762         if(input_files_ts_offset[ist->file_index])
1763             ist->next_pts= AV_NOPTS_VALUE;
1764         ist->is_start = 1;
1765     }
1766
1767     /* set meta data information from input file if required */
1768     for (i=0;i<nb_meta_data_maps;i++) {
1769         AVFormatContext *out_file;
1770         AVFormatContext *in_file;
1771
1772         int out_file_index = meta_data_maps[i].out_file;
1773         int in_file_index = meta_data_maps[i].in_file;
1774         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1775             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1776             ret = AVERROR(EINVAL);
1777             goto fail;
1778         }
1779         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1780             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1781             ret = AVERROR(EINVAL);
1782             goto fail;
1783         }
1784
1785         out_file = output_files[out_file_index];
1786         in_file = input_files[in_file_index];
1787
1788         strcpy(out_file->title, in_file->title);
1789         strcpy(out_file->author, in_file->author);
1790         strcpy(out_file->copyright, in_file->copyright);
1791         strcpy(out_file->comment, in_file->comment);
1792         strcpy(out_file->album, in_file->album);
1793         out_file->year = in_file->year;
1794         out_file->track = in_file->track;
1795         strcpy(out_file->genre, in_file->genre);
1796     }
1797
1798     /* open files and write file headers */
1799     for(i=0;i<nb_output_files;i++) {
1800         os = output_files[i];
1801         if (av_write_header(os) < 0) {
1802             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1803             ret = AVERROR(EINVAL);
1804             goto fail;
1805         }
1806     }
1807
1808     if ( !using_stdin && verbose >= 0) {
1809         fprintf(stderr, "Press [q] to stop encoding\n");
1810         url_set_interrupt_cb(decode_interrupt_cb);
1811     }
1812     term_init();
1813
1814     key = -1;
1815     timer_start = av_gettime();
1816
1817     for(; received_sigterm == 0;) {
1818         int file_index, ist_index;
1819         AVPacket pkt;
1820         double ipts_min;
1821         double opts_min;
1822
1823     redo:
1824         ipts_min= 1e100;
1825         opts_min= 1e100;
1826         /* if 'q' pressed, exits */
1827         if (!using_stdin) {
1828             if (q_pressed)
1829                 break;
1830             /* read_key() returns 0 on EOF */
1831             key = read_key();
1832             if (key == 'q')
1833                 break;
1834         }
1835
1836         /* select the stream that we must read now by looking at the
1837            smallest output pts */
1838         file_index = -1;
1839         for(i=0;i<nb_ostreams;i++) {
1840             double ipts, opts;
1841             ost = ost_table[i];
1842             os = output_files[ost->file_index];
1843             ist = ist_table[ost->source_index];
1844             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1845                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1846             else
1847                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1848             ipts = (double)ist->pts;
1849             if (!file_table[ist->file_index].eof_reached){
1850                 if(ipts < ipts_min) {
1851                     ipts_min = ipts;
1852                     if(input_sync ) file_index = ist->file_index;
1853                 }
1854                 if(opts < opts_min) {
1855                     opts_min = opts;
1856                     if(!input_sync) file_index = ist->file_index;
1857                 }
1858             }
1859             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1860                 file_index= -1;
1861                 break;
1862             }
1863         }
1864         /* if none, if is finished */
1865         if (file_index < 0) {
1866             break;
1867         }
1868
1869         /* finish if recording time exhausted */
1870         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1871             break;
1872
1873         /* finish if limit size exhausted */
1874         if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1875             break;
1876
1877         /* read a frame from it and output it in the fifo */
1878         is = input_files[file_index];
1879         if (av_read_frame(is, &pkt) < 0) {
1880             file_table[file_index].eof_reached = 1;
1881             if (opt_shortest) break; else continue; //
1882         }
1883
1884         if (do_pkt_dump) {
1885             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1886         }
1887         /* the following test is needed in case new streams appear
1888            dynamically in stream : we ignore them */
1889         if (pkt.stream_index >= file_table[file_index].nb_streams)
1890             goto discard_packet;
1891         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1892         ist = ist_table[ist_index];
1893         if (ist->discard)
1894             goto discard_packet;
1895
1896 //        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);
1897         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1898             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1899             if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1900                 input_files_ts_offset[ist->file_index]-= delta;
1901                 if (verbose > 2)
1902                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1903                 for(i=0; i<file_table[file_index].nb_streams; i++){
1904                     int index= file_table[file_index].ist_index + i;
1905                     ist_table[index]->next_pts += delta;
1906                     ist_table[index]->is_start=1;
1907                 }
1908             }
1909         }
1910
1911         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1912         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1913
1914             if (verbose >= 0)
1915                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1916                         ist->file_index, ist->index);
1917
1918             av_free_packet(&pkt);
1919             goto redo;
1920         }
1921
1922     discard_packet:
1923         av_free_packet(&pkt);
1924
1925         /* dump report by using the output first video and audio streams */
1926         print_report(output_files, ost_table, nb_ostreams, 0);
1927     }
1928
1929     /* at the end of stream, we must flush the decoder buffers */
1930     for(i=0;i<nb_istreams;i++) {
1931         ist = ist_table[i];
1932         if (ist->decoding_needed) {
1933             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1934         }
1935     }
1936
1937     term_exit();
1938
1939     /* write the trailer if needed and close file */
1940     for(i=0;i<nb_output_files;i++) {
1941         os = output_files[i];
1942         av_write_trailer(os);
1943     }
1944
1945     /* dump report by using the first video and audio streams */
1946     print_report(output_files, ost_table, nb_ostreams, 1);
1947
1948     /* close each encoder */
1949     for(i=0;i<nb_ostreams;i++) {
1950         ost = ost_table[i];
1951         if (ost->encoding_needed) {
1952             av_freep(&ost->st->codec->stats_in);
1953             avcodec_close(ost->st->codec);
1954         }
1955     }
1956
1957     /* close each decoder */
1958     for(i=0;i<nb_istreams;i++) {
1959         ist = ist_table[i];
1960         if (ist->decoding_needed) {
1961             avcodec_close(ist->st->codec);
1962         }
1963     }
1964
1965     /* finished ! */
1966
1967     ret = 0;
1968  fail1:
1969     av_freep(&bit_buffer);
1970     av_free(file_table);
1971
1972     if (ist_table) {
1973         for(i=0;i<nb_istreams;i++) {
1974             ist = ist_table[i];
1975             av_free(ist);
1976         }
1977         av_free(ist_table);
1978     }
1979     if (ost_table) {
1980         for(i=0;i<nb_ostreams;i++) {
1981             ost = ost_table[i];
1982             if (ost) {
1983                 if (ost->logfile) {
1984                     fclose(ost->logfile);
1985                     ost->logfile = NULL;
1986                 }
1987                 av_fifo_free(&ost->fifo); /* works even if fifo is not
1988                                              initialized but set to zero */
1989                 av_free(ost->pict_tmp.data[0]);
1990                 if (ost->video_resample)
1991                     sws_freeContext(ost->img_resample_ctx);
1992                 if (ost->audio_resample)
1993                     audio_resample_close(ost->resample);
1994                 av_free(ost);
1995             }
1996         }
1997         av_free(ost_table);
1998     }
1999     return ret;
2000  fail:
2001     ret = AVERROR(ENOMEM);
2002     goto fail1;
2003 }
2004
2005 #if 0
2006 int file_read(const char *filename)
2007 {
2008     URLContext *h;
2009     unsigned char buffer[1024];
2010     int len, i;
2011
2012     if (url_open(&h, filename, O_RDONLY) < 0) {
2013         printf("could not open '%s'\n", filename);
2014         return -1;
2015     }
2016     for(;;) {
2017         len = url_read(h, buffer, sizeof(buffer));
2018         if (len <= 0)
2019             break;
2020         for(i=0;i<len;i++) putchar(buffer[i]);
2021     }
2022     url_close(h);
2023     return 0;
2024 }
2025 #endif
2026
2027 static void opt_format(const char *arg)
2028 {
2029     /* compatibility stuff for pgmyuv */
2030     if (!strcmp(arg, "pgmyuv")) {
2031         pgmyuv_compatibility_hack=1;
2032 //        opt_image_format(arg);
2033         arg = "image2";
2034         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2035     }
2036
2037     file_iformat = av_find_input_format(arg);
2038     file_oformat = guess_format(arg, NULL, NULL);
2039     if (!file_iformat && !file_oformat) {
2040         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2041         exit(1);
2042     }
2043 }
2044
2045 static void opt_video_rc_eq(char *arg)
2046 {
2047     video_rc_eq = arg;
2048 }
2049
2050 static void opt_video_rc_override_string(char *arg)
2051 {
2052     video_rc_override_string = arg;
2053 }
2054
2055 static void opt_me_threshold(const char *arg)
2056 {
2057     me_threshold = atoi(arg);
2058 }
2059
2060 static void opt_verbose(const char *arg)
2061 {
2062     verbose = atoi(arg);
2063     av_log_level = atoi(arg);
2064 }
2065
2066 static void opt_frame_rate(const char *arg)
2067 {
2068     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2069         fprintf(stderr, "Incorrect frame rate\n");
2070         exit(1);
2071     }
2072 }
2073
2074 static void opt_frame_crop_top(const char *arg)
2075 {
2076     frame_topBand = atoi(arg);
2077     if (frame_topBand < 0) {
2078         fprintf(stderr, "Incorrect top crop size\n");
2079         exit(1);
2080     }
2081     if ((frame_topBand % 2) != 0) {
2082         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2083         exit(1);
2084     }
2085     if ((frame_topBand) >= frame_height){
2086         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2087         exit(1);
2088     }
2089     frame_height -= frame_topBand;
2090 }
2091
2092 static void opt_frame_crop_bottom(const char *arg)
2093 {
2094     frame_bottomBand = atoi(arg);
2095     if (frame_bottomBand < 0) {
2096         fprintf(stderr, "Incorrect bottom crop size\n");
2097         exit(1);
2098     }
2099     if ((frame_bottomBand % 2) != 0) {
2100         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2101         exit(1);
2102     }
2103     if ((frame_bottomBand) >= frame_height){
2104         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2105         exit(1);
2106     }
2107     frame_height -= frame_bottomBand;
2108 }
2109
2110 static void opt_frame_crop_left(const char *arg)
2111 {
2112     frame_leftBand = atoi(arg);
2113     if (frame_leftBand < 0) {
2114         fprintf(stderr, "Incorrect left crop size\n");
2115         exit(1);
2116     }
2117     if ((frame_leftBand % 2) != 0) {
2118         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2119         exit(1);
2120     }
2121     if ((frame_leftBand) >= frame_width){
2122         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2123         exit(1);
2124     }
2125     frame_width -= frame_leftBand;
2126 }
2127
2128 static void opt_frame_crop_right(const char *arg)
2129 {
2130     frame_rightBand = atoi(arg);
2131     if (frame_rightBand < 0) {
2132         fprintf(stderr, "Incorrect right crop size\n");
2133         exit(1);
2134     }
2135     if ((frame_rightBand % 2) != 0) {
2136         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2137         exit(1);
2138     }
2139     if ((frame_rightBand) >= frame_width){
2140         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2141         exit(1);
2142     }
2143     frame_width -= frame_rightBand;
2144 }
2145
2146 static void opt_frame_size(const char *arg)
2147 {
2148     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2149         fprintf(stderr, "Incorrect frame size\n");
2150         exit(1);
2151     }
2152     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2153         fprintf(stderr, "Frame size must be a multiple of 2\n");
2154         exit(1);
2155     }
2156 }
2157
2158
2159 #define SCALEBITS 10
2160 #define ONE_HALF  (1 << (SCALEBITS - 1))
2161 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2162
2163 #define RGB_TO_Y(r, g, b) \
2164 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2165   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2166
2167 #define RGB_TO_U(r1, g1, b1, shift)\
2168 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2169      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2170
2171 #define RGB_TO_V(r1, g1, b1, shift)\
2172 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2173    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2174
2175 static void opt_pad_color(const char *arg) {
2176     /* Input is expected to be six hex digits similar to
2177        how colors are expressed in html tags (but without the #) */
2178     int rgb = strtol(arg, NULL, 16);
2179     int r,g,b;
2180
2181     r = (rgb >> 16);
2182     g = ((rgb >> 8) & 255);
2183     b = (rgb & 255);
2184
2185     padcolor[0] = RGB_TO_Y(r,g,b);
2186     padcolor[1] = RGB_TO_U(r,g,b,0);
2187     padcolor[2] = RGB_TO_V(r,g,b,0);
2188 }
2189
2190 static void opt_frame_pad_top(const char *arg)
2191 {
2192     frame_padtop = atoi(arg);
2193     if (frame_padtop < 0) {
2194         fprintf(stderr, "Incorrect top pad size\n");
2195         exit(1);
2196     }
2197     if ((frame_padtop % 2) != 0) {
2198         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2199         exit(1);
2200     }
2201 }
2202
2203 static void opt_frame_pad_bottom(const char *arg)
2204 {
2205     frame_padbottom = atoi(arg);
2206     if (frame_padbottom < 0) {
2207         fprintf(stderr, "Incorrect bottom pad size\n");
2208         exit(1);
2209     }
2210     if ((frame_padbottom % 2) != 0) {
2211         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2212         exit(1);
2213     }
2214 }
2215
2216
2217 static void opt_frame_pad_left(const char *arg)
2218 {
2219     frame_padleft = atoi(arg);
2220     if (frame_padleft < 0) {
2221         fprintf(stderr, "Incorrect left pad size\n");
2222         exit(1);
2223     }
2224     if ((frame_padleft % 2) != 0) {
2225         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2226         exit(1);
2227     }
2228 }
2229
2230
2231 static void opt_frame_pad_right(const char *arg)
2232 {
2233     frame_padright = atoi(arg);
2234     if (frame_padright < 0) {
2235         fprintf(stderr, "Incorrect right pad size\n");
2236         exit(1);
2237     }
2238     if ((frame_padright % 2) != 0) {
2239         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2240         exit(1);
2241     }
2242 }
2243
2244
2245 static void opt_frame_pix_fmt(const char *arg)
2246 {
2247     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2248 }
2249
2250 static void opt_frame_aspect_ratio(const char *arg)
2251 {
2252     int x = 0, y = 0;
2253     double ar = 0;
2254     const char *p;
2255
2256     p = strchr(arg, ':');
2257     if (p) {
2258         x = strtol(arg, (char **)&arg, 10);
2259         if (arg == p)
2260             y = strtol(arg+1, (char **)&arg, 10);
2261         if (x > 0 && y > 0)
2262             ar = (double)x / (double)y;
2263     } else
2264         ar = strtod(arg, (char **)&arg);
2265
2266     if (!ar) {
2267         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2268         exit(1);
2269     }
2270     frame_aspect_ratio = ar;
2271 }
2272
2273 static void opt_qscale(const char *arg)
2274 {
2275     video_qscale = atof(arg);
2276     if (video_qscale <= 0 ||
2277         video_qscale > 255) {
2278         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2279         exit(1);
2280     }
2281 }
2282
2283 static void opt_qdiff(const char *arg)
2284 {
2285     video_qdiff = atoi(arg);
2286     if (video_qdiff < 0 ||
2287         video_qdiff > 31) {
2288         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2289         exit(1);
2290     }
2291 }
2292
2293 static void opt_strict(const char *arg)
2294 {
2295     strict= atoi(arg);
2296 }
2297
2298 static void opt_top_field_first(const char *arg)
2299 {
2300     top_field_first= atoi(arg);
2301 }
2302
2303 static void opt_thread_count(const char *arg)
2304 {
2305     thread_count= atoi(arg);
2306 #if !defined(HAVE_THREADS)
2307     if (verbose >= 0)
2308         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2309 #endif
2310 }
2311
2312 static void opt_audio_rate(const char *arg)
2313 {
2314     audio_sample_rate = atoi(arg);
2315 }
2316
2317 static void opt_audio_channels(const char *arg)
2318 {
2319     audio_channels = atoi(arg);
2320 }
2321
2322 static void opt_video_channel(const char *arg)
2323 {
2324     video_channel = strtol(arg, NULL, 0);
2325 }
2326
2327 static void opt_video_standard(const char *arg)
2328 {
2329     video_standard = av_strdup(arg);
2330 }
2331
2332 static void opt_codec(int *pstream_copy, int *pcodec_id,
2333                       int codec_type, const char *arg)
2334 {
2335     AVCodec *p;
2336
2337     if (!strcmp(arg, "copy")) {
2338         *pstream_copy = 1;
2339     } else {
2340         p = first_avcodec;
2341         while (p) {
2342             if (!strcmp(p->name, arg) && p->type == codec_type)
2343                 break;
2344             p = p->next;
2345         }
2346         if (p == NULL) {
2347             fprintf(stderr, "Unknown codec '%s'\n", arg);
2348             exit(1);
2349         } else {
2350             *pcodec_id = p->id;
2351         }
2352     }
2353 }
2354
2355 static void opt_audio_codec(const char *arg)
2356 {
2357     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2358 }
2359
2360 static void opt_audio_tag(const char *arg)
2361 {
2362     char *tail;
2363     audio_codec_tag= strtol(arg, &tail, 0);
2364
2365     if(!tail || *tail)
2366         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2367 }
2368
2369 static void opt_video_tag(const char *arg)
2370 {
2371     char *tail;
2372     video_codec_tag= strtol(arg, &tail, 0);
2373
2374     if(!tail || *tail)
2375         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2376 }
2377
2378 static void add_frame_hooker(const char *arg)
2379 {
2380     int argc = 0;
2381     char *argv[64];
2382     int i;
2383     char *args = av_strdup(arg);
2384
2385     using_vhook = 1;
2386
2387     argv[0] = strtok(args, " ");
2388     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2389     }
2390
2391     i = frame_hook_add(argc, argv);
2392
2393     if (i != 0) {
2394         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2395         exit(1);
2396     }
2397 }
2398
2399 const char *motion_str[] = {
2400     "zero",
2401     "full",
2402     "log",
2403     "phods",
2404     "epzs",
2405     "x1",
2406     "hex",
2407     "umh",
2408     "iter",
2409     NULL,
2410 };
2411
2412 static void opt_motion_estimation(const char *arg)
2413 {
2414     const char **p;
2415     p = motion_str;
2416     for(;;) {
2417         if (!*p) {
2418             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2419             exit(1);
2420         }
2421         if (!strcmp(*p, arg))
2422             break;
2423         p++;
2424     }
2425     me_method = (p - motion_str) + 1;
2426 }
2427
2428 static void opt_video_codec(const char *arg)
2429 {
2430     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2431 }
2432
2433 static void opt_subtitle_codec(const char *arg)
2434 {
2435     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2436 }
2437
2438 static void opt_map(const char *arg)
2439 {
2440     AVStreamMap *m;
2441     const char *p;
2442
2443     p = arg;
2444     m = &stream_maps[nb_stream_maps++];
2445
2446     m->file_index = strtol(arg, (char **)&p, 0);
2447     if (*p)
2448         p++;
2449
2450     m->stream_index = strtol(p, (char **)&p, 0);
2451     if (*p) {
2452         p++;
2453         m->sync_file_index = strtol(p, (char **)&p, 0);
2454         if (*p)
2455             p++;
2456         m->sync_stream_index = strtol(p, (char **)&p, 0);
2457     } else {
2458         m->sync_file_index = m->file_index;
2459         m->sync_stream_index = m->stream_index;
2460     }
2461 }
2462
2463 static void opt_map_meta_data(const char *arg)
2464 {
2465     AVMetaDataMap *m;
2466     const char *p;
2467
2468     p = arg;
2469     m = &meta_data_maps[nb_meta_data_maps++];
2470
2471     m->out_file = strtol(arg, (char **)&p, 0);
2472     if (*p)
2473         p++;
2474
2475     m->in_file = strtol(p, (char **)&p, 0);
2476 }
2477
2478 static void opt_recording_time(const char *arg)
2479 {
2480     recording_time = parse_date(arg, 1);
2481 }
2482
2483 static void opt_start_time(const char *arg)
2484 {
2485     start_time = parse_date(arg, 1);
2486 }
2487
2488 static void opt_rec_timestamp(const char *arg)
2489 {
2490     rec_timestamp = parse_date(arg, 0) / 1000000;
2491 }
2492
2493 static void opt_input_ts_offset(const char *arg)
2494 {
2495     input_ts_offset = parse_date(arg, 1);
2496 }
2497
2498 static void opt_input_file(const char *filename)
2499 {
2500     AVFormatContext *ic;
2501     AVFormatParameters params, *ap = &params;
2502     int err, i, ret, rfps, rfps_base;
2503     int64_t timestamp;
2504
2505     if (!strcmp(filename, "-"))
2506         filename = "pipe:";
2507
2508     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2509                    !strcmp( filename, "/dev/stdin" );
2510
2511     /* get default parameters from command line */
2512     ic = av_alloc_format_context();
2513
2514     memset(ap, 0, sizeof(*ap));
2515     ap->prealloced_context = 1;
2516     ap->sample_rate = audio_sample_rate;
2517     ap->channels = audio_channels;
2518     ap->time_base.den = frame_rate;
2519     ap->time_base.num = frame_rate_base;
2520     ap->width = frame_width + frame_padleft + frame_padright;
2521     ap->height = frame_height + frame_padtop + frame_padbottom;
2522     ap->pix_fmt = frame_pix_fmt;
2523     ap->channel = video_channel;
2524     ap->standard = video_standard;
2525     ap->video_codec_id = video_codec_id;
2526     ap->audio_codec_id = audio_codec_id;
2527     if(pgmyuv_compatibility_hack)
2528         ap->video_codec_id= CODEC_ID_PGMYUV;
2529
2530     for(i=0; i<opt_name_count; i++){
2531         const AVOption *opt;
2532         double d= av_get_double(avformat_opts, opt_names[i], &opt);
2533         if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2534             av_set_double(ic, opt_names[i], d);
2535     }
2536     /* open the input file with generic libav function */
2537     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2538     if (err < 0) {
2539         print_error(filename, err);
2540         exit(1);
2541     }
2542
2543     ic->loop_input = loop_input;
2544
2545     /* If not enough info to get the stream parameters, we decode the
2546        first frames to get it. (used in mpeg case for example) */
2547     ret = av_find_stream_info(ic);
2548     if (ret < 0 && verbose >= 0) {
2549         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2550         exit(1);
2551     }
2552
2553     timestamp = start_time;
2554     /* add the stream start time */
2555     if (ic->start_time != AV_NOPTS_VALUE)
2556         timestamp += ic->start_time;
2557
2558     /* if seeking requested, we execute it */
2559     if (start_time != 0) {
2560         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2561         if (ret < 0) {
2562             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2563                     filename, (double)timestamp / AV_TIME_BASE);
2564         }
2565         /* reset seek info */
2566         start_time = 0;
2567     }
2568
2569     /* update the current parameters so that they match the one of the input stream */
2570     for(i=0;i<ic->nb_streams;i++) {
2571         int j;
2572         AVCodecContext *enc = ic->streams[i]->codec;
2573         if(thread_count>1)
2574             avcodec_thread_init(enc, thread_count);
2575         enc->thread_count= thread_count;
2576         switch(enc->codec_type) {
2577         case CODEC_TYPE_AUDIO:
2578             for(j=0; j<opt_name_count; j++){
2579                 const AVOption *opt;
2580                 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2581                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2582                     av_set_double(enc, opt_names[j], d);
2583             }
2584             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2585             audio_channels = enc->channels;
2586             audio_sample_rate = enc->sample_rate;
2587             if(audio_disable)
2588                 ic->streams[i]->discard= AVDISCARD_ALL;
2589             break;
2590         case CODEC_TYPE_VIDEO:
2591             for(j=0; j<opt_name_count; j++){
2592                 const AVOption *opt;
2593                 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2594                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2595                     av_set_double(enc, opt_names[j], d);
2596             }
2597             frame_height = enc->height;
2598             frame_width = enc->width;
2599             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2600             frame_pix_fmt = enc->pix_fmt;
2601             rfps      = ic->streams[i]->r_frame_rate.num;
2602             rfps_base = ic->streams[i]->r_frame_rate.den;
2603             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2604             if(me_threshold)
2605                 enc->debug |= FF_DEBUG_MV;
2606
2607             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2608
2609                 if (verbose >= 0)
2610                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2611                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2612
2613                     (float)rfps / rfps_base, rfps, rfps_base);
2614             }
2615             /* update the current frame rate to match the stream frame rate */
2616             frame_rate      = rfps;
2617             frame_rate_base = rfps_base;
2618
2619             enc->rate_emu = rate_emu;
2620             if(video_disable)
2621                 ic->streams[i]->discard= AVDISCARD_ALL;
2622             else if(video_discard)
2623                 ic->streams[i]->discard= video_discard;
2624             break;
2625         case CODEC_TYPE_DATA:
2626             break;
2627         case CODEC_TYPE_SUBTITLE:
2628             break;
2629         case CODEC_TYPE_UNKNOWN:
2630             break;
2631         default:
2632             av_abort();
2633         }
2634     }
2635
2636     input_files[nb_input_files] = ic;
2637     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2638     /* dump the file content */
2639     if (verbose >= 0)
2640         dump_format(ic, nb_input_files, filename, 0);
2641
2642     nb_input_files++;
2643     file_iformat = NULL;
2644     file_oformat = NULL;
2645
2646     video_channel = 0;
2647
2648     rate_emu = 0;
2649 }
2650
2651 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2652 {
2653     int has_video, has_audio, i, j;
2654     AVFormatContext *ic;
2655
2656     has_video = 0;
2657     has_audio = 0;
2658     for(j=0;j<nb_input_files;j++) {
2659         ic = input_files[j];
2660         for(i=0;i<ic->nb_streams;i++) {
2661             AVCodecContext *enc = ic->streams[i]->codec;
2662             switch(enc->codec_type) {
2663             case CODEC_TYPE_AUDIO:
2664                 has_audio = 1;
2665                 break;
2666             case CODEC_TYPE_VIDEO:
2667                 has_video = 1;
2668                 break;
2669             case CODEC_TYPE_DATA:
2670             case CODEC_TYPE_UNKNOWN:
2671             case CODEC_TYPE_SUBTITLE:
2672                 break;
2673             default:
2674                 av_abort();
2675             }
2676         }
2677     }
2678     *has_video_ptr = has_video;
2679     *has_audio_ptr = has_audio;
2680 }
2681
2682 static void new_video_stream(AVFormatContext *oc)
2683 {
2684     AVStream *st;
2685     AVCodecContext *video_enc;
2686     int codec_id;
2687
2688     st = av_new_stream(oc, oc->nb_streams);
2689     if (!st) {
2690         fprintf(stderr, "Could not alloc stream\n");
2691         exit(1);
2692     }
2693     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2694     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2695     video_bitstream_filters= NULL;
2696
2697     if(thread_count>1)
2698         avcodec_thread_init(st->codec, thread_count);
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(thread_count>1)
2856         avcodec_thread_init(st->codec, thread_count);
2857
2858     audio_enc = st->codec;
2859     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2860     audio_enc->strict_std_compliance = strict;
2861
2862     if(audio_codec_tag)
2863         audio_enc->codec_tag= audio_codec_tag;
2864
2865     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2866         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2867         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2868     }
2869     if (audio_stream_copy) {
2870         st->stream_copy = 1;
2871         audio_enc->channels = audio_channels;
2872     } else {
2873         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2874
2875         for(i=0; i<opt_name_count; i++){
2876             const AVOption *opt;
2877             double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2878             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2879                 av_set_double(audio_enc, opt_names[i], d);
2880         }
2881
2882         if (audio_codec_id != CODEC_ID_NONE)
2883             codec_id = audio_codec_id;
2884         audio_enc->codec_id = codec_id;
2885
2886         if (audio_qscale > QSCALE_NONE) {
2887             audio_enc->flags |= CODEC_FLAG_QSCALE;
2888             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2889         }
2890         audio_enc->thread_count = thread_count;
2891         audio_enc->channels = audio_channels;
2892     }
2893     audio_enc->sample_rate = audio_sample_rate;
2894     audio_enc->time_base= (AVRational){1, audio_sample_rate};
2895     if (audio_language) {
2896         pstrcpy(st->language, sizeof(st->language), audio_language);
2897         av_free(audio_language);
2898         audio_language = NULL;
2899     }
2900
2901     /* reset some key parameters */
2902     audio_disable = 0;
2903     audio_codec_id = CODEC_ID_NONE;
2904     audio_stream_copy = 0;
2905 }
2906
2907 static void opt_new_subtitle_stream(void)
2908 {
2909     AVFormatContext *oc;
2910     AVStream *st;
2911     AVCodecContext *subtitle_enc;
2912     int i;
2913
2914     if (nb_output_files <= 0) {
2915         fprintf(stderr, "At least one output file must be specified\n");
2916         exit(1);
2917     }
2918     oc = output_files[nb_output_files - 1];
2919
2920     st = av_new_stream(oc, oc->nb_streams);
2921     if (!st) {
2922         fprintf(stderr, "Could not alloc stream\n");
2923         exit(1);
2924     }
2925     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2926
2927     subtitle_enc = st->codec;
2928     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2929     if (subtitle_stream_copy) {
2930         st->stream_copy = 1;
2931     } else {
2932         for(i=0; i<opt_name_count; i++){
2933              const AVOption *opt;
2934              double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2935              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2936                  av_set_double(subtitle_enc, opt_names[i], d);
2937         }
2938         subtitle_enc->codec_id = subtitle_codec_id;
2939     }
2940
2941     if (subtitle_language) {
2942         pstrcpy(st->language, sizeof(st->language), subtitle_language);
2943         av_free(subtitle_language);
2944         subtitle_language = NULL;
2945     }
2946
2947     subtitle_codec_id = CODEC_ID_NONE;
2948     subtitle_stream_copy = 0;
2949 }
2950
2951 static void opt_new_audio_stream(void)
2952 {
2953     AVFormatContext *oc;
2954     if (nb_output_files <= 0) {
2955         fprintf(stderr, "At least one output file must be specified\n");
2956         exit(1);
2957     }
2958     oc = output_files[nb_output_files - 1];
2959     new_audio_stream(oc);
2960 }
2961
2962 static void opt_new_video_stream(void)
2963 {
2964     AVFormatContext *oc;
2965     if (nb_output_files <= 0) {
2966         fprintf(stderr, "At least one output file must be specified\n");
2967         exit(1);
2968     }
2969     oc = output_files[nb_output_files - 1];
2970     new_video_stream(oc);
2971 }
2972
2973 static void opt_output_file(const char *filename)
2974 {
2975     AVFormatContext *oc;
2976     int use_video, use_audio, input_has_video, input_has_audio, i;
2977     AVFormatParameters params, *ap = &params;
2978
2979     if (!strcmp(filename, "-"))
2980         filename = "pipe:";
2981
2982     oc = av_alloc_format_context();
2983
2984     if (!file_oformat) {
2985         file_oformat = guess_format(NULL, filename, NULL);
2986         if (!file_oformat) {
2987             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2988                     filename);
2989             exit(1);
2990         }
2991     }
2992
2993     oc->oformat = file_oformat;
2994     pstrcpy(oc->filename, sizeof(oc->filename), filename);
2995
2996     if (!strcmp(file_oformat->name, "ffm") &&
2997         strstart(filename, "http:", NULL)) {
2998         /* special case for files sent to ffserver: we get the stream
2999            parameters from ffserver */
3000         if (read_ffserver_streams(oc, filename) < 0) {
3001             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3002             exit(1);
3003         }
3004     } else {
3005         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3006         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3007
3008         /* disable if no corresponding type found and at least one
3009            input file */
3010         if (nb_input_files > 0) {
3011             check_audio_video_inputs(&input_has_video, &input_has_audio);
3012             if (!input_has_video)
3013                 use_video = 0;
3014             if (!input_has_audio)
3015                 use_audio = 0;
3016         }
3017
3018         /* manual disable */
3019         if (audio_disable) {
3020             use_audio = 0;
3021         }
3022         if (video_disable) {
3023             use_video = 0;
3024         }
3025
3026         if (use_video) {
3027             new_video_stream(oc);
3028         }
3029
3030         if (use_audio) {
3031             new_audio_stream(oc);
3032         }
3033
3034         oc->timestamp = rec_timestamp;
3035
3036         if (str_title)
3037             pstrcpy(oc->title, sizeof(oc->title), str_title);
3038         if (str_author)
3039             pstrcpy(oc->author, sizeof(oc->author), str_author);
3040         if (str_copyright)
3041             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3042         if (str_comment)
3043             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3044         if (str_album)
3045             pstrcpy(oc->album, sizeof(oc->album), str_album);
3046     }
3047
3048     output_files[nb_output_files++] = oc;
3049
3050     /* check filename in case of an image number is expected */
3051     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3052         if (!av_filename_number_test(oc->filename)) {
3053             print_error(oc->filename, AVERROR_NUMEXPECTED);
3054             exit(1);
3055         }
3056     }
3057
3058     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3059         /* test if it already exists to avoid loosing precious files */
3060         if (!file_overwrite &&
3061             (strchr(filename, ':') == NULL ||
3062              strstart(filename, "file:", NULL))) {
3063             if (url_exist(filename)) {
3064                 int c;
3065
3066                 if ( !using_stdin ) {
3067                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3068                     fflush(stderr);
3069                     c = getchar();
3070                     if (toupper(c) != 'Y') {
3071                         fprintf(stderr, "Not overwriting - exiting\n");
3072                         exit(1);
3073                     }
3074                                 }
3075                                 else {
3076                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3077                     exit(1);
3078                                 }
3079             }
3080         }
3081
3082         /* open the file */
3083         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3084             fprintf(stderr, "Could not open '%s'\n", filename);
3085             exit(1);
3086         }
3087     }
3088
3089     memset(ap, 0, sizeof(*ap));
3090     if (av_set_parameters(oc, ap) < 0) {
3091         fprintf(stderr, "%s: Invalid encoding parameters\n",
3092                 oc->filename);
3093         exit(1);
3094     }
3095
3096     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3097     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3098     oc->loop_output = loop_output;
3099
3100     for(i=0; i<opt_name_count; i++){
3101         const AVOption *opt;
3102         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3103         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3104             av_set_double(oc, opt_names[i], d);
3105     }
3106
3107     /* reset some options */
3108     file_oformat = NULL;
3109     file_iformat = NULL;
3110 }
3111
3112 /* same option as mencoder */
3113 static void opt_pass(const char *pass_str)
3114 {
3115     int pass;
3116     pass = atoi(pass_str);
3117     if (pass != 1 && pass != 2) {
3118         fprintf(stderr, "pass number can be only 1 or 2\n");
3119         exit(1);
3120     }
3121     do_pass = pass;
3122 }
3123
3124 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3125 static int64_t getutime(void)
3126 {
3127   return av_gettime();
3128 }
3129 #else
3130 static int64_t getutime(void)
3131 {
3132     struct rusage rusage;
3133
3134     getrusage(RUSAGE_SELF, &rusage);
3135     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3136 }
3137 #endif
3138
3139 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3140 extern int ffm_nopts;
3141 #endif
3142
3143 static void show_formats(void)
3144 {
3145     AVInputFormat *ifmt;
3146     AVOutputFormat *ofmt;
3147     URLProtocol *up;
3148     AVCodec *p, *p2;
3149     const char **pp, *last_name;
3150
3151     printf("File formats:\n");
3152     last_name= "000";
3153     for(;;){
3154         int decode=0;
3155         int encode=0;
3156         const char *name=NULL;
3157         const char *long_name=NULL;
3158
3159         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3160             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3161                 strcmp(ofmt->name, last_name)>0){
3162                 name= ofmt->name;
3163                 long_name= ofmt->long_name;
3164                 encode=1;
3165             }
3166         }
3167         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3168             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3169                 strcmp(ifmt->name, last_name)>0){
3170                 name= ifmt->name;
3171                 long_name= ifmt->long_name;
3172                 encode=0;
3173             }
3174             if(name && strcmp(ifmt->name, name)==0)
3175                 decode=1;
3176         }
3177         if(name==NULL)
3178             break;
3179         last_name= name;
3180
3181         printf(
3182             " %s%s %-15s %s\n",
3183             decode ? "D":" ",
3184             encode ? "E":" ",
3185             name,
3186             long_name ? long_name:" ");
3187     }
3188     printf("\n");
3189
3190     printf("Codecs:\n");
3191     last_name= "000";
3192     for(;;){
3193         int decode=0;
3194         int encode=0;
3195         int cap=0;
3196         const char *type_str;
3197
3198         p2=NULL;
3199         for(p = first_avcodec; p != NULL; p = p->next) {
3200             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3201                 strcmp(p->name, last_name)>0){
3202                 p2= p;
3203                 decode= encode= cap=0;
3204             }
3205             if(p2 && strcmp(p->name, p2->name)==0){
3206                 if(p->decode) decode=1;
3207                 if(p->encode) encode=1;
3208                 cap |= p->capabilities;
3209             }
3210         }
3211         if(p2==NULL)
3212             break;
3213         last_name= p2->name;
3214
3215         switch(p2->type) {
3216         case CODEC_TYPE_VIDEO:
3217             type_str = "V";
3218             break;
3219         case CODEC_TYPE_AUDIO:
3220             type_str = "A";
3221             break;
3222         case CODEC_TYPE_SUBTITLE:
3223             type_str = "S";
3224             break;
3225         default:
3226             type_str = "?";
3227             break;
3228         }
3229         printf(
3230             " %s%s%s%s%s%s %s",
3231             decode ? "D": (/*p2->decoder ? "d":*/" "),
3232             encode ? "E":" ",
3233             type_str,
3234             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3235             cap & CODEC_CAP_DR1 ? "D":" ",
3236             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3237             p2->name);
3238        /* if(p2->decoder && decode==0)
3239             printf(" use %s for decoding", p2->decoder->name);*/
3240         printf("\n");
3241     }
3242     printf("\n");
3243
3244     printf("Supported file protocols:\n");
3245     for(up = first_protocol; up != NULL; up = up->next)
3246         printf(" %s:", up->name);
3247     printf("\n");
3248
3249     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3250     printf("Motion estimation methods:\n");
3251     pp = motion_str;
3252     while (*pp) {
3253         printf(" %s", *pp);
3254         if ((pp - motion_str + 1) == ME_ZERO)
3255             printf("(fastest)");
3256         else if ((pp - motion_str + 1) == ME_FULL)
3257             printf("(slowest)");
3258         else if ((pp - motion_str + 1) == ME_EPZS)
3259             printf("(default)");
3260         pp++;
3261     }
3262     printf("\n\n");
3263     printf(
3264 "Note, the names of encoders and decoders dont always match, so there are\n"
3265 "several cases where the above table shows encoder only or decoder only entries\n"
3266 "even though both encoding and decoding are supported for example, the h263\n"
3267 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3268 "worse\n");
3269     exit(1);
3270 }
3271
3272 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3273 {
3274     int i;
3275     const char *p = str;
3276     for(i = 0;; i++) {
3277         dest[i] = atoi(p);
3278         if(i == 63)
3279             break;
3280         p = strchr(p, ',');
3281         if(!p) {
3282             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3283             exit(1);
3284         }
3285         p++;
3286     }
3287 }
3288
3289 static void opt_inter_matrix(const char *arg)
3290 {
3291     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3292     parse_matrix_coeffs(inter_matrix, arg);
3293 }
3294
3295 static void opt_intra_matrix(const char *arg)
3296 {
3297     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3298     parse_matrix_coeffs(intra_matrix, arg);
3299 }
3300
3301 static void opt_target(const char *arg)
3302 {
3303     int norm = -1;
3304     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3305
3306     if(!strncmp(arg, "pal-", 4)) {
3307         norm = 0;
3308         arg += 4;
3309     } else if(!strncmp(arg, "ntsc-", 5)) {
3310         norm = 1;
3311         arg += 5;
3312     } else if(!strncmp(arg, "film-", 5)) {
3313         norm = 2;
3314         arg += 5;
3315     } else {
3316         int fr;
3317         /* Calculate FR via float to avoid int overflow */
3318         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3319         if(fr == 25000) {
3320             norm = 0;
3321         } else if((fr == 29970) || (fr == 23976)) {
3322             norm = 1;
3323         } else {
3324             /* Try to determine PAL/NTSC by peeking in the input files */
3325             if(nb_input_files) {
3326                 int i, j;
3327                 for(j = 0; j < nb_input_files; j++) {
3328                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3329                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3330                         if(c->codec_type != CODEC_TYPE_VIDEO)
3331                             continue;
3332                         fr = c->time_base.den * 1000 / c->time_base.num;
3333                         if(fr == 25000) {
3334                             norm = 0;
3335                             break;
3336                         } else if((fr == 29970) || (fr == 23976)) {
3337                             norm = 1;
3338                             break;
3339                         }
3340                     }
3341                     if(norm >= 0)
3342                         break;
3343                 }
3344             }
3345         }
3346         if(verbose && norm >= 0)
3347             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3348     }
3349
3350     if(norm < 0) {
3351         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3352         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3353         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3354         exit(1);
3355     }
3356
3357     if(!strcmp(arg, "vcd")) {
3358
3359         opt_video_codec("mpeg1video");
3360         opt_audio_codec("mp2");
3361         opt_format("vcd");
3362
3363         opt_frame_size(norm ? "352x240" : "352x288");
3364         opt_frame_rate(frame_rates[norm]);
3365         opt_default("gop", norm ? "18" : "15");
3366
3367         opt_default("b", "1150000");
3368         opt_default("maxrate", "1150000");
3369         opt_default("minrate", "1150000");
3370         opt_default("bufsize", "327680"); // 40*1024*8;
3371
3372         opt_default("ab", "224000");
3373         audio_sample_rate = 44100;
3374         audio_channels = 2;
3375
3376         opt_default("packetsize", "2324");
3377         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3378
3379         /* We have to offset the PTS, so that it is consistent with the SCR.
3380            SCR starts at 36000, but the first two packs contain only padding
3381            and the first pack from the other stream, respectively, may also have
3382            been written before.
3383            So the real data starts at SCR 36000+3*1200. */
3384         mux_preload= (36000+3*1200) / 90000.0; //0.44
3385     } else if(!strcmp(arg, "svcd")) {
3386
3387         opt_video_codec("mpeg2video");
3388         opt_audio_codec("mp2");
3389         opt_format("svcd");
3390
3391         opt_frame_size(norm ? "480x480" : "480x576");
3392         opt_frame_rate(frame_rates[norm]);
3393         opt_default("gop", norm ? "18" : "15");
3394
3395         opt_default("b", "2040000");
3396         opt_default("maxrate", "2516000");
3397         opt_default("minrate", "0"); //1145000;
3398         opt_default("bufsize", "1835008"); //224*1024*8;
3399         opt_default("flags", "+SCAN_OFFSET");
3400
3401
3402         opt_default("ab", "224000");
3403         audio_sample_rate = 44100;
3404
3405         opt_default("packetsize", "2324");
3406
3407     } else if(!strcmp(arg, "dvd")) {
3408
3409         opt_video_codec("mpeg2video");
3410         opt_audio_codec("ac3");
3411         opt_format("dvd");
3412
3413         opt_frame_size(norm ? "720x480" : "720x576");
3414         opt_frame_rate(frame_rates[norm]);
3415         opt_default("gop", norm ? "18" : "15");
3416
3417         opt_default("b", "6000000");
3418         opt_default("maxrate", "9000000");
3419         opt_default("minrate", "0"); //1500000;
3420         opt_default("bufsize", "1835008"); //224*1024*8;
3421
3422         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3423         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3424
3425         opt_default("ab", "448000");
3426         audio_sample_rate = 48000;
3427
3428     } else if(!strncmp(arg, "dv", 2)) {
3429
3430         opt_format("dv");
3431
3432         opt_frame_size(norm ? "720x480" : "720x576");
3433         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3434                                              (norm ? "yuv411p" : "yuv420p"));
3435         opt_frame_rate(frame_rates[norm]);
3436
3437         audio_sample_rate = 48000;
3438         audio_channels = 2;
3439
3440     } else {
3441         fprintf(stderr, "Unknown target: %s\n", arg);
3442         exit(1);
3443     }
3444 }
3445
3446 static void opt_video_bsf(const char *arg)
3447 {
3448     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3449     AVBitStreamFilterContext **bsfp;
3450
3451     if(!bsfc){
3452         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3453         exit(1);
3454     }
3455
3456     bsfp= &video_bitstream_filters;
3457     while(*bsfp)
3458         bsfp= &(*bsfp)->next;
3459
3460     *bsfp= bsfc;
3461 }
3462
3463 //FIXME avoid audio - video code duplication
3464 static void opt_audio_bsf(const char *arg)
3465 {
3466     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3467     AVBitStreamFilterContext **bsfp;
3468
3469     if(!bsfc){
3470         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3471         exit(1);
3472     }
3473
3474     bsfp= &audio_bitstream_filters;
3475     while(*bsfp)
3476         bsfp= &(*bsfp)->next;
3477
3478     *bsfp= bsfc;
3479 }
3480
3481 static void show_version(void)
3482 {
3483     /* TODO: add function interface to avutil and avformat */
3484     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3485            "libavutil   %d\n"
3486            "libavcodec  %d\n"
3487            "libavformat %d\n",
3488            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3489     exit(1);
3490 }
3491
3492 static int opt_default(const char *opt, const char *arg){
3493     int type;
3494     const AVOption *o= NULL;
3495     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3496
3497     for(type=0; type<CODEC_TYPE_NB; type++){
3498         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3499         if(o2)
3500             o = av_set_string(avctx_opts[type], opt, arg);
3501     }
3502     if(!o)
3503         o = av_set_string(avformat_opts, opt, arg);
3504     if(!o){
3505         if(opt[0] == 'a')
3506             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3507         else if(opt[0] == 'v')
3508             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3509         else if(opt[0] == 's')
3510             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3511     }
3512     if(!o)
3513         return -1;
3514
3515 //    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));
3516
3517     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3518     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3519     opt_names[opt_name_count++]= o->name;
3520
3521 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3522     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3523     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3524         ffm_nopts = 1;
3525 #endif
3526
3527     if(avctx_opts[0]->debug)
3528         av_log_level = AV_LOG_DEBUG;
3529     return 0;
3530 }
3531
3532 const OptionDef options[] = {
3533     /* main options */
3534     { "L", 0, {(void*)show_license}, "show license" },
3535     { "h", 0, {(void*)show_help}, "show help" },
3536     { "version", 0, {(void*)show_version}, "show version" },
3537     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3538     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3539     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3540     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3541     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3542     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3543     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3544     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3545     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3546     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3547     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3548     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3549     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3550     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3551     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3552     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3553     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3554       "add timings for benchmarking" },
3555     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3556       "dump each input packet" },
3557     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3558       "when dumping packets, also dump the payload" },
3559     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3560     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3561     { "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)", "" },
3562     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3563     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3564     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3565     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3566     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3567     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3568     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3569     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3570     { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3571
3572     /* video options */
3573     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3574     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3575     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3576     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3577     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3578     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3579     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3580     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3581     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3582     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3583     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3584     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3585     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3586     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3587     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3588     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3589     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3590     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3591     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3592     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3593     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3594     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3595     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3596     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3597       "method" },
3598     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3599     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3600     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3601       "use same video quality as source (implies VBR)" },
3602     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3603     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3604     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3605       "deinterlace pictures" },
3606     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3607     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3608     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3609     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3610     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3611     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3612     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3613     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3614     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3615     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3616
3617     /* audio options */
3618     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3619     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3620     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3621     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3622     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3623     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3624     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3625     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3626     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3627     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3628
3629     /* subtitle options */
3630     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3631     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3632     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3633
3634     /* grab options */
3635     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3636     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3637     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3638
3639     /* muxer options */
3640     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3641     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3642
3643     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3644     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3645
3646     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3647     { NULL, },
3648 };
3649
3650 static void show_banner(void)
3651 {
3652     fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3653     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3654     fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3655     fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3656     fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3657     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3658 #ifdef __GNUC__
3659     fprintf(stderr, ", gcc: " __VERSION__ "\n");
3660 #else
3661     fprintf(stderr, ", using a non-gcc compiler\n");
3662 #endif
3663 }
3664
3665 static void show_license(void)
3666 {
3667     show_banner();
3668 #ifdef CONFIG_GPL
3669     printf(
3670     "FFmpeg is free software; you can redistribute it and/or modify\n"
3671     "it under the terms of the GNU General Public License as published by\n"
3672     "the Free Software Foundation; either version 2 of the License, or\n"
3673     "(at your option) any later version.\n"
3674     "\n"
3675     "FFmpeg is distributed in the hope that it will be useful,\n"
3676     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3677     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3678     "GNU General Public License for more details.\n"
3679     "\n"
3680     "You should have received a copy of the GNU General Public License\n"
3681     "along with FFmpeg; if not, write to the Free Software\n"
3682     "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3683     );
3684 #else
3685     printf(
3686     "FFmpeg is free software; you can redistribute it and/or\n"
3687     "modify it under the terms of the GNU Lesser General Public\n"
3688     "License as published by the Free Software Foundation; either\n"
3689     "version 2.1 of the License, or (at your option) any later version.\n"
3690     "\n"
3691     "FFmpeg is distributed in the hope that it will be useful,\n"
3692     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3693     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3694     "Lesser General Public License for more details.\n"
3695     "\n"
3696     "You should have received a copy of the GNU Lesser General Public\n"
3697     "License along with FFmpeg; if not, write to the Free Software\n"
3698     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3699     );
3700 #endif
3701     exit(1);
3702 }
3703
3704 static void show_help(void)
3705 {
3706     show_banner();
3707     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3708            "Hyper fast Audio and Video encoder\n");
3709     printf("\n");
3710     show_help_options(options, "Main options:\n",
3711                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3712     show_help_options(options, "\nVideo options:\n",
3713                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3714                       OPT_VIDEO);
3715     show_help_options(options, "\nAdvanced Video options:\n",
3716                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3717                       OPT_VIDEO | OPT_EXPERT);
3718     show_help_options(options, "\nAudio options:\n",
3719                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3720                       OPT_AUDIO);
3721     show_help_options(options, "\nAdvanced Audio options:\n",
3722                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3723                       OPT_AUDIO | OPT_EXPERT);
3724     show_help_options(options, "\nSubtitle options:\n",
3725                       OPT_SUBTITLE | OPT_GRAB,
3726                       OPT_SUBTITLE);
3727     show_help_options(options, "\nAudio/Video grab options:\n",
3728                       OPT_GRAB,
3729                       OPT_GRAB);
3730     show_help_options(options, "\nAdvanced options:\n",
3731                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3732                       OPT_EXPERT);
3733     av_opt_show(avctx_opts[0], NULL);
3734     av_opt_show(avformat_opts, NULL);
3735
3736     exit(1);
3737 }
3738
3739 void parse_arg_file(const char *filename)
3740 {
3741     opt_output_file(filename);
3742 }
3743
3744 int main(int argc, char **argv)
3745 {
3746     int i;
3747     int64_t ti;
3748
3749     av_register_all();
3750
3751     for(i=0; i<CODEC_TYPE_NB; i++){
3752         avctx_opts[i]= avcodec_alloc_context2(i);
3753     }
3754     avformat_opts = av_alloc_format_context();
3755
3756     if (argc <= 1)
3757         show_help();
3758     else
3759         show_banner();
3760
3761     /* parse options */
3762     parse_options(argc, argv, options);
3763
3764     /* file converter / grab */
3765     if (nb_output_files <= 0) {
3766         fprintf(stderr, "Must supply at least one output file\n");
3767         exit(1);
3768     }
3769
3770     if (nb_input_files == 0) {
3771         fprintf(stderr, "Must supply at least one input file\n");
3772         exit(1);
3773     }
3774
3775     ti = getutime();
3776     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3777               stream_maps, nb_stream_maps);
3778     ti = getutime() - ti;
3779     if (do_benchmark) {
3780         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3781     }
3782
3783     /* close files */
3784     for(i=0;i<nb_output_files;i++) {
3785         /* maybe av_close_output_file ??? */
3786         AVFormatContext *s = output_files[i];
3787         int j;
3788         if (!(s->oformat->flags & AVFMT_NOFILE))
3789             url_fclose(&s->pb);
3790         for(j=0;j<s->nb_streams;j++) {
3791             av_free(s->streams[j]->codec);
3792             av_free(s->streams[j]);
3793         }
3794         av_free(s);
3795     }
3796     for(i=0;i<nb_input_files;i++)
3797         av_close_input_file(input_files[i]);
3798
3799     av_free_static();
3800
3801     av_free(intra_matrix);
3802     av_free(inter_matrix);
3803     av_free(opt_names);
3804
3805 #ifdef CONFIG_POWERPC_PERF
3806     extern void powerpc_display_perf_report(void);
3807     powerpc_display_perf_report();
3808 #endif /* CONFIG_POWERPC_PERF */
3809
3810     if (received_sigterm) {
3811         fprintf(stderr,
3812             "Received signal %d: terminating.\n",
3813             (int) received_sigterm);
3814         exit (255);
3815     }
3816
3817     exit(0); /* not all OS-es handle main() return value */
3818     return 0;
3819 }