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

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