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

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