ffmpeg.c

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