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