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