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++,n++) {
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].file_index].ist_index +
1646                     stream_maps[n].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].file_index, stream_maps[n].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].sync_file_index].ist_index +
1704                          stream_maps[n].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 int opt_frame_rate(const char *opt, const char *arg)
2322 {
2323     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2324         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2325         av_exit(1);
2326     }
2327     return 0;
2328 }
2329
2330 static int opt_bitrate(const char *opt, const char *arg)
2331 {
2332     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2333
2334     opt_default(opt, arg);
2335
2336     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2337         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2338
2339     return 0;
2340 }
2341
2342 static void opt_frame_crop_top(const char *arg)
2343 {
2344     frame_topBand = atoi(arg);
2345     if (frame_topBand < 0) {
2346         fprintf(stderr, "Incorrect top crop size\n");
2347         av_exit(1);
2348     }
2349     if ((frame_topBand % 2) != 0) {
2350         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2351         av_exit(1);
2352     }
2353     if ((frame_topBand) >= frame_height){
2354         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2355         av_exit(1);
2356     }
2357     frame_height -= frame_topBand;
2358 }
2359
2360 static void opt_frame_crop_bottom(const char *arg)
2361 {
2362     frame_bottomBand = atoi(arg);
2363     if (frame_bottomBand < 0) {
2364         fprintf(stderr, "Incorrect bottom crop size\n");
2365         av_exit(1);
2366     }
2367     if ((frame_bottomBand % 2) != 0) {
2368         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2369         av_exit(1);
2370     }
2371     if ((frame_bottomBand) >= frame_height){
2372         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2373         av_exit(1);
2374     }
2375     frame_height -= frame_bottomBand;
2376 }
2377
2378 static void opt_frame_crop_left(const char *arg)
2379 {
2380     frame_leftBand = atoi(arg);
2381     if (frame_leftBand < 0) {
2382         fprintf(stderr, "Incorrect left crop size\n");
2383         av_exit(1);
2384     }
2385     if ((frame_leftBand % 2) != 0) {
2386         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2387         av_exit(1);
2388     }
2389     if ((frame_leftBand) >= frame_width){
2390         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2391         av_exit(1);
2392     }
2393     frame_width -= frame_leftBand;
2394 }
2395
2396 static void opt_frame_crop_right(const char *arg)
2397 {
2398     frame_rightBand = atoi(arg);
2399     if (frame_rightBand < 0) {
2400         fprintf(stderr, "Incorrect right crop size\n");
2401         av_exit(1);
2402     }
2403     if ((frame_rightBand % 2) != 0) {
2404         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2405         av_exit(1);
2406     }
2407     if ((frame_rightBand) >= frame_width){
2408         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2409         av_exit(1);
2410     }
2411     frame_width -= frame_rightBand;
2412 }
2413
2414 static void opt_frame_size(const char *arg)
2415 {
2416     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2417         fprintf(stderr, "Incorrect frame size\n");
2418         av_exit(1);
2419     }
2420     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2421         fprintf(stderr, "Frame size must be a multiple of 2\n");
2422         av_exit(1);
2423     }
2424 }
2425
2426
2427 #define SCALEBITS 10
2428 #define ONE_HALF  (1 << (SCALEBITS - 1))
2429 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2430
2431 #define RGB_TO_Y(r, g, b) \
2432 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2433   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2434
2435 #define RGB_TO_U(r1, g1, b1, shift)\
2436 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2437      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2438
2439 #define RGB_TO_V(r1, g1, b1, shift)\
2440 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2441    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2442
2443 static void opt_pad_color(const char *arg) {
2444     /* Input is expected to be six hex digits similar to
2445        how colors are expressed in html tags (but without the #) */
2446     int rgb = strtol(arg, NULL, 16);
2447     int r,g,b;
2448
2449     r = (rgb >> 16);
2450     g = ((rgb >> 8) & 255);
2451     b = (rgb & 255);
2452
2453     padcolor[0] = RGB_TO_Y(r,g,b);
2454     padcolor[1] = RGB_TO_U(r,g,b,0);
2455     padcolor[2] = RGB_TO_V(r,g,b,0);
2456 }
2457
2458 static void opt_frame_pad_top(const char *arg)
2459 {
2460     frame_padtop = atoi(arg);
2461     if (frame_padtop < 0) {
2462         fprintf(stderr, "Incorrect top pad size\n");
2463         av_exit(1);
2464     }
2465     if ((frame_padtop % 2) != 0) {
2466         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2467         av_exit(1);
2468     }
2469 }
2470
2471 static void opt_frame_pad_bottom(const char *arg)
2472 {
2473     frame_padbottom = atoi(arg);
2474     if (frame_padbottom < 0) {
2475         fprintf(stderr, "Incorrect bottom pad size\n");
2476         av_exit(1);
2477     }
2478     if ((frame_padbottom % 2) != 0) {
2479         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2480         av_exit(1);
2481     }
2482 }
2483
2484
2485 static void opt_frame_pad_left(const char *arg)
2486 {
2487     frame_padleft = atoi(arg);
2488     if (frame_padleft < 0) {
2489         fprintf(stderr, "Incorrect left pad size\n");
2490         av_exit(1);
2491     }
2492     if ((frame_padleft % 2) != 0) {
2493         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2494         av_exit(1);
2495     }
2496 }
2497
2498
2499 static void opt_frame_pad_right(const char *arg)
2500 {
2501     frame_padright = atoi(arg);
2502     if (frame_padright < 0) {
2503         fprintf(stderr, "Incorrect right pad size\n");
2504         av_exit(1);
2505     }
2506     if ((frame_padright % 2) != 0) {
2507         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2508         av_exit(1);
2509     }
2510 }
2511
2512 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2513 {
2514     int i;
2515     char fmt_str[128];
2516     for (i=-1; i < nb_fmts; i++) {
2517         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2518         fprintf(stdout, "%s\n", fmt_str);
2519     }
2520 }
2521
2522 static void opt_frame_pix_fmt(const char *arg)
2523 {
2524     if (strcmp(arg, "list"))
2525         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2526     else {
2527         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2528         av_exit(0);
2529     }
2530 }
2531
2532 static void opt_frame_aspect_ratio(const char *arg)
2533 {
2534     int x = 0, y = 0;
2535     double ar = 0;
2536     const char *p;
2537     char *end;
2538
2539     p = strchr(arg, ':');
2540     if (p) {
2541         x = strtol(arg, &end, 10);
2542         if (end == p)
2543             y = strtol(end+1, &end, 10);
2544         if (x > 0 && y > 0)
2545             ar = (double)x / (double)y;
2546     } else
2547         ar = strtod(arg, NULL);
2548
2549     if (!ar) {
2550         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2551         av_exit(1);
2552     }
2553     frame_aspect_ratio = ar;
2554 }
2555
2556 static void opt_qscale(const char *arg)
2557 {
2558     video_qscale = atof(arg);
2559     if (video_qscale <= 0 ||
2560         video_qscale > 255) {
2561         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2562         av_exit(1);
2563     }
2564 }
2565
2566 static void opt_top_field_first(const char *arg)
2567 {
2568     top_field_first= atoi(arg);
2569 }
2570
2571 static int opt_thread_count(const char *opt, const char *arg)
2572 {
2573     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2574 #if !defined(HAVE_THREADS)
2575     if (verbose >= 0)
2576         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2577 #endif
2578     return 0;
2579 }
2580
2581 static void opt_audio_sample_fmt(const char *arg)
2582 {
2583     if (strcmp(arg, "list"))
2584         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2585     else {
2586         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2587         av_exit(0);
2588     }
2589 }
2590
2591 static int opt_audio_rate(const char *opt, const char *arg)
2592 {
2593     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2594     return 0;
2595 }
2596
2597 static int opt_audio_channels(const char *opt, const char *arg)
2598 {
2599     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2600     return 0;
2601 }
2602
2603 static void opt_video_channel(const char *arg)
2604 {
2605     video_channel = strtol(arg, NULL, 0);
2606 }
2607
2608 static void opt_video_standard(const char *arg)
2609 {
2610     video_standard = av_strdup(arg);
2611 }
2612
2613 static void opt_codec(int *pstream_copy, char **pcodec_name,
2614                       int codec_type, const char *arg)
2615 {
2616     av_freep(pcodec_name);
2617     if (!strcmp(arg, "copy")) {
2618         *pstream_copy = 1;
2619     } else {
2620         *pcodec_name = av_strdup(arg);
2621     }
2622 }
2623
2624 static void opt_audio_codec(const char *arg)
2625 {
2626     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2627 }
2628
2629 static void opt_audio_tag(const char *arg)
2630 {
2631     char *tail;
2632     audio_codec_tag= strtol(arg, &tail, 0);
2633
2634     if(!tail || *tail)
2635         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2636 }
2637
2638 static void opt_video_tag(const char *arg)
2639 {
2640     char *tail;
2641     video_codec_tag= strtol(arg, &tail, 0);
2642
2643     if(!tail || *tail)
2644         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2645 }
2646
2647 #ifdef CONFIG_VHOOK
2648 static void add_frame_hooker(const char *arg)
2649 {
2650     int argc = 0;
2651     char *argv[64];
2652     int i;
2653     char *args = av_strdup(arg);
2654
2655     using_vhook = 1;
2656
2657     argv[0] = strtok(args, " ");
2658     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2659     }
2660
2661     i = frame_hook_add(argc, argv);
2662
2663     if (i != 0) {
2664         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2665         av_exit(1);
2666     }
2667 }
2668 #endif
2669
2670 static void opt_video_codec(const char *arg)
2671 {
2672     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2673 }
2674
2675 static void opt_subtitle_codec(const char *arg)
2676 {
2677     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2678 }
2679
2680 static void opt_map(const char *arg)
2681 {
2682     AVStreamMap *m;
2683     char *p;
2684
2685     m = &stream_maps[nb_stream_maps++];
2686
2687     m->file_index = strtol(arg, &p, 0);
2688     if (*p)
2689         p++;
2690
2691     m->stream_index = strtol(p, &p, 0);
2692     if (*p) {
2693         p++;
2694         m->sync_file_index = strtol(p, &p, 0);
2695         if (*p)
2696             p++;
2697         m->sync_stream_index = strtol(p, &p, 0);
2698     } else {
2699         m->sync_file_index = m->file_index;
2700         m->sync_stream_index = m->stream_index;
2701     }
2702 }
2703
2704 static void opt_map_meta_data(const char *arg)
2705 {
2706     AVMetaDataMap *m;
2707     char *p;
2708
2709     m = &meta_data_maps[nb_meta_data_maps++];
2710
2711     m->out_file = strtol(arg, &p, 0);
2712     if (*p)
2713         p++;
2714
2715     m->in_file = strtol(p, &p, 0);
2716 }
2717
2718 static void opt_input_ts_scale(const char *arg)
2719 {
2720     unsigned int stream;
2721     double scale;
2722     char *p;
2723
2724     stream = strtol(arg, &p, 0);
2725     if (*p)
2726         p++;
2727     scale= strtod(p, &p);
2728
2729     if(stream >= MAX_STREAMS)
2730         av_exit(1);
2731
2732     input_files_ts_scale[nb_input_files][stream]= scale;
2733 }
2734
2735 static int opt_recording_time(const char *opt, const char *arg)
2736 {
2737     recording_time = parse_time_or_die(opt, arg, 1);
2738     return 0;
2739 }
2740
2741 static int opt_start_time(const char *opt, const char *arg)
2742 {
2743     start_time = parse_time_or_die(opt, arg, 1);
2744     return 0;
2745 }
2746
2747 static int opt_rec_timestamp(const char *opt, const char *arg)
2748 {
2749     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2750     return 0;
2751 }
2752
2753 static int opt_input_ts_offset(const char *opt, const char *arg)
2754 {
2755     input_ts_offset = parse_time_or_die(opt, arg, 1);
2756     return 0;
2757 }
2758
2759 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2760 {
2761     const char *codec_string = encoder ? "encoder" : "decoder";
2762     AVCodec *codec;
2763
2764     if(!name)
2765         return CODEC_ID_NONE;
2766     codec = encoder ?
2767         avcodec_find_encoder_by_name(name) :
2768         avcodec_find_decoder_by_name(name);
2769     if(!codec) {
2770         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2771         av_exit(1);
2772     }
2773     if(codec->type != type) {
2774         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2775         av_exit(1);
2776     }
2777     return codec->id;
2778 }
2779
2780 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2781 {
2782     int i;
2783     for(i=0; i<opt_name_count; i++){
2784         char buf[256];
2785         const AVOption *opt;
2786         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2787         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2788         if(str && ((opt->flags & flags) == flags))
2789             av_set_string2(ctx, opt_names[i], str, 1);
2790     }
2791 }
2792
2793 static void opt_input_file(const char *filename)
2794 {
2795     AVFormatContext *ic;
2796     AVFormatParameters params, *ap = &params;
2797     int err, i, ret, rfps, rfps_base;
2798     int64_t timestamp;
2799
2800     if (!strcmp(filename, "-"))
2801         filename = "pipe:";
2802
2803     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2804                     !strcmp(filename, "/dev/stdin");
2805
2806     /* get default parameters from command line */
2807     ic = av_alloc_format_context();
2808
2809     memset(ap, 0, sizeof(*ap));
2810     ap->prealloced_context = 1;
2811     ap->sample_rate = audio_sample_rate;
2812     ap->channels = audio_channels;
2813     ap->time_base.den = frame_rate.num;
2814     ap->time_base.num = frame_rate.den;
2815     ap->width = frame_width + frame_padleft + frame_padright;
2816     ap->height = frame_height + frame_padtop + frame_padbottom;
2817     ap->pix_fmt = frame_pix_fmt;
2818    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2819     ap->channel = video_channel;
2820     ap->standard = video_standard;
2821     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2822     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2823     if(pgmyuv_compatibility_hack)
2824         ap->video_codec_id= CODEC_ID_PGMYUV;
2825
2826     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2827
2828     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2829     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2830     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2831
2832     /* open the input file with generic libav function */
2833     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2834     if (err < 0) {
2835         print_error(filename, err);
2836         av_exit(1);
2837     }
2838     if(opt_programid) {
2839         int i;
2840         for(i=0; i<ic->nb_programs; i++)
2841             if(ic->programs[i]->id != opt_programid)
2842                 ic->programs[i]->discard = AVDISCARD_ALL;
2843     }
2844
2845     ic->loop_input = loop_input;
2846
2847     /* If not enough info to get the stream parameters, we decode the
2848        first frames to get it. (used in mpeg case for example) */
2849     ret = av_find_stream_info(ic);
2850     if (ret < 0 && verbose >= 0) {
2851         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2852         av_exit(1);
2853     }
2854
2855     timestamp = start_time;
2856     /* add the stream start time */
2857     if (ic->start_time != AV_NOPTS_VALUE)
2858         timestamp += ic->start_time;
2859
2860     /* if seeking requested, we execute it */
2861     if (start_time != 0) {
2862         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2863         if (ret < 0) {
2864             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2865                     filename, (double)timestamp / AV_TIME_BASE);
2866         }
2867         /* reset seek info */
2868         start_time = 0;
2869     }
2870
2871     /* update the current parameters so that they match the one of the input stream */
2872     for(i=0;i<ic->nb_streams;i++) {
2873         AVCodecContext *enc = ic->streams[i]->codec;
2874         if(thread_count>1)
2875             avcodec_thread_init(enc, thread_count);
2876         enc->thread_count= thread_count;
2877         switch(enc->codec_type) {
2878         case CODEC_TYPE_AUDIO:
2879             set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2880             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2881             audio_channels = enc->channels;
2882             audio_sample_rate = enc->sample_rate;
2883             audio_sample_fmt = enc->sample_fmt;
2884             if(audio_disable)
2885                 ic->streams[i]->discard= AVDISCARD_ALL;
2886             break;
2887         case CODEC_TYPE_VIDEO:
2888             set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2889             frame_height = enc->height;
2890             frame_width = enc->width;
2891             if(ic->streams[i]->sample_aspect_ratio.num)
2892                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2893             else
2894                 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2895             frame_aspect_ratio *= (float) enc->width / enc->height;
2896             frame_pix_fmt = enc->pix_fmt;
2897             rfps      = ic->streams[i]->r_frame_rate.num;
2898             rfps_base = ic->streams[i]->r_frame_rate.den;
2899             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2900             if(me_threshold)
2901                 enc->debug |= FF_DEBUG_MV;
2902
2903             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2904
2905                 if (verbose >= 0)
2906                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2907                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2908
2909                     (float)rfps / rfps_base, rfps, rfps_base);
2910             }
2911             /* update the current frame rate to match the stream frame rate */
2912             frame_rate.num = rfps;
2913             frame_rate.den = rfps_base;
2914
2915             enc->rate_emu = rate_emu;
2916             if(video_disable)
2917                 ic->streams[i]->discard= AVDISCARD_ALL;
2918             else if(video_discard)
2919                 ic->streams[i]->discard= video_discard;
2920             break;
2921         case CODEC_TYPE_DATA:
2922             break;
2923         case CODEC_TYPE_SUBTITLE:
2924             if(subtitle_disable)
2925                 ic->streams[i]->discard = AVDISCARD_ALL;
2926             break;
2927         case CODEC_TYPE_ATTACHMENT:
2928         case CODEC_TYPE_UNKNOWN:
2929             break;
2930         default:
2931             abort();
2932         }
2933     }
2934
2935     input_files[nb_input_files] = ic;
2936     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2937     /* dump the file content */
2938     if (verbose >= 0)
2939         dump_format(ic, nb_input_files, filename, 0);
2940
2941     nb_input_files++;
2942     file_iformat = NULL;
2943     file_oformat = NULL;
2944
2945     video_channel = 0;
2946
2947     rate_emu = 0;
2948     av_freep(&video_codec_name);
2949     av_freep(&audio_codec_name);
2950     av_freep(&subtitle_codec_name);
2951 }
2952
2953 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2954                                          int *has_subtitle_ptr)
2955 {
2956     int has_video, has_audio, has_subtitle, i, j;
2957     AVFormatContext *ic;
2958
2959     has_video = 0;
2960     has_audio = 0;
2961     has_subtitle = 0;
2962     for(j=0;j<nb_input_files;j++) {
2963         ic = input_files[j];
2964         for(i=0;i<ic->nb_streams;i++) {
2965             AVCodecContext *enc = ic->streams[i]->codec;
2966             switch(enc->codec_type) {
2967             case CODEC_TYPE_AUDIO:
2968                 has_audio = 1;
2969                 break;
2970             case CODEC_TYPE_VIDEO:
2971                 has_video = 1;
2972                 break;
2973             case CODEC_TYPE_SUBTITLE:
2974                 has_subtitle = 1;
2975                 break;
2976             case CODEC_TYPE_DATA:
2977             case CODEC_TYPE_ATTACHMENT:
2978             case CODEC_TYPE_UNKNOWN:
2979                 break;
2980             default:
2981                 abort();
2982             }
2983         }
2984     }
2985     *has_video_ptr = has_video;
2986     *has_audio_ptr = has_audio;
2987     *has_subtitle_ptr = has_subtitle;
2988 }
2989
2990 static void new_video_stream(AVFormatContext *oc)
2991 {
2992     AVStream *st;
2993     AVCodecContext *video_enc;
2994     int codec_id;
2995
2996     st = av_new_stream(oc, oc->nb_streams);
2997     if (!st) {
2998         fprintf(stderr, "Could not alloc stream\n");
2999         av_exit(1);
3000     }
3001     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3002     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3003     video_bitstream_filters= NULL;
3004
3005     if(thread_count>1)
3006         avcodec_thread_init(st->codec, thread_count);
3007
3008     video_enc = st->codec;
3009
3010     if(video_codec_tag)
3011         video_enc->codec_tag= video_codec_tag;
3012
3013     if(   (video_global_header&1)
3014        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3015         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3016         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3017     }
3018     if(video_global_header&2){
3019         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3020         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3021     }
3022
3023     if (video_stream_copy) {
3024         st->stream_copy = 1;
3025         video_enc->codec_type = CODEC_TYPE_VIDEO;
3026         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3027     } else {
3028         const char *p;
3029         int i;
3030         AVCodec *codec;
3031         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3032
3033         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3034         if (video_codec_name)
3035             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3036
3037         video_enc->codec_id = codec_id;
3038         codec = avcodec_find_encoder(codec_id);
3039
3040         set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3041
3042         video_enc->time_base.den = fps.num;
3043         video_enc->time_base.num = fps.den;
3044         if(codec && codec->supported_framerates){
3045             const AVRational *p= codec->supported_framerates;
3046             const AVRational *best=NULL;
3047             AVRational best_error= (AVRational){INT_MAX, 1};
3048             for(; p->den!=0; p++){
3049                 AVRational error= av_sub_q(fps, *p);
3050                 if(error.num <0) error.num *= -1;
3051                 if(av_cmp_q(error, best_error) < 0){
3052                     best_error= error;
3053                     best= p;
3054                 }
3055             }
3056             video_enc->time_base.den= best->num;
3057             video_enc->time_base.num= best->den;
3058         }
3059
3060         video_enc->width = frame_width + frame_padright + frame_padleft;
3061         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3062         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3063         video_enc->pix_fmt = frame_pix_fmt;
3064         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3065
3066         if(codec && codec->pix_fmts){
3067             const enum PixelFormat *p= codec->pix_fmts;
3068             for(; *p!=-1; p++){
3069                 if(*p == video_enc->pix_fmt)
3070                     break;
3071             }
3072             if(*p == -1)
3073                 video_enc->pix_fmt = codec->pix_fmts[0];
3074         }
3075
3076         if (intra_only)
3077             video_enc->gop_size = 0;
3078         if (video_qscale || same_quality) {
3079             video_enc->flags |= CODEC_FLAG_QSCALE;
3080             video_enc->global_quality=
3081                 st->quality = FF_QP2LAMBDA * video_qscale;
3082         }
3083
3084         if(intra_matrix)
3085             video_enc->intra_matrix = intra_matrix;
3086         if(inter_matrix)
3087             video_enc->inter_matrix = inter_matrix;
3088
3089         video_enc->thread_count = thread_count;
3090         p= video_rc_override_string;
3091         for(i=0; p; i++){
3092             int start, end, q;
3093             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3094             if(e!=3){
3095                 fprintf(stderr, "error parsing rc_override\n");
3096                 av_exit(1);
3097             }
3098             video_enc->rc_override=
3099                 av_realloc(video_enc->rc_override,
3100                            sizeof(RcOverride)*(i+1));
3101             video_enc->rc_override[i].start_frame= start;
3102             video_enc->rc_override[i].end_frame  = end;
3103             if(q>0){
3104                 video_enc->rc_override[i].qscale= q;
3105                 video_enc->rc_override[i].quality_factor= 1.0;
3106             }
3107             else{
3108                 video_enc->rc_override[i].qscale= 0;
3109                 video_enc->rc_override[i].quality_factor= -q/100.0;
3110             }
3111             p= strchr(p, '/');
3112             if(p) p++;
3113         }
3114         video_enc->rc_override_count=i;
3115         if (!video_enc->rc_initial_buffer_occupancy)
3116             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3117         video_enc->me_threshold= me_threshold;
3118         video_enc->intra_dc_precision= intra_dc_precision - 8;
3119
3120         if (do_psnr)
3121             video_enc->flags|= CODEC_FLAG_PSNR;
3122
3123         /* two pass mode */
3124         if (do_pass) {
3125             if (do_pass == 1) {
3126                 video_enc->flags |= CODEC_FLAG_PASS1;
3127             } else {
3128                 video_enc->flags |= CODEC_FLAG_PASS2;
3129             }
3130         }
3131     }
3132
3133     /* reset some key parameters */
3134     video_disable = 0;
3135     av_freep(&video_codec_name);
3136     video_stream_copy = 0;
3137 }
3138
3139 static void new_audio_stream(AVFormatContext *oc)
3140 {
3141     AVStream *st;
3142     AVCodecContext *audio_enc;
3143     int codec_id;
3144
3145     st = av_new_stream(oc, oc->nb_streams);
3146     if (!st) {
3147         fprintf(stderr, "Could not alloc stream\n");
3148         av_exit(1);
3149     }
3150     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3151
3152     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3153     audio_bitstream_filters= NULL;
3154
3155     if(thread_count>1)
3156         avcodec_thread_init(st->codec, thread_count);
3157
3158     audio_enc = st->codec;
3159     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3160
3161     if(audio_codec_tag)
3162         audio_enc->codec_tag= audio_codec_tag;
3163
3164     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3165         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3166         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3167     }
3168     if (audio_stream_copy) {
3169         st->stream_copy = 1;
3170         audio_enc->channels = audio_channels;
3171     } else {
3172         AVCodec *codec;
3173         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3174
3175         set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3176
3177         if (audio_codec_name)
3178             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3179         audio_enc->codec_id = codec_id;
3180         codec = avcodec_find_encoder(codec_id);
3181
3182         if (audio_qscale > QSCALE_NONE) {
3183             audio_enc->flags |= CODEC_FLAG_QSCALE;
3184             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3185         }
3186         audio_enc->thread_count = thread_count;
3187         audio_enc->channels = audio_channels;
3188         audio_enc->sample_fmt = audio_sample_fmt;
3189
3190         if(codec && codec->sample_fmts){
3191             const enum SampleFormat *p= codec->sample_fmts;
3192             for(; *p!=-1; p++){
3193                 if(*p == audio_enc->sample_fmt)
3194                     break;
3195             }
3196             if(*p == -1)
3197                 audio_enc->sample_fmt = codec->sample_fmts[0];
3198         }
3199     }
3200     audio_enc->sample_rate = audio_sample_rate;
3201     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3202     if (audio_language) {
3203         av_strlcpy(st->language, audio_language, sizeof(st->language));
3204         av_free(audio_language);
3205         audio_language = NULL;
3206     }
3207
3208     /* reset some key parameters */
3209     audio_disable = 0;
3210     av_freep(&audio_codec_name);
3211     audio_stream_copy = 0;
3212 }
3213
3214 static void new_subtitle_stream(AVFormatContext *oc)
3215 {
3216     AVStream *st;
3217     AVCodecContext *subtitle_enc;
3218
3219     st = av_new_stream(oc, oc->nb_streams);
3220     if (!st) {
3221         fprintf(stderr, "Could not alloc stream\n");
3222         av_exit(1);
3223     }
3224     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3225
3226     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3227     subtitle_bitstream_filters= NULL;
3228
3229     subtitle_enc = st->codec;
3230     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3231     if (subtitle_stream_copy) {
3232         st->stream_copy = 1;
3233     } else {
3234         set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3235         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3236     }
3237
3238     if (subtitle_language) {
3239         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3240         av_free(subtitle_language);
3241         subtitle_language = NULL;
3242     }
3243
3244     subtitle_disable = 0;
3245     av_freep(&subtitle_codec_name);
3246     subtitle_stream_copy = 0;
3247 }
3248
3249 static void opt_new_audio_stream(void)
3250 {
3251     AVFormatContext *oc;
3252     if (nb_output_files <= 0) {
3253         fprintf(stderr, "At least one output file must be specified\n");
3254         av_exit(1);
3255     }
3256     oc = output_files[nb_output_files - 1];
3257     new_audio_stream(oc);
3258 }
3259
3260 static void opt_new_video_stream(void)
3261 {
3262     AVFormatContext *oc;
3263     if (nb_output_files <= 0) {
3264         fprintf(stderr, "At least one output file must be specified\n");
3265         av_exit(1);
3266     }
3267     oc = output_files[nb_output_files - 1];
3268     new_video_stream(oc);
3269 }
3270
3271 static void opt_new_subtitle_stream(void)
3272 {
3273     AVFormatContext *oc;
3274     if (nb_output_files <= 0) {
3275         fprintf(stderr, "At least one output file must be specified\n");
3276         av_exit(1);
3277     }
3278     oc = output_files[nb_output_files - 1];
3279     new_subtitle_stream(oc);
3280 }
3281
3282 static void opt_output_file(const char *filename)
3283 {
3284     AVFormatContext *oc;
3285     int use_video, use_audio, use_subtitle;
3286     int input_has_video, input_has_audio, input_has_subtitle;
3287     AVFormatParameters params, *ap = &params;
3288
3289     if (!strcmp(filename, "-"))
3290         filename = "pipe:";
3291
3292     oc = av_alloc_format_context();
3293
3294     if (!file_oformat) {
3295         file_oformat = guess_format(NULL, filename, NULL);
3296         if (!file_oformat) {
3297             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3298                     filename);
3299             av_exit(1);
3300         }
3301     }
3302
3303     oc->oformat = file_oformat;
3304     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3305
3306     if (!strcmp(file_oformat->name, "ffm") &&
3307         av_strstart(filename, "http:", NULL)) {
3308         /* special case for files sent to ffserver: we get the stream
3309            parameters from ffserver */
3310         int err = read_ffserver_streams(oc, filename);
3311         if (err < 0) {
3312             print_error(filename, err);
3313             av_exit(1);
3314         }
3315     } else {
3316         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3317         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3318         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3319
3320         /* disable if no corresponding type found and at least one
3321            input file */
3322         if (nb_input_files > 0) {
3323             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3324                                          &input_has_subtitle);
3325             if (!input_has_video)
3326                 use_video = 0;
3327             if (!input_has_audio)
3328                 use_audio = 0;
3329             if (!input_has_subtitle)
3330                 use_subtitle = 0;
3331         }
3332
3333         /* manual disable */
3334         if (audio_disable) {
3335             use_audio = 0;
3336         }
3337         if (video_disable) {
3338             use_video = 0;
3339         }
3340         if (subtitle_disable) {
3341             use_subtitle = 0;
3342         }
3343
3344         if (use_video) {
3345             new_video_stream(oc);
3346         }
3347
3348         if (use_audio) {
3349             new_audio_stream(oc);
3350         }
3351
3352         if (use_subtitle) {
3353             new_subtitle_stream(oc);
3354         }
3355
3356         oc->timestamp = rec_timestamp;
3357
3358         if (str_title)
3359             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3360         if (str_author)
3361             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3362         if (str_copyright)
3363             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3364         if (str_comment)
3365             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3366         if (str_album)
3367             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3368         if (str_genre)
3369             av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3370     }
3371
3372     output_files[nb_output_files++] = oc;
3373
3374     /* check filename in case of an image number is expected */
3375     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3376         if (!av_filename_number_test(oc->filename)) {
3377             print_error(oc->filename, AVERROR_NUMEXPECTED);
3378             av_exit(1);
3379         }
3380     }
3381
3382     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3383         /* test if it already exists to avoid loosing precious files */
3384         if (!file_overwrite &&
3385             (strchr(filename, ':') == NULL ||
3386              filename[1] == ':' ||
3387              av_strstart(filename, "file:", NULL))) {
3388             if (url_exist(filename)) {
3389                 int c;
3390
3391                 if (!using_stdin) {
3392                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3393                     fflush(stderr);
3394                     c = getchar();
3395                     if (toupper(c) != 'Y') {
3396                         fprintf(stderr, "Not overwriting - exiting\n");
3397                         av_exit(1);
3398                     }
3399                 }
3400                 else {
3401                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3402                     av_exit(1);
3403                 }
3404             }
3405         }
3406
3407         /* open the file */
3408         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3409             fprintf(stderr, "Could not open '%s'\n", filename);
3410             av_exit(1);
3411         }
3412     }
3413
3414     memset(ap, 0, sizeof(*ap));
3415     if (av_set_parameters(oc, ap) < 0) {
3416         fprintf(stderr, "%s: Invalid encoding parameters\n",
3417                 oc->filename);
3418         av_exit(1);
3419     }
3420
3421     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3422     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3423     oc->loop_output = loop_output;
3424
3425     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3426
3427     /* reset some options */
3428     file_oformat = NULL;
3429     file_iformat = NULL;
3430 }
3431
3432 /* same option as mencoder */
3433 static void opt_pass(const char *pass_str)
3434 {
3435     int pass;
3436     pass = atoi(pass_str);
3437     if (pass != 1 && pass != 2) {
3438         fprintf(stderr, "pass number can be only 1 or 2\n");
3439         av_exit(1);
3440     }
3441     do_pass = pass;
3442 }
3443
3444 static int64_t getutime(void)
3445 {
3446 #ifdef HAVE_GETRUSAGE
3447     struct rusage rusage;
3448
3449     getrusage(RUSAGE_SELF, &rusage);
3450     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3451 #elif defined(HAVE_GETPROCESSTIMES)
3452     HANDLE proc;
3453     FILETIME c, e, k, u;
3454     proc = GetCurrentProcess();
3455     GetProcessTimes(proc, &c, &e, &k, &u);
3456     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3457 #else
3458     return av_gettime();
3459 #endif
3460 }
3461
3462 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3463 {
3464     int i;
3465     const char *p = str;
3466     for(i = 0;; i++) {
3467         dest[i] = atoi(p);
3468         if(i == 63)
3469             break;
3470         p = strchr(p, ',');
3471         if(!p) {
3472             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3473             av_exit(1);
3474         }
3475         p++;
3476     }
3477 }
3478
3479 static void opt_inter_matrix(const char *arg)
3480 {
3481     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3482     parse_matrix_coeffs(inter_matrix, arg);
3483 }
3484
3485 static void opt_intra_matrix(const char *arg)
3486 {
3487     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3488     parse_matrix_coeffs(intra_matrix, arg);
3489 }
3490
3491 /**
3492  * Trivial log callback.
3493  * Only suitable for show_help and similar since it lacks prefix handling.
3494  */
3495 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3496 {
3497     vfprintf(stdout, fmt, vl);
3498 }
3499
3500 static void show_help(void)
3501 {
3502     av_log_set_callback(log_callback_help);
3503     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3504            "Hyper fast Audio and Video encoder\n");
3505     printf("\n");
3506     show_help_options(options, "Main options:\n",
3507                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3508     show_help_options(options, "\nAdvanced options:\n",
3509                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3510                       OPT_EXPERT);
3511     show_help_options(options, "\nVideo options:\n",
3512                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3513                       OPT_VIDEO);
3514     show_help_options(options, "\nAdvanced Video options:\n",
3515                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3516                       OPT_VIDEO | OPT_EXPERT);
3517     show_help_options(options, "\nAudio options:\n",
3518                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3519                       OPT_AUDIO);
3520     show_help_options(options, "\nAdvanced Audio options:\n",
3521                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3522                       OPT_AUDIO | OPT_EXPERT);
3523     show_help_options(options, "\nSubtitle options:\n",
3524                       OPT_SUBTITLE | OPT_GRAB,
3525                       OPT_SUBTITLE);
3526     show_help_options(options, "\nAudio/Video grab options:\n",
3527                       OPT_GRAB,
3528                       OPT_GRAB);
3529     printf("\n");
3530     av_opt_show(avctx_opts[0], NULL);
3531     printf("\n");
3532     av_opt_show(avformat_opts, NULL);
3533     printf("\n");
3534     av_opt_show(sws_opts, NULL);
3535 }
3536
3537 static void opt_target(const char *arg)
3538 {
3539     int norm = -1;
3540     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3541
3542     if(!strncmp(arg, "pal-", 4)) {
3543         norm = 0;
3544         arg += 4;
3545     } else if(!strncmp(arg, "ntsc-", 5)) {
3546         norm = 1;
3547         arg += 5;
3548     } else if(!strncmp(arg, "film-", 5)) {
3549         norm = 2;
3550         arg += 5;
3551     } else {
3552         int fr;
3553         /* Calculate FR via float to avoid int overflow */
3554         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3555         if(fr == 25000) {
3556             norm = 0;
3557         } else if((fr == 29970) || (fr == 23976)) {
3558             norm = 1;
3559         } else {
3560             /* Try to determine PAL/NTSC by peeking in the input files */
3561             if(nb_input_files) {
3562                 int i, j;
3563                 for(j = 0; j < nb_input_files; j++) {
3564                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3565                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3566                         if(c->codec_type != CODEC_TYPE_VIDEO)
3567                             continue;
3568                         fr = c->time_base.den * 1000 / c->time_base.num;
3569                         if(fr == 25000) {
3570                             norm = 0;
3571                             break;
3572                         } else if((fr == 29970) || (fr == 23976)) {
3573                             norm = 1;
3574                             break;
3575                         }
3576                     }
3577                     if(norm >= 0)
3578                         break;
3579                 }
3580             }
3581         }
3582         if(verbose && norm >= 0)
3583             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3584     }
3585
3586     if(norm < 0) {
3587         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3588         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3589         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3590         av_exit(1);
3591     }
3592
3593     if(!strcmp(arg, "vcd")) {
3594
3595         opt_video_codec("mpeg1video");
3596         opt_audio_codec("mp2");
3597         opt_format("vcd");
3598
3599         opt_frame_size(norm ? "352x240" : "352x288");
3600         opt_frame_rate(NULL, frame_rates[norm]);
3601         opt_default("gop", norm ? "18" : "15");
3602
3603         opt_default("b", "1150000");
3604         opt_default("maxrate", "1150000");
3605         opt_default("minrate", "1150000");
3606         opt_default("bufsize", "327680"); // 40*1024*8;
3607
3608         opt_default("ab", "224000");
3609         audio_sample_rate = 44100;
3610         audio_channels = 2;
3611
3612         opt_default("packetsize", "2324");
3613         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3614
3615         /* We have to offset the PTS, so that it is consistent with the SCR.
3616            SCR starts at 36000, but the first two packs contain only padding
3617            and the first pack from the other stream, respectively, may also have
3618            been written before.
3619            So the real data starts at SCR 36000+3*1200. */
3620         mux_preload= (36000+3*1200) / 90000.0; //0.44
3621     } else if(!strcmp(arg, "svcd")) {
3622
3623         opt_video_codec("mpeg2video");
3624         opt_audio_codec("mp2");
3625         opt_format("svcd");
3626
3627         opt_frame_size(norm ? "480x480" : "480x576");
3628         opt_frame_rate(NULL, frame_rates[norm]);
3629         opt_default("gop", norm ? "18" : "15");
3630
3631         opt_default("b", "2040000");
3632         opt_default("maxrate", "2516000");
3633         opt_default("minrate", "0"); //1145000;
3634         opt_default("bufsize", "1835008"); //224*1024*8;
3635         opt_default("flags", "+SCAN_OFFSET");
3636
3637
3638         opt_default("ab", "224000");
3639         audio_sample_rate = 44100;
3640
3641         opt_default("packetsize", "2324");
3642
3643     } else if(!strcmp(arg, "dvd")) {
3644
3645         opt_video_codec("mpeg2video");
3646         opt_audio_codec("ac3");
3647         opt_format("dvd");
3648
3649         opt_frame_size(norm ? "720x480" : "720x576");
3650         opt_frame_rate(NULL, frame_rates[norm]);
3651         opt_default("gop", norm ? "18" : "15");
3652
3653         opt_default("b", "6000000");
3654         opt_default("maxrate", "9000000");
3655         opt_default("minrate", "0"); //1500000;
3656         opt_default("bufsize", "1835008"); //224*1024*8;
3657
3658         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3659         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3660
3661         opt_default("ab", "448000");
3662         audio_sample_rate = 48000;
3663
3664     } else if(!strncmp(arg, "dv", 2)) {
3665
3666         opt_format("dv");
3667
3668         opt_frame_size(norm ? "720x480" : "720x576");
3669         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3670                                              (norm ? "yuv411p" : "yuv420p"));
3671         opt_frame_rate(NULL, frame_rates[norm]);
3672
3673         audio_sample_rate = 48000;
3674         audio_channels = 2;
3675
3676     } else {
3677         fprintf(stderr, "Unknown target: %s\n", arg);
3678         av_exit(1);
3679     }
3680 }
3681
3682 static void opt_vstats_file (const char *arg)
3683 {
3684     av_free (vstats_filename);
3685     vstats_filename=av_strdup (arg);
3686 }
3687
3688 static void opt_vstats (void)
3689 {
3690     char filename[40];
3691     time_t today2 = time(NULL);
3692     struct tm *today = localtime(&today2);
3693
3694     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3695              today->tm_sec);
3696     opt_vstats_file(filename);
3697 }
3698
3699 static int opt_bsf(const char *opt, const char *arg)
3700 {
3701     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3702     AVBitStreamFilterContext **bsfp;
3703
3704     if(!bsfc){
3705         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3706         av_exit(1);
3707     }
3708
3709     bsfp= *opt == 'v' ? &video_bitstream_filters :
3710           *opt == 'a' ? &audio_bitstream_filters :
3711                         &subtitle_bitstream_filters;
3712     while(*bsfp)
3713         bsfp= &(*bsfp)->next;
3714
3715     *bsfp= bsfc;
3716
3717     return 0;
3718 }
3719
3720 static int opt_preset(const char *opt, const char *arg)
3721 {
3722     FILE *f=NULL;
3723     char tmp[1000], tmp2[1000];
3724     int i;
3725     const char *base[3]= { getenv("HOME"),
3726                            "/usr/local/share",
3727                            "/usr/share",
3728                          };
3729
3730     for(i=!base[0]; i<3 && !f; i++){
3731         snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3732         f= fopen(tmp, "r");
3733         if(!f){
3734             char *codec_name= *opt == 'v' ? video_codec_name :
3735                               *opt == 'a' ? audio_codec_name :
3736                                             subtitle_codec_name;
3737               snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3738             f= fopen(tmp, "r");
3739         }
3740     }
3741
3742     if(!f){
3743         fprintf(stderr, "Preset file not found\n");
3744         av_exit(1);
3745     }
3746
3747     while(!feof(f)){
3748         int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3749         if(e!=2){
3750             fprintf(stderr, "Preset file invalid\n");
3751             av_exit(1);
3752         }
3753         if(!strcmp(tmp, "acodec")){
3754             opt_audio_codec(tmp2);
3755         }else if(!strcmp(tmp, "vcodec")){
3756             opt_video_codec(tmp2);
3757         }else if(!strcmp(tmp, "scodec")){
3758             opt_subtitle_codec(tmp2);
3759         }else
3760             opt_default(tmp, tmp2);
3761     }
3762
3763     fclose(f);
3764
3765     return 0;
3766 }
3767
3768 static const OptionDef options[] = {
3769     /* main options */
3770     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3771     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3772     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3773     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3774     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3775     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3776     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3777     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3778     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3779     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3780     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3781     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3782     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3783     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3784     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3785     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3786     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3787     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3788     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3789     { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3790     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3791     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3792     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3793       "add timings for benchmarking" },
3794     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3795       "dump each input packet" },
3796     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3797       "when dumping packets, also dump the payload" },
3798     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3799     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3800     { "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)", "" },
3801     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3802     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3803     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3804     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3805     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3806     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3807     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3808     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3809     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3810     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3811     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3812
3813     /* video options */
3814     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3815     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3816     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3817     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3818     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3819     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3820     { "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" },
3821     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3822     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3823     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3824     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3825     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3826     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3827     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3828     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3829     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3830     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3831     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3832     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3833     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3834     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3835     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3836     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3837     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3838       "use same video quality as source (implies VBR)" },
3839     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3840     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3841     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3842       "deinterlace pictures" },
3843     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3844     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3845     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3846 #ifdef CONFIG_VHOOK
3847     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3848 #endif
3849     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3850     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3851     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3852     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3853     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3854     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3855     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3856
3857     /* audio options */
3858     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3859     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3860     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3861     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3862     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3863     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3864     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3865     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3866     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3867     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3868     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3869     { "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" },
3870
3871     /* subtitle options */
3872     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3873     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3874     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3875     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3876
3877     /* grab options */
3878     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3879     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3880     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3881
3882     /* muxer options */
3883     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3884     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3885
3886     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3887     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3888     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3889
3890     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3891     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3892     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3893
3894     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3895     { NULL, },
3896 };
3897
3898 int main(int argc, char **argv)
3899 {
3900     int i;
3901     int64_t ti;
3902
3903     avcodec_register_all();
3904     avdevice_register_all();
3905     av_register_all();
3906
3907     if(isatty(STDIN_FILENO))
3908         url_set_interrupt_cb(decode_interrupt_cb);
3909
3910     for(i=0; i<CODEC_TYPE_NB; i++){
3911         avctx_opts[i]= avcodec_alloc_context2(i);
3912     }
3913     avformat_opts = av_alloc_format_context();
3914     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3915
3916     show_banner();
3917     if (argc <= 1) {
3918         show_help();
3919         av_exit(1);
3920     }
3921
3922     /* parse options */
3923     parse_options(argc, argv, options, opt_output_file);
3924
3925     /* file converter / grab */
3926     if (nb_output_files <= 0) {
3927         fprintf(stderr, "Must supply at least one output file\n");
3928         av_exit(1);
3929     }
3930
3931     if (nb_input_files == 0) {
3932         fprintf(stderr, "Must supply at least one input file\n");
3933         av_exit(1);
3934     }
3935
3936     ti = getutime();
3937     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3938               stream_maps, nb_stream_maps);
3939     ti = getutime() - ti;
3940     if (do_benchmark) {
3941         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3942     }
3943
3944     return av_exit(0);
3945 }