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