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