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