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