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

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