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