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

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