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 #define HAVE_AV_CONFIG_H
  22 #include <signal.h>
  23 #include <limits.h>
  24 #include "avformat.h"
  25 #include "swscale.h"
  26 #include "framehook.h"
  27 #include "opt.h"
  28 #include "fifo.h"
  29
  30 #ifdef __MINGW32__
  31 #include <conio.h>
  32 #else
  33 #include <unistd.h>
  34 #include <fcntl.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/time.h>
  37 #include <termios.h>
  38 #include <sys/resource.h>
  39 #endif
  40 #ifdef CONFIG_OS2
  41 #include <sys/types.h>
  42 #include <sys/select.h>
  43 #include <stdlib.h>
  44 #endif
  45 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  46 #include <time.h>
  47
  48 #include "version.h"
  49 #include "cmdutils.h"
  50
  51 #undef NDEBUG
  52 #include <assert.h>
  53
  54 #if !defined(INFINITY) && defined(HUGE_VAL)
  55 #define INFINITY HUGE_VAL
  56 #endif
  57
  58 #undef exit
  59
  60 /* select an input stream for an output stream */
  61 typedef struct AVStreamMap {
  62     int file_index;
  63     int stream_index;
  64     int sync_file_index;
  65     int sync_stream_index;
  66 } AVStreamMap;
  67
  68 /** select an input file for an output file */
  69 typedef struct AVMetaDataMap {
  70     int out_file;
  71     int in_file;
  72 } AVMetaDataMap;
  73
  74 extern const OptionDef options[];
  75
  76 static void show_help(void);
  77 static void show_license(void);
  78 static int opt_default(const char *opt, const char *arg);
  79
  80 #define MAX_FILES 20
  81
  82 static AVFormatContext *input_files[MAX_FILES];
  83 static int64_t input_files_ts_offset[MAX_FILES];
  84 static int nb_input_files = 0;
  85
  86 static AVFormatContext *output_files[MAX_FILES];
  87 static int nb_output_files = 0;
  88
  89 static AVStreamMap stream_maps[MAX_FILES];
  90 static int nb_stream_maps;
  91
  92 static AVMetaDataMap meta_data_maps[MAX_FILES];
  93 static int nb_meta_data_maps;
  94
  95 static AVInputFormat *file_iformat;
  96 static AVOutputFormat *file_oformat;
  97 static int frame_width  = 0;
  98 static int frame_height = 0;
  99 static float frame_aspect_ratio = 0;
 100 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 101 static int frame_padtop  = 0;
 102 static int frame_padbottom = 0;
 103 static int frame_padleft  = 0;
 104 static int frame_padright = 0;
 105 static int padcolor[3] = {16,128,128}; /* default to black */
 106 static int frame_topBand  = 0;
 107 static int frame_bottomBand = 0;
 108 static int frame_leftBand  = 0;
 109 static int frame_rightBand = 0;
 110 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 111 static int frame_rate = 25;
 112 static int frame_rate_base = 1;
 113 static float video_qscale = 0;
 114 static int video_qdiff = 3;
 115 static uint16_t *intra_matrix = NULL;
 116 static uint16_t *inter_matrix = NULL;
 117 #if 0 //experimental, (can be removed)
 118 static float video_rc_qsquish=1.0;
 119 static float video_rc_qmod_amp=0;
 120 static int video_rc_qmod_freq=0;
 121 #endif
 122 static char *video_rc_override_string=NULL;
 123 static char *video_rc_eq="tex^qComp";
 124 static int me_method = ME_EPZS;
 125 static int video_disable = 0;
 126 static int video_discard = 0;
 127 static int video_codec_id = CODEC_ID_NONE;
 128 static int video_codec_tag = 0;
 129 static int same_quality = 0;
 130 static int do_deinterlace = 0;
 131 static int strict = 0;
 132 static int top_field_first = -1;
 133 static int me_threshold = 0;
 134 static int intra_dc_precision = 8;
 135 static int loop_input = 0;
 136 static int loop_output = AVFMT_NOOUTPUTLOOP;
 137 static int qp_hist = 0;
 138
 139 static int intra_only = 0;
 140 static int audio_sample_rate = 44100;
 141 #define QSCALE_NONE -99999
 142 static float audio_qscale = QSCALE_NONE;
 143 static int audio_disable = 0;
 144 static int audio_channels = 1;
 145 static int audio_codec_id = CODEC_ID_NONE;
 146 static int audio_codec_tag = 0;
 147 static char *audio_language = NULL;
 148
 149 static int subtitle_codec_id = CODEC_ID_NONE;
 150 static char *subtitle_language = NULL;
 151
 152 static float mux_preload= 0.5;
 153 static float mux_max_delay= 0.7;
 154
 155 static int64_t recording_time = 0;
 156 static int64_t start_time = 0;
 157 static int64_t rec_timestamp = 0;
 158 static int64_t input_ts_offset = 0;
 159 static int file_overwrite = 0;
 160 static char *str_title = NULL;
 161 static char *str_author = NULL;
 162 static char *str_copyright = NULL;
 163 static char *str_comment = NULL;
 164 static char *str_album = NULL;
 165 static int do_benchmark = 0;
 166 static int do_hex_dump = 0;
 167 static int do_pkt_dump = 0;
 168 static int do_psnr = 0;
 169 static int do_pass = 0;
 170 static char *pass_logfilename = NULL;
 171 static int audio_stream_copy = 0;
 172 static int video_stream_copy = 0;
 173 static int subtitle_stream_copy = 0;
 174 static int video_sync_method= 1;
 175 static int audio_sync_method= 0;
 176 static int copy_ts= 0;
 177 static int opt_shortest = 0; //
 178 static int video_global_header = 0;
 179 static char *vstats_filename;
 180 static FILE *fvstats;
 181
 182 static int rate_emu = 0;
 183
 184 static int  video_channel = 0;
 185 static char *video_standard;
 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 #ifdef CONFIG_SWSCALER
