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