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