ffmpeg.c

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include "avformat.h"
  31 #include "avdevice.h"
  32 #include "swscale.h"
  33 #include "framehook.h"
  34 #include "opt.h"
  35 #include "fifo.h"
  36 #include "avstring.h"
  37 #include "os_support.h"
  38
  39 #if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
  40 #include <windows.h>
  41 #endif
  42
  43 #if defined(HAVE_TERMIOS_H)
  44 #include <unistd.h>
  45 #include <fcntl.h>
  46 #include <sys/ioctl.h>
  47 #include <sys/time.h>
  48 #include <termios.h>
  49 #include <sys/resource.h>
  50 #elif defined(HAVE_CONIO_H)
  51 #include <conio.h>
  52 #endif
  53 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  54 #include <time.h>
  55
  56 #include "version.h"
  57 #include "cmdutils.h"
  58
  59 #undef NDEBUG
  60 #include <assert.h>
  61
  62 #if !defined(INFINITY) && defined(HUGE_VAL)
  63 #define INFINITY HUGE_VAL
  64 #endif
  65
  66 #undef exit
  67
  68 static const char program_name[] = "FFmpeg";
  69 static const int program_birth_year = 2000;
  70
  71 /* select an input stream for an output stream */
  72 typedef struct AVStreamMap {
  73     int file_index;
  74     int stream_index;
  75     int sync_file_index;
  76     int sync_stream_index;
  77 } AVStreamMap;
  78
  79 /** select an input file for an output file */
  80 typedef struct AVMetaDataMap {
  81     int out_file;
  82     int in_file;
  83 } AVMetaDataMap;
  84
  85 extern const OptionDef options[];
  86
  87 #define MAX_FILES 20
  88
  89 static AVFormatContext *input_files[MAX_FILES];
  90 static int64_t input_files_ts_offset[MAX_FILES];
  91 static int nb_input_files = 0;
  92
  93 static AVFormatContext *output_files[MAX_FILES];
  94 static int nb_output_files = 0;
  95
  96 static AVStreamMap stream_maps[MAX_FILES];
  97 static int nb_stream_maps;
  98
  99 static AVMetaDataMap meta_data_maps[MAX_FILES];
 100 static int nb_meta_data_maps;
 101
 102 static AVInputFormat *file_iformat;
 103 static AVOutputFormat *file_oformat;
 104 static int frame_width  = 0;
 105 static int frame_height = 0;
 106 static float frame_aspect_ratio = 0;
 107 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 108 static int frame_padtop  = 0;
 109 static int frame_padbottom = 0;
 110 static int frame_padleft  = 0;
 111 static int frame_padright = 0;
 112 static int padcolor[3] = {16,128,128}; /* default to black */
 113 static int frame_topBand  = 0;
 114 static int frame_bottomBand = 0;
 115 static int frame_leftBand  = 0;
 116 static int frame_rightBand = 0;
 117 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 118 static AVRational frame_rate = (AVRational) {0,0};
 119 static float video_qscale = 0;
 120 static int video_qdiff = 3;
 121 static uint16_t *intra_matrix = NULL;
 122 static uint16_t *inter_matrix = NULL;
 123 #if 0 //experimental, (can be removed)
 124 static float video_rc_qsquish=1.0;
 125 static float video_rc_qmod_amp=0;
 126 static int video_rc_qmod_freq=0;
 127 #endif
 128 static const char *video_rc_override_string=NULL;
 129 static int video_disable = 0;
 130 static int video_discard = 0;
 131 static char *video_codec_name = NULL;
 132 static int video_codec_tag = 0;
 133 static int same_quality = 0;
 134 static int do_deinterlace = 0;
 135 static int strict = 0;
 136 static int top_field_first = -1;
 137 static int me_threshold = 0;
 138 static int intra_dc_precision = 8;
 139 static int loop_input = 0;
 140 static int loop_output = AVFMT_NOOUTPUTLOOP;
 141 static int qp_hist = 0;
 142
 143 static int intra_only = 0;
 144 static int audio_sample_rate = 44100;
 145 #define QSCALE_NONE -99999
 146 static float audio_qscale = QSCALE_NONE;
 147 static int audio_disable = 0;
 148 static int audio_channels = 1;
 149 static char  *audio_codec_name = NULL;
 150 static int audio_codec_tag = 0;
 151 static char *audio_language = NULL;
 152
 153 static int subtitle_disable = 0;
 154 static char *subtitle_codec_name = NULL;
 155 static char *subtitle_language = NULL;
 156
 157 static float mux_preload= 0.5;
 158 static float mux_max_delay= 0.7;
 159
 160 static int64_t recording_time = 0;
 161 static int64_t start_time = 0;
 162 static int64_t rec_timestamp = 0;
 163 static int64_t input_ts_offset = 0;
 164 static int file_overwrite = 0;
 165 static char *str_title = NULL;
 166 static char *str_author = NULL;
 167 static char *str_copyright = NULL;
 168 static char *str_comment = NULL;
 169 static char *str_genre = NULL;
 170 static char *str_album = NULL;
 171 static int do_benchmark = 0;
 172 static int do_hex_dump = 0;
 173 static int do_pkt_dump = 0;
 174 static int do_psnr = 0;
 175 static int do_pass = 0;
 176 static char *pass_logfilename = NULL;
 177 static int audio_stream_copy = 0;
 178 static int video_stream_copy = 0;
 179 static int subtitle_stream_copy = 0;
 180 static int video_sync_method= 1;
 181 static int audio_sync_method= 0;
 182 static float audio_drift_threshold= 0.1;
 183 static int copy_ts= 0;
 184 static int opt_shortest = 0; //
 185 static int video_global_header = 0;
 186 static char *vstats_filename;
 187 static FILE *vstats_file;
 188 static int opt_programid = 0;
 189
 190 static int rate_emu = 0;
 191
 192 static int  video_channel = 0;
 193 static char *video_standard;
 194
 195 static int audio_volume = 256;
 196
 197 static int using_stdin = 0;
 198 static int using_vhook = 0;
 199 static int verbose = 1;
 200 static int thread_count= 1;
 201 static int q_pressed = 0;
 202 static int64_t video_size = 0;
 203 static int64_t audio_size = 0;
 204 static int64_t extra_size = 0;
 205 static int nb_frames_dup = 0;
 206 static int nb_frames_drop = 0;
 207 static int input_sync;
 208 static uint64_t limit_filesize = 0; //
 209
 210 static int pgmyuv_compatibility_hack=0;
 211 static float dts_delta_threshold = 10;
 212
 213 static int sws_flags = SWS_BICUBIC;
 214
 215 static const char **opt_names;
 216 static int opt_name_count;
 217 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
 218 static AVFormatContext *avformat_opts;
 219 static struct SwsContext *sws_opts;
 220 static int64_t timer_start;
 221
 222 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 223 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 224 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 225 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
 226
 227 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
 228
 229 struct AVInputStream;
 230
 231 typedef struct AVOutputStream {
 232     int file_index;          /* file index */
 233     int index;               /* stream index in the output file */
 234     int source_index;        /* AVInputStream index */
 235     AVStream *st;            /* stream in the output file */
 236     int encoding_needed;     /* true if encoding needed for this stream */
 237     int frame_number;
 238     /* input pts and corresponding output pts
 239        for A/V sync */
 240     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 241     struct AVInputStream *sync_ist; /* input stream to sync against */
 242     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 243     /* video only */
 244     int video_resample;
 245     AVFrame pict_tmp;      /* temporary image for resampling */
 246     struct SwsContext *img_resample_ctx; /* for image resampling */
 247     int resample_height;
 248
 249     int video_crop;
 250     int topBand;             /* cropping area sizes */
 251     int leftBand;
 252
 253     int video_pad;
 254     int padtop;              /* padding area sizes */
 255     int padbottom;
 256     int padleft;
 257     int padright;
 258
 259     /* audio only */
 260     int audio_resample;
 261     ReSampleContext *resample; /* for audio resampling */
 262     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
 263     FILE *logfile;
 264 } AVOutputStream;
 265
 266 typedef struct AVInputStream {
 267     int file_index;
 268     int index;
 269     AVStream *st;
 270     int discard;             /* true if stream data should be discarded */
 271     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 272     int64_t sample_index;      /* current sample */
 273
 274     int64_t       start;     /* time when read started */
 275     unsigned long frame;     /* current frame */
 276     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 277                                 is not defined */
 278     int64_t       pts;       /* current pts */
 279     int is_start;            /* is 1 at the start and after a discontinuity */
 280 } AVInputStream;
 281
 282 typedef struct AVInputFile {
 283     int eof_reached;      /* true if eof reached */
 284     int ist_index;        /* index of first stream in ist_table */
 285     int buffer_size;      /* current total buffer size */
 286     int nb_streams;       /* nb streams we are aware of */
 287 } AVInputFile;
 288
 289 #ifdef HAVE_TERMIOS_H
 290
 291 /* init terminal so that we can grab keys */
 292 static struct termios oldtty;
 293 #endif
 294
 295 static void term_exit(void)
 296 {
 297 #ifdef HAVE_TERMIOS_H
 298     tcsetattr (0, TCSANOW, &oldtty);
 299 #endif
 300 }
 301
 302 static volatile sig_atomic_t received_sigterm = 0;
 303
 304 static void
 305 sigterm_handler(int sig)
 306 {
 307     received_sigterm = sig;
 308     term_exit();
 309 }
 310
 311 static void term_init(void)
 312 {
 313 #ifdef HAVE_TERMIOS_H
 314     struct termios tty;
 315
 316     tcgetattr (0, &tty);
 317     oldtty = tty;
 318
 319     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 320                           |INLCR|IGNCR|ICRNL|IXON);
 321     tty.c_oflag |= OPOST;
 322     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 323     tty.c_cflag &= ~(CSIZE|PARENB);
 324     tty.c_cflag |= CS8;
 325     tty.c_cc[VMIN] = 1;
 326     tty.c_cc[VTIME] = 0;
 327
 328     tcsetattr (0, TCSANOW, &tty);
 329     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 330 #endif
 331
 332     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 333     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 334     /*
 335     register a function to be called at normal program termination
 336     */
 337     atexit(term_exit);
 338 #ifdef CONFIG_BEOS_NETSERVER
 339     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 340 #endif
 341 }
 342
 343 /* read a key without blocking */
 344 static int read_key(void)
 345 {
 346 #if defined(HAVE_TERMIOS_H)
 347     int n = 1;
 348     unsigned char ch;
 349 #ifndef CONFIG_BEOS_NETSERVER
 350     struct timeval tv;
 351     fd_set rfds;
 352
 353     FD_ZERO(&rfds);
 354     FD_SET(0, &rfds);
 355     tv.tv_sec = 0;
 356     tv.tv_usec = 0;
 357     n = select(1, &rfds, NULL, NULL, &tv);
 358 #endif
 359     if (n > 0) {
 360         n = read(0, &ch, 1);
 361         if (n == 1)
 362             return ch;
 363
 364         return n;
 365     }
 366 #elif defined(HAVE_CONIO_H)
 367     if(kbhit())
 368         return(getch());
 369 #endif
 370     return -1;
 371 }
 372
 373 static int decode_interrupt_cb(void)
 374 {
 375     return q_pressed || (q_pressed = read_key() == 'q');
 376 }
 377
 378 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 379 {
 380     int i, err;
 381     AVFormatContext *ic;
 382
 383     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 384     if (err < 0)
 385         return err;
 386     /* copy stream format */
 387     s->nb_streams = ic->nb_streams;
 388     for(i=0;i<ic->nb_streams;i++) {
 389         AVStream *st;
 390
 391         // FIXME: a more elegant solution is needed
 392         st = av_mallocz(sizeof(AVStream));
 393         memcpy(st, ic->streams[i], sizeof(AVStream));
 394         st->codec = avcodec_alloc_context();
 395         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
 396         s->streams[i] = st;
 397     }
 398
 399     av_close_input_file(ic);
 400     return 0;
 401 }
 402
 403 static double
 404 get_sync_ipts(const AVOutputStream *ost)
 405 {
 406     const AVInputStream *ist = ost->sync_ist;
 407     return (double)(ist->pts - start_time)/AV_TIME_BASE;
 408 }
 409
 410 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 411     int ret;
 412
 413     while(bsfc){
 414         AVPacket new_pkt= *pkt;
 415         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 416                                           &new_pkt.data, &new_pkt.size,
 417                                           pkt->data, pkt->size,
 418                                           pkt->flags & PKT_FLAG_KEY);
 419         if(a>0){
 420             av_free_packet(pkt);
 421             new_pkt.destruct= av_destruct_packet;
 422         } else if(a<0){
 423             fprintf(stderr, "%s failed for stream %d, codec %s",
 424                     bsfc->filter->name, pkt->stream_index,
 425                     avctx->codec ? avctx->codec->name : "copy");
 426             print_error("", a);
 427         }
 428         *pkt= new_pkt;
 429
 430         bsfc= bsfc->next;
 431     }
 432
 433     ret= av_interleaved_write_frame(s, pkt);
 434     if(ret < 0){
 435         print_error("av_interleaved_write_frame()", ret);
 436         exit(1);
 437     }
 438 }
 439
 440 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 441
 442 static void do_audio_out(AVFormatContext *s,
 443                          AVOutputStream *ost,
 444                          AVInputStream *ist,
 445                          unsigned char *buf, int size)
 446 {
 447     uint8_t *buftmp;
 448     static uint8_t *audio_buf = NULL;
 449     static uint8_t *audio_out = NULL;
 450     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
 451
 452     int size_out, frame_bytes, ret;
 453     AVCodecContext *enc= ost->st->codec;
 454     AVCodecContext *dec= ist->st->codec;
 455
 456     /* SC: dynamic allocation of buffers */
 457     if (!audio_buf)
 458         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
 459     if (!audio_out)
 460         audio_out = av_malloc(audio_out_size);
 461     if (!audio_buf || !audio_out)
 462         return;               /* Should signal an error ! */
 463
 464     if (enc->channels != dec->channels)
 465         ost->audio_resample = 1;
 466
 467     if (ost->audio_resample && !ost->resample) {
 468         ost->resample = audio_resample_init(enc->channels,    dec->channels,
 469                                             enc->sample_rate, dec->sample_rate);
 470         if (!ost->resample) {
 471             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 472                     dec->channels, dec->sample_rate,
 473                     enc->channels, enc->sample_rate);
 474             exit(1);
 475         }
 476     }
 477
 478     if(audio_sync_method){
 479         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 480                 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
 481         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
 482         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
 483
 484         //FIXME resample delay
 485         if(fabs(delta) > 50){
 486             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 487                 if(byte_delta < 0){
 488                     byte_delta= FFMAX(byte_delta, -size);
 489                     size += byte_delta;
 490                     buf  -= byte_delta;
 491                     if(verbose > 2)
 492                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 493                     if(!size)
 494                         return;
 495                     ist->is_start=0;
 496                 }else{
 497                     static uint8_t *input_tmp= NULL;
 498                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 499
 500                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
 501                         ist->is_start=0;
 502                     else
 503                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
 504
 505                     memset(input_tmp, 0, byte_delta);
 506                     memcpy(input_tmp + byte_delta, buf, size);
 507                     buf= input_tmp;
 508                     size += byte_delta;
 509                     if(verbose > 2)
 510                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 511                 }
 512             }else if(audio_sync_method>1){
 513                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 514                 assert(ost->audio_resample);
 515                 if(verbose > 2)
 516                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 517 //                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
 518                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 519             }
 520         }
 521     }else
 522         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 523                         - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
 524
 525     if (ost->audio_resample) {
 526         buftmp = audio_buf;
 527         size_out = audio_resample(ost->resample,
 528                                   (short *)buftmp, (short *)buf,
 529                                   size / (ist->st->codec->channels * 2));
 530         size_out = size_out * enc->channels * 2;
 531     } else {
 532         buftmp = buf;
 533         size_out = size;
 534     }
 535
 536     /* now encode as many frames as possible */
 537     if (enc->frame_size > 1) {
 538         /* output resampled raw samples */
 539         av_fifo_write(&ost->fifo, buftmp, size_out);
 540
 541         frame_bytes = enc->frame_size * 2 * enc->channels;
 542
 543         while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
 544             AVPacket pkt;
 545             av_init_packet(&pkt);
 546
 547             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 548                                        (short *)audio_buf);
 549             audio_size += ret;
 550             pkt.stream_index= ost->index;
 551             pkt.data= audio_out;
 552             pkt.size= ret;
 553             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 554                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 555             pkt.flags |= PKT_FLAG_KEY;
 556             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 557
 558             ost->sync_opts += enc->frame_size;
 559         }
 560     } else {
 561         AVPacket pkt;
 562         av_init_packet(&pkt);
 563
 564         ost->sync_opts += size_out / (2 * enc->channels);
 565
 566         /* output a pcm frame */
 567         /* XXX: change encoding codec API to avoid this ? */
 568         switch(enc->codec->id) {
 569         case CODEC_ID_PCM_S32LE:
 570         case CODEC_ID_PCM_S32BE:
 571         case CODEC_ID_PCM_U32LE:
 572         case CODEC_ID_PCM_U32BE:
 573             size_out = size_out << 1;
 574             break;
 575         case CODEC_ID_PCM_S24LE:
 576         case CODEC_ID_PCM_S24BE:
 577         case CODEC_ID_PCM_U24LE:
 578         case CODEC_ID_PCM_U24BE:
 579         case CODEC_ID_PCM_S24DAUD:
 580             size_out = size_out / 2 * 3;
 581             break;
 582         case CODEC_ID_PCM_S16LE:
 583         case CODEC_ID_PCM_S16BE:
 584         case CODEC_ID_PCM_U16LE:
 585         case CODEC_ID_PCM_U16BE:
 586             break;
 587         default:
 588             size_out = size_out >> 1;
 589             break;
 590         }
 591         ret = avcodec_encode_audio(enc, audio_out, size_out,
 592                                    (short *)buftmp);
 593         audio_size += ret;
 594         pkt.stream_index= ost->index;
 595         pkt.data= audio_out;
 596         pkt.size= ret;
 597         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 598             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 599         pkt.flags |= PKT_FLAG_KEY;
 600         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 601     }
 602 }
 603
 604 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
 605 {
 606     AVCodecContext *dec;
 607     AVPicture *picture2;
 608     AVPicture picture_tmp;
 609     uint8_t *buf = 0;
 610
 611     dec = ist->st->codec;
 612
 613     /* deinterlace : must be done before any resize */
 614     if (do_deinterlace || using_vhook) {
 615         int size;
 616
 617         /* create temporary picture */
 618         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 619         buf = av_malloc(size);
 620         if (!buf)
 621             return;
 622
 623         picture2 = &picture_tmp;
 624         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 625
 626         if (do_deinterlace){
 627             if(avpicture_deinterlace(picture2, picture,
 628                                      dec->pix_fmt, dec->width, dec->height) < 0) {
 629                 /* if error, do not deinterlace */
 630                 av_free(buf);
 631                 buf = NULL;
 632                 picture2 = picture;
 633             }
 634         } else {
 635             av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
 636         }
 637     } else {
 638         picture2 = picture;
 639     }
 640
 641     if (ENABLE_VHOOK)
 642         frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
 643                            1000000 * ist->pts / AV_TIME_BASE);
 644
 645     if (picture != picture2)
 646         *picture = *picture2;
 647     *bufp = buf;
 648 }
 649
 650 /* we begin to correct av delay at this threshold */
 651 #define AV_DELAY_MAX 0.100
 652
 653 static void do_subtitle_out(AVFormatContext *s,
 654                             AVOutputStream *ost,
 655                             AVInputStream *ist,
 656                             AVSubtitle *sub,
 657                             int64_t pts)
 658 {
 659     static uint8_t *subtitle_out = NULL;
 660     int subtitle_out_max_size = 65536;
 661     int subtitle_out_size, nb, i;
 662     AVCodecContext *enc;
 663     AVPacket pkt;
 664
 665     if (pts == AV_NOPTS_VALUE) {
 666         fprintf(stderr, "Subtitle packets must have a pts\n");
 667         return;
 668     }
 669
 670     enc = ost->st->codec;
 671
 672     if (!subtitle_out) {
 673         subtitle_out = av_malloc(subtitle_out_max_size);
 674     }
 675
 676     /* Note: DVB subtitle need one packet to draw them and one other
 677        packet to clear them */
 678     /* XXX: signal it in the codec context ? */
 679     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
 680         nb = 2;
 681     else
 682         nb = 1;
 683
 684     for(i = 0; i < nb; i++) {
 685         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
 686                                                     subtitle_out_max_size, sub);
 687
 688         av_init_packet(&pkt);
 689         pkt.stream_index = ost->index;
 690         pkt.data = subtitle_out;
 691         pkt.size = subtitle_out_size;
 692         pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
 693         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
 694             /* XXX: the pts correction is handled here. Maybe handling
 695                it in the codec would be better */
 696             if (i == 0)
 697                 pkt.pts += 90 * sub->start_display_time;
 698             else
 699                 pkt.pts += 90 * sub->end_display_time;
 700         }
 701         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 702     }
 703 }
 704
 705 static int bit_buffer_size= 1024*256;
 706 static uint8_t *bit_buffer= NULL;
 707
 708 static void do_video_out(AVFormatContext *s,
 709                          AVOutputStream *ost,
 710                          AVInputStream *ist,
 711                          AVFrame *in_picture,
 712                          int *frame_size)
 713 {
 714     int nb_frames, i, ret;
 715     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
 716     AVFrame picture_crop_temp, picture_pad_temp;
 717     AVCodecContext *enc, *dec;
 718
 719     avcodec_get_frame_defaults(&picture_crop_temp);
 720     avcodec_get_frame_defaults(&picture_pad_temp);
 721
 722     enc = ost->st->codec;
 723     dec = ist->st->codec;
 724
 725     /* by default, we output a single frame */
 726     nb_frames = 1;
 727
 728     *frame_size = 0;
 729
 730     if(video_sync_method){
 731         double vdelta;
 732         vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
 733         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
 734         if (vdelta < -1.1)
 735             nb_frames = 0;
 736         else if (video_sync_method == 2)
 737             ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
 738         else if (vdelta > 1.1)
 739             nb_frames = lrintf(vdelta);
 740 //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);
 741         if (nb_frames == 0){
 742             ++nb_frames_drop;
 743             if (verbose>2)
 744                 fprintf(stderr, "*** drop!\n");
 745         }else if (nb_frames > 1) {
 746             nb_frames_dup += nb_frames;
 747             if (verbose>2)
 748                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
 749         }
 750     }else
 751         ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
 752
 753     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
 754     if (nb_frames <= 0)
 755         return;
 756
 757     if (ost->video_crop) {
 758         if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
 759             av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
 760             return;
 761         }
 762         formatted_picture = &picture_crop_temp;
 763     } else {
 764         formatted_picture = in_picture;
 765     }
 766
 767     final_picture = formatted_picture;
 768     padding_src = formatted_picture;
 769     resampling_dst = &ost->pict_tmp;
 770     if (ost->video_pad) {
 771         final_picture = &ost->pict_tmp;
 772         if (ost->video_resample) {
 773             if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
 774                 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
 775                 return;
 776             }
 777             resampling_dst = &picture_pad_temp;
 778         }
 779     }
 780
 781     if (ost->video_resample) {
 782         padding_src = NULL;
 783         final_picture = &ost->pict_tmp;
 784         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
 785               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
 786     }
 787
 788     if (ost->video_pad) {
 789         av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
 790                 enc->height, enc->width, enc->pix_fmt,
 791                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
 792     }
 793
 794     /* duplicates frame if needed */
 795     for(i=0;i<nb_frames;i++) {
 796         AVPacket pkt;
 797         av_init_packet(&pkt);
 798         pkt.stream_index= ost->index;
 799
 800         if (s->oformat->flags & AVFMT_RAWPICTURE) {
 801             /* raw pictures are written as AVPicture structure to
 802                avoid any copies. We support temorarily the older
 803                method. */
 804             AVFrame* old_frame = enc->coded_frame;
 805             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
 806             pkt.data= (uint8_t *)final_picture;
 807             pkt.size=  sizeof(AVPicture);
 808             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
 809             pkt.flags |= PKT_FLAG_KEY;
 810
 811             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 812             enc->coded_frame = old_frame;
 813         } else {
 814             AVFrame big_picture;
 815
 816             big_picture= *final_picture;
 817             /* better than nothing: use input picture interlaced
 818                settings */
 819             big_picture.interlaced_frame = in_picture->interlaced_frame;
 820             if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
 821                 if(top_field_first == -1)
 822                     big_picture.top_field_first = in_picture->top_field_first;
 823                 else
 824                     big_picture.top_field_first = top_field_first;
 825             }
 826
 827             /* handles sameq here. This is not correct because it may
 828                not be a global option */
 829             if (same_quality) {
 830                 big_picture.quality = ist->st->quality;
 831             }else
 832                 big_picture.quality = ost->st->quality;
 833             if(!me_threshold)
 834                 big_picture.pict_type = 0;
 835 //            big_picture.pts = AV_NOPTS_VALUE;
 836             big_picture.pts= ost->sync_opts;
 837 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
 838 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
 839             ret = avcodec_encode_video(enc,
 840                                        bit_buffer, bit_buffer_size,
 841                                        &big_picture);
 842             if (ret == -1) {
 843                 fprintf(stderr, "Video encoding failed\n");
 844                 exit(1);
 845             }
 846             //enc->frame_number = enc->real_pict_num;
 847             if(ret>0){
 848                 pkt.data= bit_buffer;
 849                 pkt.size= ret;
 850                 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 851                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 852 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
 853    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
 854    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
 855
 856                 if(enc->coded_frame && enc->coded_frame->key_frame)
 857                     pkt.flags |= PKT_FLAG_KEY;
 858                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 859                 *frame_size = ret;
 860                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
 861                 //        enc->frame_number-1, enc->real_pict_num, ret,
 862                 //        enc->pict_type);
 863                 /* if two pass, output log */
 864                 if (ost->logfile && enc->stats_out) {
 865                     fprintf(ost->logfile, "%s", enc->stats_out);
 866                 }
 867             }
 868         }
 869         ost->sync_opts++;
 870         ost->frame_number++;
 871     }
 872 }
 873
 874 static double psnr(double d){
 875     if(d==0) return INFINITY;
 876     return -10.0*log(d)/log(10.0);
 877 }
 878
 879 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
 880                            int frame_size)
 881 {
 882     AVCodecContext *enc;
 883     int frame_number;
 884     double ti1, bitrate, avg_bitrate;
 885
 886     /* this is executed just the first time do_video_stats is called */
 887     if (!vstats_file) {
 888         vstats_file = fopen(vstats_filename, "w");
 889         if (!vstats_file) {
 890             perror("fopen");
 891             exit(1);
 892         }
 893     }
 894
 895     enc = ost->st->codec;
 896     if (enc->codec_type == CODEC_TYPE_VIDEO) {
 897         frame_number = ost->frame_number;
 898         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 899         if (enc->flags&CODEC_FLAG_PSNR)
 900             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
 901
 902         fprintf(vstats_file,"f_size= %6d ", frame_size);
 903         /* compute pts value */
 904         ti1 = ost->sync_opts * av_q2d(enc->time_base);
 905         if (ti1 < 0.01)
 906             ti1 = 0.01;
 907
 908         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
 909         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
 910         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
 911             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
 912         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
 913     }
 914 }
 915
 916 static void print_report(AVFormatContext **output_files,
 917                          AVOutputStream **ost_table, int nb_ostreams,
 918                          int is_last_report)
 919 {
 920     char buf[1024];
 921     AVOutputStream *ost;
 922     AVFormatContext *oc, *os;
 923     int64_t total_size;
 924     AVCodecContext *enc;
 925     int frame_number, vid, i;
 926     double bitrate, ti1, pts;
 927     static int64_t last_time = -1;
 928     static int qp_histogram[52];
 929
 930     if (!is_last_report) {
 931         int64_t cur_time;
 932         /* display the report every 0.5 seconds */
 933         cur_time = av_gettime();
 934         if (last_time == -1) {
 935             last_time = cur_time;
 936             return;
 937         }
 938         if ((cur_time - last_time) < 500000)
 939             return;
 940         last_time = cur_time;
 941     }
 942
 943
 944     oc = output_files[0];
 945
 946     total_size = url_fsize(oc->pb);
 947     if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
 948         total_size= url_ftell(oc->pb);
 949
 950     buf[0] = '\0';
 951     ti1 = 1e10;
 952     vid = 0;
 953     for(i=0;i<nb_ostreams;i++) {
 954         ost = ost_table[i];
 955         os = output_files[ost->file_index];
 956         enc = ost->st->codec;
 957         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
 958             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
 959                      enc->coded_frame && !ost->st->stream_copy ?
 960                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
 961         }
 962         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
 963             float t = (av_gettime()-timer_start) / 1000000.0;
 964
 965             frame_number = ost->frame_number;
 966             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
 967                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
 968                      enc->coded_frame && !ost->st->stream_copy ?
 969                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
 970             if(is_last_report)
 971                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
 972             if(qp_hist && enc->coded_frame){
 973                 int j;
 974                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 975                 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
 976                     qp_histogram[qp]++;
 977                 for(j=0; j<32; j++)
 978                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
 979             }
 980             if (enc->flags&CODEC_FLAG_PSNR){
 981                 int j;
 982                 double error, error_sum=0;
 983                 double scale, scale_sum=0;
 984                 char type[3]= {'Y','U','V'};
 985                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
 986                 for(j=0; j<3; j++){
 987                     if(is_last_report){
 988                         error= enc->error[j];
 989                         scale= enc->width*enc->height*255.0*255.0*frame_number;
 990                     }else{
 991                         error= enc->coded_frame->error[j];
 992                         scale= enc->width*enc->height*255.0*255.0;
 993                     }
 994                     if(j) scale/=4;
 995                     error_sum += error;
 996                     scale_sum += scale;
 997                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
 998                 }
 999                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1000             }
1001             vid = 1;
1002         }
1003         /* compute min output value */
1004         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1005         if ((pts < ti1) && (pts > 0))
1006             ti1 = pts;
1007     }
1008     if (ti1 < 0.01)
1009         ti1 = 0.01;
1010
1011     if (verbose || is_last_report) {
1012         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1013
1014         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1015             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1016             (double)total_size / 1024, ti1, bitrate);
1017
1018         if (verbose > 1)
1019           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1020                   nb_frames_dup, nb_frames_drop);
1021
1022         if (verbose >= 0)
1023             fprintf(stderr, "%s    \r", buf);
1024
1025         fflush(stderr);
1026     }
1027
1028     if (is_last_report && verbose >= 0){
1029         int64_t raw= audio_size + video_size + extra_size;
1030         fprintf(stderr, "\n");
1031         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1032                 video_size/1024.0,
1033                 audio_size/1024.0,
1034                 extra_size/1024.0,
1035                 100.0*(total_size - raw)/raw
1036         );
1037     }
1038 }
1039
1040 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1041 static int output_packet(AVInputStream *ist, int ist_index,
1042                          AVOutputStream **ost_table, int nb_ostreams,
1043                          const AVPacket *pkt)
1044 {
1045     AVFormatContext *os;
1046     AVOutputStream *ost;
1047     uint8_t *ptr;
1048     int len, ret, i;
1049     uint8_t *data_buf;
1050     int data_size, got_picture;
1051     AVFrame picture;
1052     void *buffer_to_free;
1053     static unsigned int samples_size= 0;
1054     static short *samples= NULL;
1055     AVSubtitle subtitle, *subtitle_to_free;
1056     int got_subtitle;
1057
1058     if(ist->next_pts == AV_NOPTS_VALUE)
1059         ist->next_pts= ist->pts;
1060
1061     if (pkt == NULL) {
1062         /* EOF handling */
1063         ptr = NULL;
1064         len = 0;
1065         goto handle_eof;
1066     }
1067
1068     if(pkt->dts != AV_NOPTS_VALUE)
1069         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1070
1071     len = pkt->size;
1072     ptr = pkt->data;
1073     while (len > 0) {
1074     handle_eof:
1075         ist->pts= ist->next_pts;
1076
1077         if(len && len != pkt->size && verbose>0)
1078             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1079
1080         /* decode the packet if needed */
1081         data_buf = NULL; /* fail safe */
1082         data_size = 0;
1083         subtitle_to_free = NULL;
1084         if (ist->decoding_needed) {
1085             switch(ist->st->codec->codec_type) {
1086             case CODEC_TYPE_AUDIO:{
1087                 if(pkt)
1088                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1089                 data_size= samples_size;
1090                     /* XXX: could avoid copy if PCM 16 bits with same
1091                        endianness as CPU */
1092                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1093                                            ptr, len);
1094                 if (ret < 0)
1095                     goto fail_decode;
1096                 ptr += ret;
1097                 len -= ret;
1098                 /* Some bug in mpeg audio decoder gives */
1099                 /* data_size < 0, it seems they are overflows */
1100                 if (data_size <= 0) {
1101                     /* no audio frame */
1102                     continue;
1103                 }
1104                 data_buf = (uint8_t *)samples;
1105                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1106                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1107                 break;}
1108             case CODEC_TYPE_VIDEO:
1109                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1110                     /* XXX: allocate picture correctly */
1111                     avcodec_get_frame_defaults(&picture);
1112
1113                     ret = avcodec_decode_video(ist->st->codec,
1114                                                &picture, &got_picture, ptr, len);
1115                     ist->st->quality= picture.quality;
1116                     if (ret < 0)
1117                         goto fail_decode;
1118                     if (!got_picture) {
1119                         /* no picture yet */
1120                         goto discard_packet;
1121                     }
1122                     if (ist->st->codec->time_base.num != 0) {
1123                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1124                                           ist->st->codec->time_base.num) /
1125                             ist->st->codec->time_base.den;
1126                     }
1127                     len = 0;
1128                     break;
1129             case CODEC_TYPE_SUBTITLE:
1130                 ret = avcodec_decode_subtitle(ist->st->codec,
1131                                               &subtitle, &got_subtitle, ptr, len);
1132                 if (ret < 0)
1133                     goto fail_decode;
1134                 if (!got_subtitle) {
1135                     goto discard_packet;
1136                 }
1137                 subtitle_to_free = &subtitle;
1138                 len = 0;
1139                 break;
1140             default:
1141                 goto fail_decode;
1142             }
1143         } else {
1144             switch(ist->st->codec->codec_type) {
1145             case CODEC_TYPE_AUDIO:
1146                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1147                     ist->st->codec->sample_rate;
1148                 break;
1149             case CODEC_TYPE_VIDEO:
1150                 if (ist->st->codec->time_base.num != 0) {
1151                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1152                                       ist->st->codec->time_base.num) /
1153                         ist->st->codec->time_base.den;
1154                 }
1155                 break;
1156             }
1157             data_buf = ptr;
1158             data_size = len;
1159             ret = len;
1160             len = 0;
1161         }
1162
1163         buffer_to_free = NULL;
1164         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1165             pre_process_video_frame(ist, (AVPicture *)&picture,
1166                                     &buffer_to_free);
1167         }
1168
1169         // preprocess audio (volume)
1170         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1171             if (audio_volume != 256) {
1172                 short *volp;
1173                 volp = samples;
1174                 for(i=0;i<(data_size / sizeof(short));i++) {
1175                     int v = ((*volp) * audio_volume + 128) >> 8;
1176                     if (v < -32768) v = -32768;
1177                     if (v >  32767) v = 32767;
1178                     *volp++ = v;
1179                 }
1180             }
1181         }
1182
1183         /* frame rate emulation */
1184         if (ist->st->codec->rate_emu) {
1185             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1186             int64_t now = av_gettime() - ist->start;
1187             if (pts > now)
1188                 usleep(pts - now);
1189
1190             ist->frame++;
1191         }
1192
1193 #if 0
1194         /* mpeg PTS deordering : if it is a P or I frame, the PTS
1195            is the one of the next displayed one */
1196         /* XXX: add mpeg4 too ? */
1197         if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1198             if (ist->st->codec->pict_type != B_TYPE) {
1199                 int64_t tmp;
1200                 tmp = ist->last_ip_pts;
1201                 ist->last_ip_pts  = ist->frac_pts.val;
1202                 ist->frac_pts.val = tmp;
1203             }
1204         }
1205 #endif
1206         /* if output time reached then transcode raw format,
1207            encode packets and output them */
1208         if (start_time == 0 || ist->pts >= start_time)
1209             for(i=0;i<nb_ostreams;i++) {
1210                 int frame_size;
1211
1212                 ost = ost_table[i];
1213                 if (ost->source_index == ist_index) {
1214                     os = output_files[ost->file_index];
1215
1216 #if 0
1217                     printf("%d: got pts=%0.3f %0.3f\n", i,
1218                            (double)pkt->pts / AV_TIME_BASE,
1219                            ((double)ist->pts / AV_TIME_BASE) -
1220                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1221 #endif
1222                     /* set the input output pts pairs */
1223                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1224
1225                     if (ost->encoding_needed) {
1226                         switch(ost->st->codec->codec_type) {
1227                         case CODEC_TYPE_AUDIO:
1228                             do_audio_out(os, ost, ist, data_buf, data_size);
1229                             break;
1230                         case CODEC_TYPE_VIDEO:
1231                             do_video_out(os, ost, ist, &picture, &frame_size);
1232                             video_size += frame_size;
1233                             if (vstats_filename && frame_size)
1234                                 do_video_stats(os, ost, frame_size);
1235                             break;
1236                         case CODEC_TYPE_SUBTITLE:
1237                             do_subtitle_out(os, ost, ist, &subtitle,
1238                                             pkt->pts);
1239                             break;
1240                         default:
1241                             abort();
1242                         }
1243                     } else {
1244                         AVFrame avframe; //FIXME/XXX remove this
1245                         AVPacket opkt;
1246                         av_init_packet(&opkt);
1247
1248                         if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1249                             continue;
1250
1251                         /* no reencoding needed : output the packet directly */
1252                         /* force the input stream PTS */
1253
1254                         avcodec_get_frame_defaults(&avframe);
1255                         ost->st->codec->coded_frame= &avframe;
1256                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1257
1258                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1259                             audio_size += data_size;
1260                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1261                             video_size += data_size;
1262                             ost->sync_opts++;
1263                         }
1264
1265                         opkt.stream_index= ost->index;
1266                         if(pkt->pts != AV_NOPTS_VALUE)
1267                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1268                         else
1269                             opkt.pts= AV_NOPTS_VALUE;
1270
1271                             if (pkt->dts == AV_NOPTS_VALUE)
1272                                 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1273                             else
1274                                 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1275
1276                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1277                         opkt.flags= pkt->flags;
1278
1279                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1280                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1281                             opkt.destruct= av_destruct_packet;
1282
1283                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1284                         ost->st->codec->frame_number++;
1285                         ost->frame_number++;
1286                         av_free_packet(&opkt);
1287                     }
1288                 }
1289             }
1290         av_free(buffer_to_free);
1291         /* XXX: allocate the subtitles in the codec ? */
1292         if (subtitle_to_free) {
1293             if (subtitle_to_free->rects != NULL) {
1294                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1295                     av_free(subtitle_to_free->rects[i].bitmap);
1296                     av_free(subtitle_to_free->rects[i].rgba_palette);
1297                 }
1298                 av_freep(&subtitle_to_free->rects);
1299             }
1300             subtitle_to_free->num_rects = 0;
1301             subtitle_to_free = NULL;
1302         }
1303     }
1304  discard_packet:
1305     if (pkt == NULL) {
1306         /* EOF handling */
1307
1308         for(i=0;i<nb_ostreams;i++) {
1309             ost = ost_table[i];
1310             if (ost->source_index == ist_index) {
1311                 AVCodecContext *enc= ost->st->codec;
1312                 os = output_files[ost->file_index];
1313
1314                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1315                     continue;
1316                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1317                     continue;
1318
1319                 if (ost->encoding_needed) {
1320                     for(;;) {
1321                         AVPacket pkt;
1322                         int fifo_bytes;
1323                         av_init_packet(&pkt);
1324                         pkt.stream_index= ost->index;
1325
1326                         switch(ost->st->codec->codec_type) {
1327                         case CODEC_TYPE_AUDIO:
1328                             fifo_bytes = av_fifo_size(&ost->fifo);
1329                             ret = 0;
1330                             /* encode any samples remaining in fifo */
1331                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1332                                 int fs_tmp = enc->frame_size;
1333                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1334                                 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1335                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1336                                 }
1337                                 enc->frame_size = fs_tmp;
1338                             }
1339                             if(ret <= 0) {
1340                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1341                             }
1342                             audio_size += ret;
1343                             pkt.flags |= PKT_FLAG_KEY;
1344                             break;
1345                         case CODEC_TYPE_VIDEO:
1346                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1347                             video_size += ret;
1348                             if(enc->coded_frame && enc->coded_frame->key_frame)
1349                                 pkt.flags |= PKT_FLAG_KEY;
1350                             if (ost->logfile && enc->stats_out) {
1351                                 fprintf(ost->logfile, "%s", enc->stats_out);
1352                             }
1353                             break;
1354                         default:
1355                             ret=-1;
1356                         }
1357
1358                         if(ret<=0)
1359                             break;
1360                         pkt.data= bit_buffer;
1361                         pkt.size= ret;
1362                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1363                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1364                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1365                     }
1366                 }
1367             }
1368         }
1369     }
1370
1371     return 0;
1372  fail_decode:
1373     return -1;
1374 }
1375
1376 static void print_sdp(AVFormatContext **avc, int n)
1377 {
1378     char sdp[2048];
1379
1380     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1381     printf("SDP:\n%s\n", sdp);
1382 }
1383
1384 static int stream_index_from_inputs(AVFormatContext **input_files,
1385                                     int nb_input_files,
1386                                     AVInputFile *file_table,
1387                                     AVInputStream **ist_table,
1388                                     enum CodecType type,
1389                                     int programid)
1390 {
1391     int p, q, z;
1392     for(z=0; z<nb_input_files; z++) {
1393         AVFormatContext *ic = input_files[z];
1394         for(p=0; p<ic->nb_programs; p++) {
1395             AVProgram *program = ic->programs[p];
1396             if(program->id != programid)
1397                 continue;
1398             for(q=0; q<program->nb_stream_indexes; q++) {
1399                 int sidx = program->stream_index[q];
1400                 int ris = file_table[z].ist_index + sidx;
1401                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1402                     return ris;
1403             }
1404         }
1405     }
1406
1407     return -1;
1408 }
1409
1410 /*
1411  * The following code is the main loop of the file converter
1412  */
1413 static int av_encode(AVFormatContext **output_files,
1414                      int nb_output_files,
1415                      AVFormatContext **input_files,
1416                      int nb_input_files,
1417                      AVStreamMap *stream_maps, int nb_stream_maps)
1418 {
1419     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1420     AVFormatContext *is, *os;
1421     AVCodecContext *codec, *icodec;
1422     AVOutputStream *ost, **ost_table = NULL;
1423     AVInputStream *ist, **ist_table = NULL;
1424     AVInputFile *file_table;
1425     int key;
1426     int want_sdp = 1;
1427
1428     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1429     if (!file_table)
1430         goto fail;
1431
1432     /* input stream init */
1433     j = 0;
1434     for(i=0;i<nb_input_files;i++) {
1435         is = input_files[i];
1436         file_table[i].ist_index = j;
1437         file_table[i].nb_streams = is->nb_streams;
1438         j += is->nb_streams;
1439     }
1440     nb_istreams = j;
1441
1442     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1443     if (!ist_table)
1444         goto fail;
1445
1446     for(i=0;i<nb_istreams;i++) {
1447         ist = av_mallocz(sizeof(AVInputStream));
1448         if (!ist)
1449             goto fail;
1450         ist_table[i] = ist;
1451     }
1452     j = 0;
1453     for(i=0;i<nb_input_files;i++) {
1454         is = input_files[i];
1455         for(k=0;k<is->nb_streams;k++) {
1456             ist = ist_table[j++];
1457             ist->st = is->streams[k];
1458             ist->file_index = i;
1459             ist->index = k;
1460             ist->discard = 1; /* the stream is discarded by default
1461                                  (changed later) */
1462
1463             if (ist->st->codec->rate_emu) {
1464                 ist->start = av_gettime();
1465                 ist->frame = 0;
1466             }
1467         }
1468     }
1469
1470     /* output stream init */
1471     nb_ostreams = 0;
1472     for(i=0;i<nb_output_files;i++) {
1473         os = output_files[i];
1474         if (!os->nb_streams) {
1475             fprintf(stderr, "Output file does not contain any stream\n");
1476             exit(1);
1477         }
1478         nb_ostreams += os->nb_streams;
1479     }
1480     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1481         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1482         exit(1);
1483     }
1484
1485     /* Sanity check the mapping args -- do the input files & streams exist? */
1486     for(i=0;i<nb_stream_maps;i++) {
1487         int fi = stream_maps[i].file_index;
1488         int si = stream_maps[i].stream_index;
1489
1490         if (fi < 0 || fi > nb_input_files - 1 ||
1491             si < 0 || si > file_table[fi].nb_streams - 1) {
1492             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1493             exit(1);
1494         }
1495         fi = stream_maps[i].sync_file_index;
1496         si = stream_maps[i].sync_stream_index;
1497         if (fi < 0 || fi > nb_input_files - 1 ||
1498             si < 0 || si > file_table[fi].nb_streams - 1) {
1499             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1500             exit(1);
1501         }
1502     }
1503
1504     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1505     if (!ost_table)
1506         goto fail;
1507     for(i=0;i<nb_ostreams;i++) {
1508         ost = av_mallocz(sizeof(AVOutputStream));
1509         if (!ost)
1510             goto fail;
1511         ost_table[i] = ost;
1512     }
1513
1514     n = 0;
1515     for(k=0;k<nb_output_files;k++) {
1516         os = output_files[k];
1517         for(i=0;i<os->nb_streams;i++) {
1518             int found;
1519             ost = ost_table[n++];
1520             ost->file_index = k;
1521             ost->index = i;
1522             ost->st = os->streams[i];
1523             if (nb_stream_maps > 0) {
1524                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1525                     stream_maps[n-1].stream_index;
1526
1527                 /* Sanity check that the stream types match */
1528                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1529                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1530                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1531                         ost->file_index, ost->index);
1532                     exit(1);
1533                 }
1534
1535             } else {
1536                 if(opt_programid) {
1537                     found = 0;
1538                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1539                     if(j != -1) {
1540                         ost->source_index = j;
1541                         found = 1;
1542                     }
1543                 } else {
1544                     /* get corresponding input stream index : we select the first one with the right type */
1545                     found = 0;
1546                     for(j=0;j<nb_istreams;j++) {
1547                         ist = ist_table[j];
1548                         if (ist->discard &&
1549                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1550                             ost->source_index = j;
1551                             found = 1;
1552                             break;
1553                         }
1554                     }
1555                 }
1556
1557                 if (!found) {
1558                     if(! opt_programid) {
1559                         /* try again and reuse existing stream */
1560                         for(j=0;j<nb_istreams;j++) {
1561                             ist = ist_table[j];
1562                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1563                                 ost->source_index = j;
1564                                 found = 1;
1565                             }
1566                         }
1567                     }
1568                     if (!found) {
1569                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1570                                 ost->file_index, ost->index);
1571                         exit(1);
1572                     }
1573                 }
1574             }
1575             ist = ist_table[ost->source_index];
1576             ist->discard = 0;
1577             ost->sync_ist = (nb_stream_maps > 0) ?
1578                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1579                          stream_maps[n-1].sync_stream_index] : ist;
1580         }
1581     }
1582
1583     /* for each output stream, we compute the right encoding parameters */
1584     for(i=0;i<nb_ostreams;i++) {
1585         ost = ost_table[i];
1586         os = output_files[ost->file_index];
1587         ist = ist_table[ost->source_index];
1588
1589         codec = ost->st->codec;
1590         icodec = ist->st->codec;
1591
1592         if (!ost->st->language[0])
1593             av_strlcpy(ost->st->language, ist->st->language,
1594                        sizeof(ost->st->language));
1595
1596         if (ost->st->stream_copy) {
1597             /* if stream_copy is selected, no need to decode or encode */
1598             codec->codec_id = icodec->codec_id;
1599             codec->codec_type = icodec->codec_type;
1600
1601             if(!codec->codec_tag){
1602                 if(   !os->oformat->codec_tag
1603                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1604                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1605                     codec->codec_tag = icodec->codec_tag;
1606             }
1607
1608             codec->bit_rate = icodec->bit_rate;
1609             codec->extradata= icodec->extradata;
1610             codec->extradata_size= icodec->extradata_size;
1611             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1612                 codec->time_base = icodec->time_base;
1613             else
1614                 codec->time_base = ist->st->time_base;
1615             switch(codec->codec_type) {
1616             case CODEC_TYPE_AUDIO:
1617                 codec->sample_rate = icodec->sample_rate;
1618                 codec->channels = icodec->channels;
1619                 codec->frame_size = icodec->frame_size;
1620                 codec->block_align= icodec->block_align;
1621                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1622                     codec->block_align= 0;
1623                 break;
1624             case CODEC_TYPE_VIDEO:
1625                 if(using_vhook) {
1626                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1627                     exit(1);
1628                 }
1629                 codec->pix_fmt = icodec->pix_fmt;
1630                 codec->width = icodec->width;
1631                 codec->height = icodec->height;
1632                 codec->has_b_frames = icodec->has_b_frames;
1633                 break;
1634             case CODEC_TYPE_SUBTITLE:
1635                 break;
1636             default:
1637                 abort();
1638             }
1639         } else {
1640             switch(codec->codec_type) {
1641             case CODEC_TYPE_AUDIO:
1642                 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1643                     goto fail;
1644                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1645                 icodec->request_channels = codec->channels;
1646                 ist->decoding_needed = 1;
1647                 ost->encoding_needed = 1;
1648                 break;
1649             case CODEC_TYPE_VIDEO:
1650                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1651                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1652                 ost->video_resample = ((codec->width != icodec->width -
1653                                 (frame_leftBand + frame_rightBand) +
1654                                 (frame_padleft + frame_padright)) ||
1655                         (codec->height != icodec->height -
1656                                 (frame_topBand  + frame_bottomBand) +
1657                                 (frame_padtop + frame_padbottom)) ||
1658                         (codec->pix_fmt != icodec->pix_fmt));
1659                 if (ost->video_crop) {
1660                     ost->topBand = frame_topBand;
1661                     ost->leftBand = frame_leftBand;
1662                 }
1663                 if (ost->video_pad) {
1664                     ost->padtop = frame_padtop;
1665                     ost->padleft = frame_padleft;
1666                     ost->padbottom = frame_padbottom;
1667                     ost->padright = frame_padright;
1668                     if (!ost->video_resample) {
1669                         avcodec_get_frame_defaults(&ost->pict_tmp);
1670                         if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1671                                          codec->width, codec->height ) )
1672                             goto fail;
1673                     }
1674                 }
1675                 if (ost->video_resample) {
1676                     avcodec_get_frame_defaults(&ost->pict_tmp);
1677                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1678                                          codec->width, codec->height ) ) {
1679                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1680                         exit(1);
1681                     }
1682                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1683                     ost->img_resample_ctx = sws_getContext(
1684                             icodec->width - (frame_leftBand + frame_rightBand),
1685                             icodec->height - (frame_topBand + frame_bottomBand),
1686                             icodec->pix_fmt,
1687                             codec->width - (frame_padleft + frame_padright),
1688                             codec->height - (frame_padtop + frame_padbottom),
1689                             codec->pix_fmt,
1690                             sws_flags, NULL, NULL, NULL);
1691                     if (ost->img_resample_ctx == NULL) {
1692                         fprintf(stderr, "Cannot get resampling context\n");
1693                         exit(1);
1694                     }
1695                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1696                 }
1697                 ost->encoding_needed = 1;
1698                 ist->decoding_needed = 1;
1699                 break;
1700             case CODEC_TYPE_SUBTITLE:
1701                 ost->encoding_needed = 1;
1702                 ist->decoding_needed = 1;
1703                 break;
1704             default:
1705                 abort();
1706                 break;
1707             }
1708             /* two pass mode */
1709             if (ost->encoding_needed &&
1710                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1711                 char logfilename[1024];
1712                 FILE *f;
1713                 int size;
1714                 char *logbuffer;
1715
1716                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1717                          pass_logfilename ?
1718                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1719                 if (codec->flags & CODEC_FLAG_PASS1) {
1720                     f = fopen(logfilename, "w");
1721                     if (!f) {
1722                         perror(logfilename);
1723                         exit(1);
1724                     }
1725                     ost->logfile = f;
1726                 } else {
1727                     /* read the log file */
1728                     f = fopen(logfilename, "r");
1729                     if (!f) {
1730                         perror(logfilename);
1731                         exit(1);
1732                     }
1733                     fseek(f, 0, SEEK_END);
1734                     size = ftell(f);
1735                     fseek(f, 0, SEEK_SET);
1736                     logbuffer = av_malloc(size + 1);
1737                     if (!logbuffer) {
1738                         fprintf(stderr, "Could not allocate log buffer\n");
1739                         exit(1);
1740                     }
1741                     size = fread(logbuffer, 1, size, f);
1742                     fclose(f);
1743                     logbuffer[size] = '\0';
1744                     codec->stats_in = logbuffer;
1745                 }
1746             }
1747         }
1748         if(codec->codec_type == CODEC_TYPE_VIDEO){
1749             int size= codec->width * codec->height;
1750             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1751         }
1752     }
1753
1754     if (!bit_buffer)
1755         bit_buffer = av_malloc(bit_buffer_size);
1756     if (!bit_buffer)
1757         goto fail;
1758
1759     /* dump the file output parameters - cannot be done before in case
1760        of stream copy */
1761     for(i=0;i<nb_output_files;i++) {
1762         dump_format(output_files[i], i, output_files[i]->filename, 1);
1763     }
1764
1765     /* dump the stream mapping */
1766     if (verbose >= 0) {
1767         fprintf(stderr, "Stream mapping:\n");
1768         for(i=0;i<nb_ostreams;i++) {
1769             ost = ost_table[i];
1770             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1771                     ist_table[ost->source_index]->file_index,
1772                     ist_table[ost->source_index]->index,
1773                     ost->file_index,
1774                     ost->index);
1775             if (ost->sync_ist != ist_table[ost->source_index])
1776                 fprintf(stderr, " [sync #%d.%d]",
1777                         ost->sync_ist->file_index,
1778                         ost->sync_ist->index);
1779             fprintf(stderr, "\n");
1780         }
1781     }
1782
1783     /* open each encoder */
1784     for(i=0;i<nb_ostreams;i++) {
1785         ost = ost_table[i];
1786         if (ost->encoding_needed) {
1787             AVCodec *codec;
1788             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1789             if (!codec) {
1790                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1791                         ost->file_index, ost->index);
1792                 exit(1);
1793             }
1794             if (avcodec_open(ost->st->codec, codec) < 0) {
1795                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1796                         ost->file_index, ost->index);
1797                 exit(1);
1798             }
1799             extra_size += ost->st->codec->extradata_size;
1800         }
1801     }
1802
1803     /* open each decoder */
1804     for(i=0;i<nb_istreams;i++) {
1805         ist = ist_table[i];
1806         if (ist->decoding_needed) {
1807             AVCodec *codec;
1808             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1809             if (!codec) {
1810                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1811                         ist->st->codec->codec_id, ist->file_index, ist->index);
1812                 exit(1);
1813             }
1814             if (avcodec_open(ist->st->codec, codec) < 0) {
1815                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1816                         ist->file_index, ist->index);
1817                 exit(1);
1818             }
1819             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1820             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1821         }
1822     }
1823
1824     /* init pts */
1825     for(i=0;i<nb_istreams;i++) {
1826         ist = ist_table[i];
1827         is = input_files[ist->file_index];
1828         ist->pts = 0;
1829         ist->next_pts=0;
1830         if(   input_files_ts_offset[ist->file_index] != -is->start_time
1831            && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==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(atoi(arg));
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 }