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