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

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