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