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>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
 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
1143     //while we have more to decode or while the decoder did output something on EOF
1144     while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1145     handle_eof:
1146         ist->pts= ist->next_pts;
1147
1148         if(len && len != pkt->size && verbose>0)
1149             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1150
1151         /* decode the packet if needed */
1152         data_buf = NULL; /* fail safe */
1153         data_size = 0;
1154         subtitle_to_free = NULL;
1155         if (ist->decoding_needed) {
1156             switch(ist->st->codec->codec_type) {
1157             case CODEC_TYPE_AUDIO:{
1158                 if(pkt)
1159                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1160                 data_size= samples_size;
1161                     /* XXX: could avoid copy if PCM 16 bits with same
1162                        endianness as CPU */
1163                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1164                                            ptr, len);
1165                 if (ret < 0)
1166                     goto fail_decode;
1167                 ptr += ret;
1168                 len -= ret;
1169                 /* Some bug in mpeg audio decoder gives */
1170                 /* data_size < 0, it seems they are overflows */
1171                 if (data_size <= 0) {
1172                     /* no audio frame */
1173                     continue;
1174                 }
1175                 data_buf = (uint8_t *)samples;
1176                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1177                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1178                 break;}
1179             case CODEC_TYPE_VIDEO:
1180                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1181                     /* XXX: allocate picture correctly */
1182                     avcodec_get_frame_defaults(&picture);
1183
1184                     ret = avcodec_decode_video(ist->st->codec,
1185                                                &picture, &got_picture, ptr, len);
1186                     ist->st->quality= picture.quality;
1187                     if (ret < 0)
1188                         goto fail_decode;
1189                     if (!got_picture) {
1190                         /* no picture yet */
1191                         goto discard_packet;
1192                     }
1193                     if (ist->st->codec->time_base.num != 0) {
1194                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1195                                           ist->st->codec->time_base.num) /
1196                             ist->st->codec->time_base.den;
1197                     }
1198                     len = 0;
1199                     break;
1200             case CODEC_TYPE_SUBTITLE:
1201                 ret = avcodec_decode_subtitle(ist->st->codec,
1202                                               &subtitle, &got_subtitle, ptr, len);
1203                 if (ret < 0)
1204                     goto fail_decode;
1205                 if (!got_subtitle) {
1206                     goto discard_packet;
1207                 }
1208                 subtitle_to_free = &subtitle;
1209                 len = 0;
1210                 break;
1211             default:
1212                 goto fail_decode;
1213             }
1214         } else {
1215             switch(ist->st->codec->codec_type) {
1216             case CODEC_TYPE_AUDIO:
1217                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1218                     ist->st->codec->sample_rate;
1219                 break;
1220             case CODEC_TYPE_VIDEO:
1221                 if (ist->st->codec->time_base.num != 0) {
1222                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1223                                       ist->st->codec->time_base.num) /
1224                         ist->st->codec->time_base.den;
1225                 }
1226                 break;
1227             }
1228             data_buf = ptr;
1229             data_size = len;
1230             ret = len;
1231             len = 0;
1232         }
1233
1234         buffer_to_free = NULL;
1235         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1236             pre_process_video_frame(ist, (AVPicture *)&picture,
1237                                     &buffer_to_free);
1238         }
1239
1240         // preprocess audio (volume)
1241         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1242             if (audio_volume != 256) {
1243                 short *volp;
1244                 volp = samples;
1245                 for(i=0;i<(data_size / sizeof(short));i++) {
1246                     int v = ((*volp) * audio_volume + 128) >> 8;
1247                     if (v < -32768) v = -32768;
1248                     if (v >  32767) v = 32767;
1249                     *volp++ = v;
1250                 }
1251             }
1252         }
1253
1254         /* frame rate emulation */
1255         if (ist->st->codec->rate_emu) {
1256             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1257             int64_t now = av_gettime() - ist->start;
1258             if (pts > now)
1259                 usleep(pts - now);
1260
1261             ist->frame++;
1262         }
1263
1264 #if 0
1265         /* mpeg PTS deordering : if it is a P or I frame, the PTS
1266            is the one of the next displayed one */
1267         /* XXX: add mpeg4 too ? */
1268         if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1269             if (ist->st->codec->pict_type != B_TYPE) {
1270                 int64_t tmp;
1271                 tmp = ist->last_ip_pts;
1272                 ist->last_ip_pts  = ist->frac_pts.val;
1273                 ist->frac_pts.val = tmp;
1274             }
1275         }
1276 #endif
1277         /* if output time reached then transcode raw format,
1278            encode packets and output them */
1279         if (start_time == 0 || ist->pts >= start_time)
1280             for(i=0;i<nb_ostreams;i++) {
1281                 int frame_size;
1282
1283                 ost = ost_table[i];
1284                 if (ost->source_index == ist_index) {
1285                     os = output_files[ost->file_index];
1286
1287 #if 0
1288                     printf("%d: got pts=%0.3f %0.3f\n", i,
1289                            (double)pkt->pts / AV_TIME_BASE,
1290                            ((double)ist->pts / AV_TIME_BASE) -
1291                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1292 #endif
1293                     /* set the input output pts pairs */
1294                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1295
1296                     if (ost->encoding_needed) {
1297                         switch(ost->st->codec->codec_type) {
1298                         case CODEC_TYPE_AUDIO:
1299                             do_audio_out(os, ost, ist, data_buf, data_size);
1300                             break;
1301                         case CODEC_TYPE_VIDEO:
1302                             do_video_out(os, ost, ist, &picture, &frame_size);
1303                             video_size += frame_size;
1304                             if (vstats_filename && frame_size)
1305                                 do_video_stats(os, ost, frame_size);
1306                             break;
1307                         case CODEC_TYPE_SUBTITLE:
1308                             do_subtitle_out(os, ost, ist, &subtitle,
1309                                             pkt->pts);
1310                             break;
1311                         default:
1312                             abort();
1313                         }
1314                     } else {
1315                         AVFrame avframe; //FIXME/XXX remove this
1316                         AVPacket opkt;
1317                         av_init_packet(&opkt);
1318
1319                         if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1320                             continue;
1321
1322                         /* no reencoding needed : output the packet directly */
1323                         /* force the input stream PTS */
1324
1325                         avcodec_get_frame_defaults(&avframe);
1326                         ost->st->codec->coded_frame= &avframe;
1327                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1328
1329                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1330                             audio_size += data_size;
1331                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1332                             video_size += data_size;
1333                             ost->sync_opts++;
1334                         }
1335
1336                         opkt.stream_index= ost->index;
1337                         if(pkt->pts != AV_NOPTS_VALUE)
1338                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1339                         else
1340                             opkt.pts= AV_NOPTS_VALUE;
1341
1342                         if (pkt->dts == AV_NOPTS_VALUE)
1343                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1344                         else
1345                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1346
1347                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1348                         opkt.flags= pkt->flags;
1349
1350                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1351                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1352                             opkt.destruct= av_destruct_packet;
1353
1354                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1355                         ost->st->codec->frame_number++;
1356                         ost->frame_number++;
1357                         av_free_packet(&opkt);
1358                     }
1359                 }
1360             }
1361         av_free(buffer_to_free);
1362         /* XXX: allocate the subtitles in the codec ? */
1363         if (subtitle_to_free) {
1364             if (subtitle_to_free->rects != NULL) {
1365                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1366                     av_free(subtitle_to_free->rects[i].bitmap);
1367                     av_free(subtitle_to_free->rects[i].rgba_palette);
1368                 }
1369                 av_freep(&subtitle_to_free->rects);
1370             }
1371             subtitle_to_free->num_rects = 0;
1372             subtitle_to_free = NULL;
1373         }
1374     }
1375  discard_packet:
1376     if (pkt == NULL) {
1377         /* EOF handling */
1378
1379         for(i=0;i<nb_ostreams;i++) {
1380             ost = ost_table[i];
1381             if (ost->source_index == ist_index) {
1382                 AVCodecContext *enc= ost->st->codec;
1383                 os = output_files[ost->file_index];
1384
1385                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1386                     continue;
1387                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1388                     continue;
1389
1390                 if (ost->encoding_needed) {
1391                     for(;;) {
1392                         AVPacket pkt;
1393                         int fifo_bytes;
1394                         av_init_packet(&pkt);
1395                         pkt.stream_index= ost->index;
1396
1397                         switch(ost->st->codec->codec_type) {
1398                         case CODEC_TYPE_AUDIO:
1399                             fifo_bytes = av_fifo_size(&ost->fifo);
1400                             ret = 0;
1401                             /* encode any samples remaining in fifo */
1402                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1403                                 int fs_tmp = enc->frame_size;
1404                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1405                                 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1406                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1407                                 enc->frame_size = fs_tmp;
1408                             }
1409                             if(ret <= 0) {
1410                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1411                             }
1412                             audio_size += ret;
1413                             pkt.flags |= PKT_FLAG_KEY;
1414                             break;
1415                         case CODEC_TYPE_VIDEO:
1416                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1417                             video_size += ret;
1418                             if(enc->coded_frame && enc->coded_frame->key_frame)
1419                                 pkt.flags |= PKT_FLAG_KEY;
1420                             if (ost->logfile && enc->stats_out) {
1421                                 fprintf(ost->logfile, "%s", enc->stats_out);
1422                             }
1423                             break;
1424                         default:
1425                             ret=-1;
1426                         }
1427
1428                         if(ret<=0)
1429                             break;
1430                         pkt.data= bit_buffer;
1431                         pkt.size= ret;
1432                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1433                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1434                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1435                     }
1436                 }
1437             }
1438         }
1439     }
1440
1441     return 0;
1442  fail_decode:
1443     return -1;
1444 }
1445
1446 static void print_sdp(AVFormatContext **avc, int n)
1447 {
1448     char sdp[2048];
1449
1450     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1451     printf("SDP:\n%s\n", sdp);
1452 }
1453
1454 static int stream_index_from_inputs(AVFormatContext **input_files,
1455                                     int nb_input_files,
1456                                     AVInputFile *file_table,
1457                                     AVInputStream **ist_table,
1458                                     enum CodecType type,
1459                                     int programid)
1460 {
1461     int p, q, z;
1462     for(z=0; z<nb_input_files; z++) {
1463         AVFormatContext *ic = input_files[z];
1464         for(p=0; p<ic->nb_programs; p++) {
1465             AVProgram *program = ic->programs[p];
1466             if(program->id != programid)
1467                 continue;
1468             for(q=0; q<program->nb_stream_indexes; q++) {
1469                 int sidx = program->stream_index[q];
1470                 int ris = file_table[z].ist_index + sidx;
1471                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1472                     return ris;
1473             }
1474         }
1475     }
1476
1477     return -1;
1478 }
1479
1480 /*
1481  * The following code is the main loop of the file converter
1482  */
1483 static int av_encode(AVFormatContext **output_files,
1484                      int nb_output_files,
1485                      AVFormatContext **input_files,
1486                      int nb_input_files,
1487                      AVStreamMap *stream_maps, int nb_stream_maps)
1488 {
1489     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1490     AVFormatContext *is, *os;
1491     AVCodecContext *codec, *icodec;
1492     AVOutputStream *ost, **ost_table = NULL;
1493     AVInputStream *ist, **ist_table = NULL;
1494     AVInputFile *file_table;
1495     int key;
1496     int want_sdp = 1;
1497
1498     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1499     if (!file_table)
1500         goto fail;
1501
1502     /* input stream init */
1503     j = 0;
1504     for(i=0;i<nb_input_files;i++) {
1505         is = input_files[i];
1506         file_table[i].ist_index = j;
1507         file_table[i].nb_streams = is->nb_streams;
1508         j += is->nb_streams;
1509     }
1510     nb_istreams = j;
1511
1512     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1513     if (!ist_table)
1514         goto fail;
1515
1516     for(i=0;i<nb_istreams;i++) {
1517         ist = av_mallocz(sizeof(AVInputStream));
1518         if (!ist)
1519             goto fail;
1520         ist_table[i] = ist;
1521     }
1522     j = 0;
1523     for(i=0;i<nb_input_files;i++) {
1524         is = input_files[i];
1525         for(k=0;k<is->nb_streams;k++) {
1526             ist = ist_table[j++];
1527             ist->st = is->streams[k];
1528             ist->file_index = i;
1529             ist->index = k;
1530             ist->discard = 1; /* the stream is discarded by default
1531                                  (changed later) */
1532
1533             if (ist->st->codec->rate_emu) {
1534                 ist->start = av_gettime();
1535                 ist->frame = 0;
1536             }
1537         }
1538     }
1539
1540     /* output stream init */
1541     nb_ostreams = 0;
1542     for(i=0;i<nb_output_files;i++) {
1543         os = output_files[i];
1544         if (!os->nb_streams) {
1545             fprintf(stderr, "Output file does not contain any stream\n");
1546             av_exit(1);
1547         }
1548         nb_ostreams += os->nb_streams;
1549     }
1550     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1551         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1552         av_exit(1);
1553     }
1554
1555     /* Sanity check the mapping args -- do the input files & streams exist? */
1556     for(i=0;i<nb_stream_maps;i++) {
1557         int fi = stream_maps[i].file_index;
1558         int si = stream_maps[i].stream_index;
1559
1560         if (fi < 0 || fi > nb_input_files - 1 ||
1561             si < 0 || si > file_table[fi].nb_streams - 1) {
1562             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1563             av_exit(1);
1564         }
1565         fi = stream_maps[i].sync_file_index;
1566         si = stream_maps[i].sync_stream_index;
1567         if (fi < 0 || fi > nb_input_files - 1 ||
1568             si < 0 || si > file_table[fi].nb_streams - 1) {
1569             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1570             av_exit(1);
1571         }
1572     }
1573
1574     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1575     if (!ost_table)
1576         goto fail;
1577     for(i=0;i<nb_ostreams;i++) {
1578         ost = av_mallocz(sizeof(AVOutputStream));
1579         if (!ost)
1580             goto fail;
1581         ost_table[i] = ost;
1582     }
1583
1584     n = 0;
1585     for(k=0;k<nb_output_files;k++) {
1586         os = output_files[k];
1587         for(i=0;i<os->nb_streams;i++) {
1588             int found;
1589             ost = ost_table[n++];
1590             ost->file_index = k;
1591             ost->index = i;
1592             ost->st = os->streams[i];
1593             if (nb_stream_maps > 0) {
1594                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1595                     stream_maps[n-1].stream_index;
1596
1597                 /* Sanity check that the stream types match */
1598                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1599                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1600                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1601                         ost->file_index, ost->index);
1602                     av_exit(1);
1603                 }
1604
1605             } else {
1606                 if(opt_programid) {
1607                     found = 0;
1608                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1609                     if(j != -1) {
1610                         ost->source_index = j;
1611                         found = 1;
1612                     }
1613                 } else {
1614                     /* get corresponding input stream index : we select the first one with the right type */
1615                     found = 0;
1616                     for(j=0;j<nb_istreams;j++) {
1617                         ist = ist_table[j];
1618                         if (ist->discard &&
1619                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1620                             ost->source_index = j;
1621                             found = 1;
1622                             break;
1623                         }
1624                     }
1625                 }
1626
1627                 if (!found) {
1628                     if(! opt_programid) {
1629                         /* try again and reuse existing stream */
1630                         for(j=0;j<nb_istreams;j++) {
1631                             ist = ist_table[j];
1632                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1633                                 ost->source_index = j;
1634                                 found = 1;
1635                             }
1636                         }
1637                     }
1638                     if (!found) {
1639                         int i= ost->file_index;
1640                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1641                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1642                                 ost->file_index, ost->index);
1643                         av_exit(1);
1644                     }
1645                 }
1646             }
1647             ist = ist_table[ost->source_index];
1648             ist->discard = 0;
1649             ost->sync_ist = (nb_stream_maps > 0) ?
1650                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1651                          stream_maps[n-1].sync_stream_index] : ist;
1652         }
1653     }
1654
1655     /* for each output stream, we compute the right encoding parameters */
1656     for(i=0;i<nb_ostreams;i++) {
1657         ost = ost_table[i];
1658         os = output_files[ost->file_index];
1659         ist = ist_table[ost->source_index];
1660
1661         codec = ost->st->codec;
1662         icodec = ist->st->codec;
1663
1664         if (!ost->st->language[0])
1665             av_strlcpy(ost->st->language, ist->st->language,
1666                        sizeof(ost->st->language));
1667
1668         ost->st->disposition = ist->st->disposition;
1669
1670         if (ost->st->stream_copy) {
1671             /* if stream_copy is selected, no need to decode or encode */
1672             codec->codec_id = icodec->codec_id;
1673             codec->codec_type = icodec->codec_type;
1674
1675             if(!codec->codec_tag){
1676                 if(   !os->oformat->codec_tag
1677                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1678                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1679                     codec->codec_tag = icodec->codec_tag;
1680             }
1681
1682             codec->bit_rate = icodec->bit_rate;
1683             codec->extradata= icodec->extradata;
1684             codec->extradata_size= icodec->extradata_size;
1685             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1686                 codec->time_base = icodec->time_base;
1687             else
1688                 codec->time_base = ist->st->time_base;
1689             switch(codec->codec_type) {
1690             case CODEC_TYPE_AUDIO:
1691                 if(audio_volume != 256) {
1692                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1693                     av_exit(1);
1694                 }
1695                 codec->sample_rate = icodec->sample_rate;
1696                 codec->channels = icodec->channels;
1697                 codec->frame_size = icodec->frame_size;
1698                 codec->block_align= icodec->block_align;
1699                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1700                     codec->block_align= 0;
1701                 if(codec->codec_id == CODEC_ID_AC3)
1702                     codec->block_align= 0;
1703                 break;
1704             case CODEC_TYPE_VIDEO:
1705                 if(using_vhook) {
1706                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1707                     av_exit(1);
1708                 }
1709                 codec->pix_fmt = icodec->pix_fmt;
1710                 codec->width = icodec->width;
1711                 codec->height = icodec->height;
1712                 codec->has_b_frames = icodec->has_b_frames;
1713                 break;
1714             case CODEC_TYPE_SUBTITLE:
1715                 break;
1716             default:
1717                 abort();
1718             }
1719         } else {
1720             switch(codec->codec_type) {
1721             case CODEC_TYPE_AUDIO:
1722                 if (av_fifo_init(&ost->fifo, 1024))
1723                     goto fail;
1724                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1725                 icodec->request_channels = codec->channels;
1726                 ist->decoding_needed = 1;
1727                 ost->encoding_needed = 1;
1728                 break;
1729             case CODEC_TYPE_VIDEO:
1730                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1731                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1732                 ost->video_resample = ((codec->width != icodec->width -
1733                                 (frame_leftBand + frame_rightBand) +
1734                                 (frame_padleft + frame_padright)) ||
1735                         (codec->height != icodec->height -
1736                                 (frame_topBand  + frame_bottomBand) +
1737                                 (frame_padtop + frame_padbottom)) ||
1738                         (codec->pix_fmt != icodec->pix_fmt));
1739                 if (ost->video_crop) {
1740                     ost->topBand = frame_topBand;
1741                     ost->leftBand = frame_leftBand;
1742                 }
1743                 if (ost->video_pad) {
1744                     ost->padtop = frame_padtop;
1745                     ost->padleft = frame_padleft;
1746                     ost->padbottom = frame_padbottom;
1747                     ost->padright = frame_padright;
1748                     if (!ost->video_resample) {
1749                         avcodec_get_frame_defaults(&ost->pict_tmp);
1750                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1751                                          codec->width, codec->height))
1752                             goto fail;
1753                     }
1754                 }
1755                 if (ost->video_resample) {
1756                     avcodec_get_frame_defaults(&ost->pict_tmp);
1757                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1758                                          codec->width, codec->height)) {
1759                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1760                         av_exit(1);
1761                     }
1762                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1763                     ost->img_resample_ctx = sws_getContext(
1764                             icodec->width - (frame_leftBand + frame_rightBand),
1765                             icodec->height - (frame_topBand + frame_bottomBand),
1766                             icodec->pix_fmt,
1767                             codec->width - (frame_padleft + frame_padright),
1768                             codec->height - (frame_padtop + frame_padbottom),
1769                             codec->pix_fmt,
1770                             sws_flags, NULL, NULL, NULL);
1771                     if (ost->img_resample_ctx == NULL) {
1772                         fprintf(stderr, "Cannot get resampling context\n");
1773                         av_exit(1);
1774                     }
1775                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1776                 }
1777                 ost->encoding_needed = 1;
1778                 ist->decoding_needed = 1;
1779                 break;
1780             case CODEC_TYPE_SUBTITLE:
1781                 ost->encoding_needed = 1;
1782                 ist->decoding_needed = 1;
1783                 break;
1784             default:
1785                 abort();
1786                 break;
1787             }
1788             /* two pass mode */
1789             if (ost->encoding_needed &&
1790                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1791                 char logfilename[1024];
1792                 FILE *f;
1793                 int size;
1794                 char *logbuffer;
1795
1796                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1797                          pass_logfilename ?
1798                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1799                 if (codec->flags & CODEC_FLAG_PASS1) {
1800                     f = fopen(logfilename, "w");
1801                     if (!f) {
1802                         perror(logfilename);
1803                         av_exit(1);
1804                     }
1805                     ost->logfile = f;
1806                 } else {
1807                     /* read the log file */
1808                     f = fopen(logfilename, "r");
1809                     if (!f) {
1810                         perror(logfilename);
1811                         av_exit(1);
1812                     }
1813                     fseek(f, 0, SEEK_END);
1814                     size = ftell(f);
1815                     fseek(f, 0, SEEK_SET);
1816                     logbuffer = av_malloc(size + 1);
1817                     if (!logbuffer) {
1818                         fprintf(stderr, "Could not allocate log buffer\n");
1819                         av_exit(1);
1820                     }
1821                     size = fread(logbuffer, 1, size, f);
1822                     fclose(f);
1823                     logbuffer[size] = '\0';
1824                     codec->stats_in = logbuffer;
1825                 }
1826             }
1827         }
1828         if(codec->codec_type == CODEC_TYPE_VIDEO){
1829             int size= codec->width * codec->height;
1830             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1831         }
1832     }
1833
1834     if (!bit_buffer)
1835         bit_buffer = av_malloc(bit_buffer_size);
1836     if (!bit_buffer)
1837         goto fail;
1838
1839     /* dump the file output parameters - cannot be done before in case
1840        of stream copy */
1841     for(i=0;i<nb_output_files;i++) {
1842         dump_format(output_files[i], i, output_files[i]->filename, 1);
1843     }
1844
1845     /* dump the stream mapping */
1846     if (verbose >= 0) {
1847         fprintf(stderr, "Stream mapping:\n");
1848         for(i=0;i<nb_ostreams;i++) {
1849             ost = ost_table[i];
1850             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1851                     ist_table[ost->source_index]->file_index,
1852                     ist_table[ost->source_index]->index,
1853                     ost->file_index,
1854                     ost->index);
1855             if (ost->sync_ist != ist_table[ost->source_index])
1856                 fprintf(stderr, " [sync #%d.%d]",
1857                         ost->sync_ist->file_index,
1858                         ost->sync_ist->index);
1859             fprintf(stderr, "\n");
1860         }
1861     }
1862
1863     /* open each encoder */
1864     for(i=0;i<nb_ostreams;i++) {
1865         ost = ost_table[i];
1866         if (ost->encoding_needed) {
1867             AVCodec *codec;
1868             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1869             if (!codec) {
1870                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1871                         ost->file_index, ost->index);
1872                 av_exit(1);
1873             }
1874             if (avcodec_open(ost->st->codec, codec) < 0) {
1875                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1876                         ost->file_index, ost->index);
1877                 av_exit(1);
1878             }
1879             extra_size += ost->st->codec->extradata_size;
1880         }
1881     }
1882
1883     /* open each decoder */
1884     for(i=0;i<nb_istreams;i++) {
1885         ist = ist_table[i];
1886         if (ist->decoding_needed) {
1887             AVCodec *codec;
1888             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1889             if (!codec) {
1890                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1891                         ist->st->codec->codec_id, ist->file_index, ist->index);
1892                 av_exit(1);
1893             }
1894             if (avcodec_open(ist->st->codec, codec) < 0) {
1895                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1896                         ist->file_index, ist->index);
1897                 av_exit(1);
1898             }
1899             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1900             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1901         }
1902     }
1903
1904     /* init pts */
1905     for(i=0;i<nb_istreams;i++) {
1906         ist = ist_table[i];
1907         is = input_files[ist->file_index];
1908         ist->pts = 0;
1909         ist->next_pts = AV_NOPTS_VALUE;
1910         ist->is_start = 1;
1911     }
1912
1913     /* set meta data information from input file if required */
1914     for (i=0;i<nb_meta_data_maps;i++) {
1915         AVFormatContext *out_file;
1916         AVFormatContext *in_file;
1917
1918         int out_file_index = meta_data_maps[i].out_file;
1919         int in_file_index = meta_data_maps[i].in_file;
1920         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1921             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1922             ret = AVERROR(EINVAL);
1923             goto fail;
1924         }
1925         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1926             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1927             ret = AVERROR(EINVAL);
1928             goto fail;
1929         }
1930
1931         out_file = output_files[out_file_index];
1932         in_file = input_files[in_file_index];
1933
1934         strcpy(out_file->title, in_file->title);
1935         strcpy(out_file->author, in_file->author);
1936         strcpy(out_file->copyright, in_file->copyright);
1937         strcpy(out_file->comment, in_file->comment);
1938         strcpy(out_file->album, in_file->album);
1939         out_file->year = in_file->year;
1940         out_file->track = in_file->track;
1941         strcpy(out_file->genre, in_file->genre);
1942     }
1943
1944     /* open files and write file headers */
1945     for(i=0;i<nb_output_files;i++) {
1946         os = output_files[i];
1947         if (av_write_header(os) < 0) {
1948             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1949             ret = AVERROR(EINVAL);
1950             goto fail;
1951         }
1952         if (strcmp(output_files[i]->oformat->name, "rtp")) {
1953             want_sdp = 0;
1954         }
1955     }
1956     if (want_sdp) {
1957         print_sdp(output_files, nb_output_files);
1958     }
1959
1960     if (!using_stdin && verbose >= 0) {
1961         fprintf(stderr, "Press [q] to stop encoding\n");
1962         url_set_interrupt_cb(decode_interrupt_cb);
1963     }
1964     term_init();
1965
1966     key = -1;
1967     timer_start = av_gettime();
1968
1969     for(; received_sigterm == 0;) {
1970         int file_index, ist_index;
1971         AVPacket pkt;
1972         double ipts_min;
1973         double opts_min;
1974
1975     redo:
1976         ipts_min= 1e100;
1977         opts_min= 1e100;
1978         /* if 'q' pressed, exits */
1979         if (!using_stdin) {
1980             if (q_pressed)
1981                 break;
1982             /* read_key() returns 0 on EOF */
1983             key = read_key();
1984             if (key == 'q')
1985                 break;
1986         }
1987
1988         /* select the stream that we must read now by looking at the
1989            smallest output pts */
1990         file_index = -1;
1991         for(i=0;i<nb_ostreams;i++) {
1992             double ipts, opts;
1993             ost = ost_table[i];
1994             os = output_files[ost->file_index];
1995             ist = ist_table[ost->source_index];
1996             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1997                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1998             else
1999                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2000             ipts = (double)ist->pts;
2001             if (!file_table[ist->file_index].eof_reached){
2002                 if(ipts < ipts_min) {
2003                     ipts_min = ipts;
2004                     if(input_sync ) file_index = ist->file_index;
2005                 }
2006                 if(opts < opts_min) {
2007                     opts_min = opts;
2008                     if(!input_sync) file_index = ist->file_index;
2009                 }
2010             }
2011             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2012                 file_index= -1;
2013                 break;
2014             }
2015         }
2016         /* if none, if is finished */
2017         if (file_index < 0) {
2018             break;
2019         }
2020
2021         /* finish if recording time exhausted */
2022         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2023             break;
2024
2025         /* finish if limit size exhausted */
2026         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2027             break;
2028
2029         /* read a frame from it and output it in the fifo */
2030         is = input_files[file_index];
2031         if (av_read_frame(is, &pkt) < 0) {
2032             file_table[file_index].eof_reached = 1;
2033             if (opt_shortest)
2034                 break;
2035             else
2036                 continue;
2037         }
2038
2039         if (do_pkt_dump) {
2040             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2041         }
2042         /* the following test is needed in case new streams appear
2043            dynamically in stream : we ignore them */
2044         if (pkt.stream_index >= file_table[file_index].nb_streams)
2045             goto discard_packet;
2046         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2047         ist = ist_table[ist_index];
2048         if (ist->discard)
2049             goto discard_packet;
2050
2051         if (pkt.dts != AV_NOPTS_VALUE)
2052             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2053         if (pkt.pts != AV_NOPTS_VALUE)
2054             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2055
2056 //        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);
2057         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2058             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2059             int64_t delta= pkt_dts - ist->next_pts;
2060             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2061                 input_files_ts_offset[ist->file_index]-= delta;
2062                 if (verbose > 2)
2063                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2064                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2065                 if(pkt.pts != AV_NOPTS_VALUE)
2066                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2067             }
2068         }
2069
2070         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2071         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2072
2073             if (verbose >= 0)
2074                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2075                         ist->file_index, ist->index);
2076
2077             av_free_packet(&pkt);
2078             goto redo;
2079         }
2080
2081     discard_packet:
2082         av_free_packet(&pkt);
2083
2084         /* dump report by using the output first video and audio streams */
2085         print_report(output_files, ost_table, nb_ostreams, 0);
2086     }
2087
2088     /* at the end of stream, we must flush the decoder buffers */
2089     for(i=0;i<nb_istreams;i++) {
2090         ist = ist_table[i];
2091         if (ist->decoding_needed) {
2092             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2093         }
2094     }
2095
2096     term_exit();
2097
2098     /* write the trailer if needed and close file */
2099     for(i=0;i<nb_output_files;i++) {
2100         os = output_files[i];
2101         av_write_trailer(os);
2102     }
2103
2104     /* dump report by using the first video and audio streams */
2105     print_report(output_files, ost_table, nb_ostreams, 1);
2106
2107     /* close each encoder */
2108     for(i=0;i<nb_ostreams;i++) {
2109         ost = ost_table[i];
2110         if (ost->encoding_needed) {
2111             av_freep(&ost->st->codec->stats_in);
2112             avcodec_close(ost->st->codec);
2113         }
2114     }
2115
2116     /* close each decoder */
2117     for(i=0;i<nb_istreams;i++) {
2118         ist = ist_table[i];
2119         if (ist->decoding_needed) {
2120             avcodec_close(ist->st->codec);
2121         }
2122     }
2123
2124     /* finished ! */
2125
2126     ret = 0;
2127  fail1:
2128     av_freep(&bit_buffer);
2129     av_free(file_table);
2130
2131     if (ist_table) {
2132         for(i=0;i<nb_istreams;i++) {
2133             ist = ist_table[i];
2134             av_free(ist);
2135         }
2136         av_free(ist_table);
2137     }
2138     if (ost_table) {
2139         for(i=0;i<nb_ostreams;i++) {
2140             ost = ost_table[i];
2141             if (ost) {
2142                 if (ost->logfile) {
2143                     fclose(ost->logfile);
2144                     ost->logfile = NULL;
2145                 }
2146                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2147                                              initialized but set to zero */
2148                 av_free(ost->pict_tmp.data[0]);
2149                 if (ost->video_resample)
2150                     sws_freeContext(ost->img_resample_ctx);
2151                 if (ost->resample)
2152                     audio_resample_close(ost->resample);
2153                 av_free(ost);
2154             }
2155         }
2156         av_free(ost_table);
2157     }
2158     return ret;
2159  fail:
2160     ret = AVERROR(ENOMEM);
2161     goto fail1;
2162 }
2163
2164 #if 0
2165 int file_read(const char *filename)
2166 {
2167     URLContext *h;
2168     unsigned char buffer[1024];
2169     int len, i;
2170
2171     if (url_open(&h, filename, O_RDONLY) < 0) {
2172         printf("could not open '%s'\n", filename);
2173         return -1;
2174     }
2175     for(;;) {
2176         len = url_read(h, buffer, sizeof(buffer));
2177         if (len <= 0)
2178             break;
2179         for(i=0;i<len;i++) putchar(buffer[i]);
2180     }
2181     url_close(h);
2182     return 0;
2183 }
2184 #endif
2185
2186 static void opt_format(const char *arg)
2187 {
2188     /* compatibility stuff for pgmyuv */
2189     if (!strcmp(arg, "pgmyuv")) {
2190         pgmyuv_compatibility_hack=1;
2191 //        opt_image_format(arg);
2192         arg = "image2";
2193         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2194     }
2195
2196     file_iformat = av_find_input_format(arg);
2197     file_oformat = guess_format(arg, NULL, NULL);
2198     if (!file_iformat && !file_oformat) {
2199         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2200         av_exit(1);
2201     }
2202 }
2203
2204 static int opt_default(const char *opt, const char *arg){
2205     int type;
2206     const AVOption *o= NULL;
2207     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2208
2209     for(type=0; type<CODEC_TYPE_NB; type++){
2210         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2211         if(o2)
2212             o = av_set_string2(avctx_opts[type], opt, arg, 1);
2213     }
2214     if(!o)
2215         o = av_set_string2(avformat_opts, opt, arg, 1);
2216     if(!o)
2217         o = av_set_string2(sws_opts, opt, arg, 1);
2218     if(!o){
2219         if(opt[0] == 'a')
2220             o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2221         else if(opt[0] == 'v')
2222             o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2223         else if(opt[0] == 's')
2224             o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2225     }
2226     if(!o)
2227         return -1;
2228
2229 //    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));
2230
2231     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2232     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2233     opt_names[opt_name_count++]= o->name;
2234
2235     if(avctx_opts[0]->debug || avformat_opts->debug)
2236         av_log_set_level(AV_LOG_DEBUG);
2237     return 0;
2238 }
2239
2240 static void opt_video_rc_override_string(const char *arg)
2241 {
2242     video_rc_override_string = arg;
2243 }
2244
2245 static int opt_me_threshold(const char *opt, const char *arg)
2246 {
2247     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2248     return 0;
2249 }
2250
2251 static int opt_verbose(const char *opt, const char *arg)
2252 {
2253     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2254     av_log_set_level(verbose);
2255     return 0;
2256 }
2257
2258 static void opt_frame_rate(const char *arg)
2259 {
2260     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2261         fprintf(stderr, "Incorrect frame rate\n");
2262         av_exit(1);
2263     }
2264 }
2265
2266 static int opt_bitrate(const char *opt, const char *arg)
2267 {
2268     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2269
2270     opt_default(opt, arg);
2271
2272     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2273         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2274
2275     return 0;
2276 }
2277
2278 static void opt_frame_crop_top(const char *arg)
2279 {
2280     frame_topBand = atoi(arg);
2281     if (frame_topBand < 0) {
2282         fprintf(stderr, "Incorrect top crop size\n");
2283         av_exit(1);
2284     }
2285     if ((frame_topBand % 2) != 0) {
2286         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2287         av_exit(1);
2288     }
2289     if ((frame_topBand) >= frame_height){
2290         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2291         av_exit(1);
2292     }
2293     frame_height -= frame_topBand;
2294 }
2295
2296 static void opt_frame_crop_bottom(const char *arg)
2297 {
2298     frame_bottomBand = atoi(arg);
2299     if (frame_bottomBand < 0) {
2300         fprintf(stderr, "Incorrect bottom crop size\n");
2301         av_exit(1);
2302     }
2303     if ((frame_bottomBand % 2) != 0) {
2304         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2305         av_exit(1);
2306     }
2307     if ((frame_bottomBand) >= frame_height){
2308         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2309         av_exit(1);
2310     }
2311     frame_height -= frame_bottomBand;
2312 }
2313
2314 static void opt_frame_crop_left(const char *arg)
2315 {
2316     frame_leftBand = atoi(arg);
2317     if (frame_leftBand < 0) {
2318         fprintf(stderr, "Incorrect left crop size\n");
2319         av_exit(1);
2320     }
2321     if ((frame_leftBand % 2) != 0) {
2322         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2323         av_exit(1);
2324     }
2325     if ((frame_leftBand) >= frame_width){
2326         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2327         av_exit(1);
2328     }
2329     frame_width -= frame_leftBand;
2330 }
2331
2332 static void opt_frame_crop_right(const char *arg)
2333 {
2334     frame_rightBand = atoi(arg);
2335     if (frame_rightBand < 0) {
2336         fprintf(stderr, "Incorrect right crop size\n");
2337         av_exit(1);
2338     }
2339     if ((frame_rightBand % 2) != 0) {
2340         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2341         av_exit(1);
2342     }
2343     if ((frame_rightBand) >= frame_width){
2344         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2345         av_exit(1);
2346     }
2347     frame_width -= frame_rightBand;
2348 }
2349
2350 static void opt_frame_size(const char *arg)
2351 {
2352     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2353         fprintf(stderr, "Incorrect frame size\n");
2354         av_exit(1);
2355     }
2356     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2357         fprintf(stderr, "Frame size must be a multiple of 2\n");
2358         av_exit(1);
2359     }
2360 }
2361
2362
2363 #define SCALEBITS 10
2364 #define ONE_HALF  (1 << (SCALEBITS - 1))
2365 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2366
2367 #define RGB_TO_Y(r, g, b) \
2368 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2369   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2370
2371 #define RGB_TO_U(r1, g1, b1, shift)\
2372 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2373      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2374
2375 #define RGB_TO_V(r1, g1, b1, shift)\
2376 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2377    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2378
2379 static void opt_pad_color(const char *arg) {
2380     /* Input is expected to be six hex digits similar to
2381        how colors are expressed in html tags (but without the #) */
2382     int rgb = strtol(arg, NULL, 16);
2383     int r,g,b;
2384
2385     r = (rgb >> 16);
2386     g = ((rgb >> 8) & 255);
2387     b = (rgb & 255);
2388
2389     padcolor[0] = RGB_TO_Y(r,g,b);
2390     padcolor[1] = RGB_TO_U(r,g,b,0);
2391     padcolor[2] = RGB_TO_V(r,g,b,0);
2392 }
2393
2394 static void opt_frame_pad_top(const char *arg)
2395 {
2396     frame_padtop = atoi(arg);
2397     if (frame_padtop < 0) {
2398         fprintf(stderr, "Incorrect top pad size\n");
2399         av_exit(1);
2400     }
2401     if ((frame_padtop % 2) != 0) {
2402         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2403         av_exit(1);
2404     }
2405 }
2406
2407 static void opt_frame_pad_bottom(const char *arg)
2408 {
2409     frame_padbottom = atoi(arg);
2410     if (frame_padbottom < 0) {
2411         fprintf(stderr, "Incorrect bottom pad size\n");
2412         av_exit(1);
2413     }
2414     if ((frame_padbottom % 2) != 0) {
2415         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2416         av_exit(1);
2417     }
2418 }
2419
2420
2421 static void opt_frame_pad_left(const char *arg)
2422 {
2423     frame_padleft = atoi(arg);
2424     if (frame_padleft < 0) {
2425         fprintf(stderr, "Incorrect left pad size\n");
2426         av_exit(1);
2427     }
2428     if ((frame_padleft % 2) != 0) {
2429         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2430         av_exit(1);
2431     }
2432 }
2433
2434
2435 static void opt_frame_pad_right(const char *arg)
2436 {
2437     frame_padright = atoi(arg);
2438     if (frame_padright < 0) {
2439         fprintf(stderr, "Incorrect right pad size\n");
2440         av_exit(1);
2441     }
2442     if ((frame_padright % 2) != 0) {
2443         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2444         av_exit(1);
2445     }
2446 }
2447
2448 static void list_pix_fmts(void)
2449 {
2450     int i;
2451     char pix_fmt_str[128];
2452     for (i=-1; i < PIX_FMT_NB; i++) {
2453         avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2454         fprintf(stdout, "%s\n", pix_fmt_str);
2455     }
2456 }
2457
2458 static void opt_frame_pix_fmt(const char *arg)
2459 {
2460     if (strcmp(arg, "list"))
2461         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2462     else {
2463         list_pix_fmts();
2464         av_exit(0);
2465     }
2466 }
2467
2468 static void opt_frame_aspect_ratio(const char *arg)
2469 {
2470     int x = 0, y = 0;
2471     double ar = 0;
2472     const char *p;
2473     char *end;
2474
2475     p = strchr(arg, ':');
2476     if (p) {
2477         x = strtol(arg, &end, 10);
2478         if (end == p)
2479             y = strtol(end+1, &end, 10);
2480         if (x > 0 && y > 0)
2481             ar = (double)x / (double)y;
2482     } else
2483         ar = strtod(arg, NULL);
2484
2485     if (!ar) {
2486         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2487         av_exit(1);
2488     }
2489     frame_aspect_ratio = ar;
2490 }
2491
2492 static void opt_qscale(const char *arg)
2493 {
2494     video_qscale = atof(arg);
2495     if (video_qscale <= 0 ||
2496         video_qscale > 255) {
2497         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2498         av_exit(1);
2499     }
2500 }
2501
2502 static void opt_strict(const char *arg)
2503 {
2504     strict= atoi(arg);
2505 }
2506
2507 static void opt_top_field_first(const char *arg)
2508 {
2509     top_field_first= atoi(arg);
2510 }
2511
2512 static int opt_thread_count(const char *opt, const char *arg)
2513 {
2514     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2515 #if !defined(HAVE_THREADS)
2516     if (verbose >= 0)
2517         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2518 #endif
2519     return 0;
2520 }
2521
2522 static int opt_audio_rate(const char *opt, const char *arg)
2523 {
2524     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2525     return 0;
2526 }
2527
2528 static int opt_audio_channels(const char *opt, const char *arg)
2529 {
2530     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2531     return 0;
2532 }
2533
2534 static void opt_video_channel(const char *arg)
2535 {
2536     video_channel = strtol(arg, NULL, 0);
2537 }
2538
2539 static void opt_video_standard(const char *arg)
2540 {
2541     video_standard = av_strdup(arg);
2542 }
2543
2544 static void opt_codec(int *pstream_copy, char **pcodec_name,
2545                       int codec_type, const char *arg)
2546 {
2547     av_freep(pcodec_name);
2548     if (!strcmp(arg, "copy")) {
2549         *pstream_copy = 1;
2550     } else {
2551         *pcodec_name = av_strdup(arg);
2552     }
2553 }
2554
2555 static void opt_audio_codec(const char *arg)
2556 {
2557     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2558 }
2559
2560 static void opt_audio_tag(const char *arg)
2561 {
2562     char *tail;
2563     audio_codec_tag= strtol(arg, &tail, 0);
2564
2565     if(!tail || *tail)
2566         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2567 }
2568
2569 static void opt_video_tag(const char *arg)
2570 {
2571     char *tail;
2572     video_codec_tag= strtol(arg, &tail, 0);
2573
2574     if(!tail || *tail)
2575         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2576 }
2577
2578 #ifdef CONFIG_VHOOK
2579 static void add_frame_hooker(const char *arg)
2580 {
2581     int argc = 0;
2582     char *argv[64];
2583     int i;
2584     char *args = av_strdup(arg);
2585
2586     using_vhook = 1;
2587
2588     argv[0] = strtok(args, " ");
2589     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2590     }
2591
2592     i = frame_hook_add(argc, argv);
2593
2594     if (i != 0) {
2595         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2596         av_exit(1);
2597     }
2598 }
2599 #endif
2600
2601 static void opt_video_codec(const char *arg)
2602 {
2603     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2604 }
2605
2606 static void opt_subtitle_codec(const char *arg)
2607 {
2608     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2609 }
2610
2611 static void opt_map(const char *arg)
2612 {
2613     AVStreamMap *m;
2614     char *p;
2615
2616     m = &stream_maps[nb_stream_maps++];
2617
2618     m->file_index = strtol(arg, &p, 0);
2619     if (*p)
2620         p++;
2621
2622     m->stream_index = strtol(p, &p, 0);
2623     if (*p) {
2624         p++;
2625         m->sync_file_index = strtol(p, &p, 0);
2626         if (*p)
2627             p++;
2628         m->sync_stream_index = strtol(p, &p, 0);
2629     } else {
2630         m->sync_file_index = m->file_index;
2631         m->sync_stream_index = m->stream_index;
2632     }
2633 }
2634
2635 static void opt_map_meta_data(const char *arg)
2636 {
2637     AVMetaDataMap *m;
2638     char *p;
2639
2640     m = &meta_data_maps[nb_meta_data_maps++];
2641
2642     m->out_file = strtol(arg, &p, 0);
2643     if (*p)
2644         p++;
2645
2646     m->in_file = strtol(p, &p, 0);
2647 }
2648
2649 static int opt_recording_time(const char *opt, const char *arg)
2650 {
2651     recording_time = parse_time_or_die(opt, arg, 1);
2652     return 0;
2653 }
2654
2655 static int opt_start_time(const char *opt, const char *arg)
2656 {
2657     start_time = parse_time_or_die(opt, arg, 1);
2658     return 0;
2659 }
2660
2661 static int opt_rec_timestamp(const char *opt, const char *arg)
2662 {
2663     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2664     return 0;
2665 }
2666
2667 static int opt_input_ts_offset(const char *opt, const char *arg)
2668 {
2669     input_ts_offset = parse_time_or_die(opt, arg, 1);
2670     return 0;
2671 }
2672
2673 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2674 {
2675     const char *codec_string = encoder ? "encoder" : "decoder";
2676     AVCodec *codec;
2677
2678     if(!name)
2679         return CODEC_ID_NONE;
2680     codec = encoder ?
2681         avcodec_find_encoder_by_name(name) :
2682         avcodec_find_decoder_by_name(name);
2683     if(!codec) {
2684         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2685         av_exit(1);
2686     }
2687     if(codec->type != type) {
2688         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2689         av_exit(1);
2690     }
2691     return codec->id;
2692 }
2693
2694 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2695 {
2696     int i;
2697     for(i=0; i<opt_name_count; i++){
2698         char buf[256];
2699         const AVOption *opt;
2700         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2701         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2702         if(str && ((opt->flags & flags) == flags))
2703             av_set_string2(ctx, opt_names[i], str, 1);
2704     }
2705 }
2706
2707 static void opt_input_file(const char *filename)
2708 {
2709     AVFormatContext *ic;
2710     AVFormatParameters params, *ap = &params;
2711     int err, i, ret, rfps, rfps_base;
2712     int64_t timestamp;
2713
2714     if (!strcmp(filename, "-"))
2715         filename = "pipe:";
2716
2717     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2718                     !strcmp(filename, "/dev/stdin");
2719
2720     /* get default parameters from command line */
2721     ic = av_alloc_format_context();
2722
2723     memset(ap, 0, sizeof(*ap));
2724     ap->prealloced_context = 1;
2725     ap->sample_rate = audio_sample_rate;
2726     ap->channels = audio_channels;
2727     ap->time_base.den = frame_rate.num;
2728     ap->time_base.num = frame_rate.den;
2729     ap->width = frame_width + frame_padleft + frame_padright;
2730     ap->height = frame_height + frame_padtop + frame_padbottom;
2731     ap->pix_fmt = frame_pix_fmt;
2732     ap->channel = video_channel;
2733     ap->standard = video_standard;
2734     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2735     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2736     if(pgmyuv_compatibility_hack)
2737         ap->video_codec_id= CODEC_ID_PGMYUV;
2738
2739     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2740
2741     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2742     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2743     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2744
2745     /* open the input file with generic libav function */
2746     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2747     if (err < 0) {
2748         print_error(filename, err);
2749         av_exit(1);
2750     }
2751     if(opt_programid) {
2752         int i;
2753         for(i=0; i<ic->nb_programs; i++)
2754             if(ic->programs[i]->id != opt_programid)
2755                 ic->programs[i]->discard = AVDISCARD_ALL;
2756     }
2757
2758     ic->loop_input = loop_input;
2759
2760     /* If not enough info to get the stream parameters, we decode the
2761        first frames to get it. (used in mpeg case for example) */
2762     ret = av_find_stream_info(ic);
2763     if (ret < 0 && verbose >= 0) {
2764         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2765         av_exit(1);
2766     }
2767
2768     timestamp = start_time;
2769     /* add the stream start time */
2770     if (ic->start_time != AV_NOPTS_VALUE)
2771         timestamp += ic->start_time;
2772
2773     /* if seeking requested, we execute it */
2774     if (start_time != 0) {
2775         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2776         if (ret < 0) {
2777             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2778                     filename, (double)timestamp / AV_TIME_BASE);
2779         }
2780         /* reset seek info */
2781         start_time = 0;
2782     }
2783
2784     /* update the current parameters so that they match the one of the input stream */
2785     for(i=0;i<ic->nb_streams;i++) {
2786         AVCodecContext *enc = ic->streams[i]->codec;
2787         if(thread_count>1)
2788             avcodec_thread_init(enc, thread_count);
2789         enc->thread_count= thread_count;
2790         switch(enc->codec_type) {
2791         case CODEC_TYPE_AUDIO:
2792             set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2793             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2794             audio_channels = enc->channels;
2795             audio_sample_rate = enc->sample_rate;
2796             if(audio_disable)
2797                 ic->streams[i]->discard= AVDISCARD_ALL;
2798             break;
2799         case CODEC_TYPE_VIDEO:
2800             set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2801             frame_height = enc->height;
2802             frame_width = enc->width;
2803             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2804             frame_pix_fmt = enc->pix_fmt;
2805             rfps      = ic->streams[i]->r_frame_rate.num;
2806             rfps_base = ic->streams[i]->r_frame_rate.den;
2807             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2808             if(me_threshold)
2809                 enc->debug |= FF_DEBUG_MV;
2810
2811             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2812
2813                 if (verbose >= 0)
2814                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2815                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2816
2817                     (float)rfps / rfps_base, rfps, rfps_base);
2818             }
2819             /* update the current frame rate to match the stream frame rate */
2820             frame_rate.num = rfps;
2821             frame_rate.den = rfps_base;
2822
2823             enc->rate_emu = rate_emu;
2824             if(video_disable)
2825                 ic->streams[i]->discard= AVDISCARD_ALL;
2826             else if(video_discard)
2827                 ic->streams[i]->discard= video_discard;
2828             break;
2829         case CODEC_TYPE_DATA:
2830             break;
2831         case CODEC_TYPE_SUBTITLE:
2832             if(subtitle_disable)
2833                 ic->streams[i]->discard = AVDISCARD_ALL;
2834             break;
2835         case CODEC_TYPE_ATTACHMENT:
2836         case CODEC_TYPE_UNKNOWN:
2837             break;
2838         default:
2839             abort();
2840         }
2841     }
2842
2843     input_files[nb_input_files] = ic;
2844     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2845     /* dump the file content */
2846     if (verbose >= 0)
2847         dump_format(ic, nb_input_files, filename, 0);
2848
2849     nb_input_files++;
2850     file_iformat = NULL;
2851     file_oformat = NULL;
2852
2853     video_channel = 0;
2854
2855     rate_emu = 0;
2856     av_freep(&video_codec_name);
2857     av_freep(&audio_codec_name);
2858     av_freep(&subtitle_codec_name);
2859 }
2860
2861 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2862                                          int *has_subtitle_ptr)
2863 {
2864     int has_video, has_audio, has_subtitle, i, j;
2865     AVFormatContext *ic;
2866
2867     has_video = 0;
2868     has_audio = 0;
2869     has_subtitle = 0;
2870     for(j=0;j<nb_input_files;j++) {
2871         ic = input_files[j];
2872         for(i=0;i<ic->nb_streams;i++) {
2873             AVCodecContext *enc = ic->streams[i]->codec;
2874             switch(enc->codec_type) {
2875             case CODEC_TYPE_AUDIO:
2876                 has_audio = 1;
2877                 break;
2878             case CODEC_TYPE_VIDEO:
2879                 has_video = 1;
2880                 break;
2881             case CODEC_TYPE_SUBTITLE:
2882                 has_subtitle = 1;
2883                 break;
2884             case CODEC_TYPE_DATA:
2885             case CODEC_TYPE_ATTACHMENT:
2886             case CODEC_TYPE_UNKNOWN:
2887                 break;
2888             default:
2889                 abort();
2890             }
2891         }
2892     }
2893     *has_video_ptr = has_video;
2894     *has_audio_ptr = has_audio;
2895     *has_subtitle_ptr = has_subtitle;
2896 }
2897
2898 static void new_video_stream(AVFormatContext *oc)
2899 {
2900     AVStream *st;
2901     AVCodecContext *video_enc;
2902     int codec_id;
2903
2904     st = av_new_stream(oc, oc->nb_streams);
2905     if (!st) {
2906         fprintf(stderr, "Could not alloc stream\n");
2907         av_exit(1);
2908     }
2909     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2910     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2911     video_bitstream_filters= NULL;
2912
2913     if(thread_count>1)
2914         avcodec_thread_init(st->codec, thread_count);
2915
2916     video_enc = st->codec;
2917
2918     if(video_codec_tag)
2919         video_enc->codec_tag= video_codec_tag;
2920
2921     if(   (video_global_header&1)
2922        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2923         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2924         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2925     }
2926     if(video_global_header&2){
2927         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2928         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2929     }
2930
2931     if (video_stream_copy) {
2932         st->stream_copy = 1;
2933         video_enc->codec_type = CODEC_TYPE_VIDEO;
2934     } else {
2935         const char *p;
2936         int i;
2937         AVCodec *codec;
2938         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2939
2940         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2941         if (video_codec_name)
2942             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2943
2944         video_enc->codec_id = codec_id;
2945         codec = avcodec_find_encoder(codec_id);
2946
2947         set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2948
2949         video_enc->time_base.den = fps.num;
2950         video_enc->time_base.num = fps.den;
2951         if(codec && codec->supported_framerates){
2952             const AVRational *p= codec->supported_framerates;
2953             const AVRational *best=NULL;
2954             AVRational best_error= (AVRational){INT_MAX, 1};
2955             for(; p->den!=0; p++){
2956                 AVRational error= av_sub_q(fps, *p);
2957                 if(error.num <0) error.num *= -1;
2958                 if(av_cmp_q(error, best_error) < 0){
2959                     best_error= error;
2960                     best= p;
2961                 }
2962             }
2963             video_enc->time_base.den= best->num;
2964             video_enc->time_base.num= best->den;
2965         }
2966
2967         video_enc->width = frame_width + frame_padright + frame_padleft;
2968         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2969         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2970         video_enc->pix_fmt = frame_pix_fmt;
2971
2972         if(codec && codec->pix_fmts){
2973             const enum PixelFormat *p= codec->pix_fmts;
2974             for(; *p!=-1; p++){
2975                 if(*p == video_enc->pix_fmt)
2976                     break;
2977             }
2978             if(*p == -1)
2979                 video_enc->pix_fmt = codec->pix_fmts[0];
2980         }
2981
2982         if (intra_only)
2983             video_enc->gop_size = 0;
2984         if (video_qscale || same_quality) {
2985             video_enc->flags |= CODEC_FLAG_QSCALE;
2986             video_enc->global_quality=
2987                 st->quality = FF_QP2LAMBDA * video_qscale;
2988         }
2989
2990         if(intra_matrix)
2991             video_enc->intra_matrix = intra_matrix;
2992         if(inter_matrix)
2993             video_enc->inter_matrix = inter_matrix;
2994
2995         video_enc->thread_count = thread_count;
2996         p= video_rc_override_string;
2997         for(i=0; p; i++){
2998             int start, end, q;
2999             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3000             if(e!=3){
3001                 fprintf(stderr, "error parsing rc_override\n");
3002                 av_exit(1);
3003             }
3004             video_enc->rc_override=
3005                 av_realloc(video_enc->rc_override,
3006                            sizeof(RcOverride)*(i+1));
3007             video_enc->rc_override[i].start_frame= start;
3008             video_enc->rc_override[i].end_frame  = end;
3009             if(q>0){
3010                 video_enc->rc_override[i].qscale= q;
3011                 video_enc->rc_override[i].quality_factor= 1.0;
3012             }
3013             else{
3014                 video_enc->rc_override[i].qscale= 0;
3015                 video_enc->rc_override[i].quality_factor= -q/100.0;
3016             }
3017             p= strchr(p, '/');
3018             if(p) p++;
3019         }
3020         video_enc->rc_override_count=i;
3021         if (!video_enc->rc_initial_buffer_occupancy)
3022             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3023         video_enc->me_threshold= me_threshold;
3024         video_enc->intra_dc_precision= intra_dc_precision - 8;
3025         video_enc->strict_std_compliance = strict;
3026
3027         if (do_psnr)
3028             video_enc->flags|= CODEC_FLAG_PSNR;
3029
3030         /* two pass mode */
3031         if (do_pass) {
3032             if (do_pass == 1) {
3033                 video_enc->flags |= CODEC_FLAG_PASS1;
3034             } else {
3035                 video_enc->flags |= CODEC_FLAG_PASS2;
3036             }
3037         }
3038     }
3039
3040     /* reset some key parameters */
3041     video_disable = 0;
3042     av_freep(&video_codec_name);
3043     video_stream_copy = 0;
3044 }
3045
3046 static void new_audio_stream(AVFormatContext *oc)
3047 {
3048     AVStream *st;
3049     AVCodecContext *audio_enc;
3050     int codec_id;
3051
3052     st = av_new_stream(oc, oc->nb_streams);
3053     if (!st) {
3054         fprintf(stderr, "Could not alloc stream\n");
3055         av_exit(1);
3056     }
3057     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3058
3059     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3060     audio_bitstream_filters= NULL;
3061
3062     if(thread_count>1)
3063         avcodec_thread_init(st->codec, thread_count);
3064
3065     audio_enc = st->codec;
3066     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3067     audio_enc->strict_std_compliance = strict;
3068
3069     if(audio_codec_tag)
3070         audio_enc->codec_tag= audio_codec_tag;
3071
3072     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3073         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3074         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3075     }
3076     if (audio_stream_copy) {
3077         st->stream_copy = 1;
3078         audio_enc->channels = audio_channels;
3079     } else {
3080         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3081
3082         set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3083
3084         if (audio_codec_name)
3085             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3086         audio_enc->codec_id = codec_id;
3087
3088         if (audio_qscale > QSCALE_NONE) {
3089             audio_enc->flags |= CODEC_FLAG_QSCALE;
3090             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3091         }
3092         audio_enc->thread_count = thread_count;
3093         audio_enc->channels = audio_channels;
3094     }
3095     audio_enc->sample_rate = audio_sample_rate;
3096     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3097     if (audio_language) {
3098         av_strlcpy(st->language, audio_language, sizeof(st->language));
3099         av_free(audio_language);
3100         audio_language = NULL;
3101     }
3102
3103     /* reset some key parameters */
3104     audio_disable = 0;
3105     av_freep(&audio_codec_name);
3106     audio_stream_copy = 0;
3107 }
3108
3109 static void new_subtitle_stream(AVFormatContext *oc)
3110 {
3111     AVStream *st;
3112     AVCodecContext *subtitle_enc;
3113
3114     st = av_new_stream(oc, oc->nb_streams);
3115     if (!st) {
3116         fprintf(stderr, "Could not alloc stream\n");
3117         av_exit(1);
3118     }
3119     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3120
3121     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3122     subtitle_bitstream_filters= NULL;
3123
3124     subtitle_enc = st->codec;
3125     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3126     if (subtitle_stream_copy) {
3127         st->stream_copy = 1;
3128     } else {
3129         set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3130         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3131     }
3132
3133     if (subtitle_language) {
3134         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3135         av_free(subtitle_language);
3136         subtitle_language = NULL;
3137     }
3138
3139     subtitle_disable = 0;
3140     av_freep(&subtitle_codec_name);
3141     subtitle_stream_copy = 0;
3142 }
3143
3144 static void opt_new_audio_stream(void)
3145 {
3146     AVFormatContext *oc;
3147     if (nb_output_files <= 0) {
3148         fprintf(stderr, "At least one output file must be specified\n");
3149         av_exit(1);
3150     }
3151     oc = output_files[nb_output_files - 1];
3152     new_audio_stream(oc);
3153 }
3154
3155 static void opt_new_video_stream(void)
3156 {
3157     AVFormatContext *oc;
3158     if (nb_output_files <= 0) {
3159         fprintf(stderr, "At least one output file must be specified\n");
3160         av_exit(1);
3161     }
3162     oc = output_files[nb_output_files - 1];
3163     new_video_stream(oc);
3164 }
3165
3166 static void opt_new_subtitle_stream(void)
3167 {
3168     AVFormatContext *oc;
3169     if (nb_output_files <= 0) {
3170         fprintf(stderr, "At least one output file must be specified\n");
3171         av_exit(1);
3172     }
3173     oc = output_files[nb_output_files - 1];
3174     new_subtitle_stream(oc);
3175 }
3176
3177 static void opt_output_file(const char *filename)
3178 {
3179     AVFormatContext *oc;
3180     int use_video, use_audio, use_subtitle;
3181     int input_has_video, input_has_audio, input_has_subtitle;
3182     AVFormatParameters params, *ap = &params;
3183
3184     if (!strcmp(filename, "-"))
3185         filename = "pipe:";
3186
3187     oc = av_alloc_format_context();
3188
3189     if (!file_oformat) {
3190         file_oformat = guess_format(NULL, filename, NULL);
3191         if (!file_oformat) {
3192             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3193                     filename);
3194             av_exit(1);
3195         }
3196     }
3197
3198     oc->oformat = file_oformat;
3199     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3200
3201     if (!strcmp(file_oformat->name, "ffm") &&
3202         av_strstart(filename, "http:", NULL)) {
3203         /* special case for files sent to ffserver: we get the stream
3204            parameters from ffserver */
3205         int err = read_ffserver_streams(oc, filename);
3206         if (err < 0) {
3207             print_error(filename, err);
3208             av_exit(1);
3209         }
3210     } else {
3211         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3212         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3213         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3214
3215         /* disable if no corresponding type found and at least one
3216            input file */
3217         if (nb_input_files > 0) {
3218             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3219                                          &input_has_subtitle);
3220             if (!input_has_video)
3221                 use_video = 0;
3222             if (!input_has_audio)
3223                 use_audio = 0;
3224             if (!input_has_subtitle)
3225                 use_subtitle = 0;
3226         }
3227
3228         /* manual disable */
3229         if (audio_disable) {
3230             use_audio = 0;
3231         }
3232         if (video_disable) {
3233             use_video = 0;
3234         }
3235         if (subtitle_disable) {
3236             use_subtitle = 0;
3237         }
3238
3239         if (use_video) {
3240             new_video_stream(oc);
3241         }
3242
3243         if (use_audio) {
3244             new_audio_stream(oc);
3245         }
3246
3247         if (use_subtitle) {
3248             new_subtitle_stream(oc);
3249         }
3250
3251         oc->timestamp = rec_timestamp;
3252
3253         if (str_title)
3254             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3255         if (str_author)
3256             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3257         if (str_copyright)
3258             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3259         if (str_comment)
3260             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3261         if (str_album)
3262             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3263         if (str_genre)
3264             av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3265     }
3266
3267     output_files[nb_output_files++] = oc;
3268
3269     /* check filename in case of an image number is expected */
3270     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3271         if (!av_filename_number_test(oc->filename)) {
3272             print_error(oc->filename, AVERROR_NUMEXPECTED);
3273             av_exit(1);
3274         }
3275     }
3276
3277     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3278         /* test if it already exists to avoid loosing precious files */
3279         if (!file_overwrite &&
3280             (strchr(filename, ':') == NULL ||
3281              filename[1] == ':' ||
3282              av_strstart(filename, "file:", NULL))) {
3283             if (url_exist(filename)) {
3284                 int c;
3285
3286                 if (!using_stdin) {
3287                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3288                     fflush(stderr);
3289                     c = getchar();
3290                     if (toupper(c) != 'Y') {
3291                         fprintf(stderr, "Not overwriting - exiting\n");
3292                         av_exit(1);
3293                     }
3294                 }
3295                 else {
3296                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3297                     av_exit(1);
3298                 }
3299             }
3300         }
3301
3302         /* open the file */
3303         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3304             fprintf(stderr, "Could not open '%s'\n", filename);
3305             av_exit(1);
3306         }
3307     }
3308
3309     memset(ap, 0, sizeof(*ap));
3310     if (av_set_parameters(oc, ap) < 0) {
3311         fprintf(stderr, "%s: Invalid encoding parameters\n",
3312                 oc->filename);
3313         av_exit(1);
3314     }
3315
3316     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3317     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3318     oc->loop_output = loop_output;
3319
3320     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3321
3322     /* reset some options */
3323     file_oformat = NULL;
3324     file_iformat = NULL;
3325 }
3326
3327 /* same option as mencoder */
3328 static void opt_pass(const char *pass_str)
3329 {
3330     int pass;
3331     pass = atoi(pass_str);
3332     if (pass != 1 && pass != 2) {
3333         fprintf(stderr, "pass number can be only 1 or 2\n");
3334         av_exit(1);
3335     }
3336     do_pass = pass;
3337 }
3338
3339 static int64_t getutime(void)
3340 {
3341 #ifdef HAVE_GETRUSAGE
3342     struct rusage rusage;
3343
3344     getrusage(RUSAGE_SELF, &rusage);
3345     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3346 #elif defined(HAVE_GETPROCESSTIMES)
3347     HANDLE proc;
3348     FILETIME c, e, k, u;
3349     proc = GetCurrentProcess();
3350     GetProcessTimes(proc, &c, &e, &k, &u);
3351     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3352 #else
3353     return av_gettime();
3354 #endif
3355 }
3356
3357 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3358 {
3359     int i;
3360     const char *p = str;
3361     for(i = 0;; i++) {
3362         dest[i] = atoi(p);
3363         if(i == 63)
3364             break;
3365         p = strchr(p, ',');
3366         if(!p) {
3367             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3368             av_exit(1);
3369         }
3370         p++;
3371     }
3372 }
3373
3374 static void opt_inter_matrix(const char *arg)
3375 {
3376     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3377     parse_matrix_coeffs(inter_matrix, arg);
3378 }
3379
3380 static void opt_intra_matrix(const char *arg)
3381 {
3382     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3383     parse_matrix_coeffs(intra_matrix, arg);
3384 }
3385
3386 /**
3387  * Trivial log callback.
3388  * Only suitable for show_help and similar since it lacks prefix handling.
3389  */
3390 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3391 {
3392     vfprintf(stdout, fmt, vl);
3393 }
3394
3395 static void show_help(void)
3396 {
3397     av_log_set_callback(log_callback_help);
3398     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3399            "Hyper fast Audio and Video encoder\n");
3400     printf("\n");
3401     show_help_options(options, "Main options:\n",
3402                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3403     show_help_options(options, "\nAdvanced options:\n",
3404                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3405                       OPT_EXPERT);
3406     show_help_options(options, "\nVideo options:\n",
3407                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3408                       OPT_VIDEO);
3409     show_help_options(options, "\nAdvanced Video options:\n",
3410                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3411                       OPT_VIDEO | OPT_EXPERT);
3412     show_help_options(options, "\nAudio options:\n",
3413                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3414                       OPT_AUDIO);
3415     show_help_options(options, "\nAdvanced Audio options:\n",
3416                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3417                       OPT_AUDIO | OPT_EXPERT);
3418     show_help_options(options, "\nSubtitle options:\n",
3419                       OPT_SUBTITLE | OPT_GRAB,
3420                       OPT_SUBTITLE);
3421     show_help_options(options, "\nAudio/Video grab options:\n",
3422                       OPT_GRAB,
3423                       OPT_GRAB);
3424     printf("\n");
3425     av_opt_show(avctx_opts[0], NULL);
3426     printf("\n");
3427     av_opt_show(avformat_opts, NULL);
3428     printf("\n");
3429     av_opt_show(sws_opts, NULL);
3430 }
3431
3432 static void opt_target(const char *arg)
3433 {
3434     int norm = -1;
3435     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3436
3437     if(!strncmp(arg, "pal-", 4)) {
3438         norm = 0;
3439         arg += 4;
3440     } else if(!strncmp(arg, "ntsc-", 5)) {
3441         norm = 1;
3442         arg += 5;
3443     } else if(!strncmp(arg, "film-", 5)) {
3444         norm = 2;
3445         arg += 5;
3446     } else {
3447         int fr;
3448         /* Calculate FR via float to avoid int overflow */
3449         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3450         if(fr == 25000) {
3451             norm = 0;
3452         } else if((fr == 29970) || (fr == 23976)) {
3453             norm = 1;
3454         } else {
3455             /* Try to determine PAL/NTSC by peeking in the input files */
3456             if(nb_input_files) {
3457                 int i, j;
3458                 for(j = 0; j < nb_input_files; j++) {
3459                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3460                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3461                         if(c->codec_type != CODEC_TYPE_VIDEO)
3462                             continue;
3463                         fr = c->time_base.den * 1000 / c->time_base.num;
3464                         if(fr == 25000) {
3465                             norm = 0;
3466                             break;
3467                         } else if((fr == 29970) || (fr == 23976)) {
3468                             norm = 1;
3469                             break;
3470                         }
3471                     }
3472                     if(norm >= 0)
3473                         break;
3474                 }
3475             }
3476         }
3477         if(verbose && norm >= 0)
3478             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3479     }
3480
3481     if(norm < 0) {
3482         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3483         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3484         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3485         av_exit(1);
3486     }
3487
3488     if(!strcmp(arg, "vcd")) {
3489
3490         opt_video_codec("mpeg1video");
3491         opt_audio_codec("mp2");
3492         opt_format("vcd");
3493
3494         opt_frame_size(norm ? "352x240" : "352x288");
3495         opt_frame_rate(frame_rates[norm]);
3496         opt_default("gop", norm ? "18" : "15");
3497
3498         opt_default("b", "1150000");
3499         opt_default("maxrate", "1150000");
3500         opt_default("minrate", "1150000");
3501         opt_default("bufsize", "327680"); // 40*1024*8;
3502
3503         opt_default("ab", "224000");
3504         audio_sample_rate = 44100;
3505         audio_channels = 2;
3506
3507         opt_default("packetsize", "2324");
3508         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3509
3510         /* We have to offset the PTS, so that it is consistent with the SCR.
3511            SCR starts at 36000, but the first two packs contain only padding
3512            and the first pack from the other stream, respectively, may also have
3513            been written before.
3514            So the real data starts at SCR 36000+3*1200. */
3515         mux_preload= (36000+3*1200) / 90000.0; //0.44
3516     } else if(!strcmp(arg, "svcd")) {
3517
3518         opt_video_codec("mpeg2video");
3519         opt_audio_codec("mp2");
3520         opt_format("svcd");
3521
3522         opt_frame_size(norm ? "480x480" : "480x576");
3523         opt_frame_rate(frame_rates[norm]);
3524         opt_default("gop", norm ? "18" : "15");
3525
3526         opt_default("b", "2040000");
3527         opt_default("maxrate", "2516000");
3528         opt_default("minrate", "0"); //1145000;
3529         opt_default("bufsize", "1835008"); //224*1024*8;
3530         opt_default("flags", "+SCAN_OFFSET");
3531
3532
3533         opt_default("ab", "224000");
3534         audio_sample_rate = 44100;
3535
3536         opt_default("packetsize", "2324");
3537
3538     } else if(!strcmp(arg, "dvd")) {
3539
3540         opt_video_codec("mpeg2video");
3541         opt_audio_codec("ac3");
3542         opt_format("dvd");
3543
3544         opt_frame_size(norm ? "720x480" : "720x576");
3545         opt_frame_rate(frame_rates[norm]);
3546         opt_default("gop", norm ? "18" : "15");
3547
3548         opt_default("b", "6000000");
3549         opt_default("maxrate", "9000000");
3550         opt_default("minrate", "0"); //1500000;
3551         opt_default("bufsize", "1835008"); //224*1024*8;
3552
3553         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3554         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3555
3556         opt_default("ab", "448000");
3557         audio_sample_rate = 48000;
3558
3559     } else if(!strncmp(arg, "dv", 2)) {
3560
3561         opt_format("dv");
3562
3563         opt_frame_size(norm ? "720x480" : "720x576");
3564         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3565                                              (norm ? "yuv411p" : "yuv420p"));
3566         opt_frame_rate(frame_rates[norm]);
3567
3568         audio_sample_rate = 48000;
3569         audio_channels = 2;
3570
3571     } else {
3572         fprintf(stderr, "Unknown target: %s\n", arg);
3573         av_exit(1);
3574     }
3575 }
3576
3577 static void opt_vstats_file (const char *arg)
3578 {
3579     av_free (vstats_filename);
3580     vstats_filename=av_strdup (arg);
3581 }
3582
3583 static void opt_vstats (void)
3584 {
3585     char filename[40];
3586     time_t today2 = time(NULL);
3587     struct tm *today = localtime(&today2);
3588
3589     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3590              today->tm_sec);
3591     opt_vstats_file(filename);
3592 }
3593
3594 static int opt_bsf(const char *opt, const char *arg)
3595 {
3596     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3597     AVBitStreamFilterContext **bsfp;
3598
3599     if(!bsfc){
3600         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3601         av_exit(1);
3602     }
3603
3604     bsfp= *opt == 'v' ? &video_bitstream_filters :
3605           *opt == 'a' ? &audio_bitstream_filters :
3606                         &subtitle_bitstream_filters;
3607     while(*bsfp)
3608         bsfp= &(*bsfp)->next;
3609
3610     *bsfp= bsfc;
3611
3612     return 0;
3613 }
3614
3615 static int opt_preset(const char *opt, const char *arg)
3616 {
3617     FILE *f=NULL;
3618     char tmp[1000], tmp2[1000];
3619     int i;
3620     const char *base[3]= { getenv("HOME"),
3621                            "/usr/local/share",
3622                            "/usr/share",
3623                          };
3624
3625     for(i=!base[0]; i<3 && !f; i++){
3626         snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3627         f= fopen(tmp, "r");
3628         if(!f){
3629             char *codec_name= *opt == 'v' ? video_codec_name :
3630                               *opt == 'a' ? audio_codec_name :
3631                                             subtitle_codec_name;
3632               snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3633             f= fopen(tmp, "r");
3634         }
3635     }
3636
3637     if(!f){
3638         fprintf(stderr, "Preset file not found\n");
3639         av_exit(1);
3640     }
3641
3642     while(!feof(f)){
3643         int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3644         if(e!=2){
3645             fprintf(stderr, "Preset file invalid\n");
3646             av_exit(1);
3647         }
3648         if(!strcmp(tmp, "acodec")){
3649             opt_audio_codec(tmp2);
3650         }else if(!strcmp(tmp, "vcodec")){
3651             opt_video_codec(tmp2);
3652         }else if(!strcmp(tmp, "scodec")){
3653             opt_subtitle_codec(tmp2);
3654         }else
3655             opt_default(tmp, tmp2);
3656     }
3657
3658     fclose(f);
3659
3660     return 0;
3661 }
3662
3663 static const OptionDef options[] = {
3664     /* main options */
3665     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3666     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3667     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3668     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3669     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3670     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3671     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3672     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3673     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3674     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3675     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3676     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3677     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3678     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3679     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3680     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3681     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3682     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3683     { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3684     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3685     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3686     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3687       "add timings for benchmarking" },
3688     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3689       "dump each input packet" },
3690     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3691       "when dumping packets, also dump the payload" },
3692     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3693     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3694     { "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)", "" },
3695     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3696     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3697     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3698     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3699     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3700     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3701     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3702     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3703     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3704     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3705     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3706
3707     /* video options */
3708     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3709     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3710     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3711     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3712     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3713     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3714     { "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" },
3715     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3716     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3717     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3718     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3719     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3720     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3721     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3722     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3723     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3724     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3725     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3726     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3727     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3728     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3729     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3730     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3731     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3732     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3733       "use same video quality as source (implies VBR)" },
3734     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3735     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3736     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3737       "deinterlace pictures" },
3738     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3739     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3740     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3741 #ifdef CONFIG_VHOOK
3742     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3743 #endif
3744     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3745     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3746     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3747     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3748     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3749     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3750     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3751
3752     /* audio options */
3753     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3754     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3755     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3756     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3757     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3758     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3759     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3760     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3761     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3762     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3763     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3764
3765     /* subtitle options */
3766     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3767     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3768     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3769     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3770
3771     /* grab options */
3772     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3773     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3774     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3775
3776     /* muxer options */
3777     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3778     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3779
3780     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3781     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3782     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3783
3784     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3785     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3786     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3787
3788     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3789     { NULL, },
3790 };
3791
3792 int main(int argc, char **argv)
3793 {
3794     int i;
3795     int64_t ti;
3796
3797     avcodec_register_all();
3798     avdevice_register_all();
3799     av_register_all();
3800
3801     if(isatty(STDIN_FILENO))
3802         url_set_interrupt_cb(decode_interrupt_cb);
3803
3804     for(i=0; i<CODEC_TYPE_NB; i++){
3805         avctx_opts[i]= avcodec_alloc_context2(i);
3806     }
3807     avformat_opts = av_alloc_format_context();
3808     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3809
3810     show_banner();
3811     if (argc <= 1) {
3812         show_help();
3813         av_exit(1);
3814     }
3815
3816     /* parse options */
3817     parse_options(argc, argv, options, opt_output_file);
3818
3819     /* file converter / grab */
3820     if (nb_output_files <= 0) {
3821         fprintf(stderr, "Must supply at least one output file\n");
3822         av_exit(1);
3823     }
3824
3825     if (nb_input_files == 0) {
3826         fprintf(stderr, "Must supply at least one input file\n");
3827         av_exit(1);
3828     }
3829
3830     ti = getutime();
3831     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3832               stream_maps, nb_stream_maps);
3833     ti = getutime() - ti;
3834     if (do_benchmark) {
3835         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3836     }
3837
3838     return av_exit(0);
3839 }