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

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