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