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

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