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

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