ffmpeg.c

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