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