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(ost->st->codec->codec_id != CODEC_ID_H264) {
1411                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1412                             opkt.destruct= av_destruct_packet;
1413                         } else {
1414                             opkt.data = data_buf;
1415                             opkt.size = data_size;
1416                         }
1417
1418                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1419                         ost->st->codec->frame_number++;
1420                         ost->frame_number++;
1421                         av_free_packet(&opkt);
1422                     }
1423                 }
1424             }
1425         av_free(buffer_to_free);
1426         /* XXX: allocate the subtitles in the codec ? */
1427         if (subtitle_to_free) {
1428             if (subtitle_to_free->rects != NULL) {
1429                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1430                     av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1431                     av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1432                     av_freep(&subtitle_to_free->rects[i]);
1433                 }
1434                 av_freep(&subtitle_to_free->rects);
1435             }
1436             subtitle_to_free->num_rects = 0;
1437             subtitle_to_free = NULL;
1438         }
1439     }
1440  discard_packet:
1441     if (pkt == NULL) {
1442         /* EOF handling */
1443
1444         for(i=0;i<nb_ostreams;i++) {
1445             ost = ost_table[i];
1446             if (ost->source_index == ist_index) {
1447                 AVCodecContext *enc= ost->st->codec;
1448                 os = output_files[ost->file_index];
1449
1450                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1451                     continue;
1452                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1453                     continue;
1454
1455                 if (ost->encoding_needed) {
1456                     for(;;) {
1457                         AVPacket pkt;
1458                         int fifo_bytes;
1459                         av_init_packet(&pkt);
1460                         pkt.stream_index= ost->index;
1461
1462                         switch(ost->st->codec->codec_type) {
1463                         case CODEC_TYPE_AUDIO:
1464                             fifo_bytes = av_fifo_size(ost->fifo);
1465                             ret = 0;
1466                             /* encode any samples remaining in fifo */
1467                             if (fifo_bytes > 0) {
1468                                 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1469                                 int fs_tmp = enc->frame_size;
1470
1471                                 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1472                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1473                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1474                                 } else { /* pad */
1475                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1476                                     if (samples_size < frame_bytes)
1477                                         av_exit(1);
1478                                     memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1479                                 }
1480
1481                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1482                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1483                                                           ost->st->time_base.num, enc->sample_rate);
1484                                 enc->frame_size = fs_tmp;
1485                             }
1486                             if(ret <= 0) {
1487                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1488                             }
1489                             if (ret < 0) {
1490                                 fprintf(stderr, "Audio encoding failed\n");
1491                                 av_exit(1);
1492                             }
1493                             audio_size += ret;
1494                             pkt.flags |= PKT_FLAG_KEY;
1495                             break;
1496                         case CODEC_TYPE_VIDEO:
1497                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1498                             if (ret < 0) {
1499                                 fprintf(stderr, "Video encoding failed\n");
1500                                 av_exit(1);
1501                             }
1502                             video_size += ret;
1503                             if(enc->coded_frame && enc->coded_frame->key_frame)
1504                                 pkt.flags |= PKT_FLAG_KEY;
1505                             if (ost->logfile && enc->stats_out) {
1506                                 fprintf(ost->logfile, "%s", enc->stats_out);
1507                             }
1508                             break;
1509                         default:
1510                             ret=-1;
1511                         }
1512
1513                         if(ret<=0)
1514                             break;
1515                         pkt.data= bit_buffer;
1516                         pkt.size= ret;
1517                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1518                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1519                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1520                     }
1521                 }
1522             }
1523         }
1524     }
1525
1526     return 0;
1527  fail_decode:
1528     return -1;
1529 }
1530
1531 static void print_sdp(AVFormatContext **avc, int n)
1532 {
1533     char sdp[2048];
1534
1535     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1536     printf("SDP:\n%s\n", sdp);
1537     fflush(stdout);
1538 }
1539
1540 static int stream_index_from_inputs(AVFormatContext **input_files,
1541                                     int nb_input_files,
1542                                     AVInputFile *file_table,
1543                                     AVInputStream **ist_table,
1544                                     enum CodecType type,
1545                                     int programid)
1546 {
1547     int p, q, z;
1548     for(z=0; z<nb_input_files; z++) {
1549         AVFormatContext *ic = input_files[z];
1550         for(p=0; p<ic->nb_programs; p++) {
1551             AVProgram *program = ic->programs[p];
1552             if(program->id != programid)
1553                 continue;
1554             for(q=0; q<program->nb_stream_indexes; q++) {
1555                 int sidx = program->stream_index[q];
1556                 int ris = file_table[z].ist_index + sidx;
1557                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1558                     return ris;
1559             }
1560         }
1561     }
1562
1563     return -1;
1564 }
1565
1566 /*
1567  * The following code is the main loop of the file converter
1568  */
1569 static int av_encode(AVFormatContext **output_files,
1570                      int nb_output_files,
1571                      AVFormatContext **input_files,
1572                      int nb_input_files,
1573                      AVStreamMap *stream_maps, int nb_stream_maps)
1574 {
1575     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1576     AVFormatContext *is, *os;
1577     AVCodecContext *codec, *icodec;
1578     AVOutputStream *ost, **ost_table = NULL;
1579     AVInputStream *ist, **ist_table = NULL;
1580     AVInputFile *file_table;
1581     char error[1024];
1582     int key;
1583     int want_sdp = 1;
1584     uint8_t no_packet[MAX_FILES]={0};
1585     int no_packet_count=0;
1586
1587     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1588     if (!file_table)
1589         goto fail;
1590
1591     /* input stream init */
1592     j = 0;
1593     for(i=0;i<nb_input_files;i++) {
1594         is = input_files[i];
1595         file_table[i].ist_index = j;
1596         file_table[i].nb_streams = is->nb_streams;
1597         j += is->nb_streams;
1598     }
1599     nb_istreams = j;
1600
1601     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1602     if (!ist_table)
1603         goto fail;
1604
1605     for(i=0;i<nb_istreams;i++) {
1606         ist = av_mallocz(sizeof(AVInputStream));
1607         if (!ist)
1608             goto fail;
1609         ist_table[i] = ist;
1610     }
1611     j = 0;
1612     for(i=0;i<nb_input_files;i++) {
1613         is = input_files[i];
1614         for(k=0;k<is->nb_streams;k++) {
1615             ist = ist_table[j++];
1616             ist->st = is->streams[k];
1617             ist->file_index = i;
1618             ist->index = k;
1619             ist->discard = 1; /* the stream is discarded by default
1620                                  (changed later) */
1621
1622             if (rate_emu) {
1623                 ist->start = av_gettime();
1624             }
1625         }
1626     }
1627
1628     /* output stream init */
1629     nb_ostreams = 0;
1630     for(i=0;i<nb_output_files;i++) {
1631         os = output_files[i];
1632         if (!os->nb_streams) {
1633             dump_format(output_files[i], i, output_files[i]->filename, 1);
1634             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1635             av_exit(1);
1636         }
1637         nb_ostreams += os->nb_streams;
1638     }
1639     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1640         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1641         av_exit(1);
1642     }
1643
1644     /* Sanity check the mapping args -- do the input files & streams exist? */
1645     for(i=0;i<nb_stream_maps;i++) {
1646         int fi = stream_maps[i].file_index;
1647         int si = stream_maps[i].stream_index;
1648
1649         if (fi < 0 || fi > nb_input_files - 1 ||
1650             si < 0 || si > file_table[fi].nb_streams - 1) {
1651             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1652             av_exit(1);
1653         }
1654         fi = stream_maps[i].sync_file_index;
1655         si = stream_maps[i].sync_stream_index;
1656         if (fi < 0 || fi > nb_input_files - 1 ||
1657             si < 0 || si > file_table[fi].nb_streams - 1) {
1658             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1659             av_exit(1);
1660         }
1661     }
1662
1663     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1664     if (!ost_table)
1665         goto fail;
1666     for(i=0;i<nb_ostreams;i++) {
1667         ost = av_mallocz(sizeof(AVOutputStream));
1668         if (!ost)
1669             goto fail;
1670         ost_table[i] = ost;
1671     }
1672
1673     n = 0;
1674     for(k=0;k<nb_output_files;k++) {
1675         os = output_files[k];
1676         for(i=0;i<os->nb_streams;i++,n++) {
1677             int found;
1678             ost = ost_table[n];
1679             ost->file_index = k;
1680             ost->index = i;
1681             ost->st = os->streams[i];
1682             if (nb_stream_maps > 0) {
1683                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1684                     stream_maps[n].stream_index;
1685
1686                 /* Sanity check that the stream types match */
1687                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1688                     int i= ost->file_index;
1689                     dump_format(output_files[i], i, output_files[i]->filename, 1);
1690                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1691                         stream_maps[n].file_index, stream_maps[n].stream_index,
1692                         ost->file_index, ost->index);
1693                     av_exit(1);
1694                 }
1695
1696             } else {
1697                 if(opt_programid) {
1698                     found = 0;
1699                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1700                     if(j != -1) {
1701                         ost->source_index = j;
1702                         found = 1;
1703                     }
1704                 } else {
1705                     /* get corresponding input stream index : we select the first one with the right type */
1706                     found = 0;
1707                     for(j=0;j<nb_istreams;j++) {
1708                         ist = ist_table[j];
1709                         if (ist->discard &&
1710                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1711                             ost->source_index = j;
1712                             found = 1;
1713                             break;
1714                         }
1715                     }
1716                 }
1717
1718                 if (!found) {
1719                     if(! opt_programid) {
1720                         /* try again and reuse existing stream */
1721                         for(j=0;j<nb_istreams;j++) {
1722                             ist = ist_table[j];
1723                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1724                                 ost->source_index = j;
1725                                 found = 1;
1726                             }
1727                         }
1728                     }
1729                     if (!found) {
1730                         int i= ost->file_index;
1731                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1732                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1733                                 ost->file_index, ost->index);
1734                         av_exit(1);
1735                     }
1736                 }
1737             }
1738             ist = ist_table[ost->source_index];
1739             ist->discard = 0;
1740             ost->sync_ist = (nb_stream_maps > 0) ?
1741                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1742                          stream_maps[n].sync_stream_index] : ist;
1743         }
1744     }
1745
1746     /* for each output stream, we compute the right encoding parameters */
1747     for(i=0;i<nb_ostreams;i++) {
1748         AVMetadataTag *lang;
1749         ost = ost_table[i];
1750         os = output_files[ost->file_index];
1751         ist = ist_table[ost->source_index];
1752
1753         codec = ost->st->codec;
1754         icodec = ist->st->codec;
1755
1756         if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1757             &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1758             av_metadata_set(&ost->st->metadata, "language", lang->value);
1759
1760         ost->st->disposition = ist->st->disposition;
1761         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1762         codec->chroma_sample_location = icodec->chroma_sample_location;
1763
1764         if (ost->st->stream_copy) {
1765             /* if stream_copy is selected, no need to decode or encode */
1766             codec->codec_id = icodec->codec_id;
1767             codec->codec_type = icodec->codec_type;
1768
1769             if(!codec->codec_tag){
1770                 if(   !os->oformat->codec_tag
1771                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1772                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1773                     codec->codec_tag = icodec->codec_tag;
1774             }
1775
1776             codec->bit_rate = icodec->bit_rate;
1777             codec->extradata= icodec->extradata;
1778             codec->extradata_size= icodec->extradata_size;
1779             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){
1780                 codec->time_base = icodec->time_base;
1781                 codec->time_base.num *= icodec->ticks_per_frame;
1782             }else
1783                 codec->time_base = ist->st->time_base;
1784             switch(codec->codec_type) {
1785             case CODEC_TYPE_AUDIO:
1786                 if(audio_volume != 256) {
1787                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1788                     av_exit(1);
1789                 }
1790                 codec->channel_layout = icodec->channel_layout;
1791                 codec->sample_rate = icodec->sample_rate;
1792                 codec->channels = icodec->channels;
1793                 codec->frame_size = icodec->frame_size;
1794                 codec->block_align= icodec->block_align;
1795                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1796                     codec->block_align= 0;
1797                 if(codec->codec_id == CODEC_ID_AC3)
1798                     codec->block_align= 0;
1799                 break;
1800             case CODEC_TYPE_VIDEO:
1801                 codec->pix_fmt = icodec->pix_fmt;
1802                 codec->width = icodec->width;
1803                 codec->height = icodec->height;
1804                 codec->has_b_frames = icodec->has_b_frames;
1805                 break;
1806             case CODEC_TYPE_SUBTITLE:
1807                 codec->width = icodec->width;
1808                 codec->height = icodec->height;
1809                 break;
1810             default:
1811                 abort();
1812             }
1813         } else {
1814             switch(codec->codec_type) {
1815             case CODEC_TYPE_AUDIO:
1816                 ost->fifo= av_fifo_alloc(1024);
1817                 if(!ost->fifo)
1818                     goto fail;
1819                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1820                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1821                 icodec->request_channels = codec->channels;
1822                 ist->decoding_needed = 1;
1823                 ost->encoding_needed = 1;
1824                 break;
1825             case CODEC_TYPE_VIDEO:
1826                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1827                     fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1828                     av_exit(1);
1829                 }
1830                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1831                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1832                 ost->video_resample = ((codec->width != icodec->width -
1833                                 (frame_leftBand + frame_rightBand) +
1834                                 (frame_padleft + frame_padright)) ||
1835                         (codec->height != icodec->height -
1836                                 (frame_topBand  + frame_bottomBand) +
1837                                 (frame_padtop + frame_padbottom)) ||
1838                         (codec->pix_fmt != icodec->pix_fmt));
1839                 if (ost->video_crop) {
1840                     ost->topBand = frame_topBand;
1841                     ost->leftBand = frame_leftBand;
1842                 }
1843                 if (ost->video_pad) {
1844                     ost->padtop = frame_padtop;
1845                     ost->padleft = frame_padleft;
1846                     ost->padbottom = frame_padbottom;
1847                     ost->padright = frame_padright;
1848                     if (!ost->video_resample) {
1849                         avcodec_get_frame_defaults(&ost->pict_tmp);
1850                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1851                                          codec->width, codec->height))
1852                             goto fail;
1853                     }
1854                 }
1855                 if (ost->video_resample) {
1856                     avcodec_get_frame_defaults(&ost->pict_tmp);
1857                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1858                                          codec->width, codec->height)) {
1859                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1860                         av_exit(1);
1861                     }
1862                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1863                     ost->img_resample_ctx = sws_getContext(
1864                             icodec->width - (frame_leftBand + frame_rightBand),
1865                             icodec->height - (frame_topBand + frame_bottomBand),
1866                             icodec->pix_fmt,
1867                             codec->width - (frame_padleft + frame_padright),
1868                             codec->height - (frame_padtop + frame_padbottom),
1869                             codec->pix_fmt,
1870                             sws_flags, NULL, NULL, NULL);
1871                     if (ost->img_resample_ctx == NULL) {
1872                         fprintf(stderr, "Cannot get resampling context\n");
1873                         av_exit(1);
1874                     }
1875                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1876                     codec->bits_per_raw_sample= 0;
1877                 }
1878                 ost->encoding_needed = 1;
1879                 ist->decoding_needed = 1;
1880                 break;
1881             case CODEC_TYPE_SUBTITLE:
1882                 ost->encoding_needed = 1;
1883                 ist->decoding_needed = 1;
1884                 break;
1885             default:
1886                 abort();
1887                 break;
1888             }
1889             /* two pass mode */
1890             if (ost->encoding_needed &&
1891                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1892                 char logfilename[1024];
1893                 FILE *f;
1894                 int size;
1895                 char *logbuffer;
1896
1897                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1898                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1899                          i);
1900                 if (codec->flags & CODEC_FLAG_PASS1) {
1901                     f = fopen(logfilename, "w");
1902                     if (!f) {
1903                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1904                         av_exit(1);
1905                     }
1906                     ost->logfile = f;
1907                 } else {
1908                     /* read the log file */
1909                     f = fopen(logfilename, "r");
1910                     if (!f) {
1911                         fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1912                         av_exit(1);
1913                     }
1914                     fseek(f, 0, SEEK_END);
1915                     size = ftell(f);
1916                     fseek(f, 0, SEEK_SET);
1917                     logbuffer = av_malloc(size + 1);
1918                     if (!logbuffer) {
1919                         fprintf(stderr, "Could not allocate log buffer\n");
1920                         av_exit(1);
1921                     }
1922                     size = fread(logbuffer, 1, size, f);
1923                     fclose(f);
1924                     logbuffer[size] = '\0';
1925                     codec->stats_in = logbuffer;
1926                 }
1927             }
1928         }
1929         if(codec->codec_type == CODEC_TYPE_VIDEO){
1930             int size= codec->width * codec->height;
1931             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1932         }
1933     }
1934
1935     if (!bit_buffer)
1936         bit_buffer = av_malloc(bit_buffer_size);
1937     if (!bit_buffer) {
1938         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
1939                 bit_buffer_size);
1940         ret = AVERROR(ENOMEM);
1941         goto fail;
1942     }
1943
1944     /* open each encoder */
1945     for(i=0;i<nb_ostreams;i++) {
1946         ost = ost_table[i];
1947         if (ost->encoding_needed) {
1948             AVCodec *codec = output_codecs[i];
1949             if (!codec)
1950                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1951             if (!codec) {
1952                 snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1953                         ost->file_index, ost->index);
1954                 ret = AVERROR(EINVAL);
1955                 goto dump_format;
1956             }
1957             if (avcodec_open(ost->st->codec, codec) < 0) {
1958                 snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1959                         ost->file_index, ost->index);
1960                 ret = AVERROR(EINVAL);
1961                 goto dump_format;
1962             }
1963             extra_size += ost->st->codec->extradata_size;
1964         }
1965     }
1966
1967     /* open each decoder */
1968     for(i=0;i<nb_istreams;i++) {
1969         ist = ist_table[i];
1970         if (ist->decoding_needed) {
1971             AVCodec *codec = input_codecs[i];
1972             if (!codec)
1973                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1974             if (!codec) {
1975                 snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1976                         ist->st->codec->codec_id, ist->file_index, ist->index);
1977                 ret = AVERROR(EINVAL);
1978                 goto dump_format;
1979             }
1980             if (avcodec_open(ist->st->codec, codec) < 0) {
1981                 snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1982                         ist->file_index, ist->index);
1983                 ret = AVERROR(EINVAL);
1984                 goto dump_format;
1985             }
1986             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1987             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1988         }
1989     }
1990
1991     /* init pts */
1992     for(i=0;i<nb_istreams;i++) {
1993         ist = ist_table[i];
1994         ist->pts = 0;
1995         ist->next_pts = AV_NOPTS_VALUE;
1996         ist->is_start = 1;
1997     }
1998
1999     /* set meta data information from input file if required */
2000     for (i=0;i<nb_meta_data_maps;i++) {
2001         AVFormatContext *out_file;
2002         AVFormatContext *in_file;
2003         AVMetadataTag *mtag;
2004
2005         int out_file_index = meta_data_maps[i].out_file;
2006         int in_file_index = meta_data_maps[i].in_file;
2007         if (out_file_index < 0 || out_file_index >= nb_output_files) {
2008             snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2009                      out_file_index, out_file_index, in_file_index);
2010             ret = AVERROR(EINVAL);
2011             goto dump_format;
2012         }
2013         if (in_file_index < 0 || in_file_index >= nb_input_files) {
2014             snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2015                      in_file_index, out_file_index, in_file_index);
2016             ret = AVERROR(EINVAL);
2017             goto dump_format;
2018         }
2019
2020         out_file = output_files[out_file_index];
2021         in_file = input_files[in_file_index];
2022
2023
2024         mtag=NULL;
2025         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2026             av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2027         av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2028                                     in_file->iformat->metadata_conv);
2029     }
2030
2031     /* open files and write file headers */
2032     for(i=0;i<nb_output_files;i++) {
2033         os = output_files[i];
2034         if (av_write_header(os) < 0) {
2035             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2036             ret = AVERROR(EINVAL);
2037             goto dump_format;
2038         }
2039         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2040             want_sdp = 0;
2041         }
2042     }
2043
2044  dump_format:
2045     /* dump the file output parameters - cannot be done before in case
2046        of stream copy */
2047     for(i=0;i<nb_output_files;i++) {
2048         dump_format(output_files[i], i, output_files[i]->filename, 1);
2049     }
2050
2051     /* dump the stream mapping */
2052     if (verbose >= 0) {
2053         fprintf(stderr, "Stream mapping:\n");
2054         for(i=0;i<nb_ostreams;i++) {
2055             ost = ost_table[i];
2056             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2057                     ist_table[ost->source_index]->file_index,
2058                     ist_table[ost->source_index]->index,
2059                     ost->file_index,
2060                     ost->index);
2061             if (ost->sync_ist != ist_table[ost->source_index])
2062                 fprintf(stderr, " [sync #%d.%d]",
2063                         ost->sync_ist->file_index,
2064                         ost->sync_ist->index);
2065             fprintf(stderr, "\n");
2066         }
2067     }
2068
2069     if (ret) {
2070         fprintf(stderr, "%s\n", error);
2071         goto fail;
2072     }
2073
2074     if (want_sdp) {
2075         print_sdp(output_files, nb_output_files);
2076     }
2077
2078     if (!using_stdin && verbose >= 0) {
2079         fprintf(stderr, "Press [q] to stop encoding\n");
2080         url_set_interrupt_cb(decode_interrupt_cb);
2081     }
2082     term_init();
2083
2084     timer_start = av_gettime();
2085
2086     for(; received_sigterm == 0;) {
2087         int file_index, ist_index;
2088         AVPacket pkt;
2089         double ipts_min;
2090         double opts_min;
2091
2092     redo:
2093         ipts_min= 1e100;
2094         opts_min= 1e100;
2095         /* if 'q' pressed, exits */
2096         if (!using_stdin) {
2097             if (q_pressed)
2098                 break;
2099             /* read_key() returns 0 on EOF */
2100             key = read_key();
2101             if (key == 'q')
2102                 break;
2103         }
2104
2105         /* select the stream that we must read now by looking at the
2106            smallest output pts */
2107         file_index = -1;
2108         for(i=0;i<nb_ostreams;i++) {
2109             double ipts, opts;
2110             ost = ost_table[i];
2111             os = output_files[ost->file_index];
2112             ist = ist_table[ost->source_index];
2113             if(no_packet[ist->file_index])
2114                 continue;
2115             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2116                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2117             else
2118                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2119             ipts = (double)ist->pts;
2120             if (!file_table[ist->file_index].eof_reached){
2121                 if(ipts < ipts_min) {
2122                     ipts_min = ipts;
2123                     if(input_sync ) file_index = ist->file_index;
2124                 }
2125                 if(opts < opts_min) {
2126                     opts_min = opts;
2127                     if(!input_sync) file_index = ist->file_index;
2128                 }
2129             }
2130             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2131                 file_index= -1;
2132                 break;
2133             }
2134         }
2135         /* if none, if is finished */
2136         if (file_index < 0) {
2137             if(no_packet_count){
2138                 no_packet_count=0;
2139                 memset(no_packet, 0, sizeof(no_packet));
2140                 usleep(10000);
2141                 continue;
2142             }
2143             break;
2144         }
2145
2146         /* finish if recording time exhausted */
2147         if (opts_min >= (recording_time / 1000000.0))
2148             break;
2149
2150         /* finish if limit size exhausted */
2151         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2152             break;
2153
2154         /* read a frame from it and output it in the fifo */
2155         is = input_files[file_index];
2156         ret= av_read_frame(is, &pkt);
2157         if(ret == AVERROR(EAGAIN)){
2158             no_packet[file_index]=1;
2159             no_packet_count++;
2160             continue;
2161         }
2162         if (ret < 0) {
2163             file_table[file_index].eof_reached = 1;
2164             if (opt_shortest)
2165                 break;
2166             else
2167                 continue;
2168         }
2169
2170         no_packet_count=0;
2171         memset(no_packet, 0, sizeof(no_packet));
2172
2173         if (do_pkt_dump) {
2174             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2175         }
2176         /* the following test is needed in case new streams appear
2177            dynamically in stream : we ignore them */
2178         if (pkt.stream_index >= file_table[file_index].nb_streams)
2179             goto discard_packet;
2180         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2181         ist = ist_table[ist_index];
2182         if (ist->discard)
2183             goto discard_packet;
2184
2185         if (pkt.dts != AV_NOPTS_VALUE)
2186             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2187         if (pkt.pts != AV_NOPTS_VALUE)
2188             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2189
2190         if(input_files_ts_scale[file_index][pkt.stream_index]){
2191             if(pkt.pts != AV_NOPTS_VALUE)
2192                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2193             if(pkt.dts != AV_NOPTS_VALUE)
2194                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2195         }
2196
2197 //        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);
2198         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2199             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2200             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2201             int64_t delta= pkt_dts - ist->next_pts;
2202             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2203                 input_files_ts_offset[ist->file_index]-= delta;
2204                 if (verbose > 2)
2205                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2206                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2207                 if(pkt.pts != AV_NOPTS_VALUE)
2208                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2209             }
2210         }
2211
2212         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2213         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2214
2215             if (verbose >= 0)
2216                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2217                         ist->file_index, ist->index);
2218             if (exit_on_error)
2219                 av_exit(1);
2220             av_free_packet(&pkt);
2221             goto redo;
2222         }
2223
2224     discard_packet:
2225         av_free_packet(&pkt);
2226
2227         /* dump report by using the output first video and audio streams */
2228         print_report(output_files, ost_table, nb_ostreams, 0);
2229     }
2230
2231     /* at the end of stream, we must flush the decoder buffers */
2232     for(i=0;i<nb_istreams;i++) {
2233         ist = ist_table[i];
2234         if (ist->decoding_needed) {
2235             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2236         }
2237     }
2238
2239     term_exit();
2240
2241     /* write the trailer if needed and close file */
2242     for(i=0;i<nb_output_files;i++) {
2243         os = output_files[i];
2244         av_write_trailer(os);
2245     }
2246
2247     /* dump report by using the first video and audio streams */
2248     print_report(output_files, ost_table, nb_ostreams, 1);
2249
2250     /* close each encoder */
2251     for(i=0;i<nb_ostreams;i++) {
2252         ost = ost_table[i];
2253         if (ost->encoding_needed) {
2254             av_freep(&ost->st->codec->stats_in);
2255             avcodec_close(ost->st->codec);
2256         }
2257     }
2258
2259     /* close each decoder */
2260     for(i=0;i<nb_istreams;i++) {
2261         ist = ist_table[i];
2262         if (ist->decoding_needed) {
2263             avcodec_close(ist->st->codec);
2264         }
2265     }
2266
2267     /* finished ! */
2268     ret = 0;
2269
2270  fail:
2271     av_freep(&bit_buffer);
2272     av_free(file_table);
2273
2274     if (ist_table) {
2275         for(i=0;i<nb_istreams;i++) {
2276             ist = ist_table[i];
2277             av_free(ist);
2278         }
2279         av_free(ist_table);
2280     }
2281     if (ost_table) {
2282         for(i=0;i<nb_ostreams;i++) {
2283             ost = ost_table[i];
2284             if (ost) {
2285                 if (ost->logfile) {
2286                     fclose(ost->logfile);
2287                     ost->logfile = NULL;
2288                 }
2289                 av_fifo_free(ost->fifo); /* works even if fifo is not
2290                                              initialized but set to zero */
2291                 av_free(ost->pict_tmp.data[0]);
2292                 if (ost->video_resample)
2293                     sws_freeContext(ost->img_resample_ctx);
2294                 if (ost->resample)
2295                     audio_resample_close(ost->resample);
2296                 if (ost->reformat_ctx)
2297                     av_audio_convert_free(ost->reformat_ctx);
2298                 av_free(ost);
2299             }
2300         }
2301         av_free(ost_table);
2302     }
2303     return ret;
2304 }
2305
2306 #if 0
2307 int file_read(const char *filename)
2308 {
2309     URLContext *h;
2310     unsigned char buffer[1024];
2311     int len, i;
2312
2313     if (url_open(&h, filename, O_RDONLY) < 0) {
2314         printf("could not open '%s'\n", filename);
2315         return -1;
2316     }
2317     for(;;) {
2318         len = url_read(h, buffer, sizeof(buffer));
2319         if (len <= 0)
2320             break;
2321         for(i=0;i<len;i++) putchar(buffer[i]);
2322     }
2323     url_close(h);
2324     return 0;
2325 }
2326 #endif
2327
2328 static void opt_format(const char *arg)
2329 {
2330     /* compatibility stuff for pgmyuv */
2331     if (!strcmp(arg, "pgmyuv")) {
2332         pgmyuv_compatibility_hack=1;
2333 //        opt_image_format(arg);
2334         arg = "image2";
2335         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2336     }
2337
2338     file_iformat = av_find_input_format(arg);
2339     file_oformat = guess_format(arg, NULL, NULL);
2340     if (!file_iformat && !file_oformat) {
2341         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2342         av_exit(1);
2343     }
2344 }
2345
2346 static void opt_video_rc_override_string(const char *arg)
2347 {
2348     video_rc_override_string = arg;
2349 }
2350
2351 static int opt_me_threshold(const char *opt, const char *arg)
2352 {
2353     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2354     return 0;
2355 }
2356
2357 static int opt_verbose(const char *opt, const char *arg)
2358 {
2359     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2360     return 0;
2361 }
2362
2363 static int opt_frame_rate(const char *opt, const char *arg)
2364 {
2365     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2366         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2367         av_exit(1);
2368     }
2369     return 0;
2370 }
2371
2372 static int opt_bitrate(const char *opt, const char *arg)
2373 {
2374     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2375
2376     opt_default(opt, arg);
2377
2378     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2379         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2380
2381     return 0;
2382 }
2383
2384 static void opt_frame_crop_top(const char *arg)
2385 {
2386     frame_topBand = atoi(arg);
2387     if (frame_topBand < 0) {
2388         fprintf(stderr, "Incorrect top crop size\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) >= frame_height){
2406         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2407         av_exit(1);
2408     }
2409     frame_height -= frame_bottomBand;
2410 }
2411
2412 static void opt_frame_crop_left(const char *arg)
2413 {
2414     frame_leftBand = atoi(arg);
2415     if (frame_leftBand < 0) {
2416         fprintf(stderr, "Incorrect left crop size\n");
2417         av_exit(1);
2418     }
2419     if ((frame_leftBand) >= frame_width){
2420         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2421         av_exit(1);
2422     }
2423     frame_width -= frame_leftBand;
2424 }
2425
2426 static void opt_frame_crop_right(const char *arg)
2427 {
2428     frame_rightBand = atoi(arg);
2429     if (frame_rightBand < 0) {
2430         fprintf(stderr, "Incorrect right crop size\n");
2431         av_exit(1);
2432     }
2433     if ((frame_rightBand) >= frame_width){
2434         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2435         av_exit(1);
2436     }
2437     frame_width -= frame_rightBand;
2438 }
2439
2440 static void opt_frame_size(const char *arg)
2441 {
2442     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2443         fprintf(stderr, "Incorrect frame size\n");
2444         av_exit(1);
2445     }
2446     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2447         fprintf(stderr, "Frame size must be a multiple of 2\n");
2448         av_exit(1);
2449     }
2450 }
2451
2452 static void opt_pad_color(const char *arg) {
2453     /* Input is expected to be six hex digits similar to
2454        how colors are expressed in html tags (but without the #) */
2455     int rgb = strtol(arg, NULL, 16);
2456     int r,g,b;
2457
2458     r = (rgb >> 16);
2459     g = ((rgb >> 8) & 255);
2460     b = (rgb & 255);
2461
2462     padcolor[0] = RGB_TO_Y(r,g,b);
2463     padcolor[1] = RGB_TO_U(r,g,b,0);
2464     padcolor[2] = RGB_TO_V(r,g,b,0);
2465 }
2466
2467 static void opt_frame_pad_top(const char *arg)
2468 {
2469     frame_padtop = atoi(arg);
2470     if (frame_padtop < 0) {
2471         fprintf(stderr, "Incorrect top pad size\n");
2472         av_exit(1);
2473     }
2474 }
2475
2476 static void opt_frame_pad_bottom(const char *arg)
2477 {
2478     frame_padbottom = atoi(arg);
2479     if (frame_padbottom < 0) {
2480         fprintf(stderr, "Incorrect bottom pad size\n");
2481         av_exit(1);
2482     }
2483 }
2484
2485
2486 static void opt_frame_pad_left(const char *arg)
2487 {
2488     frame_padleft = atoi(arg);
2489     if (frame_padleft < 0) {
2490         fprintf(stderr, "Incorrect left pad size\n");
2491         av_exit(1);
2492     }
2493 }
2494
2495
2496 static void opt_frame_pad_right(const char *arg)
2497 {
2498     frame_padright = atoi(arg);
2499     if (frame_padright < 0) {
2500         fprintf(stderr, "Incorrect right pad size\n");
2501         av_exit(1);
2502     }
2503 }
2504
2505 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2506 {
2507     int i;
2508     char fmt_str[128];
2509     for (i=-1; i < nb_fmts; i++) {
2510         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2511         fprintf(stdout, "%s\n", fmt_str);
2512     }
2513 }
2514
2515 static void opt_frame_pix_fmt(const char *arg)
2516 {
2517     if (strcmp(arg, "list")) {
2518         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2519         if (frame_pix_fmt == PIX_FMT_NONE) {
2520             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2521             av_exit(1);
2522         }
2523     } else {
2524         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2525         av_exit(0);
2526     }
2527 }
2528
2529 static void opt_frame_aspect_ratio(const char *arg)
2530 {
2531     int x = 0, y = 0;
2532     double ar = 0;
2533     const char *p;
2534     char *end;
2535
2536     p = strchr(arg, ':');
2537     if (p) {
2538         x = strtol(arg, &end, 10);
2539         if (end == p)
2540             y = strtol(end+1, &end, 10);
2541         if (x > 0 && y > 0)
2542             ar = (double)x / (double)y;
2543     } else
2544         ar = strtod(arg, NULL);
2545
2546     if (!ar) {
2547         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2548         av_exit(1);
2549     }
2550     frame_aspect_ratio = ar;
2551 }
2552
2553 static int opt_metadata(const char *opt, const char *arg)
2554 {
2555     char *mid= strchr(arg, '=');
2556
2557     if(!mid){
2558         fprintf(stderr, "Missing =\n");
2559         av_exit(1);
2560     }
2561     *mid++= 0;
2562
2563     metadata_count++;
2564     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2565     metadata[metadata_count-1].key  = av_strdup(arg);
2566     metadata[metadata_count-1].value= av_strdup(mid);
2567
2568     return 0;
2569 }
2570
2571 static void opt_qscale(const char *arg)
2572 {
2573     video_qscale = atof(arg);
2574     if (video_qscale <= 0 ||
2575         video_qscale > 255) {
2576         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2577         av_exit(1);
2578     }
2579 }
2580
2581 static void opt_top_field_first(const char *arg)
2582 {
2583     top_field_first= atoi(arg);
2584 }
2585
2586 static int opt_thread_count(const char *opt, const char *arg)
2587 {
2588     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2589 #if !HAVE_THREADS
2590     if (verbose >= 0)
2591         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2592 #endif
2593     return 0;
2594 }
2595
2596 static void opt_audio_sample_fmt(const char *arg)
2597 {
2598     if (strcmp(arg, "list"))
2599         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2600     else {
2601         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2602         av_exit(0);
2603     }
2604 }
2605
2606 static int opt_audio_rate(const char *opt, const char *arg)
2607 {
2608     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2609     return 0;
2610 }
2611
2612 static int opt_audio_channels(const char *opt, const char *arg)
2613 {
2614     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2615     return 0;
2616 }
2617
2618 static void opt_video_channel(const char *arg)
2619 {
2620     video_channel = strtol(arg, NULL, 0);
2621 }
2622
2623 static void opt_video_standard(const char *arg)
2624 {
2625     video_standard = av_strdup(arg);
2626 }
2627
2628 static void opt_codec(int *pstream_copy, char **pcodec_name,
2629                       int codec_type, const char *arg)
2630 {
2631     av_freep(pcodec_name);
2632     if (!strcmp(arg, "copy")) {
2633         *pstream_copy = 1;
2634     } else {
2635         *pcodec_name = av_strdup(arg);
2636     }
2637 }
2638
2639 static void opt_audio_codec(const char *arg)
2640 {
2641     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2642 }
2643
2644 static void opt_audio_tag(const char *arg)
2645 {
2646     char *tail;
2647     audio_codec_tag= strtol(arg, &tail, 0);
2648
2649     if(!tail || *tail)
2650         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2651 }
2652
2653 static void opt_video_tag(const char *arg)
2654 {
2655     char *tail;
2656     video_codec_tag= strtol(arg, &tail, 0);
2657
2658     if(!tail || *tail)
2659         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2660 }
2661
2662 static void opt_video_codec(const char *arg)
2663 {
2664     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2665 }
2666
2667 static void opt_subtitle_codec(const char *arg)
2668 {
2669     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2670 }
2671
2672 static void opt_subtitle_tag(const char *arg)
2673 {
2674     char *tail;
2675     subtitle_codec_tag= strtol(arg, &tail, 0);
2676
2677     if(!tail || *tail)
2678         subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2679 }
2680
2681 static void opt_map(const char *arg)
2682 {
2683     AVStreamMap *m;
2684     char *p;
2685
2686     m = &stream_maps[nb_stream_maps++];
2687
2688     m->file_index = strtol(arg, &p, 0);
2689     if (*p)
2690         p++;
2691
2692     m->stream_index = strtol(p, &p, 0);
2693     if (*p) {
2694         p++;
2695         m->sync_file_index = strtol(p, &p, 0);
2696         if (*p)
2697             p++;
2698         m->sync_stream_index = strtol(p, &p, 0);
2699     } else {
2700         m->sync_file_index = m->file_index;
2701         m->sync_stream_index = m->stream_index;
2702     }
2703 }
2704
2705 static void opt_map_meta_data(const char *arg)
2706 {
2707     AVMetaDataMap *m;
2708     char *p;
2709
2710     m = &meta_data_maps[nb_meta_data_maps++];
2711
2712     m->out_file = strtol(arg, &p, 0);
2713     if (*p)
2714         p++;
2715
2716     m->in_file = strtol(p, &p, 0);
2717 }
2718
2719 static void opt_input_ts_scale(const char *arg)
2720 {
2721     unsigned int stream;
2722     double scale;
2723     char *p;
2724
2725     stream = strtol(arg, &p, 0);
2726     if (*p)
2727         p++;
2728     scale= strtod(p, &p);
2729
2730     if(stream >= MAX_STREAMS)
2731         av_exit(1);
2732
2733     input_files_ts_scale[nb_input_files][stream]= scale;
2734 }
2735
2736 static int opt_recording_time(const char *opt, const char *arg)
2737 {
2738     recording_time = parse_time_or_die(opt, arg, 1);
2739     return 0;
2740 }
2741
2742 static int opt_start_time(const char *opt, const char *arg)
2743 {
2744     start_time = parse_time_or_die(opt, arg, 1);
2745     return 0;
2746 }
2747
2748 static int opt_rec_timestamp(const char *opt, const char *arg)
2749 {
2750     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2751     return 0;
2752 }
2753
2754 static int opt_input_ts_offset(const char *opt, const char *arg)
2755 {
2756     input_ts_offset = parse_time_or_die(opt, arg, 1);
2757     return 0;
2758 }
2759
2760 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2761 {
2762     const char *codec_string = encoder ? "encoder" : "decoder";
2763     AVCodec *codec;
2764
2765     if(!name)
2766         return CODEC_ID_NONE;
2767     codec = encoder ?
2768         avcodec_find_encoder_by_name(name) :
2769         avcodec_find_decoder_by_name(name);
2770     if(!codec) {
2771         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2772         av_exit(1);
2773     }
2774     if(codec->type != type) {
2775         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2776         av_exit(1);
2777     }
2778     return codec->id;
2779 }
2780
2781 static void opt_input_file(const char *filename)
2782 {
2783     AVFormatContext *ic;
2784     AVFormatParameters params, *ap = &params;
2785     int err, i, ret, rfps, rfps_base;
2786     int64_t timestamp;
2787
2788     if (!strcmp(filename, "-"))
2789         filename = "pipe:";
2790
2791     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2792                     !strcmp(filename, "/dev/stdin");
2793
2794     /* get default parameters from command line */
2795     ic = avformat_alloc_context();
2796
2797     memset(ap, 0, sizeof(*ap));
2798     ap->prealloced_context = 1;
2799     ap->sample_rate = audio_sample_rate;
2800     ap->channels = audio_channels;
2801     ap->time_base.den = frame_rate.num;
2802     ap->time_base.num = frame_rate.den;
2803     ap->width = frame_width + frame_padleft + frame_padright;
2804     ap->height = frame_height + frame_padtop + frame_padbottom;
2805     ap->pix_fmt = frame_pix_fmt;
2806    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2807     ap->channel = video_channel;
2808     ap->standard = video_standard;
2809     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2810     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2811     if(pgmyuv_compatibility_hack)
2812         ap->video_codec_id= CODEC_ID_PGMYUV;
2813
2814     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2815
2816     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2817     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2818     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2819     ic->flags |= AVFMT_FLAG_NONBLOCK;
2820
2821     /* open the input file with generic libav function */
2822     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2823     if (err < 0) {
2824         print_error(filename, err);
2825         av_exit(1);
2826     }
2827     if(opt_programid) {
2828         int i;
2829         for(i=0; i<ic->nb_programs; i++)
2830             if(ic->programs[i]->id != opt_programid)
2831                 ic->programs[i]->discard = AVDISCARD_ALL;
2832     }
2833
2834     ic->loop_input = loop_input;
2835
2836     /* If not enough info to get the stream parameters, we decode the
2837        first frames to get it. (used in mpeg case for example) */
2838     ret = av_find_stream_info(ic);
2839     if (ret < 0 && verbose >= 0) {
2840         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2841         av_exit(1);
2842     }
2843
2844     timestamp = start_time;
2845     /* add the stream start time */
2846     if (ic->start_time != AV_NOPTS_VALUE)
2847         timestamp += ic->start_time;
2848
2849     /* if seeking requested, we execute it */
2850     if (start_time != 0) {
2851         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2852         if (ret < 0) {
2853             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2854                     filename, (double)timestamp / AV_TIME_BASE);
2855         }
2856         /* reset seek info */
2857         start_time = 0;
2858     }
2859
2860     /* update the current parameters so that they match the one of the input stream */
2861     for(i=0;i<ic->nb_streams;i++) {
2862         AVCodecContext *enc = ic->streams[i]->codec;
2863         if(thread_count>1)
2864             avcodec_thread_init(enc, thread_count);
2865         enc->thread_count= thread_count;
2866         switch(enc->codec_type) {
2867         case CODEC_TYPE_AUDIO:
2868             set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2869             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2870             channel_layout = enc->channel_layout;
2871             audio_channels = enc->channels;
2872             audio_sample_rate = enc->sample_rate;
2873             audio_sample_fmt = enc->sample_fmt;
2874             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2875             if(audio_disable)
2876                 ic->streams[i]->discard= AVDISCARD_ALL;
2877             break;
2878         case CODEC_TYPE_VIDEO:
2879             set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2880             frame_height = enc->height;
2881             frame_width = enc->width;
2882             if(ic->streams[i]->sample_aspect_ratio.num)
2883                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2884             else
2885                 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2886             frame_aspect_ratio *= (float) enc->width / enc->height;
2887             frame_pix_fmt = enc->pix_fmt;
2888             rfps      = ic->streams[i]->r_frame_rate.num;
2889             rfps_base = ic->streams[i]->r_frame_rate.den;
2890             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2891             if(me_threshold)
2892                 enc->debug |= FF_DEBUG_MV;
2893
2894             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2895
2896                 if (verbose >= 0)
2897                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2898                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2899
2900                     (float)rfps / rfps_base, rfps, rfps_base);
2901             }
2902             /* update the current frame rate to match the stream frame rate */
2903             frame_rate.num = rfps;
2904             frame_rate.den = rfps_base;
2905
2906             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2907             if(video_disable)
2908                 ic->streams[i]->discard= AVDISCARD_ALL;
2909             else if(video_discard)
2910                 ic->streams[i]->discard= video_discard;
2911             break;
2912         case CODEC_TYPE_DATA:
2913             break;
2914         case CODEC_TYPE_SUBTITLE:
2915             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2916             if(subtitle_disable)
2917                 ic->streams[i]->discard = AVDISCARD_ALL;
2918             break;
2919         case CODEC_TYPE_ATTACHMENT:
2920         case CODEC_TYPE_UNKNOWN:
2921             nb_icodecs++;
2922             break;
2923         default:
2924             abort();
2925         }
2926     }
2927
2928     input_files[nb_input_files] = ic;
2929     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2930     /* dump the file content */
2931     if (verbose >= 0)
2932         dump_format(ic, nb_input_files, filename, 0);
2933
2934     nb_input_files++;
2935     file_iformat = NULL;
2936     file_oformat = NULL;
2937
2938     video_channel = 0;
2939
2940     av_freep(&video_codec_name);
2941     av_freep(&audio_codec_name);
2942     av_freep(&subtitle_codec_name);
2943 }
2944
2945 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2946                                          int *has_subtitle_ptr)
2947 {
2948     int has_video, has_audio, has_subtitle, i, j;
2949     AVFormatContext *ic;
2950
2951     has_video = 0;
2952     has_audio = 0;
2953     has_subtitle = 0;
2954     for(j=0;j<nb_input_files;j++) {
2955         ic = input_files[j];
2956         for(i=0;i<ic->nb_streams;i++) {
2957             AVCodecContext *enc = ic->streams[i]->codec;
2958             switch(enc->codec_type) {
2959             case CODEC_TYPE_AUDIO:
2960                 has_audio = 1;
2961                 break;
2962             case CODEC_TYPE_VIDEO:
2963                 has_video = 1;
2964                 break;
2965             case CODEC_TYPE_SUBTITLE:
2966                 has_subtitle = 1;
2967                 break;
2968             case CODEC_TYPE_DATA:
2969             case CODEC_TYPE_ATTACHMENT:
2970             case CODEC_TYPE_UNKNOWN:
2971                 break;
2972             default:
2973                 abort();
2974             }
2975         }
2976     }
2977     *has_video_ptr = has_video;
2978     *has_audio_ptr = has_audio;
2979     *has_subtitle_ptr = has_subtitle;
2980 }
2981
2982 static void new_video_stream(AVFormatContext *oc)
2983 {
2984     AVStream *st;
2985     AVCodecContext *video_enc;
2986     int codec_id;
2987
2988     st = av_new_stream(oc, oc->nb_streams);
2989     if (!st) {
2990         fprintf(stderr, "Could not alloc stream\n");
2991         av_exit(1);
2992     }
2993     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2994     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2995     video_bitstream_filters= NULL;
2996
2997     if(thread_count>1)
2998         avcodec_thread_init(st->codec, thread_count);
2999
3000     video_enc = st->codec;
3001
3002     if(video_codec_tag)
3003         video_enc->codec_tag= video_codec_tag;
3004
3005     if(   (video_global_header&1)
3006        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3007         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3008         avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3009     }
3010     if(video_global_header&2){
3011         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3012         avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3013     }
3014
3015     if (video_stream_copy) {
3016         st->stream_copy = 1;
3017         video_enc->codec_type = CODEC_TYPE_VIDEO;
3018         video_enc->sample_aspect_ratio =
3019         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3020     } else {
3021         const char *p;
3022         int i;
3023         AVCodec *codec;
3024         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3025
3026         if (video_codec_name) {
3027             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3028             codec = avcodec_find_encoder_by_name(video_codec_name);
3029             output_codecs[nb_ocodecs] = codec;
3030         } else {
3031             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3032             codec = avcodec_find_encoder(codec_id);
3033         }
3034
3035         video_enc->codec_id = codec_id;
3036
3037         set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3038
3039         if (codec && codec->supported_framerates && !force_fps)
3040             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3041         video_enc->time_base.den = fps.num;
3042         video_enc->time_base.num = fps.den;
3043
3044         video_enc->width = frame_width + frame_padright + frame_padleft;
3045         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3046         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3047         video_enc->pix_fmt = frame_pix_fmt;
3048         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3049
3050         if(codec && codec->pix_fmts){
3051             const enum PixelFormat *p= codec->pix_fmts;
3052             for(; *p!=-1; p++){
3053                 if(*p == video_enc->pix_fmt)
3054                     break;
3055             }
3056             if(*p == -1)
3057                 video_enc->pix_fmt = codec->pix_fmts[0];
3058         }
3059
3060         if (intra_only)
3061             video_enc->gop_size = 0;
3062         if (video_qscale || same_quality) {
3063             video_enc->flags |= CODEC_FLAG_QSCALE;
3064             video_enc->global_quality=
3065                 st->quality = FF_QP2LAMBDA * video_qscale;
3066         }
3067
3068         if(intra_matrix)
3069             video_enc->intra_matrix = intra_matrix;
3070         if(inter_matrix)
3071             video_enc->inter_matrix = inter_matrix;
3072
3073         video_enc->thread_count = thread_count;
3074         p= video_rc_override_string;
3075         for(i=0; p; i++){
3076             int start, end, q;
3077             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3078             if(e!=3){
3079                 fprintf(stderr, "error parsing rc_override\n");
3080                 av_exit(1);
3081             }
3082             video_enc->rc_override=
3083                 av_realloc(video_enc->rc_override,
3084                            sizeof(RcOverride)*(i+1));
3085             video_enc->rc_override[i].start_frame= start;
3086             video_enc->rc_override[i].end_frame  = end;
3087             if(q>0){
3088                 video_enc->rc_override[i].qscale= q;
3089                 video_enc->rc_override[i].quality_factor= 1.0;
3090             }
3091             else{
3092                 video_enc->rc_override[i].qscale= 0;
3093                 video_enc->rc_override[i].quality_factor= -q/100.0;
3094             }
3095             p= strchr(p, '/');
3096             if(p) p++;
3097         }
3098         video_enc->rc_override_count=i;
3099         if (!video_enc->rc_initial_buffer_occupancy)
3100             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3101         video_enc->me_threshold= me_threshold;
3102         video_enc->intra_dc_precision= intra_dc_precision - 8;
3103
3104         if (do_psnr)
3105             video_enc->flags|= CODEC_FLAG_PSNR;
3106
3107         /* two pass mode */
3108         if (do_pass) {
3109             if (do_pass == 1) {
3110                 video_enc->flags |= CODEC_FLAG_PASS1;
3111             } else {
3112                 video_enc->flags |= CODEC_FLAG_PASS2;
3113             }
3114         }
3115     }
3116     nb_ocodecs++;
3117
3118     /* reset some key parameters */
3119     video_disable = 0;
3120     av_freep(&video_codec_name);
3121     video_stream_copy = 0;
3122 }
3123
3124 static void new_audio_stream(AVFormatContext *oc)
3125 {
3126     AVStream *st;
3127     AVCodecContext *audio_enc;
3128     int codec_id;
3129
3130     st = av_new_stream(oc, oc->nb_streams);
3131     if (!st) {
3132         fprintf(stderr, "Could not alloc stream\n");
3133         av_exit(1);
3134     }
3135     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3136
3137     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3138     audio_bitstream_filters= NULL;
3139
3140     if(thread_count>1)
3141         avcodec_thread_init(st->codec, thread_count);
3142
3143     audio_enc = st->codec;
3144     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3145
3146     if(audio_codec_tag)
3147         audio_enc->codec_tag= audio_codec_tag;
3148
3149     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3150         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3151         avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3152     }
3153     if (audio_stream_copy) {
3154         st->stream_copy = 1;
3155         audio_enc->channels = audio_channels;
3156     } else {
3157         AVCodec *codec;
3158
3159         set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3160
3161         if (audio_codec_name) {
3162             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3163             codec = avcodec_find_encoder_by_name(audio_codec_name);
3164             output_codecs[nb_ocodecs] = codec;
3165         } else {
3166             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3167             codec = avcodec_find_encoder(codec_id);
3168         }
3169         audio_enc->codec_id = codec_id;
3170
3171         if (audio_qscale > QSCALE_NONE) {
3172             audio_enc->flags |= CODEC_FLAG_QSCALE;
3173             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3174         }
3175         audio_enc->thread_count = thread_count;
3176         audio_enc->channels = audio_channels;
3177         audio_enc->sample_fmt = audio_sample_fmt;
3178         audio_enc->channel_layout = channel_layout;
3179         if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3180             audio_enc->channel_layout = 0;
3181
3182         if(codec && codec->sample_fmts){
3183             const enum SampleFormat *p= codec->sample_fmts;
3184             for(; *p!=-1; p++){
3185                 if(*p == audio_enc->sample_fmt)
3186                     break;
3187             }
3188             if(*p == -1)
3189                 audio_enc->sample_fmt = codec->sample_fmts[0];
3190         }
3191     }
3192     nb_ocodecs++;
3193     audio_enc->sample_rate = audio_sample_rate;
3194     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3195     if (audio_language) {
3196         av_metadata_set(&st->metadata, "language", audio_language);
3197         av_free(audio_language);
3198         audio_language = NULL;
3199     }
3200
3201     /* reset some key parameters */
3202     audio_disable = 0;
3203     av_freep(&audio_codec_name);
3204     audio_stream_copy = 0;
3205 }
3206
3207 static void new_subtitle_stream(AVFormatContext *oc)
3208 {
3209     AVStream *st;
3210     AVCodecContext *subtitle_enc;
3211
3212     st = av_new_stream(oc, oc->nb_streams);
3213     if (!st) {
3214         fprintf(stderr, "Could not alloc stream\n");
3215         av_exit(1);
3216     }
3217     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3218
3219     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3220     subtitle_bitstream_filters= NULL;
3221
3222     subtitle_enc = st->codec;
3223     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3224
3225     if(subtitle_codec_tag)
3226         subtitle_enc->codec_tag= subtitle_codec_tag;
3227
3228     if (subtitle_stream_copy) {
3229         st->stream_copy = 1;
3230     } else {
3231         set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3232         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3233         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3234     }
3235     nb_ocodecs++;
3236
3237     if (subtitle_language) {
3238         av_metadata_set(&st->metadata, "language", subtitle_language);
3239         av_free(subtitle_language);
3240         subtitle_language = NULL;
3241     }
3242
3243     subtitle_disable = 0;
3244     av_freep(&subtitle_codec_name);
3245     subtitle_stream_copy = 0;
3246 }
3247
3248 static void opt_new_audio_stream(void)
3249 {
3250     AVFormatContext *oc;
3251     if (nb_output_files <= 0) {
3252         fprintf(stderr, "At least one output file must be specified\n");
3253         av_exit(1);
3254     }
3255     oc = output_files[nb_output_files - 1];
3256     new_audio_stream(oc);
3257 }
3258
3259 static void opt_new_video_stream(void)
3260 {
3261     AVFormatContext *oc;
3262     if (nb_output_files <= 0) {
3263         fprintf(stderr, "At least one output file must be specified\n");
3264         av_exit(1);
3265     }
3266     oc = output_files[nb_output_files - 1];
3267     new_video_stream(oc);
3268 }
3269
3270 static void opt_new_subtitle_stream(void)
3271 {
3272     AVFormatContext *oc;
3273     if (nb_output_files <= 0) {
3274         fprintf(stderr, "At least one output file must be specified\n");
3275         av_exit(1);
3276     }
3277     oc = output_files[nb_output_files - 1];
3278     new_subtitle_stream(oc);
3279 }
3280
3281 static void opt_output_file(const char *filename)
3282 {
3283     AVFormatContext *oc;
3284     int use_video, use_audio, use_subtitle;
3285     int input_has_video, input_has_audio, input_has_subtitle;
3286     AVFormatParameters params, *ap = &params;
3287
3288     if (!strcmp(filename, "-"))
3289         filename = "pipe:";
3290
3291     oc = avformat_alloc_context();
3292
3293     if (!file_oformat) {
3294         file_oformat = guess_format(NULL, filename, NULL);
3295         if (!file_oformat) {
3296             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3297                     filename);
3298             av_exit(1);
3299         }
3300     }
3301
3302     oc->oformat = file_oformat;
3303     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3304
3305     if (!strcmp(file_oformat->name, "ffm") &&
3306         av_strstart(filename, "http:", NULL)) {
3307         /* special case for files sent to ffserver: we get the stream
3308            parameters from ffserver */
3309         int err = read_ffserver_streams(oc, filename);
3310         if (err < 0) {
3311             print_error(filename, err);
3312             av_exit(1);
3313         }
3314     } else {
3315         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3316         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3317         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3318
3319         /* disable if no corresponding type found and at least one
3320            input file */
3321         if (nb_input_files > 0) {
3322             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3323                                          &input_has_subtitle);
3324             if (!input_has_video)
3325                 use_video = 0;
3326             if (!input_has_audio)
3327                 use_audio = 0;
3328             if (!input_has_subtitle)
3329                 use_subtitle = 0;
3330         }
3331
3332         /* manual disable */
3333         if (audio_disable) {
3334             use_audio = 0;
3335         }
3336         if (video_disable) {
3337             use_video = 0;
3338         }
3339         if (subtitle_disable) {
3340             use_subtitle = 0;
3341         }
3342
3343         if (use_video) {
3344             new_video_stream(oc);
3345         }
3346
3347         if (use_audio) {
3348             new_audio_stream(oc);
3349         }
3350
3351         if (use_subtitle) {
3352             new_subtitle_stream(oc);
3353         }
3354
3355         oc->timestamp = rec_timestamp;
3356
3357         for(; metadata_count>0; metadata_count--){
3358             av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3359                                            metadata[metadata_count-1].value);
3360         }
3361         av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3362     }
3363
3364     output_files[nb_output_files++] = oc;
3365
3366     /* check filename in case of an image number is expected */
3367     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3368         if (!av_filename_number_test(oc->filename)) {
3369             print_error(oc->filename, AVERROR_NUMEXPECTED);
3370             av_exit(1);
3371         }
3372     }
3373
3374     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3375         /* test if it already exists to avoid loosing precious files */
3376         if (!file_overwrite &&
3377             (strchr(filename, ':') == NULL ||
3378              filename[1] == ':' ||
3379              av_strstart(filename, "file:", NULL))) {
3380             if (url_exist(filename)) {
3381                 if (!using_stdin) {
3382                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3383                     fflush(stderr);
3384                     if (!read_yesno()) {
3385                         fprintf(stderr, "Not overwriting - exiting\n");
3386                         av_exit(1);
3387                     }
3388                 }
3389                 else {
3390                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3391                     av_exit(1);
3392                 }
3393             }
3394         }
3395
3396         /* open the file */
3397         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3398             fprintf(stderr, "Could not open '%s'\n", filename);
3399             av_exit(1);
3400         }
3401     }
3402
3403     memset(ap, 0, sizeof(*ap));
3404     if (av_set_parameters(oc, ap) < 0) {
3405         fprintf(stderr, "%s: Invalid encoding parameters\n",
3406                 oc->filename);
3407         av_exit(1);
3408     }
3409
3410     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3411     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3412     oc->loop_output = loop_output;
3413     oc->flags |= AVFMT_FLAG_NONBLOCK;
3414
3415     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3416
3417     /* reset some options */
3418     file_oformat = NULL;
3419     file_iformat = NULL;
3420 }
3421
3422 /* same option as mencoder */
3423 static void opt_pass(const char *pass_str)
3424 {
3425     int pass;
3426     pass = atoi(pass_str);
3427     if (pass != 1 && pass != 2) {
3428         fprintf(stderr, "pass number can be only 1 or 2\n");
3429         av_exit(1);
3430     }
3431     do_pass = pass;
3432 }
3433
3434 static int64_t getutime(void)
3435 {
3436 #if HAVE_GETRUSAGE
3437     struct rusage rusage;
3438
3439     getrusage(RUSAGE_SELF, &rusage);
3440     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3441 #elif HAVE_GETPROCESSTIMES
3442     HANDLE proc;
3443     FILETIME c, e, k, u;
3444     proc = GetCurrentProcess();
3445     GetProcessTimes(proc, &c, &e, &k, &u);
3446     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3447 #else
3448     return av_gettime();
3449 #endif
3450 }
3451
3452 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3453 {
3454     int i;
3455     const char *p = str;
3456     for(i = 0;; i++) {
3457         dest[i] = atoi(p);
3458         if(i == 63)
3459             break;
3460         p = strchr(p, ',');
3461         if(!p) {
3462             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3463             av_exit(1);
3464         }
3465         p++;
3466     }
3467 }
3468
3469 static void opt_inter_matrix(const char *arg)
3470 {
3471     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3472     parse_matrix_coeffs(inter_matrix, arg);
3473 }
3474
3475 static void opt_intra_matrix(const char *arg)
3476 {
3477     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3478     parse_matrix_coeffs(intra_matrix, arg);
3479 }
3480
3481 /**
3482  * Trivial log callback.
3483  * Only suitable for show_help and similar since it lacks prefix handling.
3484  */
3485 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3486 {
3487     vfprintf(stdout, fmt, vl);
3488 }
3489
3490 static void show_help(void)
3491 {
3492     av_log_set_callback(log_callback_help);
3493     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3494            "Hyper fast Audio and Video encoder\n");
3495     printf("\n");
3496     show_help_options(options, "Main options:\n",
3497                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3498     show_help_options(options, "\nAdvanced options:\n",
3499                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3500                       OPT_EXPERT);
3501     show_help_options(options, "\nVideo options:\n",
3502                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3503                       OPT_VIDEO);
3504     show_help_options(options, "\nAdvanced Video options:\n",
3505                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3506                       OPT_VIDEO | OPT_EXPERT);
3507     show_help_options(options, "\nAudio options:\n",
3508                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3509                       OPT_AUDIO);
3510     show_help_options(options, "\nAdvanced Audio options:\n",
3511                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3512                       OPT_AUDIO | OPT_EXPERT);
3513     show_help_options(options, "\nSubtitle options:\n",
3514                       OPT_SUBTITLE | OPT_GRAB,
3515                       OPT_SUBTITLE);
3516     show_help_options(options, "\nAudio/Video grab options:\n",
3517                       OPT_GRAB,
3518                       OPT_GRAB);
3519     printf("\n");
3520     av_opt_show(avcodec_opts[0], NULL);
3521     printf("\n");
3522     av_opt_show(avformat_opts, NULL);
3523     printf("\n");
3524     av_opt_show(sws_opts, NULL);
3525 }
3526
3527 static void opt_target(const char *arg)
3528 {
3529     int norm = -1;
3530     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3531
3532     if(!strncmp(arg, "pal-", 4)) {
3533         norm = 0;
3534         arg += 4;
3535     } else if(!strncmp(arg, "ntsc-", 5)) {
3536         norm = 1;
3537         arg += 5;
3538     } else if(!strncmp(arg, "film-", 5)) {
3539         norm = 2;
3540         arg += 5;
3541     } else {
3542         int fr;
3543         /* Calculate FR via float to avoid int overflow */
3544         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3545         if(fr == 25000) {
3546             norm = 0;
3547         } else if((fr == 29970) || (fr == 23976)) {
3548             norm = 1;
3549         } else {
3550             /* Try to determine PAL/NTSC by peeking in the input files */
3551             if(nb_input_files) {
3552                 int i, j;
3553                 for(j = 0; j < nb_input_files; j++) {
3554                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3555                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3556                         if(c->codec_type != CODEC_TYPE_VIDEO)
3557                             continue;
3558                         fr = c->time_base.den * 1000 / c->time_base.num;
3559                         if(fr == 25000) {
3560                             norm = 0;
3561                             break;
3562                         } else if((fr == 29970) || (fr == 23976)) {
3563                             norm = 1;
3564                             break;
3565                         }
3566                     }
3567                     if(norm >= 0)
3568                         break;
3569                 }
3570             }
3571         }
3572         if(verbose && norm >= 0)
3573             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3574     }
3575
3576     if(norm < 0) {
3577         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3578         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3579         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3580         av_exit(1);
3581     }
3582
3583     if(!strcmp(arg, "vcd")) {
3584
3585         opt_video_codec("mpeg1video");
3586         opt_audio_codec("mp2");
3587         opt_format("vcd");
3588
3589         opt_frame_size(norm ? "352x240" : "352x288");
3590         opt_frame_rate(NULL, frame_rates[norm]);
3591         opt_default("gop", norm ? "18" : "15");
3592
3593         opt_default("b", "1150000");
3594         opt_default("maxrate", "1150000");
3595         opt_default("minrate", "1150000");
3596         opt_default("bufsize", "327680"); // 40*1024*8;
3597
3598         opt_default("ab", "224000");
3599         audio_sample_rate = 44100;
3600         audio_channels = 2;
3601
3602         opt_default("packetsize", "2324");
3603         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3604
3605         /* We have to offset the PTS, so that it is consistent with the SCR.
3606            SCR starts at 36000, but the first two packs contain only padding
3607            and the first pack from the other stream, respectively, may also have
3608            been written before.
3609            So the real data starts at SCR 36000+3*1200. */
3610         mux_preload= (36000+3*1200) / 90000.0; //0.44
3611     } else if(!strcmp(arg, "svcd")) {
3612
3613         opt_video_codec("mpeg2video");
3614         opt_audio_codec("mp2");
3615         opt_format("svcd");
3616
3617         opt_frame_size(norm ? "480x480" : "480x576");
3618         opt_frame_rate(NULL, frame_rates[norm]);
3619         opt_default("gop", norm ? "18" : "15");
3620
3621         opt_default("b", "2040000");
3622         opt_default("maxrate", "2516000");
3623         opt_default("minrate", "0"); //1145000;
3624         opt_default("bufsize", "1835008"); //224*1024*8;
3625         opt_default("flags", "+scan_offset");
3626
3627
3628         opt_default("ab", "224000");
3629         audio_sample_rate = 44100;
3630
3631         opt_default("packetsize", "2324");
3632
3633     } else if(!strcmp(arg, "dvd")) {
3634
3635         opt_video_codec("mpeg2video");
3636         opt_audio_codec("ac3");
3637         opt_format("dvd");
3638
3639         opt_frame_size(norm ? "720x480" : "720x576");
3640         opt_frame_rate(NULL, frame_rates[norm]);
3641         opt_default("gop", norm ? "18" : "15");
3642
3643         opt_default("b", "6000000");
3644         opt_default("maxrate", "9000000");
3645         opt_default("minrate", "0"); //1500000;
3646         opt_default("bufsize", "1835008"); //224*1024*8;
3647
3648         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3649         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3650
3651         opt_default("ab", "448000");
3652         audio_sample_rate = 48000;
3653
3654     } else if(!strncmp(arg, "dv", 2)) {
3655
3656         opt_format("dv");
3657
3658         opt_frame_size(norm ? "720x480" : "720x576");
3659         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3660                                              (norm ? "yuv411p" : "yuv420p"));
3661         opt_frame_rate(NULL, frame_rates[norm]);
3662
3663         audio_sample_rate = 48000;
3664         audio_channels = 2;
3665
3666     } else {
3667         fprintf(stderr, "Unknown target: %s\n", arg);
3668         av_exit(1);
3669     }
3670 }
3671
3672 static void opt_vstats_file (const char *arg)
3673 {
3674     av_free (vstats_filename);
3675     vstats_filename=av_strdup (arg);
3676 }
3677
3678 static void opt_vstats (void)
3679 {
3680     char filename[40];
3681     time_t today2 = time(NULL);
3682     struct tm *today = localtime(&today2);
3683
3684     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3685              today->tm_sec);
3686     opt_vstats_file(filename);
3687 }
3688
3689 static int opt_bsf(const char *opt, const char *arg)
3690 {
3691     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3692     AVBitStreamFilterContext **bsfp;
3693
3694     if(!bsfc){
3695         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3696         av_exit(1);
3697     }
3698
3699     bsfp= *opt == 'v' ? &video_bitstream_filters :
3700           *opt == 'a' ? &audio_bitstream_filters :
3701                         &subtitle_bitstream_filters;
3702     while(*bsfp)
3703         bsfp= &(*bsfp)->next;
3704
3705     *bsfp= bsfc;
3706
3707     return 0;
3708 }
3709
3710 static int opt_preset(const char *opt, const char *arg)
3711 {
3712     FILE *f=NULL;
3713     char filename[1000], tmp[1000], tmp2[1000], line[1000];
3714     int i;
3715     const char *base[2]= { getenv("HOME"),
3716                            FFMPEG_DATADIR,
3717                          };
3718
3719     for(i=!base[0]; i<2 && !f; i++){
3720         snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3721         f= fopen(filename, "r");
3722         if(!f){
3723             char *codec_name= *opt == 'v' ? video_codec_name :
3724                               *opt == 'a' ? audio_codec_name :
3725                                             subtitle_codec_name;
3726             snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3727             f= fopen(filename, "r");
3728         }
3729     }
3730     if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3731               is_dos_path(arg))){
3732         av_strlcpy(filename, arg, sizeof(filename));
3733         f= fopen(filename, "r");
3734     }
3735
3736     if(!f){
3737         fprintf(stderr, "File for preset '%s' not found\n", arg);
3738         av_exit(1);
3739     }
3740
3741     while(!feof(f)){
3742         int e= fscanf(f, "%999[^\n]\n", line) - 1;
3743         if(line[0] == '#' && !e)
3744             continue;
3745         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3746         if(e){
3747             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3748             av_exit(1);
3749         }
3750         if(!strcmp(tmp, "acodec")){
3751             opt_audio_codec(tmp2);
3752         }else if(!strcmp(tmp, "vcodec")){
3753             opt_video_codec(tmp2);
3754         }else if(!strcmp(tmp, "scodec")){
3755             opt_subtitle_codec(tmp2);
3756         }else if(opt_default(tmp, tmp2) < 0){
3757             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3758             av_exit(1);
3759         }
3760     }
3761
3762     fclose(f);
3763
3764     return 0;
3765 }
3766
3767 static const OptionDef options[] = {
3768     /* main options */
3769     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3770     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3771     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3772     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3773     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3774     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3775     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3776     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3777     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3778     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3779     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3780     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3781     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3782     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3783     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3784     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3785     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3786     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3787       "add timings for benchmarking" },
3788     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3789       "dump each input packet" },
3790     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3791       "when dumping packets, also dump the payload" },
3792     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3793     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3794     { "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)", "" },
3795     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3796     { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "logging level number or string" },
3797     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3798     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3799     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3800     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3801     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3802     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3803     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3804     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3805     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3806     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3807     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3808     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3809
3810     /* video options */
3811     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3812     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3813     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3814     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3815     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3816     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3817     { "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" },
3818     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3819     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3820     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3821     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3822     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3823     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3824     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3825     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3826     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3827     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3828     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3829     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3830     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3831     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3832     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3833     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3834     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3835       "use same video quality as source (implies VBR)" },
3836     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3837     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3838     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3839       "deinterlace pictures" },
3840     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3841     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3842     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3843     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3844     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3845     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3846     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3847     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3848     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3849     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3850     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3851
3852     /* audio options */
3853     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3854     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3855     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3856     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3857     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3858     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3859     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3860     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3861     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3862     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3863     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3864     { "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" },
3865
3866     /* subtitle options */
3867     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3868     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3869     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3870     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3871     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3872
3873     /* grab options */
3874     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3875     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3876     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3877
3878     /* muxer options */
3879     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3880     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3881
3882     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3883     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3884     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3885
3886     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3887     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3888     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3889
3890     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3891     { NULL, },
3892 };
3893
3894 int main(int argc, char **argv)
3895 {
3896     int i;
3897     int64_t ti;
3898
3899     avcodec_register_all();
3900     avdevice_register_all();
3901     av_register_all();
3902
3903     if(isatty(STDIN_FILENO))
3904         url_set_interrupt_cb(decode_interrupt_cb);
3905
3906     for(i=0; i<CODEC_TYPE_NB; i++){
3907         avcodec_opts[i]= avcodec_alloc_context2(i);
3908     }
3909     avformat_opts = avformat_alloc_context();
3910     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3911
3912     show_banner();
3913
3914     /* parse options */
3915     parse_options(argc, argv, options, opt_output_file);
3916
3917     /* file converter / grab */
3918     if (nb_output_files <= 0) {
3919         fprintf(stderr, "At least one output file must be specified\n");
3920         av_exit(1);
3921     }
3922
3923     if (nb_input_files == 0) {
3924         fprintf(stderr, "At least one input file must be specified\n");
3925         av_exit(1);
3926     }
3927
3928     ti = getutime();
3929     if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3930                   stream_maps, nb_stream_maps) < 0)
3931         av_exit(1);
3932     ti = getutime() - ti;
3933     if (do_benchmark) {
3934         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3935     }
3936
3937     return av_exit(0);
3938 }