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