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

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