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