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 defined(HAVE_THREADS)
2569         if(thread_count>1)
2570             avcodec_thread_init(enc, thread_count);
2571 #endif
2572         enc->thread_count= thread_count;
2573         switch(enc->codec_type) {
2574         case CODEC_TYPE_AUDIO:
2575             for(j=0; j<opt_name_count; j++){
2576                 const AVOption *opt;
2577                 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2578                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2579                     av_set_double(enc, opt_names[j], d);
2580             }
2581             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2582             audio_channels = enc->channels;
2583             audio_sample_rate = enc->sample_rate;
2584             if(audio_disable)
2585                 ic->streams[i]->discard= AVDISCARD_ALL;
2586             break;
2587         case CODEC_TYPE_VIDEO:
2588             for(j=0; j<opt_name_count; j++){
2589                 const AVOption *opt;
2590                 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2591                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2592                     av_set_double(enc, opt_names[j], d);
2593             }
2594             frame_height = enc->height;
2595             frame_width = enc->width;
2596             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2597             frame_pix_fmt = enc->pix_fmt;
2598             rfps      = ic->streams[i]->r_frame_rate.num;
2599             rfps_base = ic->streams[i]->r_frame_rate.den;
2600             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2601             if(me_threshold)
2602                 enc->debug |= FF_DEBUG_MV;
2603
2604             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2605
2606                 if (verbose >= 0)
2607                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2608                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2609
2610                     (float)rfps / rfps_base, rfps, rfps_base);
2611             }
2612             /* update the current frame rate to match the stream frame rate */
2613             frame_rate      = rfps;
2614             frame_rate_base = rfps_base;
2615
2616             enc->rate_emu = rate_emu;
2617             if(video_disable)
2618                 ic->streams[i]->discard= AVDISCARD_ALL;
2619             else if(video_discard)
2620                 ic->streams[i]->discard= video_discard;
2621             break;
2622         case CODEC_TYPE_DATA:
2623             break;
2624         case CODEC_TYPE_SUBTITLE:
2625             break;
2626         case CODEC_TYPE_UNKNOWN:
2627             break;
2628         default:
2629             av_abort();
2630         }
2631     }
2632
2633     input_files[nb_input_files] = ic;
2634     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2635     /* dump the file content */
2636     if (verbose >= 0)
2637         dump_format(ic, nb_input_files, filename, 0);
2638
2639     nb_input_files++;
2640     file_iformat = NULL;
2641     file_oformat = NULL;
2642
2643     video_channel = 0;
2644
2645     rate_emu = 0;
2646 }
2647
2648 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2649 {
2650     int has_video, has_audio, i, j;
2651     AVFormatContext *ic;
2652
2653     has_video = 0;
2654     has_audio = 0;
2655     for(j=0;j<nb_input_files;j++) {
2656         ic = input_files[j];
2657         for(i=0;i<ic->nb_streams;i++) {
2658             AVCodecContext *enc = ic->streams[i]->codec;
2659             switch(enc->codec_type) {
2660             case CODEC_TYPE_AUDIO:
2661                 has_audio = 1;
2662                 break;
2663             case CODEC_TYPE_VIDEO:
2664                 has_video = 1;
2665                 break;
2666             case CODEC_TYPE_DATA:
2667             case CODEC_TYPE_UNKNOWN:
2668             case CODEC_TYPE_SUBTITLE:
2669                 break;
2670             default:
2671                 av_abort();
2672             }
2673         }
2674     }
2675     *has_video_ptr = has_video;
2676     *has_audio_ptr = has_audio;
2677 }
2678
2679 static void new_video_stream(AVFormatContext *oc)
2680 {
2681     AVStream *st;
2682     AVCodecContext *video_enc;
2683     int codec_id;
2684
2685     st = av_new_stream(oc, oc->nb_streams);
2686     if (!st) {
2687         fprintf(stderr, "Could not alloc stream\n");
2688         exit(1);
2689     }
2690     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2691     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2692     video_bitstream_filters= NULL;
2693
2694 #if defined(HAVE_THREADS)
2695     if(thread_count>1)
2696         avcodec_thread_init(st->codec, thread_count);
2697 #endif
2698
2699     video_enc = st->codec;
2700
2701     if(video_codec_tag)
2702         video_enc->codec_tag= video_codec_tag;
2703
2704     if(   (video_global_header&1)
2705        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2706         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2707         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2708     }
2709     if(video_global_header&2){
2710         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2711         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2712     }
2713
2714     if (video_stream_copy) {
2715         st->stream_copy = 1;
2716         video_enc->codec_type = CODEC_TYPE_VIDEO;
2717     } else {
2718         char *p;
2719         int i;
2720         AVCodec *codec;
2721
2722         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2723         if (video_codec_id != CODEC_ID_NONE)
2724             codec_id = video_codec_id;
2725
2726         video_enc->codec_id = codec_id;
2727         codec = avcodec_find_encoder(codec_id);
2728
2729         for(i=0; i<opt_name_count; i++){
2730              const AVOption *opt;
2731              double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2732              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2733                  av_set_double(video_enc, opt_names[i], d);
2734         }
2735
2736         video_enc->time_base.den = frame_rate;
2737         video_enc->time_base.num = frame_rate_base;
2738         if(codec && codec->supported_framerates){
2739             const AVRational *p= codec->supported_framerates;
2740             AVRational req= (AVRational){frame_rate, frame_rate_base};
2741             const AVRational *best=NULL;
2742             AVRational best_error= (AVRational){INT_MAX, 1};
2743             for(; p->den!=0; p++){
2744                 AVRational error= av_sub_q(req, *p);
2745                 if(error.num <0) error.num *= -1;
2746                 if(av_cmp_q(error, best_error) < 0){
2747                     best_error= error;
2748                     best= p;
2749                 }
2750             }
2751             video_enc->time_base.den= best->num;
2752             video_enc->time_base.num= best->den;
2753         }
2754
2755         video_enc->width = frame_width + frame_padright + frame_padleft;
2756         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2757         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2758         video_enc->pix_fmt = frame_pix_fmt;
2759
2760         if(codec && codec->pix_fmts){
2761             const enum PixelFormat *p= codec->pix_fmts;
2762             for(; *p!=-1; p++){
2763                 if(*p == video_enc->pix_fmt)
2764                     break;
2765             }
2766             if(*p == -1)
2767                 video_enc->pix_fmt = codec->pix_fmts[0];
2768         }
2769
2770         if (intra_only)
2771             video_enc->gop_size = 0;
2772         if (video_qscale || same_quality) {
2773             video_enc->flags |= CODEC_FLAG_QSCALE;
2774             video_enc->global_quality=
2775                 st->quality = FF_QP2LAMBDA * video_qscale;
2776         }
2777
2778         if(intra_matrix)
2779             video_enc->intra_matrix = intra_matrix;
2780         if(inter_matrix)
2781             video_enc->inter_matrix = inter_matrix;
2782
2783         video_enc->max_qdiff = video_qdiff;
2784         video_enc->rc_eq = video_rc_eq;
2785         video_enc->thread_count = thread_count;
2786         p= video_rc_override_string;
2787         for(i=0; p; i++){
2788             int start, end, q;
2789             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2790             if(e!=3){
2791                 fprintf(stderr, "error parsing rc_override\n");
2792                 exit(1);
2793             }
2794             video_enc->rc_override=
2795                 av_realloc(video_enc->rc_override,
2796                            sizeof(RcOverride)*(i+1));
2797             video_enc->rc_override[i].start_frame= start;
2798             video_enc->rc_override[i].end_frame  = end;
2799             if(q>0){
2800                 video_enc->rc_override[i].qscale= q;
2801                 video_enc->rc_override[i].quality_factor= 1.0;
2802             }
2803             else{
2804                 video_enc->rc_override[i].qscale= 0;
2805                 video_enc->rc_override[i].quality_factor= -q/100.0;
2806             }
2807             p= strchr(p, '/');
2808             if(p) p++;
2809         }
2810         video_enc->rc_override_count=i;
2811         if (!video_enc->rc_initial_buffer_occupancy)
2812             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2813         video_enc->me_threshold= me_threshold;
2814         video_enc->intra_dc_precision= intra_dc_precision - 8;
2815         video_enc->strict_std_compliance = strict;
2816
2817         if (do_psnr)
2818             video_enc->flags|= CODEC_FLAG_PSNR;
2819
2820         video_enc->me_method = me_method;
2821
2822         /* two pass mode */
2823         if (do_pass) {
2824             if (do_pass == 1) {
2825                 video_enc->flags |= CODEC_FLAG_PASS1;
2826             } else {
2827                 video_enc->flags |= CODEC_FLAG_PASS2;
2828             }
2829         }
2830     }
2831
2832     /* reset some key parameters */
2833     video_disable = 0;
2834     video_codec_id = CODEC_ID_NONE;
2835     video_stream_copy = 0;
2836 }
2837
2838 static void new_audio_stream(AVFormatContext *oc)
2839 {
2840     AVStream *st;
2841     AVCodecContext *audio_enc;
2842     int codec_id, i;
2843
2844     st = av_new_stream(oc, oc->nb_streams);
2845     if (!st) {
2846         fprintf(stderr, "Could not alloc stream\n");
2847         exit(1);
2848     }
2849     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2850
2851     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2852     audio_bitstream_filters= NULL;
2853
2854 #if defined(HAVE_THREADS)
2855     if(thread_count>1)
2856         avcodec_thread_init(st->codec, thread_count);
2857 #endif
2858
2859     audio_enc = st->codec;
2860     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2861     audio_enc->strict_std_compliance = strict;
2862
2863     if(audio_codec_tag)
2864         audio_enc->codec_tag= audio_codec_tag;
2865
2866     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2867         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2868         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2869     }
2870     if (audio_stream_copy) {
2871         st->stream_copy = 1;
2872         audio_enc->channels = audio_channels;
2873     } else {
2874         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2875
2876         for(i=0; i<opt_name_count; i++){
2877             const AVOption *opt;
2878             double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2879             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2880                 av_set_double(audio_enc, opt_names[i], d);
2881         }
2882
2883         if (audio_codec_id != CODEC_ID_NONE)
2884             codec_id = audio_codec_id;
2885         audio_enc->codec_id = codec_id;
2886
2887         if (audio_qscale > QSCALE_NONE) {
2888             audio_enc->flags |= CODEC_FLAG_QSCALE;
2889             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2890         }
2891         audio_enc->thread_count = thread_count;
2892         audio_enc->channels = audio_channels;
2893     }
2894     audio_enc->sample_rate = audio_sample_rate;
2895     audio_enc->time_base= (AVRational){1, audio_sample_rate};
2896     if (audio_language) {
2897         pstrcpy(st->language, sizeof(st->language), audio_language);
2898         av_free(audio_language);
2899         audio_language = NULL;
2900     }
2901
2902     /* reset some key parameters */
2903     audio_disable = 0;
2904     audio_codec_id = CODEC_ID_NONE;
2905     audio_stream_copy = 0;
2906 }
2907
2908 static void opt_new_subtitle_stream(void)
2909 {
2910     AVFormatContext *oc;
2911     AVStream *st;
2912     AVCodecContext *subtitle_enc;
2913     int i;
2914
2915     if (nb_output_files <= 0) {
2916         fprintf(stderr, "At least one output file must be specified\n");
2917         exit(1);
2918     }
2919     oc = output_files[nb_output_files - 1];
2920
2921     st = av_new_stream(oc, oc->nb_streams);
2922     if (!st) {
2923         fprintf(stderr, "Could not alloc stream\n");
2924         exit(1);
2925     }
2926     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2927
2928     subtitle_enc = st->codec;
2929     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2930     if (subtitle_stream_copy) {
2931         st->stream_copy = 1;
2932     } else {
2933         for(i=0; i<opt_name_count; i++){
2934              const AVOption *opt;
2935              double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2936              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2937                  av_set_double(subtitle_enc, opt_names[i], d);
2938         }
2939         subtitle_enc->codec_id = subtitle_codec_id;
2940     }
2941
2942     if (subtitle_language) {
2943         pstrcpy(st->language, sizeof(st->language), subtitle_language);
2944         av_free(subtitle_language);
2945         subtitle_language = NULL;
2946     }
2947
2948     subtitle_codec_id = CODEC_ID_NONE;
2949     subtitle_stream_copy = 0;
2950 }
2951
2952 static void opt_new_audio_stream(void)
2953 {
2954     AVFormatContext *oc;
2955     if (nb_output_files <= 0) {
2956         fprintf(stderr, "At least one output file must be specified\n");
2957         exit(1);
2958     }
2959     oc = output_files[nb_output_files - 1];
2960     new_audio_stream(oc);
2961 }
2962
2963 static void opt_new_video_stream(void)
2964 {
2965     AVFormatContext *oc;
2966     if (nb_output_files <= 0) {
2967         fprintf(stderr, "At least one output file must be specified\n");
2968         exit(1);
2969     }
2970     oc = output_files[nb_output_files - 1];
2971     new_video_stream(oc);
2972 }
2973
2974 static void opt_output_file(const char *filename)
2975 {
2976     AVFormatContext *oc;
2977     int use_video, use_audio, input_has_video, input_has_audio, i;
2978     AVFormatParameters params, *ap = &params;
2979
2980     if (!strcmp(filename, "-"))
2981         filename = "pipe:";
2982
2983     oc = av_alloc_format_context();
2984
2985     if (!file_oformat) {
2986         file_oformat = guess_format(NULL, filename, NULL);
2987         if (!file_oformat) {
2988             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2989                     filename);
2990             exit(1);
2991         }
2992     }
2993
2994     oc->oformat = file_oformat;
2995     pstrcpy(oc->filename, sizeof(oc->filename), filename);
2996
2997     if (!strcmp(file_oformat->name, "ffm") &&
2998         strstart(filename, "http:", NULL)) {
2999         /* special case for files sent to ffserver: we get the stream
3000            parameters from ffserver */
3001         if (read_ffserver_streams(oc, filename) < 0) {
3002             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3003             exit(1);
3004         }
3005     } else {
3006         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3007         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3008
3009         /* disable if no corresponding type found and at least one
3010            input file */
3011         if (nb_input_files > 0) {
3012             check_audio_video_inputs(&input_has_video, &input_has_audio);
3013             if (!input_has_video)
3014                 use_video = 0;
3015             if (!input_has_audio)
3016                 use_audio = 0;
3017         }
3018
3019         /* manual disable */
3020         if (audio_disable) {
3021             use_audio = 0;
3022         }
3023         if (video_disable) {
3024             use_video = 0;
3025         }
3026
3027         if (use_video) {
3028             new_video_stream(oc);
3029         }
3030
3031         if (use_audio) {
3032             new_audio_stream(oc);
3033         }
3034
3035         oc->timestamp = rec_timestamp;
3036
3037         if (str_title)
3038             pstrcpy(oc->title, sizeof(oc->title), str_title);
3039         if (str_author)
3040             pstrcpy(oc->author, sizeof(oc->author), str_author);
3041         if (str_copyright)
3042             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3043         if (str_comment)
3044             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3045         if (str_album)
3046             pstrcpy(oc->album, sizeof(oc->album), str_album);
3047     }
3048
3049     output_files[nb_output_files++] = oc;
3050
3051     /* check filename in case of an image number is expected */
3052     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3053         if (!av_filename_number_test(oc->filename)) {
3054             print_error(oc->filename, AVERROR_NUMEXPECTED);
3055             exit(1);
3056         }
3057     }
3058
3059     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3060         /* test if it already exists to avoid loosing precious files */
3061         if (!file_overwrite &&
3062             (strchr(filename, ':') == NULL ||
3063              strstart(filename, "file:", NULL))) {
3064             if (url_exist(filename)) {
3065                 int c;
3066
3067                 if ( !using_stdin ) {
3068                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3069                     fflush(stderr);
3070                     c = getchar();
3071                     if (toupper(c) != 'Y') {
3072                         fprintf(stderr, "Not overwriting - exiting\n");
3073                         exit(1);
3074                     }
3075                                 }
3076                                 else {
3077                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3078                     exit(1);
3079                                 }
3080             }
3081         }
3082
3083         /* open the file */
3084         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3085             fprintf(stderr, "Could not open '%s'\n", filename);
3086             exit(1);
3087         }
3088     }
3089
3090     memset(ap, 0, sizeof(*ap));
3091     if (av_set_parameters(oc, ap) < 0) {
3092         fprintf(stderr, "%s: Invalid encoding parameters\n",
3093                 oc->filename);
3094         exit(1);
3095     }
3096
3097     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3098     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3099     oc->loop_output = loop_output;
3100
3101     for(i=0; i<opt_name_count; i++){
3102         const AVOption *opt;
3103         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3104         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3105             av_set_double(oc, opt_names[i], d);
3106     }
3107
3108     /* reset some options */
3109     file_oformat = NULL;
3110     file_iformat = NULL;
3111 }
3112
3113 /* same option as mencoder */
3114 static void opt_pass(const char *pass_str)
3115 {
3116     int pass;
3117     pass = atoi(pass_str);
3118     if (pass != 1 && pass != 2) {
3119         fprintf(stderr, "pass number can be only 1 or 2\n");
3120         exit(1);
3121     }
3122     do_pass = pass;
3123 }
3124
3125 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3126 static int64_t getutime(void)
3127 {
3128   return av_gettime();
3129 }
3130 #else
3131 static int64_t getutime(void)
3132 {
3133     struct rusage rusage;
3134
3135     getrusage(RUSAGE_SELF, &rusage);
3136     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3137 }
3138 #endif
3139
3140 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3141 extern int ffm_nopts;
3142 #endif
3143
3144 static void show_formats(void)
3145 {
3146     AVInputFormat *ifmt;
3147     AVOutputFormat *ofmt;
3148     URLProtocol *up;
3149     AVCodec *p, *p2;
3150     const char **pp, *last_name;
3151
3152     printf("File formats:\n");
3153     last_name= "000";
3154     for(;;){
3155         int decode=0;
3156         int encode=0;
3157         const char *name=NULL;
3158         const char *long_name=NULL;
3159
3160         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3161             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3162                 strcmp(ofmt->name, last_name)>0){
3163                 name= ofmt->name;
3164                 long_name= ofmt->long_name;
3165                 encode=1;
3166             }
3167         }
3168         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3169             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3170                 strcmp(ifmt->name, last_name)>0){
3171                 name= ifmt->name;
3172                 long_name= ifmt->long_name;
3173                 encode=0;
3174             }
3175             if(name && strcmp(ifmt->name, name)==0)
3176                 decode=1;
3177         }
3178         if(name==NULL)
3179             break;
3180         last_name= name;
3181
3182         printf(
3183             " %s%s %-15s %s\n",
3184             decode ? "D":" ",
3185             encode ? "E":" ",
3186             name,
3187             long_name ? long_name:" ");
3188     }
3189     printf("\n");
3190
3191     printf("Codecs:\n");
3192     last_name= "000";
3193     for(;;){
3194         int decode=0;
3195         int encode=0;
3196         int cap=0;
3197         const char *type_str;
3198
3199         p2=NULL;
3200         for(p = first_avcodec; p != NULL; p = p->next) {
3201             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3202                 strcmp(p->name, last_name)>0){
3203                 p2= p;
3204                 decode= encode= cap=0;
3205             }
3206             if(p2 && strcmp(p->name, p2->name)==0){
3207                 if(p->decode) decode=1;
3208                 if(p->encode) encode=1;
3209                 cap |= p->capabilities;
3210             }
3211         }
3212         if(p2==NULL)
3213             break;
3214         last_name= p2->name;
3215
3216         switch(p2->type) {
3217         case CODEC_TYPE_VIDEO:
3218             type_str = "V";
3219             break;
3220         case CODEC_TYPE_AUDIO:
3221             type_str = "A";
3222             break;
3223         case CODEC_TYPE_SUBTITLE:
3224             type_str = "S";
3225             break;
3226         default:
3227             type_str = "?";
3228             break;
3229         }
3230         printf(
3231             " %s%s%s%s%s%s %s",
3232             decode ? "D": (/*p2->decoder ? "d":*/" "),
3233             encode ? "E":" ",
3234             type_str,
3235             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3236             cap & CODEC_CAP_DR1 ? "D":" ",
3237             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3238             p2->name);
3239        /* if(p2->decoder && decode==0)
3240             printf(" use %s for decoding", p2->decoder->name);*/
3241         printf("\n");
3242     }
3243     printf("\n");
3244
3245     printf("Supported file protocols:\n");
3246     for(up = first_protocol; up != NULL; up = up->next)
3247         printf(" %s:", up->name);
3248     printf("\n");
3249
3250     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3251     printf("Motion estimation methods:\n");
3252     pp = motion_str;
3253     while (*pp) {
3254         printf(" %s", *pp);
3255         if ((pp - motion_str + 1) == ME_ZERO)
3256             printf("(fastest)");
3257         else if ((pp - motion_str + 1) == ME_FULL)
3258             printf("(slowest)");
3259         else if ((pp - motion_str + 1) == ME_EPZS)
3260             printf("(default)");
3261         pp++;
3262     }
3263     printf("\n\n");
3264     printf(
3265 "Note, the names of encoders and decoders dont always match, so there are\n"
3266 "several cases where the above table shows encoder only or decoder only entries\n"
3267 "even though both encoding and decoding are supported for example, the h263\n"
3268 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3269 "worse\n");
3270     exit(1);
3271 }
3272
3273 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3274 {
3275     int i;
3276     const char *p = str;
3277     for(i = 0;; i++) {
3278         dest[i] = atoi(p);
3279         if(i == 63)
3280             break;
3281         p = strchr(p, ',');
3282         if(!p) {
3283             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3284             exit(1);
3285         }
3286         p++;
3287     }
3288 }
3289
3290 static void opt_inter_matrix(const char *arg)
3291 {
3292     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3293     parse_matrix_coeffs(inter_matrix, arg);
3294 }
3295
3296 static void opt_intra_matrix(const char *arg)
3297 {
3298     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3299     parse_matrix_coeffs(intra_matrix, arg);
3300 }
3301
3302 static void opt_target(const char *arg)
3303 {
3304     int norm = -1;
3305     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3306
3307     if(!strncmp(arg, "pal-", 4)) {
3308         norm = 0;
3309         arg += 4;
3310     } else if(!strncmp(arg, "ntsc-", 5)) {
3311         norm = 1;
3312         arg += 5;
3313     } else if(!strncmp(arg, "film-", 5)) {
3314         norm = 2;
3315         arg += 5;
3316     } else {
3317         int fr;
3318         /* Calculate FR via float to avoid int overflow */
3319         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3320         if(fr == 25000) {
3321             norm = 0;
3322         } else if((fr == 29970) || (fr == 23976)) {
3323             norm = 1;
3324         } else {
3325             /* Try to determine PAL/NTSC by peeking in the input files */
3326             if(nb_input_files) {
3327                 int i, j;
3328                 for(j = 0; j < nb_input_files; j++) {
3329                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3330                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3331                         if(c->codec_type != CODEC_TYPE_VIDEO)
3332                             continue;
3333                         fr = c->time_base.den * 1000 / c->time_base.num;
3334                         if(fr == 25000) {
3335                             norm = 0;
3336                             break;
3337                         } else if((fr == 29970) || (fr == 23976)) {
3338                             norm = 1;
3339                             break;
3340                         }
3341                     }
3342                     if(norm >= 0)
3343                         break;
3344                 }
3345             }
3346         }
3347         if(verbose && norm >= 0)
3348             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3349     }
3350
3351     if(norm < 0) {
3352         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3353         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3354         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3355         exit(1);
3356     }
3357
3358     if(!strcmp(arg, "vcd")) {
3359
3360         opt_video_codec("mpeg1video");
3361         opt_audio_codec("mp2");
3362         opt_format("vcd");
3363
3364         opt_frame_size(norm ? "352x240" : "352x288");
3365         opt_frame_rate(frame_rates[norm]);
3366         opt_default("gop", norm ? "18" : "15");
3367
3368         opt_default("b", "1150000");
3369         opt_default("maxrate", "1150000");
3370         opt_default("minrate", "1150000");
3371         opt_default("bufsize", "327680"); // 40*1024*8;
3372
3373         opt_default("ab", "224000");
3374         audio_sample_rate = 44100;
3375         audio_channels = 2;
3376
3377         opt_default("packetsize", "2324");
3378         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3379
3380         /* We have to offset the PTS, so that it is consistent with the SCR.
3381            SCR starts at 36000, but the first two packs contain only padding
3382            and the first pack from the other stream, respectively, may also have
3383            been written before.
3384            So the real data starts at SCR 36000+3*1200. */
3385         mux_preload= (36000+3*1200) / 90000.0; //0.44
3386     } else if(!strcmp(arg, "svcd")) {
3387
3388         opt_video_codec("mpeg2video");
3389         opt_audio_codec("mp2");
3390         opt_format("svcd");
3391
3392         opt_frame_size(norm ? "480x480" : "480x576");
3393         opt_frame_rate(frame_rates[norm]);
3394         opt_default("gop", norm ? "18" : "15");
3395
3396         opt_default("b", "2040000");
3397         opt_default("maxrate", "2516000");
3398         opt_default("minrate", "0"); //1145000;
3399         opt_default("bufsize", "1835008"); //224*1024*8;
3400         opt_default("flags", "+SCAN_OFFSET");
3401
3402
3403         opt_default("ab", "224000");
3404         audio_sample_rate = 44100;
3405
3406         opt_default("packetsize", "2324");
3407
3408     } else if(!strcmp(arg, "dvd")) {
3409
3410         opt_video_codec("mpeg2video");
3411         opt_audio_codec("ac3");
3412         opt_format("dvd");
3413
3414         opt_frame_size(norm ? "720x480" : "720x576");
3415         opt_frame_rate(frame_rates[norm]);
3416         opt_default("gop", norm ? "18" : "15");
3417
3418         opt_default("b", "6000000");
3419         opt_default("maxrate", "9000000");
3420         opt_default("minrate", "0"); //1500000;
3421         opt_default("bufsize", "1835008"); //224*1024*8;
3422
3423         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3424         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3425
3426         opt_default("ab", "448000");
3427         audio_sample_rate = 48000;
3428
3429     } else if(!strncmp(arg, "dv", 2)) {
3430
3431         opt_format("dv");
3432
3433         opt_frame_size(norm ? "720x480" : "720x576");
3434         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3435                                              (norm ? "yuv411p" : "yuv420p"));
3436         opt_frame_rate(frame_rates[norm]);
3437
3438         audio_sample_rate = 48000;
3439         audio_channels = 2;
3440
3441     } else {
3442         fprintf(stderr, "Unknown target: %s\n", arg);
3443         exit(1);
3444     }
3445 }
3446
3447 static void opt_video_bsf(const char *arg)
3448 {
3449     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3450     AVBitStreamFilterContext **bsfp;
3451
3452     if(!bsfc){
3453         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3454         exit(1);
3455     }
3456
3457     bsfp= &video_bitstream_filters;
3458     while(*bsfp)
3459         bsfp= &(*bsfp)->next;
3460
3461     *bsfp= bsfc;
3462 }
3463
3464 //FIXME avoid audio - video code duplication
3465 static void opt_audio_bsf(const char *arg)
3466 {
3467     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3468     AVBitStreamFilterContext **bsfp;
3469
3470     if(!bsfc){
3471         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3472         exit(1);
3473     }
3474
3475     bsfp= &audio_bitstream_filters;
3476     while(*bsfp)
3477         bsfp= &(*bsfp)->next;
3478
3479     *bsfp= bsfc;
3480 }
3481
3482 static void show_version(void)
3483 {
3484     /* TODO: add function interface to avutil and avformat */
3485     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3486            "libavutil   %d\n"
3487            "libavcodec  %d\n"
3488            "libavformat %d\n",
3489            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3490     exit(1);
3491 }
3492
3493 static int opt_default(const char *opt, const char *arg){
3494     int type;
3495     const AVOption *o= NULL;
3496     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3497
3498     for(type=0; type<CODEC_TYPE_NB; type++){
3499         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3500         if(o2)
3501             o = av_set_string(avctx_opts[type], opt, arg);
3502     }
3503     if(!o)
3504         o = av_set_string(avformat_opts, opt, arg);
3505     if(!o){
3506         if(opt[0] == 'a')
3507             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3508         else if(opt[0] == 'v')
3509             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3510         else if(opt[0] == 's')
3511             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3512     }
3513     if(!o)
3514         return -1;
3515
3516 //    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));
3517
3518     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3519     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3520     opt_names[opt_name_count++]= o->name;
3521
3522 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3523     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3524     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3525         ffm_nopts = 1;
3526 #endif
3527
3528     if(avctx_opts[0]->debug)
3529         av_log_level = AV_LOG_DEBUG;
3530     return 0;
3531 }
3532
3533 const OptionDef options[] = {
3534     /* main options */
3535     { "L", 0, {(void*)show_license}, "show license" },
3536     { "h", 0, {(void*)show_help}, "show help" },
3537     { "version", 0, {(void*)show_version}, "show version" },
3538     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3539     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3540     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3541     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3542     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3543     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3544     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3545     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3546     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3547     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3548     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3549     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3550     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3551     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3552     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3553     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3554     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3555       "add timings for benchmarking" },
3556     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3557       "dump each input packet" },
3558     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3559       "when dumping packets, also dump the payload" },
3560     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3561     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3562     { "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)", "" },
3563     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3564     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3565     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3566     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3567     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3568     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3569     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3570     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3571     { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3572
3573     /* video options */
3574     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3575     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3576     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3577     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3578     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3579     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3580     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3581     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3582     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3583     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3584     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3585     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3586     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3587     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3588     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3589     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3590     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3591     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3592     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3593     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3594     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3595     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3596     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3597     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3598       "method" },
3599     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3600     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3601     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3602       "use same video quality as source (implies VBR)" },
3603     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3604     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3605     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3606       "deinterlace pictures" },
3607     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3608     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3609     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3610     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3611     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3612     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3613     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3614     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3615     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3616     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3617
3618     /* audio options */
3619     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3620     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3621     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3622     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3623     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3624     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3625     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3626     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3627     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3628     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3629
3630     /* subtitle options */
3631     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3632     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3633     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3634
3635     /* grab options */
3636     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3637     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3638     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3639
3640     /* muxer options */
3641     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3642     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3643
3644     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3645     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3646
3647     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3648     { NULL, },
3649 };
3650
3651 static void show_banner(void)
3652 {
3653     fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3654     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3655     fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3656     fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3657     fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3658     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3659 #ifdef __GNUC__
3660     fprintf(stderr, ", gcc: " __VERSION__ "\n");
3661 #else
3662     fprintf(stderr, ", using a non-gcc compiler\n");
3663 #endif
3664 }
3665
3666 static void show_license(void)
3667 {
3668     show_banner();
3669 #ifdef CONFIG_GPL
3670     printf(
3671     "FFmpeg is free software; you can redistribute it and/or modify\n"
3672     "it under the terms of the GNU General Public License as published by\n"
3673     "the Free Software Foundation; either version 2 of the License, or\n"
3674     "(at your option) any later version.\n"
3675     "\n"
3676     "FFmpeg is distributed in the hope that it will be useful,\n"
3677     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3678     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3679     "GNU General Public License for more details.\n"
3680     "\n"
3681     "You should have received a copy of the GNU General Public License\n"
3682     "along with FFmpeg; if not, write to the Free Software\n"
3683     "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3684     );
3685 #else
3686     printf(
3687     "FFmpeg is free software; you can redistribute it and/or\n"
3688     "modify it under the terms of the GNU Lesser General Public\n"
3689     "License as published by the Free Software Foundation; either\n"
3690     "version 2.1 of the License, or (at your option) any later version.\n"
3691     "\n"
3692     "FFmpeg is distributed in the hope that it will be useful,\n"
3693     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3694     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3695     "Lesser General Public License for more details.\n"
3696     "\n"
3697     "You should have received a copy of the GNU Lesser General Public\n"
3698     "License along with FFmpeg; if not, write to the Free Software\n"
3699     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3700     );
3701 #endif
3702     exit(1);
3703 }
3704
3705 static void show_help(void)
3706 {
3707     show_banner();
3708     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3709            "Hyper fast Audio and Video encoder\n");
3710     printf("\n");
3711     show_help_options(options, "Main options:\n",
3712                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3713     show_help_options(options, "\nVideo options:\n",
3714                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3715                       OPT_VIDEO);
3716     show_help_options(options, "\nAdvanced Video options:\n",
3717                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3718                       OPT_VIDEO | OPT_EXPERT);
3719     show_help_options(options, "\nAudio options:\n",
3720                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3721                       OPT_AUDIO);
3722     show_help_options(options, "\nAdvanced Audio options:\n",
3723                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3724                       OPT_AUDIO | OPT_EXPERT);
3725     show_help_options(options, "\nSubtitle options:\n",
3726                       OPT_SUBTITLE | OPT_GRAB,
3727                       OPT_SUBTITLE);
3728     show_help_options(options, "\nAudio/Video grab options:\n",
3729                       OPT_GRAB,
3730                       OPT_GRAB);
3731     show_help_options(options, "\nAdvanced options:\n",
3732                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3733                       OPT_EXPERT);
3734     av_opt_show(avctx_opts[0], NULL);
3735     av_opt_show(avformat_opts, NULL);
3736
3737     exit(1);
3738 }
3739
3740 void parse_arg_file(const char *filename)
3741 {
3742     opt_output_file(filename);
3743 }
3744
3745 int main(int argc, char **argv)
3746 {
3747     int i;
3748     int64_t ti;
3749
3750     av_register_all();
3751
3752     for(i=0; i<CODEC_TYPE_NB; i++){
3753         avctx_opts[i]= avcodec_alloc_context2(i);
3754     }
3755     avformat_opts = av_alloc_format_context();
3756
3757     if (argc <= 1)
3758         show_help();
3759     else
3760         show_banner();
3761
3762     /* parse options */
3763     parse_options(argc, argv, options);
3764
3765     /* file converter / grab */
3766     if (nb_output_files <= 0) {
3767         fprintf(stderr, "Must supply at least one output file\n");
3768         exit(1);
3769     }
3770
3771     if (nb_input_files == 0) {
3772         fprintf(stderr, "Must supply at least one input file\n");
3773         exit(1);
3774     }
3775
3776     ti = getutime();
3777     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3778               stream_maps, nb_stream_maps);
3779     ti = getutime() - ti;
3780     if (do_benchmark) {
3781         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3782     }
3783
3784     /* close files */
3785     for(i=0;i<nb_output_files;i++) {
3786         /* maybe av_close_output_file ??? */
3787         AVFormatContext *s = output_files[i];
3788         int j;
3789         if (!(s->oformat->flags & AVFMT_NOFILE))
3790             url_fclose(&s->pb);
3791         for(j=0;j<s->nb_streams;j++) {
3792             av_free(s->streams[j]->codec);
3793             av_free(s->streams[j]);
3794         }
3795         av_free(s);
3796     }
3797     for(i=0;i<nb_input_files;i++)
3798         av_close_input_file(input_files[i]);
3799
3800     av_free_static();
3801
3802     av_free(intra_matrix);
3803     av_free(inter_matrix);
3804     av_free(opt_names);
3805
3806 #ifdef CONFIG_POWERPC_PERF
3807     extern void powerpc_display_perf_report(void);
3808     powerpc_display_perf_report();
3809 #endif /* CONFIG_POWERPC_PERF */
3810
3811     if (received_sigterm) {
3812         fprintf(stderr,
3813             "Received signal %d: terminating.\n",
3814             (int) received_sigterm);
3815         exit (255);
3816     }
3817
3818     exit(0); /* not all OS-es handle main() return value */
3819     return 0;
3820 }