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