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