ffmpeg.c

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