ffmpeg.c

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