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