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