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