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