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