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