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