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