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

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