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