ffmpeg.c

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