1614                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1615 #endif
1616                     ost->img_resample_ctx = sws_getContext(
1617                             icodec->width - (frame_leftBand + frame_rightBand),
1618                             icodec->height - (frame_topBand + frame_bottomBand),
1619                             icodec->pix_fmt,
1620                             codec->width - (frame_padleft + frame_padright),
1621                             codec->height - (frame_padtop + frame_padbottom),
1622                             codec->pix_fmt,
1623                             sws_flags, NULL, NULL, NULL);
1624                     if (ost->img_resample_ctx == NULL) {
1625                         fprintf(stderr, "Cannot get resampling context\n");
1626                         exit(1);
1627                     }
1628                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1629                 }
1630                 ost->encoding_needed = 1;
1631                 ist->decoding_needed = 1;
1632                 break;
1633             case CODEC_TYPE_SUBTITLE:
1634                 ost->encoding_needed = 1;
1635                 ist->decoding_needed = 1;
1636                 break;
1637             default:
1638                 av_abort();
1639                 break;
1640             }
1641             /* two pass mode */
1642             if (ost->encoding_needed &&
1643                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1644                 char logfilename[1024];
1645                 FILE *f;
1646                 int size;
1647                 char *logbuffer;
1648
1649                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1650                          pass_logfilename ?
1651                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1652                 if (codec->flags & CODEC_FLAG_PASS1) {
1653                     f = fopen(logfilename, "w");
1654                     if (!f) {
1655                         perror(logfilename);
1656                         exit(1);
1657                     }
1658                     ost->logfile = f;
1659                 } else {
1660                     /* read the log file */
1661                     f = fopen(logfilename, "r");
1662                     if (!f) {
1663                         perror(logfilename);
1664                         exit(1);
1665                     }
1666                     fseek(f, 0, SEEK_END);
1667                     size = ftell(f);
1668                     fseek(f, 0, SEEK_SET);
1669                     logbuffer = av_malloc(size + 1);
1670                     if (!logbuffer) {
1671                         fprintf(stderr, "Could not allocate log buffer\n");
1672                         exit(1);
1673                     }
1674                     size = fread(logbuffer, 1, size, f);
1675                     fclose(f);
1676                     logbuffer[size] = '\0';
1677                     codec->stats_in = logbuffer;
1678                 }
1679             }
1680         }
1681         if(codec->codec_type == CODEC_TYPE_VIDEO){
1682             int size= codec->width * codec->height;
1683             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1684         }
1685     }
1686
1687     if (!bit_buffer)
1688         bit_buffer = av_malloc(bit_buffer_size);
1689     if (!bit_buffer)
1690         goto fail;
1691
1692     /* dump the file output parameters - cannot be done before in case
1693        of stream copy */
1694     for(i=0;i<nb_output_files;i++) {
1695         dump_format(output_files[i], i, output_files[i]->filename, 1);
1696     }
1697
1698     /* dump the stream mapping */
1699     if (verbose >= 0) {
1700         fprintf(stderr, "Stream mapping:\n");
1701         for(i=0;i<nb_ostreams;i++) {
1702             ost = ost_table[i];
1703             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1704                     ist_table[ost->source_index]->file_index,
1705                     ist_table[ost->source_index]->index,
1706                     ost->file_index,
1707                     ost->index);
1708             if (ost->sync_ist != ist_table[ost->source_index])
1709                 fprintf(stderr, " [sync #%d.%d]",
1710                         ost->sync_ist->file_index,
1711                         ost->sync_ist->index);
1712             fprintf(stderr, "\n");
1713         }
1714     }
1715
1716     /* open each encoder */
1717     for(i=0;i<nb_ostreams;i++) {
1718         ost = ost_table[i];
1719         if (ost->encoding_needed) {
1720             AVCodec *codec;
1721             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1722             if (!codec) {
1723                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1724                         ost->file_index, ost->index);
1725                 exit(1);
1726             }
1727             if (avcodec_open(ost->st->codec, codec) < 0) {
1728                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1729                         ost->file_index, ost->index);
1730                 exit(1);
1731             }
1732             extra_size += ost->st->codec->extradata_size;
1733         }
1734     }
1735
1736     /* open each decoder */
1737     for(i=0;i<nb_istreams;i++) {
1738         ist = ist_table[i];
1739         if (ist->decoding_needed) {
1740             AVCodec *codec;
1741             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1742             if (!codec) {
1743                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1744                         ist->st->codec->codec_id, ist->file_index, ist->index);
1745                 exit(1);
1746             }
1747             if (avcodec_open(ist->st->codec, codec) < 0) {
1748                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1749                         ist->file_index, ist->index);
1750                 exit(1);
1751             }
1752             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1753             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1754         }
1755     }
1756
1757     /* init pts */
1758     for(i=0;i<nb_istreams;i++) {
1759         ist = ist_table[i];
1760         is = input_files[ist->file_index];
1761         ist->pts = 0;
1762         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1763         if(ist->st->start_time == AV_NOPTS_VALUE)
1764             ist->next_pts=0;
1765         if(input_files_ts_offset[ist->file_index])
1766             ist->next_pts= AV_NOPTS_VALUE;
1767         ist->is_start = 1;
1768     }
1769
1770     /* set meta data information from input file if required */
1771     for (i=0;i<nb_meta_data_maps;i++) {
1772         AVFormatContext *out_file;
1773         AVFormatContext *in_file;
1774
1775         int out_file_index = meta_data_maps[i].out_file;
1776         int in_file_index = meta_data_maps[i].in_file;
1777         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1778             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1779             ret = AVERROR(EINVAL);
1780             goto fail;
1781         }
1782         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1783             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1784             ret = AVERROR(EINVAL);
1785             goto fail;
1786         }
1787
1788         out_file = output_files[out_file_index];
1789         in_file = input_files[in_file_index];
1790
1791         strcpy(out_file->title, in_file->title);
1792         strcpy(out_file->author, in_file->author);
1793         strcpy(out_file->copyright, in_file->copyright);
1794         strcpy(out_file->comment, in_file->comment);
1795         strcpy(out_file->album, in_file->album);
1796         out_file->year = in_file->year;
1797         out_file->track = in_file->track;
1798         strcpy(out_file->genre, in_file->genre);
1799     }
1800
1801     /* open files and write file headers */
1802     for(i=0;i<nb_output_files;i++) {
1803         os = output_files[i];
1804         if (av_write_header(os) < 0) {
1805             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1806             ret = AVERROR(EINVAL);
1807             goto fail;
1808         }
1809     }
1810
1811     if ( !using_stdin && verbose >= 0) {
1812         fprintf(stderr, "Press [q] to stop encoding\n");
1813         url_set_interrupt_cb(decode_interrupt_cb);
1814     }
1815     term_init();
1816
1817     key = -1;
1818     timer_start = av_gettime();
1819
1820     for(; received_sigterm == 0;) {
1821         int file_index, ist_index;
1822         AVPacket pkt;
1823         double ipts_min;
1824         double opts_min;
1825
1826     redo:
1827         ipts_min= 1e100;
1828         opts_min= 1e100;
1829         /* if 'q' pressed, exits */
1830         if (!using_stdin) {
1831             if (q_pressed)
1832                 break;
1833             /* read_key() returns 0 on EOF */
1834             key = read_key();
1835             if (key == 'q')
1836                 break;
1837         }
1838
1839         /* select the stream that we must read now by looking at the
1840            smallest output pts */
1841         file_index = -1;
1842         for(i=0;i<nb_ostreams;i++) {
1843             double ipts, opts;
1844             ost = ost_table[i];
1845             os = output_files[ost->file_index];
1846             ist = ist_table[ost->source_index];
1847             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1848                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1849             else
1850                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1851             ipts = (double)ist->pts;
1852             if (!file_table[ist->file_index].eof_reached){
1853                 if(ipts < ipts_min) {
1854                     ipts_min = ipts;
1855                     if(input_sync ) file_index = ist->file_index;
1856                 }
1857                 if(opts < opts_min) {
1858                     opts_min = opts;
1859                     if(!input_sync) file_index = ist->file_index;
1860                 }
1861             }
1862             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1863                 file_index= -1;
1864                 break;
1865             }
1866         }
1867         /* if none, if is finished */
1868         if (file_index < 0) {
1869             break;
1870         }
1871
1872         /* finish if recording time exhausted */
1873         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1874             break;
1875
1876         /* finish if limit size exhausted */
1877         if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1878             break;
1879
1880         /* read a frame from it and output it in the fifo */
1881         is = input_files[file_index];
1882         if (av_read_frame(is, &pkt) < 0) {
1883             file_table[file_index].eof_reached = 1;
1884             if (opt_shortest) break; else continue; //
1885         }
1886
1887         if (do_pkt_dump) {
1888             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1889         }
1890         /* the following test is needed in case new streams appear
1891            dynamically in stream : we ignore them */
1892         if (pkt.stream_index >= file_table[file_index].nb_streams)
1893             goto discard_packet;
1894         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1895         ist = ist_table[ist_index];
1896         if (ist->discard)
1897             goto discard_packet;
1898
1899 //        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);
1900         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1901             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1902             if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1903                 input_files_ts_offset[ist->file_index]-= delta;
1904                 if (verbose > 2)
1905                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1906                 for(i=0; i<file_table[file_index].nb_streams; i++){
1907                     int index= file_table[file_index].ist_index + i;
1908                     ist_table[index]->next_pts += delta;
1909                     ist_table[index]->is_start=1;
1910                 }
1911             }
1912         }
1913
1914         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1915         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1916
1917             if (verbose >= 0)
1918                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1919                         ist->file_index, ist->index);
1920
1921             av_free_packet(&pkt);
1922             goto redo;
1923         }
1924
1925     discard_packet:
1926         av_free_packet(&pkt);
1927
1928         /* dump report by using the output first video and audio streams */
1929         print_report(output_files, ost_table, nb_ostreams, 0);
1930     }
1931
1932     /* at the end of stream, we must flush the decoder buffers */
1933     for(i=0;i<nb_istreams;i++) {
1934         ist = ist_table[i];
1935         if (ist->decoding_needed) {
1936             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1937         }
1938     }
1939
1940     term_exit();
1941
1942     /* write the trailer if needed and close file */
1943     for(i=0;i<nb_output_files;i++) {
1944         os = output_files[i];
1945         av_write_trailer(os);
1946     }
1947
1948     /* dump report by using the first video and audio streams */
1949     print_report(output_files, ost_table, nb_ostreams, 1);
1950
1951     /* close each encoder */
1952     for(i=0;i<nb_ostreams;i++) {
1953         ost = ost_table[i];
1954         if (ost->encoding_needed) {
1955             av_freep(&ost->st->codec->stats_in);
1956             avcodec_close(ost->st->codec);
1957         }
1958     }
1959
1960     /* close each decoder */
1961     for(i=0;i<nb_istreams;i++) {
1962         ist = ist_table[i];
1963         if (ist->decoding_needed) {
1964             avcodec_close(ist->st->codec);
1965         }
1966     }
1967
1968     /* finished ! */
1969
1970     ret = 0;
1971  fail1:
1972     av_freep(&bit_buffer);
1973     av_free(file_table);
1974
1975     if (ist_table) {
1976         for(i=0;i<nb_istreams;i++) {
1977             ist = ist_table[i];
1978             av_free(ist);
1979         }
1980         av_free(ist_table);
1981     }
1982     if (ost_table) {
1983         for(i=0;i<nb_ostreams;i++) {
1984             ost = ost_table[i];
1985             if (ost) {
1986                 if (ost->logfile) {
1987                     fclose(ost->logfile);
1988                     ost->logfile = NULL;
1989                 }
1990                 av_fifo_free(&ost->fifo); /* works even if fifo is not
1991                                              initialized but set to zero */
1992                 av_free(ost->pict_tmp.data[0]);
1993                 if (ost->video_resample)
1994                     sws_freeContext(ost->img_resample_ctx);
1995                 if (ost->audio_resample)
1996                     audio_resample_close(ost->resample);
1997                 av_free(ost);
1998             }
1999         }
2000         av_free(ost_table);
2001     }
2002     return ret;
2003  fail:
2004     ret = AVERROR(ENOMEM);
2005     goto fail1;
2006 }
2007
2008 #if 0
2009 int file_read(const char *filename)
2010 {
2011     URLContext *h;
2012     unsigned char buffer[1024];
2013     int len, i;
2014
2015     if (url_open(&h, filename, O_RDONLY) < 0) {
2016         printf("could not open '%s'\n", filename);
2017         return -1;
2018     }
2019     for(;;) {
2020         len = url_read(h, buffer, sizeof(buffer));
2021         if (len <= 0)
2022             break;
2023         for(i=0;i<len;i++) putchar(buffer[i]);
2024     }
2025     url_close(h);
2026     return 0;
2027 }
2028 #endif
2029
2030 static void opt_format(const char *arg)
2031 {
2032     /* compatibility stuff for pgmyuv */
2033     if (!strcmp(arg, "pgmyuv")) {
2034         pgmyuv_compatibility_hack=1;
2035 //        opt_image_format(arg);
2036         arg = "image2";
2037         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2038     }
2039
2040     file_iformat = av_find_input_format(arg);
2041     file_oformat = guess_format(arg, NULL, NULL);
2042     if (!file_iformat && !file_oformat) {
2043         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2044         exit(1);
2045     }
2046 }
2047
2048 static void opt_video_rc_eq(char *arg)
2049 {
2050     video_rc_eq = arg;
2051 }
2052
2053 static void opt_video_rc_override_string(char *arg)
2054 {
2055     video_rc_override_string = arg;
2056 }
2057
2058 static void opt_me_threshold(const char *arg)
2059 {
2060     me_threshold = atoi(arg);
2061 }
2062
2063 static void opt_verbose(const char *arg)
2064 {
2065     verbose = atoi(arg);
2066     av_log_level = atoi(arg);
2067 }
2068
2069 static void opt_frame_rate(const char *arg)
2070 {
2071     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2072         fprintf(stderr, "Incorrect frame rate\n");
2073         exit(1);
2074     }
2075 }
2076
2077 static void opt_frame_crop_top(const char *arg)
2078 {
2079     frame_topBand = atoi(arg);
2080     if (frame_topBand < 0) {
2081         fprintf(stderr, "Incorrect top crop size\n");
2082         exit(1);
2083     }
2084     if ((frame_topBand % 2) != 0) {
2085         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2086         exit(1);
2087     }
2088     if ((frame_topBand) >= frame_height){
2089         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2090         exit(1);
2091     }
2092     frame_height -= frame_topBand;
2093 }
2094
2095 static void opt_frame_crop_bottom(const char *arg)
2096 {
2097     frame_bottomBand = atoi(arg);
2098     if (frame_bottomBand < 0) {
2099         fprintf(stderr, "Incorrect bottom crop size\n");
2100         exit(1);
2101     }
2102     if ((frame_bottomBand % 2) != 0) {
2103         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2104         exit(1);
2105     }
2106     if ((frame_bottomBand) >= frame_height){
2107         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2108         exit(1);
2109     }
2110     frame_height -= frame_bottomBand;
2111 }
2112
2113 static void opt_frame_crop_left(const char *arg)
2114 {
2115     frame_leftBand = atoi(arg);
2116     if (frame_leftBand < 0) {
2117         fprintf(stderr, "Incorrect left crop size\n");
2118         exit(1);
2119     }
2120     if ((frame_leftBand % 2) != 0) {
2121         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2122         exit(1);
2123     }
2124     if ((frame_leftBand) >= frame_width){
2125         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2126         exit(1);
2127     }
2128     frame_width -= frame_leftBand;
2129 }
2130
2131 static void opt_frame_crop_right(const char *arg)
2132 {
2133     frame_rightBand = atoi(arg);
2134     if (frame_rightBand < 0) {
2135         fprintf(stderr, "Incorrect right crop size\n");
2136         exit(1);
2137     }
2138     if ((frame_rightBand % 2) != 0) {
2139         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2140         exit(1);
2141     }
2142     if ((frame_rightBand) >= frame_width){
2143         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2144         exit(1);
2145     }
2146     frame_width -= frame_rightBand;
2147 }
2148
2149 static void opt_frame_size(const char *arg)
2150 {
2151     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2152         fprintf(stderr, "Incorrect frame size\n");
2153         exit(1);
2154     }
2155     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2156         fprintf(stderr, "Frame size must be a multiple of 2\n");
2157         exit(1);
2158     }
2159 }
2160
2161
2162 #define SCALEBITS 10
2163 #define ONE_HALF  (1 << (SCALEBITS - 1))
2164 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2165
2166 #define RGB_TO_Y(r, g, b) \
2167 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2168   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2169
2170 #define RGB_TO_U(r1, g1, b1, shift)\
2171 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2172      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2173
2174 #define RGB_TO_V(r1, g1, b1, shift)\
2175 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2176    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2177
2178 static void opt_pad_color(const char *arg) {
2179     /* Input is expected to be six hex digits similar to
2180        how colors are expressed in html tags (but without the #) */
2181     int rgb = strtol(arg, NULL, 16);
2182     int r,g,b;
2183
2184     r = (rgb >> 16);
2185     g = ((rgb >> 8) & 255);
2186     b = (rgb & 255);
2187
2188     padcolor[0] = RGB_TO_Y(r,g,b);
2189     padcolor[1] = RGB_TO_U(r,g,b,0);
2190     padcolor[2] = RGB_TO_V(r,g,b,0);
2191 }
2192
2193 static void opt_frame_pad_top(const char *arg)
2194 {
2195     frame_padtop = atoi(arg);
2196     if (frame_padtop < 0) {
2197         fprintf(stderr, "Incorrect top pad size\n");
2198         exit(1);
2199     }
2200     if ((frame_padtop % 2) != 0) {
2201         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2202         exit(1);
2203     }
2204 }
2205
2206 static void opt_frame_pad_bottom(const char *arg)
2207 {
2208     frame_padbottom = atoi(arg);
2209     if (frame_padbottom < 0) {
2210         fprintf(stderr, "Incorrect bottom pad size\n");
2211         exit(1);
2212     }
2213     if ((frame_padbottom % 2) != 0) {
2214         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2215         exit(1);
2216     }
2217 }
2218
2219
2220 static void opt_frame_pad_left(const char *arg)
2221 {
2222     frame_padleft = atoi(arg);
2223     if (frame_padleft < 0) {
2224         fprintf(stderr, "Incorrect left pad size\n");
2225         exit(1);
2226     }
2227     if ((frame_padleft % 2) != 0) {
2228         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2229         exit(1);
2230     }
2231 }
2232
2233
2234 static void opt_frame_pad_right(const char *arg)
2235 {
2236     frame_padright = atoi(arg);
2237     if (frame_padright < 0) {
2238         fprintf(stderr, "Incorrect right pad size\n");
2239         exit(1);
2240     }
2241     if ((frame_padright % 2) != 0) {
2242         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2243         exit(1);
2244     }
2245 }
2246
2247
2248 static void opt_frame_pix_fmt(const char *arg)
2249 {
2250     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2251 }
2252
2253 static void opt_frame_aspect_ratio(const char *arg)
2254 {
2255     int x = 0, y = 0;
2256     double ar = 0;
2257     const char *p;
2258
2259     p = strchr(arg, ':');
2260     if (p) {
2261         x = strtol(arg, (char **)&arg, 10);
2262         if (arg == p)
2263             y = strtol(arg+1, (char **)&arg, 10);
2264         if (x > 0 && y > 0)
2265             ar = (double)x / (double)y;
2266     } else
2267         ar = strtod(arg, (char **)&arg);
2268
2269     if (!ar) {
2270         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2271         exit(1);
2272     }
2273     frame_aspect_ratio = ar;
2274 }
2275
2276 static void opt_qscale(const char *arg)
2277 {
2278     video_qscale = atof(arg);
2279     if (video_qscale <= 0 ||
2280         video_qscale > 255) {
2281         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2282         exit(1);
2283     }
2284 }
2285
2286 static void opt_qdiff(const char *arg)
2287 {
2288     video_qdiff = atoi(arg);
2289     if (video_qdiff < 0 ||
2290         video_qdiff > 31) {
2291         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2292         exit(1);
2293     }
2294 }
2295
2296 static void opt_strict(const char *arg)
2297 {
2298     strict= atoi(arg);
2299 }
2300
2301 static void opt_top_field_first(const char *arg)
2302 {
2303     top_field_first= atoi(arg);
2304 }
2305
2306 static void opt_thread_count(const char *arg)
2307 {
2308     thread_count= atoi(arg);
2309 #if !defined(HAVE_THREADS)
2310     if (verbose >= 0)
2311         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2312 #endif
2313 }
2314
2315 static void opt_audio_rate(const char *arg)
2316 {
2317     audio_sample_rate = atoi(arg);
2318 }
2319
2320 static void opt_audio_channels(const char *arg)
2321 {
2322     audio_channels = atoi(arg);
2323 }
2324
2325 static void opt_video_channel(const char *arg)
2326 {
2327     video_channel = strtol(arg, NULL, 0);
2328 }
2329
2330 static void opt_video_standard(const char *arg)
2331 {
2332     video_standard = av_strdup(arg);
2333 }
2334
2335 static void opt_codec(int *pstream_copy, int *pcodec_id,
2336                       int codec_type, const char *arg)
2337 {
2338     AVCodec *p;
2339
2340     if (!strcmp(arg, "copy")) {
2341         *pstream_copy = 1;
2342     } else {
2343         p = first_avcodec;
2344         while (p) {
2345             if (!strcmp(p->name, arg) && p->type == codec_type)
2346                 break;
2347             p = p->next;
2348         }
2349         if (p == NULL) {
2350             fprintf(stderr, "Unknown codec '%s'\n", arg);
2351             exit(1);
2352         } else {
2353             *pcodec_id = p->id;
2354         }
2355     }
2356 }
2357
2358 static void opt_audio_codec(const char *arg)
2359 {
2360     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2361 }
2362
2363 static void opt_audio_tag(const char *arg)
2364 {
2365     char *tail;
2366     audio_codec_tag= strtol(arg, &tail, 0);
2367
2368     if(!tail || *tail)
2369         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2370 }
2371
2372 static void opt_video_tag(const char *arg)
2373 {
2374     char *tail;
2375     video_codec_tag= strtol(arg, &tail, 0);
2376
2377     if(!tail || *tail)
2378         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2379 }
2380
2381 static void add_frame_hooker(const char *arg)
2382 {
2383     int argc = 0;
2384     char *argv[64];
2385     int i;
2386     char *args = av_strdup(arg);
2387
2388     using_vhook = 1;
2389
2390     argv[0] = strtok(args, " ");
2391     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2392     }
2393
2394     i = frame_hook_add(argc, argv);
2395
2396     if (i != 0) {
2397         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2398         exit(1);
2399     }
2400 }
2401
2402 const char *motion_str[] = {
2403     "zero",
2404     "full",
2405     "log",
2406     "phods",
2407     "epzs",
2408     "x1",
2409     "hex",
2410     "umh",
2411     "iter",
2412     NULL,
2413 };
2414
2415 static void opt_motion_estimation(const char *arg)
2416 {
2417     const char **p;
2418     p = motion_str;
2419     for(;;) {
2420         if (!*p) {
2421             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2422             exit(1);
2423         }
2424         if (!strcmp(*p, arg))
2425             break;
2426         p++;
2427     }
2428     me_method = (p - motion_str) + 1;
2429 }
2430
2431 static void opt_video_codec(const char *arg)
2432 {
2433     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2434 }
2435
2436 static void opt_subtitle_codec(const char *arg)
2437 {
2438     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2439 }
2440
2441 static void opt_map(const char *arg)
2442 {
2443     AVStreamMap *m;
2444     const char *p;
2445
2446     p = arg;
2447     m = &stream_maps[nb_stream_maps++];
2448
2449     m->file_index = strtol(arg, (char **)&p, 0);
2450     if (*p)
2451         p++;
2452
2453     m->stream_index = strtol(p, (char **)&p, 0);
2454     if (*p) {
2455         p++;
2456         m->sync_file_index = strtol(p, (char **)&p, 0);
2457         if (*p)
2458             p++;
2459         m->sync_stream_index = strtol(p, (char **)&p, 0);
2460     } else {
2461         m->sync_file_index = m->file_index;
2462         m->sync_stream_index = m->stream_index;
2463     }
2464 }
2465
2466 static void opt_map_meta_data(const char *arg)
2467 {
2468     AVMetaDataMap *m;
2469     const char *p;
2470
2471     p = arg;
2472     m = &meta_data_maps[nb_meta_data_maps++];
2473
2474     m->out_file = strtol(arg, (char **)&p, 0);
2475     if (*p)
2476         p++;
2477
2478     m->in_file = strtol(p, (char **)&p, 0);
2479 }
2480
2481 static void opt_recording_time(const char *arg)
2482 {
2483     recording_time = parse_date(arg, 1);
2484 }
2485
2486 static void opt_start_time(const char *arg)
2487 {
2488     start_time = parse_date(arg, 1);
2489 }
2490
2491 static void opt_rec_timestamp(const char *arg)
2492 {
2493     rec_timestamp = parse_date(arg, 0) / 1000000;
2494 }
2495
2496 static void opt_input_ts_offset(const char *arg)
2497 {
2498     input_ts_offset = parse_date(arg, 1);
2499 }
2500
2501 static void opt_input_file(const char *filename)
2502 {
2503     AVFormatContext *ic;
2504     AVFormatParameters params, *ap = &params;
2505     int err, i, ret, rfps, rfps_base;
2506     int64_t timestamp;
2507
2508     if (!strcmp(filename, "-"))
2509         filename = "pipe:";
2510
2511     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2512                    !strcmp( filename, "/dev/stdin" );
2513
2514     /* get default parameters from command line */
2515     ic = av_alloc_format_context();
2516
2517     memset(ap, 0, sizeof(*ap));
2518     ap->prealloced_context = 1;
2519     ap->sample_rate = audio_sample_rate;
2520     ap->channels = audio_channels;
2521     ap->time_base.den = frame_rate;
2522     ap->time_base.num = frame_rate_base;
2523     ap->width = frame_width + frame_padleft + frame_padright;
2524     ap->height = frame_height + frame_padtop + frame_padbottom;
2525     ap->pix_fmt = frame_pix_fmt;
2526     ap->channel = video_channel;
2527     ap->standard = video_standard;
2528     ap->video_codec_id = video_codec_id;
2529     ap->audio_codec_id = audio_codec_id;
2530     if(pgmyuv_compatibility_hack)
2531         ap->video_codec_id= CODEC_ID_PGMYUV;
2532
2533     for(i=0; i<opt_name_count; i++){
2534         const AVOption *opt;
2535         double d= av_get_double(avformat_opts, opt_names[i], &opt);
2536         if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2537             av_set_double(ic, opt_names[i], d);
2538     }
2539     /* open the input file with generic libav function */
2540     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2541     if (err < 0) {
2542         print_error(filename, err);
2543         exit(1);
2544     }
2545
2546     ic->loop_input = loop_input;
2547
2548     /* If not enough info to get the stream parameters, we decode the
2549        first frames to get it. (used in mpeg case for example) */
2550     ret = av_find_stream_info(ic);
2551     if (ret < 0 && verbose >= 0) {
2552         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2553         exit(1);
2554     }
2555
2556     timestamp = start_time;
2557     /* add the stream start time */
2558     if (ic->start_time != AV_NOPTS_VALUE)
2559         timestamp += ic->start_time;
2560
2561     /* if seeking requested, we execute it */
2562     if (start_time != 0) {
2563         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2564         if (ret < 0) {
2565             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2566                     filename, (double)timestamp / AV_TIME_BASE);
2567         }
2568         /* reset seek info */
2569         start_time = 0;
2570     }
2571
2572     /* update the current parameters so that they match the one of the input stream */
2573     for(i=0;i<ic->nb_streams;i++) {
2574         int j;
2575         AVCodecContext *enc = ic->streams[i]->codec;
2576         if(thread_count>1)
2577             avcodec_thread_init(enc, thread_count);
2578         enc->thread_count= thread_count;
2579         switch(enc->codec_type) {
2580         case CODEC_TYPE_AUDIO:
2581             for(j=0; j<opt_name_count; j++){
2582                 const AVOption *opt;
2583                 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2584                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2585                     av_set_double(enc, opt_names[j], d);
2586             }
2587             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2588             audio_channels = enc->channels;
2589             audio_sample_rate = enc->sample_rate;
2590             if(audio_disable)
2591                 ic->streams[i]->discard= AVDISCARD_ALL;
2592             break;
2593         case CODEC_TYPE_VIDEO:
2594             for(j=0; j<opt_name_count; j++){
2595                 const AVOption *opt;
2596                 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2597                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2598                     av_set_double(enc, opt_names[j], d);
2599             }
2600             frame_height = enc->height;
2601             frame_width = enc->width;
2602             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2603             frame_pix_fmt = enc->pix_fmt;
2604             rfps      = ic->streams[i]->r_frame_rate.num;
2605             rfps_base = ic->streams[i]->r_frame_rate.den;
2606             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2607             if(me_threshold)
2608                 enc->debug |= FF_DEBUG_MV;
2609
2610             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2611
2612                 if (verbose >= 0)
2613                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2614                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2615
2616                     (float)rfps / rfps_base, rfps, rfps_base);
2617             }
2618             /* update the current frame rate to match the stream frame rate */
2619             frame_rate      = rfps;
2620             frame_rate_base = rfps_base;
2621
2622             enc->rate_emu = rate_emu;
2623             if(video_disable)
2624                 ic->streams[i]->discard= AVDISCARD_ALL;
2625             else if(video_discard)
2626                 ic->streams[i]->discard= video_discard;
2627             break;
2628         case CODEC_TYPE_DATA:
2629             break;
2630         case CODEC_TYPE_SUBTITLE:
2631             break;
2632         case CODEC_TYPE_UNKNOWN:
2633             break;
2634         default:
2635             av_abort();
2636         }
2637     }
2638
2639     input_files[nb_input_files] = ic;
2640     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2641     /* dump the file content */
2642     if (verbose >= 0)
2643         dump_format(ic, nb_input_files, filename, 0);
2644
2645     nb_input_files++;
2646     file_iformat = NULL;
2647     file_oformat = NULL;
2648
2649     video_channel = 0;
2650
2651     rate_emu = 0;
2652 }
2653
2654 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2655 {
2656     int has_video, has_audio, i, j;
2657     AVFormatContext *ic;
2658
2659     has_video = 0;
2660     has_audio = 0;
2661     for(j=0;j<nb_input_files;j++) {
2662         ic = input_files[j];
2663         for(i=0;i<ic->nb_streams;i++) {
2664             AVCodecContext *enc = ic->streams[i]->codec;
2665             switch(enc->codec_type) {
2666             case CODEC_TYPE_AUDIO:
2667                 has_audio = 1;
2668                 break;
2669             case CODEC_TYPE_VIDEO:
2670                 has_video = 1;
2671                 break;
2672             case CODEC_TYPE_DATA:
2673             case CODEC_TYPE_UNKNOWN:
2674             case CODEC_TYPE_SUBTITLE:
2675                 break;
2676             default:
2677                 av_abort();
2678             }
2679         }
2680     }
2681     *has_video_ptr = has_video;
2682     *has_audio_ptr = has_audio;
2683 }
2684
2685 static void new_video_stream(AVFormatContext *oc)
2686 {
2687     AVStream *st;
2688     AVCodecContext *video_enc;
2689     int codec_id;
2690
2691     st = av_new_stream(oc, oc->nb_streams);
2692     if (!st) {
2693         fprintf(stderr, "Could not alloc stream\n");
2694         exit(1);
2695     }
2696     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2697     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2698     video_bitstream_filters= NULL;
2699
2700     if(thread_count>1)
2701         avcodec_thread_init(st->codec, thread_count);
2702
2703     video_enc = st->codec;
2704
2705     if(video_codec_tag)
2706         video_enc->codec_tag= video_codec_tag;
2707
2708     if(   (video_global_header&1)
2709        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2710         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2711         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2712     }
2713     if(video_global_header&2){
2714         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2715         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2716     }
2717
2718     if (video_stream_copy) {
2719         st->stream_copy = 1;
2720         video_enc->codec_type = CODEC_TYPE_VIDEO;
2721     } else {
2722         char *p;
2723         int i;
2724         AVCodec *codec;
2725
2726         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2727         if (video_codec_id != CODEC_ID_NONE)
2728             codec_id = video_codec_id;
2729
2730         video_enc->codec_id = codec_id;
2731         codec = avcodec_find_encoder(codec_id);
2732
2733         for(i=0; i<opt_name_count; i++){
2734              const AVOption *opt;
2735              double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2736              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2737                  av_set_double(video_enc, opt_names[i], d);
2738         }
2739
2740         video_enc->time_base.den = frame_rate;
2741         video_enc->time_base.num = frame_rate_base;
2742         if(codec && codec->supported_framerates){
2743             const AVRational *p= codec->supported_framerates;
2744             AVRational req= (AVRational){frame_rate, frame_rate_base};
2745             const AVRational *best=NULL;
2746             AVRational best_error= (AVRational){INT_MAX, 1};
2747             for(; p->den!=0; p++){
2748                 AVRational error= av_sub_q(req, *p);
2749                 if(error.num <0) error.num *= -1;
2750                 if(av_cmp_q(error, best_error) < 0){
2751                     best_error= error;
2752                     best= p;
2753                 }
2754             }
2755             video_enc->time_base.den= best->num;
2756             video_enc->time_base.num= best->den;
2757         }
2758
2759         video_enc->width = frame_width + frame_padright + frame_padleft;
2760         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2761         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2762         video_enc->pix_fmt = frame_pix_fmt;
2763
2764         if(codec && codec->pix_fmts){
2765             const enum PixelFormat *p= codec->pix_fmts;
2766             for(; *p!=-1; p++){
2767                 if(*p == video_enc->pix_fmt)
2768                     break;
2769             }
2770             if(*p == -1)
2771                 video_enc->pix_fmt = codec->pix_fmts[0];
2772         }
2773
2774         if (intra_only)
2775             video_enc->gop_size = 0;
2776         if (video_qscale || same_quality) {
2777             video_enc->flags |= CODEC_FLAG_QSCALE;
2778             video_enc->global_quality=
2779                 st->quality = FF_QP2LAMBDA * video_qscale;
2780         }
2781
2782         if(intra_matrix)
2783             video_enc->intra_matrix = intra_matrix;
2784         if(inter_matrix)
2785             video_enc->inter_matrix = inter_matrix;
2786
2787         video_enc->max_qdiff = video_qdiff;
2788         video_enc->rc_eq = video_rc_eq;
2789         video_enc->thread_count = thread_count;
2790         p= video_rc_override_string;
2791         for(i=0; p; i++){
2792             int start, end, q;
2793             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2794             if(e!=3){
2795                 fprintf(stderr, "error parsing rc_override\n");
2796                 exit(1);
2797             }
2798             video_enc->rc_override=
2799                 av_realloc(video_enc->rc_override,
2800                            sizeof(RcOverride)*(i+1));
2801             video_enc->rc_override[i].start_frame= start;
2802             video_enc->rc_override[i].end_frame  = end;
2803             if(q>0){
2804                 video_enc->rc_override[i].qscale= q;
2805                 video_enc->rc_override[i].quality_factor= 1.0;
2806             }
2807             else{
2808                 video_enc->rc_override[i].qscale= 0;
2809                 video_enc->rc_override[i].quality_factor= -q/100.0;
2810             }
2811             p= strchr(p, '/');
2812             if(p) p++;
2813         }
2814         video_enc->rc_override_count=i;
2815         if (!video_enc->rc_initial_buffer_occupancy)
2816             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2817         video_enc->me_threshold= me_threshold;
2818         video_enc->intra_dc_precision= intra_dc_precision - 8;
2819         video_enc->strict_std_compliance = strict;
2820
2821         if (do_psnr)
2822             video_enc->flags|= CODEC_FLAG_PSNR;
2823
2824         video_enc->me_method = me_method;
2825
2826         /* two pass mode */
2827         if (do_pass) {
2828             if (do_pass == 1) {
2829                 video_enc->flags |= CODEC_FLAG_PASS1;
2830             } else {
2831                 video_enc->flags |= CODEC_FLAG_PASS2;
2832             }
2833         }
2834     }
2835
2836     /* reset some key parameters */
2837     video_disable = 0;
2838     video_codec_id = CODEC_ID_NONE;
2839     video_stream_copy = 0;
2840 }
2841
2842 static void new_audio_stream(AVFormatContext *oc)
2843 {
2844     AVStream *st;
2845     AVCodecContext *audio_enc;
2846     int codec_id, i;
2847
2848     st = av_new_stream(oc, oc->nb_streams);
2849     if (!st) {
2850         fprintf(stderr, "Could not alloc stream\n");
2851         exit(1);
2852     }
2853     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2854
2855     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2856     audio_bitstream_filters= NULL;
2857
2858     if(thread_count>1)
2859         avcodec_thread_init(st->codec, thread_count);
2860
2861     audio_enc = st->codec;
2862     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2863     audio_enc->strict_std_compliance = strict;
2864
2865     if(audio_codec_tag)
2866         audio_enc->codec_tag= audio_codec_tag;
2867
2868     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2869         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2870         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2871     }
2872     if (audio_stream_copy) {
2873         st->stream_copy = 1;
2874         audio_enc->channels = audio_channels;
2875     } else {
2876         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2877
2878         for(i=0; i<opt_name_count; i++){
2879             const AVOption *opt;
2880             double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2881             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2882                 av_set_double(audio_enc, opt_names[i], d);
2883         }
2884
2885         if (audio_codec_id != CODEC_ID_NONE)
2886             codec_id = audio_codec_id;
2887         audio_enc->codec_id = codec_id;
2888
2889         if (audio_qscale > QSCALE_NONE) {
2890             audio_enc->flags |= CODEC_FLAG_QSCALE;
2891             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2892         }
2893         audio_enc->thread_count = thread_count;
2894         audio_enc->channels = audio_channels;
2895     }
2896     audio_enc->sample_rate = audio_sample_rate;
2897     audio_enc->time_base= (AVRational){1, audio_sample_rate};
2898     if (audio_language) {
2899         pstrcpy(st->language, sizeof(st->language), audio_language);
2900         av_free(audio_language);
2901         audio_language = NULL;
2902     }
2903
2904     /* reset some key parameters */
2905     audio_disable = 0;
2906     audio_codec_id = CODEC_ID_NONE;
2907     audio_stream_copy = 0;
2908 }
2909
2910 static void opt_new_subtitle_stream(void)
2911 {
2912     AVFormatContext *oc;
2913     AVStream *st;
2914     AVCodecContext *subtitle_enc;
2915     int i;
2916
2917     if (nb_output_files <= 0) {
2918         fprintf(stderr, "At least one output file must be specified\n");
2919         exit(1);
2920     }
2921     oc = output_files[nb_output_files - 1];
2922
2923     st = av_new_stream(oc, oc->nb_streams);
2924     if (!st) {
2925         fprintf(stderr, "Could not alloc stream\n");
2926         exit(1);
2927     }
2928     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2929
2930     subtitle_enc = st->codec;
2931     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2932     if (subtitle_stream_copy) {
2933         st->stream_copy = 1;
2934     } else {
2935         for(i=0; i<opt_name_count; i++){
2936              const AVOption *opt;
2937              double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2938              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2939                  av_set_double(subtitle_enc, opt_names[i], d);
2940         }
2941         subtitle_enc->codec_id = subtitle_codec_id;
2942     }
2943
2944     if (subtitle_language) {
2945         pstrcpy(st->language, sizeof(st->language), subtitle_language);
2946         av_free(subtitle_language);
2947         subtitle_language = NULL;
2948     }
2949
2950     subtitle_codec_id = CODEC_ID_NONE;
2951     subtitle_stream_copy = 0;
2952 }
2953
2954 static void opt_new_audio_stream(void)
2955 {
2956     AVFormatContext *oc;
2957     if (nb_output_files <= 0) {
2958         fprintf(stderr, "At least one output file must be specified\n");
2959         exit(1);
2960     }
2961     oc = output_files[nb_output_files - 1];
2962     new_audio_stream(oc);
2963 }
2964
2965 static void opt_new_video_stream(void)
2966 {
2967     AVFormatContext *oc;
2968     if (nb_output_files <= 0) {
2969         fprintf(stderr, "At least one output file must be specified\n");
2970         exit(1);
2971     }
2972     oc = output_files[nb_output_files - 1];
2973     new_video_stream(oc);
2974 }
2975
2976 static void opt_output_file(const char *filename)
2977 {
2978     AVFormatContext *oc;
2979     int use_video, use_audio, input_has_video, input_has_audio, i;
2980     AVFormatParameters params, *ap = &params;
2981
2982     if (!strcmp(filename, "-"))
2983         filename = "pipe:";
2984
2985     oc = av_alloc_format_context();
2986
2987     if (!file_oformat) {
2988         file_oformat = guess_format(NULL, filename, NULL);
2989         if (!file_oformat) {
2990             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2991                     filename);
2992             exit(1);
2993         }
2994     }
2995
2996     oc->oformat = file_oformat;
2997     pstrcpy(oc->filename, sizeof(oc->filename), filename);
2998
2999     if (!strcmp(file_oformat->name, "ffm") &&
3000         strstart(filename, "http:", NULL)) {
3001         /* special case for files sent to ffserver: we get the stream
3002            parameters from ffserver */
3003         if (read_ffserver_streams(oc, filename) < 0) {
3004             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3005             exit(1);
3006         }
3007     } else {
3008         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3009         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3010
3011         /* disable if no corresponding type found and at least one
3012            input file */
3013         if (nb_input_files > 0) {
3014             check_audio_video_inputs(&input_has_video, &input_has_audio);
3015             if (!input_has_video)
3016                 use_video = 0;
3017             if (!input_has_audio)
3018                 use_audio = 0;
3019         }
3020
3021         /* manual disable */
3022         if (audio_disable) {
3023             use_audio = 0;
3024         }
3025         if (video_disable) {
3026             use_video = 0;
3027         }
3028
3029         if (use_video) {
3030             new_video_stream(oc);
3031         }
3032
3033         if (use_audio) {
3034             new_audio_stream(oc);
3035         }
3036
3037         oc->timestamp = rec_timestamp;
3038
3039         if (str_title)
3040             pstrcpy(oc->title, sizeof(oc->title), str_title);
3041         if (str_author)
3042             pstrcpy(oc->author, sizeof(oc->author), str_author);
3043         if (str_copyright)
3044             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3045         if (str_comment)
3046             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3047         if (str_album)
3048             pstrcpy(oc->album, sizeof(oc->album), str_album);
3049     }
3050
3051     output_files[nb_output_files++] = oc;
3052
3053     /* check filename in case of an image number is expected */
3054     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3055         if (!av_filename_number_test(oc->filename)) {
3056             print_error(oc->filename, AVERROR_NUMEXPECTED);
3057             exit(1);
3058         }
3059     }
3060
3061     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3062         /* test if it already exists to avoid loosing precious files */
3063         if (!file_overwrite &&
3064             (strchr(filename, ':') == NULL ||
3065              strstart(filename, "file:", NULL))) {
3066             if (url_exist(filename)) {
3067                 int c;
3068
3069                 if ( !using_stdin ) {
3070                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3071                     fflush(stderr);
3072                     c = getchar();
3073                     if (toupper(c) != 'Y') {
3074                         fprintf(stderr, "Not overwriting - exiting\n");
3075                         exit(1);
3076                     }
3077                                 }
3078                                 else {
3079                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3080                     exit(1);
3081                                 }
3082             }
3083         }
3084
3085         /* open the file */
3086         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3087             fprintf(stderr, "Could not open '%s'\n", filename);
3088             exit(1);
3089         }
3090     }
3091
3092     memset(ap, 0, sizeof(*ap));
3093     if (av_set_parameters(oc, ap) < 0) {
3094         fprintf(stderr, "%s: Invalid encoding parameters\n",
3095                 oc->filename);
3096         exit(1);
3097     }
3098
3099     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3100     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3101     oc->loop_output = loop_output;
3102
3103     for(i=0; i<opt_name_count; i++){
3104         const AVOption *opt;
3105         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3106         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3107             av_set_double(oc, opt_names[i], d);
3108     }
3109
3110     /* reset some options */
3111     file_oformat = NULL;
3112     file_iformat = NULL;
3113 }
3114
3115 /* same option as mencoder */
3116 static void opt_pass(const char *pass_str)
3117 {
3118     int pass;
3119     pass = atoi(pass_str);
3120     if (pass != 1 && pass != 2) {
3121         fprintf(stderr, "pass number can be only 1 or 2\n");
3122         exit(1);
3123     }
3124     do_pass = pass;
3125 }
3126
3127 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3128 static int64_t getutime(void)
3129 {
3130   return av_gettime();
3131 }
3132 #else
3133 static int64_t getutime(void)
3134 {
3135     struct rusage rusage;
3136
3137     getrusage(RUSAGE_SELF, &rusage);
3138     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3139 }
3140 #endif
3141
3142 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3143 extern int ffm_nopts;
3144 #endif
3145
3146 static void show_formats(void)
3147 {
3148     AVInputFormat *ifmt;
3149     AVOutputFormat *ofmt;
3150     URLProtocol *up;
3151     AVCodec *p, *p2;
3152     const char **pp, *last_name;
3153
3154     printf("File formats:\n");
3155     last_name= "000";
3156     for(;;){
3157         int decode=0;
3158         int encode=0;
3159         const char *name=NULL;
3160         const char *long_name=NULL;
3161
3162         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3163             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3164                 strcmp(ofmt->name, last_name)>0){
3165                 name= ofmt->name;
3166                 long_name= ofmt->long_name;
3167                 encode=1;
3168             }
3169         }
3170         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3171             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3172                 strcmp(ifmt->name, last_name)>0){
3173                 name= ifmt->name;
3174                 long_name= ifmt->long_name;
3175                 encode=0;
3176             }
3177             if(name && strcmp(ifmt->name, name)==0)
3178                 decode=1;
3179         }
3180         if(name==NULL)
3181             break;
3182         last_name= name;
3183
3184         printf(
3185             " %s%s %-15s %s\n",
3186             decode ? "D":" ",
3187             encode ? "E":" ",
3188             name,
3189             long_name ? long_name:" ");
3190     }
3191     printf("\n");
3192
3193     printf("Codecs:\n");
3194     last_name= "000";
3195     for(;;){
3196         int decode=0;
3197         int encode=0;
3198         int cap=0;
3199         const char *type_str;
3200
3201         p2=NULL;
3202         for(p = first_avcodec; p != NULL; p = p->next) {
3203             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3204                 strcmp(p->name, last_name)>0){
3205                 p2= p;
3206                 decode= encode= cap=0;
3207             }
3208             if(p2 && strcmp(p->name, p2->name)==0){
3209                 if(p->decode) decode=1;
3210                 if(p->encode) encode=1;
3211                 cap |= p->capabilities;
3212             }
3213         }
3214         if(p2==NULL)
3215             break;
3216         last_name= p2->name;
3217
3218         switch(p2->type) {
3219         case CODEC_TYPE_VIDEO:
3220             type_str = "V";
3221             break;
3222         case CODEC_TYPE_AUDIO:
3223             type_str = "A";
3224             break;
3225         case CODEC_TYPE_SUBTITLE:
3226             type_str = "S";
3227             break;
3228         default:
3229             type_str = "?";
3230             break;
3231         }
3232         printf(
3233             " %s%s%s%s%s%s %s",
3234             decode ? "D": (/*p2->decoder ? "d":*/" "),
3235             encode ? "E":" ",
3236             type_str,
3237             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3238             cap & CODEC_CAP_DR1 ? "D":" ",
3239             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3240             p2->name);
3241        /* if(p2->decoder && decode==0)
3242             printf(" use %s for decoding", p2->decoder->name);*/
3243         printf("\n");
3244     }
3245     printf("\n");
3246
3247     printf("Supported file protocols:\n");
3248     for(up = first_protocol; up != NULL; up = up->next)
3249         printf(" %s:", up->name);
3250     printf("\n");
3251
3252     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3253     printf("Motion estimation methods:\n");
3254     pp = motion_str;
3255     while (*pp) {
3256         printf(" %s", *pp);
3257         if ((pp - motion_str + 1) == ME_ZERO)
3258             printf("(fastest)");
3259         else if ((pp - motion_str + 1) == ME_FULL)
3260             printf("(slowest)");
3261         else if ((pp - motion_str + 1) == ME_EPZS)
3262             printf("(default)");
3263         pp++;
3264     }
3265     printf("\n\n");
3266     printf(
3267 "Note, the names of encoders and decoders dont always match, so there are\n"
3268 "several cases where the above table shows encoder only or decoder only entries\n"
3269 "even though both encoding and decoding are supported for example, the h263\n"
3270 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3271 "worse\n");
3272     exit(1);
3273 }
3274
3275 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3276 {
3277     int i;
3278     const char *p = str;
3279     for(i = 0;; i++) {
3280         dest[i] = atoi(p);
3281         if(i == 63)
3282             break;
3283         p = strchr(p, ',');
3284         if(!p) {
3285             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3286             exit(1);
3287         }
3288         p++;
3289     }
3290 }
3291
3292 static void opt_inter_matrix(const char *arg)
3293 {
3294     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3295     parse_matrix_coeffs(inter_matrix, arg);
3296 }
3297
3298 static void opt_intra_matrix(const char *arg)
3299 {
3300     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3301     parse_matrix_coeffs(intra_matrix, arg);
3302 }
3303
3304 static void opt_target(const char *arg)
3305 {
3306     int norm = -1;
3307     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3308
3309     if(!strncmp(arg, "pal-", 4)) {
3310         norm = 0;
3311         arg += 4;
3312     } else if(!strncmp(arg, "ntsc-", 5)) {
3313         norm = 1;
3314         arg += 5;
3315     } else if(!strncmp(arg, "film-", 5)) {
3316         norm = 2;
3317         arg += 5;
3318     } else {
3319         int fr;
3320         /* Calculate FR via float to avoid int overflow */
3321         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3322         if(fr == 25000) {
3323             norm = 0;
3324         } else if((fr == 29970) || (fr == 23976)) {
3325             norm = 1;
3326         } else {
3327             /* Try to determine PAL/NTSC by peeking in the input files */
3328             if(nb_input_files) {
3329                 int i, j;
3330                 for(j = 0; j < nb_input_files; j++) {
3331                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3332                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3333                         if(c->codec_type != CODEC_TYPE_VIDEO)
3334                             continue;
3335                         fr = c->time_base.den * 1000 / c->time_base.num;
3336                         if(fr == 25000) {
3337                             norm = 0;
3338                             break;
3339                         } else if((fr == 29970) || (fr == 23976)) {
3340                             norm = 1;
3341                             break;
3342                         }
3343                     }
3344                     if(norm >= 0)
3345                         break;
3346                 }
3347             }
3348         }
3349         if(verbose && norm >= 0)
3350             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3351     }
3352
3353     if(norm < 0) {
3354         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3355         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3356         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3357         exit(1);
3358     }
3359
3360     if(!strcmp(arg, "vcd")) {
3361
3362         opt_video_codec("mpeg1video");
3363         opt_audio_codec("mp2");
3364         opt_format("vcd");
3365
3366         opt_frame_size(norm ? "352x240" : "352x288");
3367         opt_frame_rate(frame_rates[norm]);
3368         opt_default("gop", norm ? "18" : "15");
3369
3370         opt_default("b", "1150000");
3371         opt_default("maxrate", "1150000");
3372         opt_default("minrate", "1150000");
3373         opt_default("bufsize", "327680"); // 40*1024*8;
3374
3375         opt_default("ab", "224000");
3376         audio_sample_rate = 44100;
3377         audio_channels = 2;
3378
3379         opt_default("packetsize", "2324");
3380         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3381
3382         /* We have to offset the PTS, so that it is consistent with the SCR.
3383            SCR starts at 36000, but the first two packs contain only padding
3384            and the first pack from the other stream, respectively, may also have
3385            been written before.
3386            So the real data starts at SCR 36000+3*1200. */
3387         mux_preload= (36000+3*1200) / 90000.0; //0.44
3388     } else if(!strcmp(arg, "svcd")) {
3389
3390         opt_video_codec("mpeg2video");
3391         opt_audio_codec("mp2");
3392         opt_format("svcd");
3393
3394         opt_frame_size(norm ? "480x480" : "480x576");
3395         opt_frame_rate(frame_rates[norm]);
3396         opt_default("gop", norm ? "18" : "15");
3397
3398         opt_default("b", "2040000");
3399         opt_default("maxrate", "2516000");
3400         opt_default("minrate", "0"); //1145000;
3401         opt_default("bufsize", "1835008"); //224*1024*8;
3402         opt_default("flags", "+SCAN_OFFSET");
3403
3404
3405         opt_default("ab", "224000");
3406         audio_sample_rate = 44100;
3407
3408         opt_default("packetsize", "2324");
3409
3410     } else if(!strcmp(arg, "dvd")) {
3411
3412         opt_video_codec("mpeg2video");
3413         opt_audio_codec("ac3");
3414         opt_format("dvd");
3415
3416         opt_frame_size(norm ? "720x480" : "720x576");
3417         opt_frame_rate(frame_rates[norm]);
3418         opt_default("gop", norm ? "18" : "15");
3419
3420         opt_default("b", "6000000");
3421         opt_default("maxrate", "9000000");
3422         opt_default("minrate", "0"); //1500000;
3423         opt_default("bufsize", "1835008"); //224*1024*8;
3424
3425         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3426         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3427
3428         opt_default("ab", "448000");
3429         audio_sample_rate = 48000;
3430
3431     } else if(!strncmp(arg, "dv", 2)) {
3432
3433         opt_format("dv");
3434
3435         opt_frame_size(norm ? "720x480" : "720x576");
3436         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3437                                              (norm ? "yuv411p" : "yuv420p"));
3438         opt_frame_rate(frame_rates[norm]);
3439
3440         audio_sample_rate = 48000;
3441         audio_channels = 2;
3442
3443     } else {
3444         fprintf(stderr, "Unknown target: %s\n", arg);
3445         exit(1);
3446     }
3447 }
3448
3449 static void opt_vstats_file (const char *arg)
3450 {
3451     av_free (vstats_filename);
3452     vstats_filename=av_strdup (arg);
3453 }
3454
3455 static void opt_vstats (void)
3456 {
3457     char filename[40];
3458     time_t today2 = time(NULL);
3459     struct tm *today = localtime(&today2);
3460
3461     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3462              today->tm_sec);
3463     opt_vstats_file(filename);
3464 }
3465
3466 static void opt_video_bsf(const char *arg)
3467 {
3468     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3469     AVBitStreamFilterContext **bsfp;
3470
3471     if(!bsfc){
3472         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3473         exit(1);
3474     }
3475
3476     bsfp= &video_bitstream_filters;
3477     while(*bsfp)
3478         bsfp= &(*bsfp)->next;
3479
3480     *bsfp= bsfc;
3481 }
3482
3483 //FIXME avoid audio - video code duplication
3484 static void opt_audio_bsf(const char *arg)
3485 {
3486     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3487     AVBitStreamFilterContext **bsfp;
3488
3489     if(!bsfc){
3490         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3491         exit(1);
3492     }
3493
3494     bsfp= &audio_bitstream_filters;
3495     while(*bsfp)
3496         bsfp= &(*bsfp)->next;
3497
3498     *bsfp= bsfc;
3499 }
3500
3501 static void show_version(void)
3502 {
3503     /* TODO: add function interface to avutil and avformat */
3504     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3505            "libavutil   %d\n"
3506            "libavcodec  %d\n"
3507            "libavformat %d\n",
3508            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3509     exit(1);
3510 }
3511
3512 static int opt_default(const char *opt, const char *arg){
3513     int type;
3514     const AVOption *o= NULL;
3515     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3516
3517     for(type=0; type<CODEC_TYPE_NB; type++){
3518         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3519         if(o2)
3520             o = av_set_string(avctx_opts[type], opt, arg);
3521     }
3522     if(!o)
3523         o = av_set_string(avformat_opts, opt, arg);
3524 #ifdef CONFIG_SWSCALER
3525     if(!o)
3526         o = av_set_string(sws_opts, opt, arg);
3527 #endif
3528     if(!o){
3529         if(opt[0] == 'a')
3530             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3531         else if(opt[0] == 'v')
3532             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3533         else if(opt[0] == 's')
3534             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3535     }
3536     if(!o)
3537         return -1;
3538
3539 //    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));
3540
3541     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3542     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3543     opt_names[opt_name_count++]= o->name;
3544
3545 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3546     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3547     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3548         ffm_nopts = 1;
3549 #endif
3550
3551     if(avctx_opts[0]->debug)
3552         av_log_level = AV_LOG_DEBUG;
3553     return 0;
3554 }
3555
3556 const OptionDef options[] = {
3557     /* main options */
3558     { "L", 0, {(void*)show_license}, "show license" },
3559     { "h", 0, {(void*)show_help}, "show help" },
3560     { "version", 0, {(void*)show_version}, "show version" },
3561     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3562     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3563     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3564     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3565     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3566     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3567     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3568     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3569     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3570     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3571     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3572     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3573     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3574     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3575     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3576     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3577     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3578       "add timings for benchmarking" },
3579     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3580       "dump each input packet" },
3581     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3582       "when dumping packets, also dump the payload" },
3583     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3584     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3585     { "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)", "" },
3586     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3587     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3588     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3589     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3590     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3591     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3592     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3593     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3594     { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3595
3596     /* video options */
3597     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3598     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3599     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3600     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3601     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3602     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3603     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3604     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3605     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3606     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3607     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3608     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3609     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3610     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3611     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3612     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3613     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3614     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3615     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3616     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3617     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3618     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3619     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3620     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3621       "method" },
3622     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3623     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3624     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3625       "use same video quality as source (implies VBR)" },
3626     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3627     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3628     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3629       "deinterlace pictures" },
3630     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3631     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3632     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3633     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3634     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3635     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3636     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3637     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3638     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3639     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3640     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3641
3642     /* audio options */
3643     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3644     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3645     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3646     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3647     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3648     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3649     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3650     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3651     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3652     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3653
3654     /* subtitle options */
3655     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3656     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3657     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3658
3659     /* grab options */
3660     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3661     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3662     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3663
3664     /* muxer options */
3665     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3666     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3667
3668     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3669     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3670
3671     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3672     { NULL, },
3673 };
3674
3675 static void show_banner(void)
3676 {
3677     fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3678     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3679     fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3680     fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3681     fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3682     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3683 #ifdef __GNUC__
3684     fprintf(stderr, ", gcc: " __VERSION__ "\n");
3685 #else
3686     fprintf(stderr, ", using a non-gcc compiler\n");
3687 #endif
3688 }
3689
3690 static void show_license(void)
3691 {
3692     show_banner();
3693 #ifdef CONFIG_GPL
3694     printf(
3695     "FFmpeg is free software; you can redistribute it and/or modify\n"
3696     "it under the terms of the GNU General Public License as published by\n"
3697     "the Free Software Foundation; either version 2 of the License, or\n"
3698     "(at your option) any later version.\n"
3699     "\n"
3700     "FFmpeg is distributed in the hope that it will be useful,\n"
3701     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3702     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3703     "GNU General Public License for more details.\n"
3704     "\n"
3705     "You should have received a copy of the GNU General Public License\n"
3706     "along with FFmpeg; if not, write to the Free Software\n"
3707     "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3708     );
3709 #else
3710     printf(
3711     "FFmpeg is free software; you can redistribute it and/or\n"
3712     "modify it under the terms of the GNU Lesser General Public\n"
3713     "License as published by the Free Software Foundation; either\n"
3714     "version 2.1 of the License, or (at your option) any later version.\n"
3715     "\n"
3716     "FFmpeg is distributed in the hope that it will be useful,\n"
3717     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3718     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3719     "Lesser General Public License for more details.\n"
3720     "\n"
3721     "You should have received a copy of the GNU Lesser General Public\n"
3722     "License along with FFmpeg; if not, write to the Free Software\n"
3723     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3724     );
3725 #endif
3726     exit(1);
3727 }
3728
3729 /**
3730  * Trivial log callback.
3731  * Only suitable for show_help and similar since it lacks prefix handling.
3732  */
3733 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3734 {
3735     vfprintf(stdout, fmt, vl);
3736 }
3737
3738 static void show_help(void)
3739 {
3740     av_log_set_callback(log_callback_help);
3741     show_banner();
3742     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3743            "Hyper fast Audio and Video encoder\n");
3744     printf("\n");
3745     show_help_options(options, "Main options:\n",
3746                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3747     show_help_options(options, "\nVideo options:\n",
3748                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3749                       OPT_VIDEO);
3750     show_help_options(options, "\nAdvanced Video options:\n",
3751                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3752                       OPT_VIDEO | OPT_EXPERT);
3753     show_help_options(options, "\nAudio options:\n",
3754                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3755                       OPT_AUDIO);
3756     show_help_options(options, "\nAdvanced Audio options:\n",
3757                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3758                       OPT_AUDIO | OPT_EXPERT);
3759     show_help_options(options, "\nSubtitle options:\n",
3760                       OPT_SUBTITLE | OPT_GRAB,
3761                       OPT_SUBTITLE);
3762     show_help_options(options, "\nAudio/Video grab options:\n",
3763                       OPT_GRAB,
3764                       OPT_GRAB);
3765     show_help_options(options, "\nAdvanced options:\n",
3766                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3767                       OPT_EXPERT);
3768     av_opt_show(avctx_opts[0], NULL);
3769     av_opt_show(avformat_opts, NULL);
3770 #ifdef CONFIG_SWSCALER
3771     av_opt_show(sws_opts, NULL);
3772 #endif
3773
3774     exit(1);
3775 }
3776
3777 void parse_arg_file(const char *filename)
3778 {
3779     opt_output_file(filename);
3780 }
3781
3782 int main(int argc, char **argv)
3783 {
3784     int i;
3785     int64_t ti;
3786
3787     av_register_all();
3788
3789     for(i=0; i<CODEC_TYPE_NB; i++){
3790         avctx_opts[i]= avcodec_alloc_context2(i);
3791     }
3792     avformat_opts = av_alloc_format_context();
3793 #ifdef CONFIG_SWSCALER
3794     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, sws_flags, NULL,NULL,NULL);
3795 #endif
3796
3797     if (argc <= 1)
3798         show_help();
3799     else
3800         show_banner();
3801
3802     /* parse options */
3803     parse_options(argc, argv, options);
3804
3805     /* file converter / grab */
3806     if (nb_output_files <= 0) {
3807         fprintf(stderr, "Must supply at least one output file\n");
3808         exit(1);
3809     }
3810
3811     if (nb_input_files == 0) {
3812         fprintf(stderr, "Must supply at least one input file\n");
3813         exit(1);
3814     }
3815
3816     ti = getutime();
3817     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3818               stream_maps, nb_stream_maps);
3819     ti = getutime() - ti;
3820     if (do_benchmark) {
3821         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3822     }
3823
3824     /* close files */
3825     for(i=0;i<nb_output_files;i++) {
3826         /* maybe av_close_output_file ??? */
3827         AVFormatContext *s = output_files[i];
3828         int j;
3829         if (!(s->oformat->flags & AVFMT_NOFILE))
3830             url_fclose(&s->pb);
3831         for(j=0;j<s->nb_streams;j++) {
3832             av_free(s->streams[j]->codec);
3833             av_free(s->streams[j]);
3834         }
3835         av_free(s);
3836     }
3837     for(i=0;i<nb_input_files;i++)
3838         av_close_input_file(input_files[i]);
3839
3840     av_free_static();
3841
3842     av_free(intra_matrix);
3843     av_free(inter_matrix);
3844
3845     if (fvstats)
3846         fclose(fvstats);
3847     av_free(vstats_filename);
3848
3849     av_free(opt_names);
3850
3851     av_free(video_standard);
3852
3853 #ifdef CONFIG_POWERPC_PERF
3854     extern void powerpc_display_perf_report(void);
3855     powerpc_display_perf_report();
3856 #endif /* CONFIG_POWERPC_PERF */
3857
3858     if (received_sigterm) {
3859         fprintf(stderr,
3860             "Received signal %d: terminating.\n",
3861             (int) received_sigterm);
3862         exit (255);
3863     }
3864
3865     exit(0); /* not all OS-es handle main() return value */
3866     return 0;
3867 }