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