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