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