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

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