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

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