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

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