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

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