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

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