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

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