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